Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit c7d9d279 authored by Masanori Ogino's avatar Masanori Ogino
Browse files

Fix the problem that color drawable cache key conflicts another drawable one. 

The cache key of a color drawable resource may be the same as another
drawable resource's value.

Change-Id: Ia971bb242ceac5e8f9346094009a10f356399ab9
(Reduced duplicated codes and replace TAB to white spaces)

And try to fix compile error.
parent 4696f2fb

core/java/android/content/res/Resources.java

100644 → 100755
+69 −38
Original line number Diff line number Diff line
@@ -25,6 +25,7 @@ import org.xmlpull.v1.XmlPullParserException; 
import android.graphics.Movie;

import android.graphics.drawable.Drawable;

import android.graphics.drawable.ColorDrawable;

import android.graphics.drawable.Drawable.ConstantState;

import android.os.Build;

import android.os.Bundle;

import android.os.SystemProperties;
@@ -66,6 +67,8 @@ public class Resources { 
            = new LongSparseArray<Drawable.ConstantState>();

    private static final SparseArray<ColorStateList> mPreloadedColorStateLists

            = new SparseArray<ColorStateList>();

    private static final LongSparseArray<Drawable.ConstantState> sPreloadedColorDrawables

            = new LongSparseArray<Drawable.ConstantState>();

    private static boolean mPreloaded;



    /*package*/ final TypedValue mTmpValue = new TypedValue();
@@ -75,6 +78,8 @@ public class Resources { 
            = new LongSparseArray<WeakReference<Drawable.ConstantState> >();

    private final SparseArray<WeakReference<ColorStateList> > mColorStateListCache

            = new SparseArray<WeakReference<ColorStateList> >();

    private final LongSparseArray<WeakReference<Drawable.ConstantState> > mColorDrawableCache

            = new LongSparseArray<WeakReference<Drawable.ConstantState> >();

    private boolean mPreloading;



    /*package*/ TypedArray mCachedStyledAttributes = null;
@@ -1299,13 +1304,32 @@ public class Resources { 
                    (int)(mMetrics.density*160), mConfiguration.keyboard,

                    keyboardHidden, mConfiguration.navigation, width, height,

                    mConfiguration.screenLayout, mConfiguration.uiMode, sSdkVersion);

            int N = mDrawableCache.size();



            drawableCacheClear(mDrawableCache, configChanges);

            drawableCacheClear(mColorDrawableCache, configChanges);



            mColorStateListCache.clear();





            flushLayoutCache();

        }

        synchronized (mSync) {

            if (mPluralRule != null) {

                mPluralRule = PluralRules.ruleForLocale(config.locale);

            }

        }

    }



    private void drawableCacheClear(

            LongSparseArray<WeakReference<ConstantState>> cache,

            int configChanges) {

        int N = cache.size();

        if (DEBUG_CONFIG) {

            Log.d(TAG, "Cleaning up drawables config changes: 0x"

                    + Integer.toHexString(configChanges));

        }

        for (int i=0; i<N; i++) {

                WeakReference<Drawable.ConstantState> ref = mDrawableCache.valueAt(i);

            WeakReference<Drawable.ConstantState> ref = cache.valueAt(i);

            if (ref != null) {

                Drawable.ConstantState cs = ref.get();

                if (cs != null) {
@@ -1317,10 +1341,10 @@ public class Resources { 
                                    + " / " + cs + " with changes: 0x"

                                    + Integer.toHexString(cs.getChangingConfigurations()));

                        }

                            mDrawableCache.setValueAt(i, null);

                        cache.setValueAt(i, null);

                    } else if (DEBUG_CONFIG) {

                        Log.d(TAG, "(Keeping #0x"

                                    + Long.toHexString(mDrawableCache.keyAt(i))

                                + Long.toHexString(cache.keyAt(i))

                                + " / " + cs + " with changes: 0x"

                                + Integer.toHexString(cs.getChangingConfigurations())

                                + ")");
@@ -1328,15 +1352,7 @@ public class Resources { 
                }

            }

        }

            mDrawableCache.clear();

            mColorStateListCache.clear();

            flushLayoutCache();

        }

        synchronized (mSync) {

            if (mPluralRule != null) {

                mPluralRule = PluralRules.ruleForLocale(config.locale);

            }

        }

        cache.clear();

    }



    /**
@@ -1661,13 +1677,18 @@ public class Resources { 
        }



        final long key = (((long) value.assetCookie) << 32) | value.data;

        Drawable dr = getCachedDrawable(key);

        boolean isColorDrawable = false;

        if (value.type >= TypedValue.TYPE_FIRST_COLOR_INT &&

                value.type <= TypedValue.TYPE_LAST_COLOR_INT) {

            isColorDrawable = true;

        }

        Drawable dr = getCachedDrawable(isColorDrawable ? mColorDrawableCache : mDrawableCache, key);



        if (dr != null) {

            return dr;

        }



        Drawable.ConstantState cs = sPreloadedDrawables.get(key);

        Drawable.ConstantState cs = isColorDrawable ? sPreloadedColorDrawables.get(key) : sPreloadedDrawables.get(key);

        if (cs != null) {

            dr = cs.newDrawable(this);

        } else {
@@ -1726,34 +1747,44 @@ public class Resources { 
            cs = dr.getConstantState();

            if (cs != null) {

                if (mPreloading) {

                    if (isColorDrawable) {

                        sPreloadedColorDrawables.put(key, cs);

                    } else {

                        sPreloadedDrawables.put(key, cs);

                    }

                } else {

                    synchronized (mTmpValue) {

                        //Log.i(TAG, "Saving cached drawable @ #" +

                        //        Integer.toHexString(key.intValue())

                        //        + " in " + this + ": " + cs);

                        if (isColorDrawable) {

                            mColorDrawableCache.put(key, new WeakReference<Drawable.ConstantState>(cs));

                        } else {

                            mDrawableCache.put(key, new WeakReference<Drawable.ConstantState>(cs));

                        }

                    }

                }

            }

        }



        return dr;

    }



    private Drawable getCachedDrawable(long key) {

    private Drawable getCachedDrawable(

            LongSparseArray<WeakReference<ConstantState>> drawableCache,

            long key) {

        synchronized (mTmpValue) {

            WeakReference<Drawable.ConstantState> wr = mDrawableCache.get(key);

            WeakReference<Drawable.ConstantState> wr = drawableCache.get(key);

            if (wr != null) {   // we have the key

                Drawable.ConstantState entry = wr.get();

                if (entry != null) {

                    //Log.i(TAG, "Returning cached drawable @ #" +

                    //        Integer.toHexString(((Integer)key).intValue())

                    //        + " in " + this + ": " + entry);

                    return entry.newDrawable(this);

                    return entry.newDrawable();

                }

                else {  // our entry has been purged

                    mDrawableCache.delete(key);

                    drawableCache.delete(key);

                }

            }

        }