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#include "ResourceCache.h"
18#include "Caches.h"
19
20namespace android {
21
22using namespace uirenderer;
23ANDROID_SINGLETON_STATIC_INSTANCE(ResourceCache);
24
25namespace uirenderer {
26
27///////////////////////////////////////////////////////////////////////////////
28// Resource cache
29///////////////////////////////////////////////////////////////////////////////
30
31void ResourceCache::logCache() {
32    ALOGD("ResourceCache: cacheReport:");
33    for (size_t i = 0; i < mCache->size(); ++i) {
34        ResourceReference* ref = mCache->valueAt(i);
35        ALOGD("  ResourceCache: mCache(%zu): resource, ref = 0x%p, 0x%p",
36                i, mCache->keyAt(i), mCache->valueAt(i));
37        ALOGD("  ResourceCache: mCache(%zu): refCount, destroyed, type = %d, %d, %d",
38                i, ref->refCount, ref->destroyed, ref->resourceType);
39    }
40}
41
42ResourceCache::ResourceCache() {
43    Mutex::Autolock _l(mLock);
44    mCache = new KeyedVector<const void*, ResourceReference*>();
45}
46
47ResourceCache::~ResourceCache() {
48    Mutex::Autolock _l(mLock);
49    delete mCache;
50}
51
52void ResourceCache::lock() {
53    mLock.lock();
54}
55
56void ResourceCache::unlock() {
57    mLock.unlock();
58}
59
60void ResourceCache::incrementRefcount(void* resource, ResourceType resourceType) {
61    Mutex::Autolock _l(mLock);
62    incrementRefcountLocked(resource, resourceType);
63}
64
65void ResourceCache::incrementRefcount(const Res_png_9patch* patchResource) {
66    incrementRefcount((void*) patchResource, kNinePatch);
67}
68
69void ResourceCache::incrementRefcountLocked(void* resource, ResourceType resourceType) {
70    ssize_t index = mCache->indexOfKey(resource);
71    ResourceReference* ref = index >= 0 ? mCache->valueAt(index) : nullptr;
72    if (ref == nullptr || mCache->size() == 0) {
73        ref = new ResourceReference(resourceType);
74        mCache->add(resource, ref);
75    }
76    ref->refCount++;
77}
78
79void ResourceCache::decrementRefcount(void* resource) {
80    Mutex::Autolock _l(mLock);
81    decrementRefcountLocked(resource);
82}
83
84void ResourceCache::decrementRefcount(const Res_png_9patch* patchResource) {
85    decrementRefcount((void*) patchResource);
86}
87
88void ResourceCache::decrementRefcountLocked(void* resource) {
89    ssize_t index = mCache->indexOfKey(resource);
90    ResourceReference* ref = index >= 0 ? mCache->valueAt(index) : nullptr;
91    if (ref == nullptr) {
92        // Should not get here - shouldn't get a call to decrement if we're not yet tracking it
93        return;
94    }
95    ref->refCount--;
96    if (ref->refCount == 0) {
97        deleteResourceReferenceLocked(resource, ref);
98    }
99}
100
101void ResourceCache::decrementRefcountLocked(const Res_png_9patch* patchResource) {
102    decrementRefcountLocked((void*) patchResource);
103}
104
105void ResourceCache::destructor(Res_png_9patch* resource) {
106    Mutex::Autolock _l(mLock);
107    destructorLocked(resource);
108}
109
110void ResourceCache::destructorLocked(Res_png_9patch* resource) {
111    ssize_t index = mCache->indexOfKey(resource);
112    ResourceReference* ref = index >= 0 ? mCache->valueAt(index) : nullptr;
113    if (ref == nullptr) {
114        // If we're not tracking this resource, just delete it
115        if (Caches::hasInstance()) {
116            Caches::getInstance().patchCache.removeDeferred(resource);
117        } else {
118            // A Res_png_9patch is actually an array of byte that's larger
119            // than sizeof(Res_png_9patch). It must be freed as an array.
120            delete[] (int8_t*) resource;
121        }
122        return;
123    }
124    ref->destroyed = true;
125    if (ref->refCount == 0) {
126        deleteResourceReferenceLocked(resource, ref);
127    }
128}
129
130/**
131 * This method should only be called while the mLock mutex is held (that mutex is grabbed
132 * by the various destructor() and recycle() methods which call this method).
133 */
134void ResourceCache::deleteResourceReferenceLocked(const void* resource, ResourceReference* ref) {
135    if (ref->destroyed) {
136        switch (ref->resourceType) {
137            case kNinePatch: {
138                if (Caches::hasInstance()) {
139                    Caches::getInstance().patchCache.removeDeferred((Res_png_9patch*) resource);
140                } else {
141                    // A Res_png_9patch is actually an array of byte that's larger
142                    // than sizeof(Res_png_9patch). It must be freed as an array.
143                    int8_t* patch = (int8_t*) resource;
144                    delete[] patch;
145                }
146            }
147            break;
148        }
149    }
150    mCache->removeItem(resource);
151    delete ref;
152}
153
154}; // namespace uirenderer
155}; // namespace android
156