| // Copyright 2014 The Chromium Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include "ui/android/resources/resource_manager_impl.h" |
| |
| #include <stddef.h> |
| |
| #include <utility> |
| #include <vector> |
| |
| #include "base/android/jni_array.h" |
| #include "base/android/jni_string.h" |
| #include "base/trace_event/trace_event.h" |
| #include "cc/resources/scoped_ui_resource.h" |
| #include "jni/ResourceManager_jni.h" |
| #include "ui/android/resources/ui_resource_provider.h" |
| #include "ui/android/window_android.h" |
| #include "ui/gfx/android/java_bitmap.h" |
| #include "ui/gfx/geometry/rect.h" |
| |
| using base::android::JavaArrayOfIntArrayToIntVector; |
| using base::android::JavaRef; |
| |
| namespace ui { |
| |
| // static |
| ResourceManagerImpl* ResourceManagerImpl::FromJavaObject(jobject jobj) { |
| return reinterpret_cast<ResourceManagerImpl*>( |
| Java_ResourceManager_getNativePtr(base::android::AttachCurrentThread(), |
| jobj)); |
| } |
| |
| ResourceManagerImpl::ResourceManagerImpl(gfx::NativeWindow native_window) |
| : host_(nullptr) { |
| JNIEnv* env = base::android::AttachCurrentThread(); |
| java_obj_.Reset(env, Java_ResourceManager_create( |
| env, native_window->GetJavaObject().obj(), |
| reinterpret_cast<intptr_t>(this)) |
| .obj()); |
| DCHECK(!java_obj_.is_null()); |
| } |
| |
| ResourceManagerImpl::~ResourceManagerImpl() { |
| Java_ResourceManager_destroy(base::android::AttachCurrentThread(), |
| java_obj_.obj()); |
| } |
| |
| void ResourceManagerImpl::Init(cc::LayerTreeHost* host) { |
| DCHECK(!host_); |
| DCHECK(host); |
| host_ = host; |
| } |
| |
| base::android::ScopedJavaLocalRef<jobject> |
| ResourceManagerImpl::GetJavaObject() { |
| return base::android::ScopedJavaLocalRef<jobject>(java_obj_); |
| } |
| |
| ResourceManager::Resource* ResourceManagerImpl::GetResource( |
| AndroidResourceType res_type, |
| int res_id) { |
| DCHECK_GE(res_type, ANDROID_RESOURCE_TYPE_FIRST); |
| DCHECK_LE(res_type, ANDROID_RESOURCE_TYPE_LAST); |
| |
| Resource* resource = resources_[res_type].Lookup(res_id); |
| |
| if (!resource || res_type == ANDROID_RESOURCE_TYPE_DYNAMIC || |
| res_type == ANDROID_RESOURCE_TYPE_DYNAMIC_BITMAP) { |
| RequestResourceFromJava(res_type, res_id); |
| resource = resources_[res_type].Lookup(res_id); |
| } |
| |
| return resource; |
| } |
| |
| void ResourceManagerImpl::PreloadResource(AndroidResourceType res_type, |
| int res_id) { |
| DCHECK_GE(res_type, ANDROID_RESOURCE_TYPE_FIRST); |
| DCHECK_LE(res_type, ANDROID_RESOURCE_TYPE_LAST); |
| |
| // Don't send out a query if the resource is already loaded. |
| if (resources_[res_type].Lookup(res_id)) |
| return; |
| |
| PreloadResourceFromJava(res_type, res_id); |
| } |
| |
| void ResourceManagerImpl::OnResourceReady(JNIEnv* env, |
| const JavaRef<jobject>& jobj, |
| jint res_type, |
| jint res_id, |
| const JavaRef<jobject>& bitmap, |
| jint padding_left, |
| jint padding_top, |
| jint padding_right, |
| jint padding_bottom, |
| jint aperture_left, |
| jint aperture_top, |
| jint aperture_right, |
| jint aperture_bottom) { |
| DCHECK_GE(res_type, ANDROID_RESOURCE_TYPE_FIRST); |
| DCHECK_LE(res_type, ANDROID_RESOURCE_TYPE_LAST); |
| TRACE_EVENT2("ui", "ResourceManagerImpl::OnResourceReady", |
| "resource_type", res_type, |
| "resource_id", res_id); |
| |
| Resource* resource = resources_[res_type].Lookup(res_id); |
| if (!resource) { |
| resource = new Resource(); |
| resources_[res_type].AddWithID(resource, res_id); |
| } |
| |
| gfx::JavaBitmap jbitmap(bitmap.obj()); |
| resource->size = jbitmap.size(); |
| resource->padding.SetRect(padding_left, padding_top, |
| padding_right - padding_left, |
| padding_bottom - padding_top); |
| resource->aperture.SetRect(aperture_left, aperture_top, |
| aperture_right - aperture_left, |
| aperture_bottom - aperture_top); |
| |
| SkBitmap skbitmap = gfx::CreateSkBitmapFromJavaBitmap(jbitmap); |
| skbitmap.setImmutable(); |
| resource->ui_resource = |
| cc::ScopedUIResource::Create(host_, cc::UIResourceBitmap(skbitmap)); |
| } |
| |
| CrushedSpriteResource* ResourceManagerImpl::GetCrushedSpriteResource( |
| int bitmap_res_id, int metadata_res_id) { |
| CrushedSpriteResource* resource = |
| crushed_sprite_resources_.Lookup(bitmap_res_id); |
| if (!resource) { |
| RequestCrushedSpriteResourceFromJava(bitmap_res_id, metadata_res_id, false); |
| resource = crushed_sprite_resources_.Lookup(bitmap_res_id); |
| } else if (resource->BitmapHasBeenEvictedFromMemory()) { |
| RequestCrushedSpriteResourceFromJava(bitmap_res_id, metadata_res_id, true); |
| } |
| |
| return resource; |
| } |
| |
| void ResourceManagerImpl::OnCrushedSpriteResourceReady( |
| JNIEnv* env, |
| const JavaRef<jobject>& jobj, |
| jint bitmap_res_id, |
| const JavaRef<jobject>& bitmap, |
| const JavaRef<jobjectArray>& frame_rects, |
| jint unscaled_sprite_width, |
| jint unscaled_sprite_height, |
| jfloat scaled_sprite_width, |
| jfloat scaled_sprite_height) { |
| // Construct source and destination rectangles for each frame from |
| // |frame_rects|. |
| std::vector<std::vector<int>> all_frame_rects_vector; |
| JavaArrayOfIntArrayToIntVector(env, frame_rects.obj(), |
| &all_frame_rects_vector); |
| CrushedSpriteResource::SrcDstRects src_dst_rects = |
| ProcessCrushedSpriteFrameRects(all_frame_rects_vector); |
| |
| SkBitmap skbitmap = |
| gfx::CreateSkBitmapFromJavaBitmap(gfx::JavaBitmap(bitmap.obj())); |
| |
| CrushedSpriteResource* resource = new CrushedSpriteResource( |
| skbitmap, |
| src_dst_rects, |
| gfx::Size(unscaled_sprite_width, unscaled_sprite_height), |
| gfx::Size(scaled_sprite_width, scaled_sprite_height)); |
| |
| if (crushed_sprite_resources_.Lookup(bitmap_res_id)) { |
| crushed_sprite_resources_.Replace(bitmap_res_id, resource); |
| } else { |
| crushed_sprite_resources_.AddWithID(resource, bitmap_res_id); |
| } |
| } |
| |
| CrushedSpriteResource::SrcDstRects |
| ResourceManagerImpl::ProcessCrushedSpriteFrameRects( |
| std::vector<std::vector<int>> frame_rects_vector) { |
| CrushedSpriteResource::SrcDstRects src_dst_rects; |
| for (size_t i = 0; i < frame_rects_vector.size(); ++i) { |
| std::vector<int> frame_ints = frame_rects_vector[i]; |
| CrushedSpriteResource::FrameSrcDstRects frame_src_dst_rects; |
| |
| // Create source and destination gfx::Rect's for each rectangle in |
| // |frame_ints|. Each rectangle consists of 6 values: |
| // i: destination x i+1: destination y i+2: source x i+3: source y |
| // i+4: width i+5: height |
| for (size_t j = 0; j < frame_ints.size(); j += 6) { |
| gfx::Rect sprite_rect_destination(frame_ints[j], |
| frame_ints[j+1], |
| frame_ints[j+4], |
| frame_ints[j+5]); |
| gfx::Rect sprite_rect_source(frame_ints[j+2], |
| frame_ints[j+3], |
| frame_ints[j+4], |
| frame_ints[j+5]); |
| frame_src_dst_rects.push_back(std::pair<gfx::Rect, gfx::Rect>( |
| sprite_rect_source, sprite_rect_destination)); |
| } |
| src_dst_rects.push_back(frame_src_dst_rects); |
| } |
| return src_dst_rects; |
| } |
| |
| void ResourceManagerImpl::OnCrushedSpriteResourceReloaded( |
| JNIEnv* env, |
| const JavaRef<jobject>& jobj, |
| jint bitmap_res_id, |
| const JavaRef<jobject>& bitmap) { |
| CrushedSpriteResource* resource = |
| crushed_sprite_resources_.Lookup(bitmap_res_id); |
| if (!resource) { |
| // Cannot reload a resource that has not been previously loaded. |
| return; |
| } |
| SkBitmap skbitmap = |
| gfx::CreateSkBitmapFromJavaBitmap(gfx::JavaBitmap(bitmap.obj())); |
| resource->SetBitmap(skbitmap); |
| } |
| |
| // static |
| bool ResourceManagerImpl::RegisterResourceManager(JNIEnv* env) { |
| return RegisterNativesImpl(env); |
| } |
| |
| void ResourceManagerImpl::PreloadResourceFromJava(AndroidResourceType res_type, |
| int res_id) { |
| TRACE_EVENT2("ui", "ResourceManagerImpl::PreloadResourceFromJava", |
| "resource_type", res_type, |
| "resource_id", res_id); |
| Java_ResourceManager_preloadResource(base::android::AttachCurrentThread(), |
| java_obj_.obj(), res_type, res_id); |
| } |
| |
| void ResourceManagerImpl::RequestResourceFromJava(AndroidResourceType res_type, |
| int res_id) { |
| TRACE_EVENT2("ui", "ResourceManagerImpl::RequestResourceFromJava", |
| "resource_type", res_type, |
| "resource_id", res_id); |
| Java_ResourceManager_resourceRequested(base::android::AttachCurrentThread(), |
| java_obj_.obj(), res_type, res_id); |
| } |
| |
| void ResourceManagerImpl::RequestCrushedSpriteResourceFromJava( |
| int bitmap_res_id, int metadata_res_id, bool reloading) { |
| TRACE_EVENT2("ui", |
| "ResourceManagerImpl::RequestCrushedSpriteResourceFromJava", |
| "bitmap_res_id", bitmap_res_id, |
| "metadata_res_id", metadata_res_id); |
| Java_ResourceManager_crushedSpriteResourceRequested( |
| base::android::AttachCurrentThread(), java_obj_.obj(), |
| bitmap_res_id, metadata_res_id, reloading); |
| } |
| |
| } // namespace ui |
