460 lines
20 KiB
Java
460 lines
20 KiB
Java
package androidx.appcompat.widget;
|
|
|
|
import android.content.Context;
|
|
import android.content.res.ColorStateList;
|
|
import android.content.res.Resources;
|
|
import android.content.res.XmlResourceParser;
|
|
import android.graphics.PorterDuff;
|
|
import android.graphics.PorterDuffColorFilter;
|
|
import android.graphics.drawable.Drawable;
|
|
import android.graphics.drawable.LayerDrawable;
|
|
import android.os.Build;
|
|
import android.util.AttributeSet;
|
|
import android.util.Log;
|
|
import android.util.TypedValue;
|
|
import android.util.Xml;
|
|
import androidx.appcompat.graphics.drawable.AnimatedStateListDrawableCompat;
|
|
import androidx.appcompat.resources.Compatibility;
|
|
import androidx.appcompat.resources.R;
|
|
import androidx.collection.LongSparseArray;
|
|
import androidx.collection.LruCache;
|
|
import androidx.collection.SimpleArrayMap;
|
|
import androidx.collection.SparseArrayCompat;
|
|
import androidx.core.content.ContextCompat;
|
|
import androidx.core.graphics.drawable.DrawableCompat;
|
|
import androidx.vectordrawable.graphics.drawable.AnimatedVectorDrawableCompat;
|
|
import androidx.vectordrawable.graphics.drawable.VectorDrawableCompat;
|
|
import java.lang.ref.WeakReference;
|
|
import java.util.WeakHashMap;
|
|
import org.xmlpull.v1.XmlPullParser;
|
|
import org.xmlpull.v1.XmlPullParserException;
|
|
|
|
/* loaded from: classes.dex */
|
|
public final class ResourceManagerInternal {
|
|
private static final boolean DEBUG = false;
|
|
private static ResourceManagerInternal INSTANCE = null;
|
|
private static final String PLATFORM_VD_CLAZZ = "android.graphics.drawable.VectorDrawable";
|
|
private static final String SKIP_DRAWABLE_TAG = "appcompat_skip_skip";
|
|
private static final String TAG = "ResourceManagerInternal";
|
|
private SimpleArrayMap<String, InflateDelegate> mDelegates;
|
|
private final WeakHashMap<Context, LongSparseArray<WeakReference<Drawable.ConstantState>>> mDrawableCaches = new WeakHashMap<>(0);
|
|
private boolean mHasCheckedVectorDrawableSetup;
|
|
private ResourceManagerHooks mHooks;
|
|
private SparseArrayCompat<String> mKnownDrawableIdTags;
|
|
private WeakHashMap<Context, SparseArrayCompat<ColorStateList>> mTintLists;
|
|
private TypedValue mTypedValue;
|
|
private static final PorterDuff.Mode DEFAULT_MODE = PorterDuff.Mode.SRC_IN;
|
|
private static final ColorFilterLruCache COLOR_FILTER_CACHE = new ColorFilterLruCache(6);
|
|
|
|
private interface InflateDelegate {
|
|
Drawable createFromXmlInner(Context context, XmlPullParser xmlPullParser, AttributeSet attributeSet, Resources.Theme theme);
|
|
}
|
|
|
|
public interface ResourceManagerHooks {
|
|
Drawable createDrawableFor(ResourceManagerInternal resourceManagerInternal, Context context, int i);
|
|
|
|
ColorStateList getTintListForDrawableRes(Context context, int i);
|
|
|
|
PorterDuff.Mode getTintModeForDrawableRes(int i);
|
|
|
|
boolean tintDrawable(Context context, int i, Drawable drawable);
|
|
|
|
boolean tintDrawableUsingColorFilter(Context context, int i, Drawable drawable);
|
|
}
|
|
|
|
public static synchronized ResourceManagerInternal get() {
|
|
ResourceManagerInternal resourceManagerInternal;
|
|
synchronized (ResourceManagerInternal.class) {
|
|
if (INSTANCE == null) {
|
|
ResourceManagerInternal resourceManagerInternal2 = new ResourceManagerInternal();
|
|
INSTANCE = resourceManagerInternal2;
|
|
installDefaultInflateDelegates(resourceManagerInternal2);
|
|
}
|
|
resourceManagerInternal = INSTANCE;
|
|
}
|
|
return resourceManagerInternal;
|
|
}
|
|
|
|
private static void installDefaultInflateDelegates(ResourceManagerInternal resourceManagerInternal) {
|
|
if (Build.VERSION.SDK_INT < 24) {
|
|
resourceManagerInternal.addDelegate("vector", new VdcInflateDelegate());
|
|
resourceManagerInternal.addDelegate("animated-vector", new AvdcInflateDelegate());
|
|
resourceManagerInternal.addDelegate("animated-selector", new AsldcInflateDelegate());
|
|
resourceManagerInternal.addDelegate("drawable", new DrawableDelegate());
|
|
}
|
|
}
|
|
|
|
public synchronized void setHooks(ResourceManagerHooks resourceManagerHooks) {
|
|
this.mHooks = resourceManagerHooks;
|
|
}
|
|
|
|
public synchronized Drawable getDrawable(Context context, int i) {
|
|
return getDrawable(context, i, false);
|
|
}
|
|
|
|
synchronized Drawable getDrawable(Context context, int i, boolean z) {
|
|
Drawable loadDrawableFromDelegates;
|
|
checkVectorDrawableSetup(context);
|
|
loadDrawableFromDelegates = loadDrawableFromDelegates(context, i);
|
|
if (loadDrawableFromDelegates == null) {
|
|
loadDrawableFromDelegates = createDrawableIfNeeded(context, i);
|
|
}
|
|
if (loadDrawableFromDelegates == null) {
|
|
loadDrawableFromDelegates = ContextCompat.getDrawable(context, i);
|
|
}
|
|
if (loadDrawableFromDelegates != null) {
|
|
loadDrawableFromDelegates = tintDrawable(context, i, z, loadDrawableFromDelegates);
|
|
}
|
|
if (loadDrawableFromDelegates != null) {
|
|
DrawableUtils.fixDrawable(loadDrawableFromDelegates);
|
|
}
|
|
return loadDrawableFromDelegates;
|
|
}
|
|
|
|
public synchronized void onConfigurationChanged(Context context) {
|
|
LongSparseArray<WeakReference<Drawable.ConstantState>> longSparseArray = this.mDrawableCaches.get(context);
|
|
if (longSparseArray != null) {
|
|
longSparseArray.clear();
|
|
}
|
|
}
|
|
|
|
private static long createCacheKey(TypedValue typedValue) {
|
|
return (typedValue.assetCookie << 32) | typedValue.data;
|
|
}
|
|
|
|
private Drawable createDrawableIfNeeded(Context context, int i) {
|
|
if (this.mTypedValue == null) {
|
|
this.mTypedValue = new TypedValue();
|
|
}
|
|
TypedValue typedValue = this.mTypedValue;
|
|
context.getResources().getValue(i, typedValue, true);
|
|
long createCacheKey = createCacheKey(typedValue);
|
|
Drawable cachedDrawable = getCachedDrawable(context, createCacheKey);
|
|
if (cachedDrawable != null) {
|
|
return cachedDrawable;
|
|
}
|
|
ResourceManagerHooks resourceManagerHooks = this.mHooks;
|
|
Drawable createDrawableFor = resourceManagerHooks == null ? null : resourceManagerHooks.createDrawableFor(this, context, i);
|
|
if (createDrawableFor != null) {
|
|
createDrawableFor.setChangingConfigurations(typedValue.changingConfigurations);
|
|
addDrawableToCache(context, createCacheKey, createDrawableFor);
|
|
}
|
|
return createDrawableFor;
|
|
}
|
|
|
|
private Drawable tintDrawable(Context context, int i, boolean z, Drawable drawable) {
|
|
ColorStateList tintList = getTintList(context, i);
|
|
if (tintList != null) {
|
|
if (DrawableUtils.canSafelyMutateDrawable(drawable)) {
|
|
drawable = drawable.mutate();
|
|
}
|
|
Drawable wrap = DrawableCompat.wrap(drawable);
|
|
DrawableCompat.setTintList(wrap, tintList);
|
|
PorterDuff.Mode tintMode = getTintMode(i);
|
|
if (tintMode == null) {
|
|
return wrap;
|
|
}
|
|
DrawableCompat.setTintMode(wrap, tintMode);
|
|
return wrap;
|
|
}
|
|
ResourceManagerHooks resourceManagerHooks = this.mHooks;
|
|
if ((resourceManagerHooks == null || !resourceManagerHooks.tintDrawable(context, i, drawable)) && !tintDrawableUsingColorFilter(context, i, drawable) && z) {
|
|
return null;
|
|
}
|
|
return drawable;
|
|
}
|
|
|
|
private Drawable loadDrawableFromDelegates(Context context, int i) {
|
|
int next;
|
|
SimpleArrayMap<String, InflateDelegate> simpleArrayMap = this.mDelegates;
|
|
if (simpleArrayMap == null || simpleArrayMap.isEmpty()) {
|
|
return null;
|
|
}
|
|
SparseArrayCompat<String> sparseArrayCompat = this.mKnownDrawableIdTags;
|
|
if (sparseArrayCompat != null) {
|
|
String str = sparseArrayCompat.get(i);
|
|
if (SKIP_DRAWABLE_TAG.equals(str) || (str != null && this.mDelegates.get(str) == null)) {
|
|
return null;
|
|
}
|
|
} else {
|
|
this.mKnownDrawableIdTags = new SparseArrayCompat<>();
|
|
}
|
|
if (this.mTypedValue == null) {
|
|
this.mTypedValue = new TypedValue();
|
|
}
|
|
TypedValue typedValue = this.mTypedValue;
|
|
Resources resources = context.getResources();
|
|
resources.getValue(i, typedValue, true);
|
|
long createCacheKey = createCacheKey(typedValue);
|
|
Drawable cachedDrawable = getCachedDrawable(context, createCacheKey);
|
|
if (cachedDrawable != null) {
|
|
return cachedDrawable;
|
|
}
|
|
if (typedValue.string != null && typedValue.string.toString().endsWith(".xml")) {
|
|
try {
|
|
XmlResourceParser xml = resources.getXml(i);
|
|
AttributeSet asAttributeSet = Xml.asAttributeSet(xml);
|
|
do {
|
|
next = xml.next();
|
|
if (next == 2) {
|
|
break;
|
|
}
|
|
} while (next != 1);
|
|
if (next != 2) {
|
|
throw new XmlPullParserException("No start tag found");
|
|
}
|
|
String name = xml.getName();
|
|
this.mKnownDrawableIdTags.append(i, name);
|
|
InflateDelegate inflateDelegate = this.mDelegates.get(name);
|
|
if (inflateDelegate != null) {
|
|
cachedDrawable = inflateDelegate.createFromXmlInner(context, xml, asAttributeSet, context.getTheme());
|
|
}
|
|
if (cachedDrawable != null) {
|
|
cachedDrawable.setChangingConfigurations(typedValue.changingConfigurations);
|
|
addDrawableToCache(context, createCacheKey, cachedDrawable);
|
|
}
|
|
} catch (Exception e) {
|
|
Log.e(TAG, "Exception while inflating drawable", e);
|
|
}
|
|
}
|
|
if (cachedDrawable == null) {
|
|
this.mKnownDrawableIdTags.append(i, SKIP_DRAWABLE_TAG);
|
|
}
|
|
return cachedDrawable;
|
|
}
|
|
|
|
private synchronized Drawable getCachedDrawable(Context context, long j) {
|
|
LongSparseArray<WeakReference<Drawable.ConstantState>> longSparseArray = this.mDrawableCaches.get(context);
|
|
if (longSparseArray == null) {
|
|
return null;
|
|
}
|
|
WeakReference<Drawable.ConstantState> weakReference = longSparseArray.get(j);
|
|
if (weakReference != null) {
|
|
Drawable.ConstantState constantState = weakReference.get();
|
|
if (constantState != null) {
|
|
return constantState.newDrawable(context.getResources());
|
|
}
|
|
longSparseArray.remove(j);
|
|
}
|
|
return null;
|
|
}
|
|
|
|
private synchronized boolean addDrawableToCache(Context context, long j, Drawable drawable) {
|
|
Drawable.ConstantState constantState = drawable.getConstantState();
|
|
if (constantState == null) {
|
|
return false;
|
|
}
|
|
LongSparseArray<WeakReference<Drawable.ConstantState>> longSparseArray = this.mDrawableCaches.get(context);
|
|
if (longSparseArray == null) {
|
|
longSparseArray = new LongSparseArray<>();
|
|
this.mDrawableCaches.put(context, longSparseArray);
|
|
}
|
|
longSparseArray.put(j, new WeakReference<>(constantState));
|
|
return true;
|
|
}
|
|
|
|
synchronized Drawable onDrawableLoadedFromResources(Context context, VectorEnabledTintResources vectorEnabledTintResources, int i) {
|
|
Drawable loadDrawableFromDelegates = loadDrawableFromDelegates(context, i);
|
|
if (loadDrawableFromDelegates == null) {
|
|
loadDrawableFromDelegates = vectorEnabledTintResources.getDrawableCanonical(i);
|
|
}
|
|
if (loadDrawableFromDelegates == null) {
|
|
return null;
|
|
}
|
|
return tintDrawable(context, i, false, loadDrawableFromDelegates);
|
|
}
|
|
|
|
boolean tintDrawableUsingColorFilter(Context context, int i, Drawable drawable) {
|
|
ResourceManagerHooks resourceManagerHooks = this.mHooks;
|
|
return resourceManagerHooks != null && resourceManagerHooks.tintDrawableUsingColorFilter(context, i, drawable);
|
|
}
|
|
|
|
private void addDelegate(String str, InflateDelegate inflateDelegate) {
|
|
if (this.mDelegates == null) {
|
|
this.mDelegates = new SimpleArrayMap<>();
|
|
}
|
|
this.mDelegates.put(str, inflateDelegate);
|
|
}
|
|
|
|
PorterDuff.Mode getTintMode(int i) {
|
|
ResourceManagerHooks resourceManagerHooks = this.mHooks;
|
|
if (resourceManagerHooks == null) {
|
|
return null;
|
|
}
|
|
return resourceManagerHooks.getTintModeForDrawableRes(i);
|
|
}
|
|
|
|
synchronized ColorStateList getTintList(Context context, int i) {
|
|
ColorStateList tintListFromCache;
|
|
tintListFromCache = getTintListFromCache(context, i);
|
|
if (tintListFromCache == null) {
|
|
ResourceManagerHooks resourceManagerHooks = this.mHooks;
|
|
tintListFromCache = resourceManagerHooks == null ? null : resourceManagerHooks.getTintListForDrawableRes(context, i);
|
|
if (tintListFromCache != null) {
|
|
addTintListToCache(context, i, tintListFromCache);
|
|
}
|
|
}
|
|
return tintListFromCache;
|
|
}
|
|
|
|
private ColorStateList getTintListFromCache(Context context, int i) {
|
|
SparseArrayCompat<ColorStateList> sparseArrayCompat;
|
|
WeakHashMap<Context, SparseArrayCompat<ColorStateList>> weakHashMap = this.mTintLists;
|
|
if (weakHashMap == null || (sparseArrayCompat = weakHashMap.get(context)) == null) {
|
|
return null;
|
|
}
|
|
return sparseArrayCompat.get(i);
|
|
}
|
|
|
|
private void addTintListToCache(Context context, int i, ColorStateList colorStateList) {
|
|
if (this.mTintLists == null) {
|
|
this.mTintLists = new WeakHashMap<>();
|
|
}
|
|
SparseArrayCompat<ColorStateList> sparseArrayCompat = this.mTintLists.get(context);
|
|
if (sparseArrayCompat == null) {
|
|
sparseArrayCompat = new SparseArrayCompat<>();
|
|
this.mTintLists.put(context, sparseArrayCompat);
|
|
}
|
|
sparseArrayCompat.append(i, colorStateList);
|
|
}
|
|
|
|
private static class ColorFilterLruCache extends LruCache<Integer, PorterDuffColorFilter> {
|
|
public ColorFilterLruCache(int i) {
|
|
super(i);
|
|
}
|
|
|
|
PorterDuffColorFilter get(int i, PorterDuff.Mode mode) {
|
|
return get(Integer.valueOf(generateCacheKey(i, mode)));
|
|
}
|
|
|
|
PorterDuffColorFilter put(int i, PorterDuff.Mode mode, PorterDuffColorFilter porterDuffColorFilter) {
|
|
return put(Integer.valueOf(generateCacheKey(i, mode)), porterDuffColorFilter);
|
|
}
|
|
|
|
private static int generateCacheKey(int i, PorterDuff.Mode mode) {
|
|
return ((i + 31) * 31) + mode.hashCode();
|
|
}
|
|
}
|
|
|
|
static void tintDrawable(Drawable drawable, TintInfo tintInfo, int[] iArr) {
|
|
int[] state = drawable.getState();
|
|
if (DrawableUtils.canSafelyMutateDrawable(drawable) && drawable.mutate() != drawable) {
|
|
Log.d(TAG, "Mutated drawable is not the same instance as the input.");
|
|
return;
|
|
}
|
|
if ((drawable instanceof LayerDrawable) && drawable.isStateful()) {
|
|
drawable.setState(new int[0]);
|
|
drawable.setState(state);
|
|
}
|
|
if (tintInfo.mHasTintList || tintInfo.mHasTintMode) {
|
|
drawable.setColorFilter(createTintFilter(tintInfo.mHasTintList ? tintInfo.mTintList : null, tintInfo.mHasTintMode ? tintInfo.mTintMode : DEFAULT_MODE, iArr));
|
|
} else {
|
|
drawable.clearColorFilter();
|
|
}
|
|
if (Build.VERSION.SDK_INT <= 23) {
|
|
drawable.invalidateSelf();
|
|
}
|
|
}
|
|
|
|
private static PorterDuffColorFilter createTintFilter(ColorStateList colorStateList, PorterDuff.Mode mode, int[] iArr) {
|
|
if (colorStateList == null || mode == null) {
|
|
return null;
|
|
}
|
|
return getPorterDuffColorFilter(colorStateList.getColorForState(iArr, 0), mode);
|
|
}
|
|
|
|
public static synchronized PorterDuffColorFilter getPorterDuffColorFilter(int i, PorterDuff.Mode mode) {
|
|
PorterDuffColorFilter porterDuffColorFilter;
|
|
synchronized (ResourceManagerInternal.class) {
|
|
ColorFilterLruCache colorFilterLruCache = COLOR_FILTER_CACHE;
|
|
porterDuffColorFilter = colorFilterLruCache.get(i, mode);
|
|
if (porterDuffColorFilter == null) {
|
|
porterDuffColorFilter = new PorterDuffColorFilter(i, mode);
|
|
colorFilterLruCache.put(i, mode, porterDuffColorFilter);
|
|
}
|
|
}
|
|
return porterDuffColorFilter;
|
|
}
|
|
|
|
private void checkVectorDrawableSetup(Context context) {
|
|
if (this.mHasCheckedVectorDrawableSetup) {
|
|
return;
|
|
}
|
|
this.mHasCheckedVectorDrawableSetup = true;
|
|
Drawable drawable = getDrawable(context, R.drawable.abc_vector_test);
|
|
if (drawable == null || !isVectorDrawable(drawable)) {
|
|
this.mHasCheckedVectorDrawableSetup = false;
|
|
throw new IllegalStateException("This app has been built with an incorrect configuration. Please configure your build for VectorDrawableCompat.");
|
|
}
|
|
}
|
|
|
|
private static boolean isVectorDrawable(Drawable drawable) {
|
|
return (drawable instanceof VectorDrawableCompat) || PLATFORM_VD_CLAZZ.equals(drawable.getClass().getName());
|
|
}
|
|
|
|
private static class VdcInflateDelegate implements InflateDelegate {
|
|
VdcInflateDelegate() {
|
|
}
|
|
|
|
@Override // androidx.appcompat.widget.ResourceManagerInternal.InflateDelegate
|
|
public Drawable createFromXmlInner(Context context, XmlPullParser xmlPullParser, AttributeSet attributeSet, Resources.Theme theme) {
|
|
try {
|
|
return VectorDrawableCompat.createFromXmlInner(context.getResources(), xmlPullParser, attributeSet, theme);
|
|
} catch (Exception e) {
|
|
Log.e("VdcInflateDelegate", "Exception while inflating <vector>", e);
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
|
|
private static class AvdcInflateDelegate implements InflateDelegate {
|
|
AvdcInflateDelegate() {
|
|
}
|
|
|
|
@Override // androidx.appcompat.widget.ResourceManagerInternal.InflateDelegate
|
|
public Drawable createFromXmlInner(Context context, XmlPullParser xmlPullParser, AttributeSet attributeSet, Resources.Theme theme) {
|
|
try {
|
|
return AnimatedVectorDrawableCompat.createFromXmlInner(context, context.getResources(), xmlPullParser, attributeSet, theme);
|
|
} catch (Exception e) {
|
|
Log.e("AvdcInflateDelegate", "Exception while inflating <animated-vector>", e);
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
|
|
static class AsldcInflateDelegate implements InflateDelegate {
|
|
AsldcInflateDelegate() {
|
|
}
|
|
|
|
@Override // androidx.appcompat.widget.ResourceManagerInternal.InflateDelegate
|
|
public Drawable createFromXmlInner(Context context, XmlPullParser xmlPullParser, AttributeSet attributeSet, Resources.Theme theme) {
|
|
try {
|
|
return AnimatedStateListDrawableCompat.createFromXmlInner(context, context.getResources(), xmlPullParser, attributeSet, theme);
|
|
} catch (Exception e) {
|
|
Log.e("AsldcInflateDelegate", "Exception while inflating <animated-selector>", e);
|
|
return null;
|
|
}
|
|
}
|
|
}
|
|
|
|
static class DrawableDelegate implements InflateDelegate {
|
|
DrawableDelegate() {
|
|
}
|
|
|
|
@Override // androidx.appcompat.widget.ResourceManagerInternal.InflateDelegate
|
|
public Drawable createFromXmlInner(Context context, XmlPullParser xmlPullParser, AttributeSet attributeSet, Resources.Theme theme) {
|
|
String classAttribute = attributeSet.getClassAttribute();
|
|
if (classAttribute != null) {
|
|
try {
|
|
Drawable drawable = (Drawable) DrawableDelegate.class.getClassLoader().loadClass(classAttribute).asSubclass(Drawable.class).getDeclaredConstructor(new Class[0]).newInstance(new Object[0]);
|
|
Compatibility.Api21Impl.inflate(drawable, context.getResources(), xmlPullParser, attributeSet, theme);
|
|
return drawable;
|
|
} catch (Exception e) {
|
|
Log.e("DrawableDelegate", "Exception while inflating <drawable>", e);
|
|
}
|
|
}
|
|
return null;
|
|
}
|
|
}
|
|
}
|