Home | History | Annotate | Download | only in hwui 
      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 
     50     ResourceReference() { refCount = 0; recycled = false; destroyed = false;}
     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