• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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 
26 #include <utils/KeyedVector.h>
27 
28 #include <androidfw/ResourceTypes.h>
29 
30 #include "Layer.h"
31 
32 namespace android {
33 namespace uirenderer {
34 
35 /**
36  * Type of Resource being cached
37  */
38 enum ResourceType {
39     kBitmap,
40     kShader,
41     kColorFilter,
42     kNinePatch,
43     kPath,
44     kLayer
45 };
46 
47 class ResourceReference {
48 public:
49 
ResourceReference()50     ResourceReference() { refCount = 0; recycled = false; destroyed = false;}
ResourceReference(ResourceType type)51     ResourceReference(ResourceType type) {
52         refCount = 0; recycled = false; destroyed = false; resourceType = type;
53     }
54 
55     int refCount;
56     bool recycled;
57     bool destroyed;
58     ResourceType resourceType;
59 };
60 
61 class ANDROID_API ResourceCache {
62 public:
63     ResourceCache();
64     ~ResourceCache();
65 
66     /**
67      * When using these two methods, make sure to only invoke the *Locked()
68      * variants of increment/decrementRefcount(), recyle() and destructor()
69      */
70     void lock();
71     void unlock();
72 
73     void incrementRefcount(SkPath* resource);
74     void incrementRefcount(SkBitmap* resource);
75     void incrementRefcount(SkiaShader* resource);
76     void incrementRefcount(SkiaColorFilter* resource);
77     void incrementRefcount(Res_png_9patch* resource);
78     void incrementRefcount(Layer* resource);
79 
80     void incrementRefcountLocked(SkPath* resource);
81     void incrementRefcountLocked(SkBitmap* resource);
82     void incrementRefcountLocked(SkiaShader* resource);
83     void incrementRefcountLocked(SkiaColorFilter* resource);
84     void incrementRefcountLocked(Res_png_9patch* resource);
85     void incrementRefcountLocked(Layer* resource);
86 
87     void decrementRefcount(SkBitmap* resource);
88     void decrementRefcount(SkPath* resource);
89     void decrementRefcount(SkiaShader* resource);
90     void decrementRefcount(SkiaColorFilter* resource);
91     void decrementRefcount(Res_png_9patch* resource);
92     void decrementRefcount(Layer* resource);
93 
94     void decrementRefcountLocked(SkBitmap* resource);
95     void decrementRefcountLocked(SkPath* resource);
96     void decrementRefcountLocked(SkiaShader* resource);
97     void decrementRefcountLocked(SkiaColorFilter* resource);
98     void decrementRefcountLocked(Res_png_9patch* resource);
99     void decrementRefcountLocked(Layer* resource);
100 
101     void destructor(SkPath* resource);
102     void destructor(SkBitmap* resource);
103     void destructor(SkiaShader* resource);
104     void destructor(SkiaColorFilter* resource);
105     void destructor(Res_png_9patch* resource);
106 
107     void destructorLocked(SkPath* resource);
108     void destructorLocked(SkBitmap* resource);
109     void destructorLocked(SkiaShader* resource);
110     void destructorLocked(SkiaColorFilter* resource);
111     void destructorLocked(Res_png_9patch* resource);
112 
113     bool recycle(SkBitmap* resource);
114     bool recycleLocked(SkBitmap* resource);
115 
116 private:
117     void deleteResourceReferenceLocked(void* resource, ResourceReference* ref);
118 
119     void incrementRefcount(void* resource, ResourceType resourceType);
120     void incrementRefcountLocked(void* resource, ResourceType resourceType);
121 
122     void decrementRefcount(void* resource);
123     void decrementRefcountLocked(void* resource);
124 
125     void logCache();
126 
127     /**
128      * Used to increment, decrement, and destroy. Incrementing is generally accessed on the UI
129      * thread, but destroying resources may be called from the GC thread, the finalizer thread,
130      * or a reference queue finalization thread.
131      */
132     mutable Mutex mLock;
133 
134     KeyedVector<void*, ResourceReference*>* mCache;
135 };
136 
137 }; // namespace uirenderer
138 }; // namespace android
139 
140 #endif // ANDROID_HWUI_RESOURCE_CACHE_H
141