1 /* 2 * Copyright (C) 2010 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 #ifndef ANDROID_HWUI_RESOURCE_CACHE_H 18 #define ANDROID_HWUI_RESOURCE_CACHE_H 19 20 #include <cutils/compiler.h> 21 22 #include <SkBitmap.h> 23 #include <SkiaColorFilter.h> 24 #include <SkiaShader.h> 25 #include <utils/KeyedVector.h> 26 #include "Layer.h" 27 28 namespace android { 29 namespace uirenderer { 30 31 /** 32 * Type of Resource being cached 33 */ 34 enum ResourceType { 35 kBitmap, 36 kShader, 37 kColorFilter, 38 kPath, 39 kLayer 40 }; 41 42 class ResourceReference { 43 public: 44 ResourceReference()45 ResourceReference() { refCount = 0; recycled = false; destroyed = false;} ResourceReference(ResourceType type)46 ResourceReference(ResourceType type) { 47 refCount = 0; recycled = false; destroyed = false; resourceType = type; 48 } 49 50 int refCount; 51 bool recycled; 52 bool destroyed; 53 ResourceType resourceType; 54 }; 55 56 class ANDROID_API ResourceCache { 57 public: 58 ResourceCache(); 59 ~ResourceCache(); 60 61 /** 62 * When using these two methods, make sure to only invoke the *Locked() 63 * variants of increment/decrementRefcount(), recyle() and destructor() 64 */ 65 void lock(); 66 void unlock(); 67 68 void incrementRefcount(SkPath* resource); 69 void incrementRefcount(SkBitmap* resource); 70 void incrementRefcount(SkiaShader* resource); 71 void incrementRefcount(SkiaColorFilter* resource); 72 void incrementRefcount(Layer* resource); 73 74 void incrementRefcountLocked(SkPath* resource); 75 void incrementRefcountLocked(SkBitmap* resource); 76 void incrementRefcountLocked(SkiaShader* resource); 77 void incrementRefcountLocked(SkiaColorFilter* resource); 78 void incrementRefcountLocked(Layer* resource); 79 80 void decrementRefcount(SkBitmap* resource); 81 void decrementRefcount(SkPath* resource); 82 void decrementRefcount(SkiaShader* resource); 83 void decrementRefcount(SkiaColorFilter* resource); 84 void decrementRefcount(Layer* resource); 85 86 void decrementRefcountLocked(SkBitmap* resource); 87 void decrementRefcountLocked(SkPath* resource); 88 void decrementRefcountLocked(SkiaShader* resource); 89 void decrementRefcountLocked(SkiaColorFilter* resource); 90 void decrementRefcountLocked(Layer* resource); 91 92 void destructor(SkPath* resource); 93 void destructor(SkBitmap* resource); 94 void destructor(SkiaShader* resource); 95 void destructor(SkiaColorFilter* resource); 96 97 void destructorLocked(SkPath* resource); 98 void destructorLocked(SkBitmap* resource); 99 void destructorLocked(SkiaShader* resource); 100 void destructorLocked(SkiaColorFilter* resource); 101 102 bool recycle(SkBitmap* resource); 103 bool recycleLocked(SkBitmap* resource); 104 105 private: 106 void deleteResourceReferenceLocked(void* resource, ResourceReference* ref); 107 108 void incrementRefcount(void* resource, ResourceType resourceType); 109 void incrementRefcountLocked(void* resource, ResourceType resourceType); 110 111 void decrementRefcount(void* resource); 112 void decrementRefcountLocked(void* resource); 113 114 void logCache(); 115 116 /** 117 * Used to increment, decrement, and destroy. Incrementing is generally accessed on the UI 118 * thread, but destroying resources may be called from the GC thread, the finalizer thread, 119 * or a reference queue finalization thread. 120 */ 121 mutable Mutex mLock; 122 123 KeyedVector<void*, ResourceReference*>* mCache; 124 }; 125 126 }; // namespace uirenderer 127 }; // namespace android 128 129 #endif // ANDROID_HWUI_RESOURCE_CACHE_H 130