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 
24 #include <utils/KeyedVector.h>
25 #include <utils/Singleton.h>
26 
27 #include <androidfw/ResourceTypes.h>
28 
29 #include "Layer.h"
30 
31 namespace android {
32 namespace uirenderer {
33 
34 /**
35  * Type of Resource being cached
36  */
37 enum ResourceType {
38     kBitmap,
39     kNinePatch,
40     kPath
41 };
42 
43 class ResourceReference {
44 public:
45 
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: public Singleton<ResourceCache> {
57     ResourceCache();
58     ~ResourceCache();
59 
60     friend class Singleton<ResourceCache>;
61 
62 public:
63 
64     /**
65      * When using these two methods, make sure to only invoke the *Locked()
66      * variants of increment/decrementRefcount(), recyle() and destructor()
67      */
68     void lock();
69     void unlock();
70 
71     void incrementRefcount(const SkPath* resource);
72     void incrementRefcount(const SkBitmap* resource);
73     void incrementRefcount(const Res_png_9patch* resource);
74 
75     void incrementRefcountLocked(const SkPath* resource);
76     void incrementRefcountLocked(const SkBitmap* resource);
77     void incrementRefcountLocked(const Res_png_9patch* resource);
78 
79     void decrementRefcount(const SkBitmap* resource);
80     void decrementRefcount(const SkPath* resource);
81     void decrementRefcount(const Res_png_9patch* resource);
82 
83     void decrementRefcountLocked(const SkBitmap* resource);
84     void decrementRefcountLocked(const SkPath* resource);
85     void decrementRefcountLocked(const Res_png_9patch* resource);
86 
87     void destructor(SkPath* resource);
88     void destructor(const SkBitmap* resource);
89     void destructor(Res_png_9patch* resource);
90 
91     void destructorLocked(SkPath* resource);
92     void destructorLocked(const SkBitmap* resource);
93     void destructorLocked(Res_png_9patch* resource);
94 
95     bool recycle(SkBitmap* resource);
96     bool recycleLocked(SkBitmap* resource);
97 
98 private:
99     void deleteResourceReferenceLocked(const void* resource, ResourceReference* ref);
100 
101     void incrementRefcount(void* resource, ResourceType resourceType);
102     void incrementRefcountLocked(void* resource, ResourceType resourceType);
103 
104     void decrementRefcount(void* resource);
105     void decrementRefcountLocked(void* resource);
106 
107     void logCache();
108 
109     /**
110      * Used to increment, decrement, and destroy. Incrementing is generally accessed on the UI
111      * thread, but destroying resources may be called from the GC thread, the finalizer thread,
112      * or a reference queue finalization thread.
113      */
114     mutable Mutex mLock;
115 
116     KeyedVector<const void*, ResourceReference*>* mCache;
117 };
118 
119 }; // namespace uirenderer
120 }; // namespace android
121 
122 #endif // ANDROID_HWUI_RESOURCE_CACHE_H
123