Initial import of ADIF API reverse-engineering toolkit

apk_decompiled/sources/androidx/core/app/CoreComponentFactory.java

@@ -0,0 +1,41 @@
+package androidx.core.app;
+
+import android.app.Activity;
+import android.app.AppComponentFactory;
+import android.app.Application;
+import android.app.Service;
+import android.content.BroadcastReceiver;
+import android.content.ContentProvider;
+import android.content.Intent;
+
+/* loaded from: classes.dex */
+public class CoreComponentFactory extends AppComponentFactory {
+    public static <T> T checkCompatWrapper(T t2) {
+        return t2;
+    }
+
+    @Override // android.app.AppComponentFactory
+    public Activity instantiateActivity(ClassLoader classLoader, String str, Intent intent) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
+        return (Activity) checkCompatWrapper(super.instantiateActivity(classLoader, str, intent));
+    }
+
+    @Override // android.app.AppComponentFactory
+    public Application instantiateApplication(ClassLoader classLoader, String str) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
+        return (Application) checkCompatWrapper(super.instantiateApplication(classLoader, str));
+    }
+
+    @Override // android.app.AppComponentFactory
+    public ContentProvider instantiateProvider(ClassLoader classLoader, String str) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
+        return (ContentProvider) checkCompatWrapper(super.instantiateProvider(classLoader, str));
+    }
+
+    @Override // android.app.AppComponentFactory
+    public BroadcastReceiver instantiateReceiver(ClassLoader classLoader, String str, Intent intent) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
+        return (BroadcastReceiver) checkCompatWrapper(super.instantiateReceiver(classLoader, str, intent));
+    }
+
+    @Override // android.app.AppComponentFactory
+    public Service instantiateService(ClassLoader classLoader, String str, Intent intent) throws InstantiationException, IllegalAccessException, ClassNotFoundException {
+        return (Service) checkCompatWrapper(super.instantiateService(classLoader, str, intent));
+    }
+}

apk_decompiled/sources/androidx/core/app/RemoteActionCompat.java

@@ -0,0 +1,27 @@
+package androidx.core.app;
+
+import D0.d;
+import android.app.PendingIntent;
+import androidx.core.graphics.drawable.IconCompat;
+
+/* loaded from: classes.dex */
+public final class RemoteActionCompat implements d {
+
+    /* renamed from: a, reason: collision with root package name */
+    public IconCompat f2777a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public CharSequence f2778b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public CharSequence f2779c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public PendingIntent f2780d;
+
+    /* renamed from: e, reason: collision with root package name */
+    public boolean f2781e;
+
+    /* renamed from: f, reason: collision with root package name */
+    public boolean f2782f;
+}

apk_decompiled/sources/androidx/core/app/RemoteActionCompatParcelizer.java

@@ -0,0 +1,69 @@
+package androidx.core.app;
+
+import D0.b;
+import D0.c;
+import D0.d;
+import android.app.PendingIntent;
+import android.os.Parcel;
+import android.text.TextUtils;
+import androidx.core.graphics.drawable.IconCompat;
+
+/* loaded from: classes.dex */
+public class RemoteActionCompatParcelizer {
+    public static RemoteActionCompat read(b bVar) {
+        RemoteActionCompat remoteActionCompat = new RemoteActionCompat();
+        d dVar = remoteActionCompat.f2777a;
+        boolean z3 = true;
+        if (bVar.e(1)) {
+            dVar = bVar.g();
+        }
+        remoteActionCompat.f2777a = (IconCompat) dVar;
+        CharSequence charSequence = remoteActionCompat.f2778b;
+        if (bVar.e(2)) {
+            charSequence = (CharSequence) TextUtils.CHAR_SEQUENCE_CREATOR.createFromParcel(((c) bVar).f365e);
+        }
+        remoteActionCompat.f2778b = charSequence;
+        CharSequence charSequence2 = remoteActionCompat.f2779c;
+        if (bVar.e(3)) {
+            charSequence2 = (CharSequence) TextUtils.CHAR_SEQUENCE_CREATOR.createFromParcel(((c) bVar).f365e);
+        }
+        remoteActionCompat.f2779c = charSequence2;
+        remoteActionCompat.f2780d = (PendingIntent) bVar.f(remoteActionCompat.f2780d, 4);
+        boolean z4 = remoteActionCompat.f2781e;
+        if (bVar.e(5)) {
+            z4 = ((c) bVar).f365e.readInt() != 0;
+        }
+        remoteActionCompat.f2781e = z4;
+        boolean z5 = remoteActionCompat.f2782f;
+        if (!bVar.e(6)) {
+            z3 = z5;
+        } else if (((c) bVar).f365e.readInt() == 0) {
+            z3 = false;
+        }
+        remoteActionCompat.f2782f = z3;
+        return remoteActionCompat;
+    }
+
+    public static void write(RemoteActionCompat remoteActionCompat, b bVar) {
+        bVar.getClass();
+        IconCompat iconCompat = remoteActionCompat.f2777a;
+        bVar.h(1);
+        bVar.i(iconCompat);
+        CharSequence charSequence = remoteActionCompat.f2778b;
+        bVar.h(2);
+        Parcel parcel = ((c) bVar).f365e;
+        TextUtils.writeToParcel(charSequence, parcel, 0);
+        CharSequence charSequence2 = remoteActionCompat.f2779c;
+        bVar.h(3);
+        TextUtils.writeToParcel(charSequence2, parcel, 0);
+        PendingIntent pendingIntent = remoteActionCompat.f2780d;
+        bVar.h(4);
+        parcel.writeParcelable(pendingIntent, 0);
+        boolean z3 = remoteActionCompat.f2781e;
+        bVar.h(5);
+        parcel.writeInt(z3 ? 1 : 0);
+        boolean z4 = remoteActionCompat.f2782f;
+        bVar.h(6);
+        parcel.writeInt(z4 ? 1 : 0);
+    }
+}

apk_decompiled/sources/androidx/core/content/FileProvider.java

@@ -0,0 +1,343 @@
+package androidx.core.content;
+
+import C.w;
+import D.h;
+import D.i;
+import D.j;
+import D.k;
+import android.annotation.SuppressLint;
+import android.content.ContentProvider;
+import android.content.ContentValues;
+import android.content.Context;
+import android.content.pm.ProviderInfo;
+import android.content.res.XmlResourceParser;
+import android.database.Cursor;
+import android.database.MatrixCursor;
+import android.net.Uri;
+import android.os.Bundle;
+import android.os.Environment;
+import android.os.ParcelFileDescriptor;
+import android.text.TextUtils;
+import android.webkit.MimeTypeMap;
+import com.adif.elcanomovil.widget.DefaultWidgetPayloadHandler;
+import com.google.firebase.analytics.FirebaseAnalytics;
+import com.google.firebase.sessions.settings.RemoteSettings;
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.util.HashMap;
+import java.util.Map;
+import org.xmlpull.v1.XmlPullParserException;
+
+/* loaded from: classes.dex */
+public class FileProvider extends ContentProvider {
+    private static final String ATTR_NAME = "name";
+    private static final String ATTR_PATH = "path";
+    private static final String DISPLAYNAME_FIELD = "displayName";
+    private static final String META_DATA_FILE_PROVIDER_PATHS = "android.support.FILE_PROVIDER_PATHS";
+    private static final String TAG_CACHE_PATH = "cache-path";
+    private static final String TAG_EXTERNAL = "external-path";
+    private static final String TAG_EXTERNAL_CACHE = "external-cache-path";
+    private static final String TAG_EXTERNAL_FILES = "external-files-path";
+    private static final String TAG_EXTERNAL_MEDIA = "external-media-path";
+    private static final String TAG_FILES_PATH = "files-path";
+    private static final String TAG_ROOT_PATH = "root-path";
+    private String mAuthority;
+    private j mLocalPathStrategy;
+    private final Object mLock;
+    private final int mResourceId;
+    private static final String[] COLUMNS = {"_display_name", "_size"};
+    private static final File DEVICE_ROOT = new File(RemoteSettings.FORWARD_SLASH_STRING);
+    private static final HashMap<String, j> sCache = new HashMap<>();
+
+    public FileProvider() {
+        this(0);
+    }
+
+    private static File buildPath(File file, String... strArr) {
+        for (String str : strArr) {
+            if (str != null) {
+                file = new File(file, str);
+            }
+        }
+        return file;
+    }
+
+    private static String[] copyOf(String[] strArr, int i) {
+        String[] strArr2 = new String[i];
+        System.arraycopy(strArr, 0, strArr2, 0, i);
+        return strArr2;
+    }
+
+    public static XmlResourceParser getFileProviderPathsMetaData(Context context, String str, ProviderInfo providerInfo, int i) {
+        if (providerInfo == null) {
+            throw new IllegalArgumentException(w.z("Couldn't find meta-data for provider with authority ", str));
+        }
+        if (providerInfo.metaData == null && i != 0) {
+            Bundle bundle = new Bundle(1);
+            providerInfo.metaData = bundle;
+            bundle.putInt(META_DATA_FILE_PROVIDER_PATHS, i);
+        }
+        XmlResourceParser loadXmlMetaData = providerInfo.loadXmlMetaData(context.getPackageManager(), META_DATA_FILE_PROVIDER_PATHS);
+        if (loadXmlMetaData != null) {
+            return loadXmlMetaData;
+        }
+        throw new IllegalArgumentException("Missing android.support.FILE_PROVIDER_PATHS meta-data");
+    }
+
+    private j getLocalPathStrategy() {
+        j jVar;
+        synchronized (this.mLock) {
+            try {
+                if (this.mAuthority == null) {
+                    throw new NullPointerException("mAuthority is null. Did you override attachInfo and did not call super.attachInfo()?");
+                }
+                if (this.mLocalPathStrategy == null) {
+                    this.mLocalPathStrategy = getPathStrategy(getContext(), this.mAuthority, this.mResourceId);
+                }
+                jVar = this.mLocalPathStrategy;
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+        return jVar;
+    }
+
+    private static j getPathStrategy(Context context, String str, int i) {
+        j jVar;
+        HashMap<String, j> hashMap = sCache;
+        synchronized (hashMap) {
+            try {
+                jVar = hashMap.get(str);
+                if (jVar == null) {
+                    try {
+                        try {
+                            jVar = parsePathStrategy(context, str, i);
+                            hashMap.put(str, jVar);
+                        } catch (IOException e4) {
+                            throw new IllegalArgumentException("Failed to parse android.support.FILE_PROVIDER_PATHS meta-data", e4);
+                        }
+                    } catch (XmlPullParserException e5) {
+                        throw new IllegalArgumentException("Failed to parse android.support.FILE_PROVIDER_PATHS meta-data", e5);
+                    }
+                }
+            } catch (Throwable th) {
+                throw th;
+            }
+        }
+        return jVar;
+    }
+
+    public static Uri getUriForFile(Context context, String str, File file) {
+        String substring;
+        k kVar = (k) getPathStrategy(context, str, 0);
+        kVar.getClass();
+        try {
+            String canonicalPath = file.getCanonicalPath();
+            Map.Entry entry = null;
+            for (Map.Entry entry2 : kVar.f359b.entrySet()) {
+                String path = ((File) entry2.getValue()).getPath();
+                if (k.a(canonicalPath, path) && (entry == null || path.length() > ((File) entry.getValue()).getPath().length())) {
+                    entry = entry2;
+                }
+            }
+            if (entry != null) {
+                String path2 = ((File) entry.getValue()).getPath();
+                if (path2.endsWith(RemoteSettings.FORWARD_SLASH_STRING)) {
+                    substring = canonicalPath.substring(path2.length());
+                } else {
+                    substring = canonicalPath.substring(path2.length() + 1);
+                }
+                return new Uri.Builder().scheme(FirebaseAnalytics.Param.CONTENT).authority(kVar.f358a).encodedPath(Uri.encode((String) entry.getKey()) + '/' + Uri.encode(substring, RemoteSettings.FORWARD_SLASH_STRING)).build();
+            }
+            throw new IllegalArgumentException(w.z("Failed to find configured root that contains ", canonicalPath));
+        } catch (IOException unused) {
+            throw new IllegalArgumentException("Failed to resolve canonical path for " + file);
+        }
+    }
+
+    private static int modeToMode(String str) {
+        if ("r".equals(str)) {
+            return 268435456;
+        }
+        if (DefaultWidgetPayloadHandler.IS_WIDGET_JSON_TYPE.equals(str) || "wt".equals(str)) {
+            return 738197504;
+        }
+        if ("wa".equals(str)) {
+            return 704643072;
+        }
+        if ("rw".equals(str)) {
+            return 939524096;
+        }
+        if ("rwt".equals(str)) {
+            return 1006632960;
+        }
+        throw new IllegalArgumentException(w.z("Invalid mode: ", str));
+    }
+
+    private static j parsePathStrategy(Context context, String str, int i) throws IOException, XmlPullParserException {
+        k kVar = new k(str);
+        XmlResourceParser fileProviderPathsMetaData = getFileProviderPathsMetaData(context, str, context.getPackageManager().resolveContentProvider(str, 128), i);
+        while (true) {
+            int next = fileProviderPathsMetaData.next();
+            if (next == 1) {
+                return kVar;
+            }
+            if (next == 2) {
+                String name = fileProviderPathsMetaData.getName();
+                File file = null;
+                String attributeValue = fileProviderPathsMetaData.getAttributeValue(null, "name");
+                String attributeValue2 = fileProviderPathsMetaData.getAttributeValue(null, "path");
+                if (TAG_ROOT_PATH.equals(name)) {
+                    file = DEVICE_ROOT;
+                } else if (TAG_FILES_PATH.equals(name)) {
+                    file = context.getFilesDir();
+                } else if (TAG_CACHE_PATH.equals(name)) {
+                    file = context.getCacheDir();
+                } else if (TAG_EXTERNAL.equals(name)) {
+                    file = Environment.getExternalStorageDirectory();
+                } else if (TAG_EXTERNAL_FILES.equals(name)) {
+                    File[] externalFilesDirs = h.getExternalFilesDirs(context, null);
+                    if (externalFilesDirs.length > 0) {
+                        file = externalFilesDirs[0];
+                    }
+                } else if (TAG_EXTERNAL_CACHE.equals(name)) {
+                    File[] externalCacheDirs = h.getExternalCacheDirs(context);
+                    if (externalCacheDirs.length > 0) {
+                        file = externalCacheDirs[0];
+                    }
+                } else if (TAG_EXTERNAL_MEDIA.equals(name)) {
+                    File[] a2 = i.a(context);
+                    if (a2.length > 0) {
+                        file = a2[0];
+                    }
+                }
+                if (file != null) {
+                    File buildPath = buildPath(file, attributeValue2);
+                    if (TextUtils.isEmpty(attributeValue)) {
+                        throw new IllegalArgumentException("Name must not be empty");
+                    }
+                    try {
+                        kVar.f359b.put(attributeValue, buildPath.getCanonicalFile());
+                    } catch (IOException e4) {
+                        throw new IllegalArgumentException("Failed to resolve canonical path for " + buildPath, e4);
+                    }
+                } else {
+                    continue;
+                }
+            }
+        }
+    }
+
+    /* JADX INFO: Access modifiers changed from: private */
+    public static String removeTrailingSlash(String str) {
+        return (str.length() <= 0 || str.charAt(str.length() + (-1)) != '/') ? str : str.substring(0, str.length() - 1);
+    }
+
+    @Override // android.content.ContentProvider
+    public void attachInfo(Context context, ProviderInfo providerInfo) {
+        super.attachInfo(context, providerInfo);
+        if (providerInfo.exported) {
+            throw new SecurityException("Provider must not be exported");
+        }
+        if (!providerInfo.grantUriPermissions) {
+            throw new SecurityException("Provider must grant uri permissions");
+        }
+        String str = providerInfo.authority.split(";")[0];
+        synchronized (this.mLock) {
+            this.mAuthority = str;
+        }
+        HashMap<String, j> hashMap = sCache;
+        synchronized (hashMap) {
+            hashMap.remove(str);
+        }
+    }
+
+    @Override // android.content.ContentProvider
+    public int delete(Uri uri, String str, String[] strArr) {
+        return ((k) getLocalPathStrategy()).b(uri).delete() ? 1 : 0;
+    }
+
+    @Override // android.content.ContentProvider
+    public String getType(Uri uri) {
+        File b4 = ((k) getLocalPathStrategy()).b(uri);
+        int lastIndexOf = b4.getName().lastIndexOf(46);
+        if (lastIndexOf < 0) {
+            return "application/octet-stream";
+        }
+        String mimeTypeFromExtension = MimeTypeMap.getSingleton().getMimeTypeFromExtension(b4.getName().substring(lastIndexOf + 1));
+        return mimeTypeFromExtension != null ? mimeTypeFromExtension : "application/octet-stream";
+    }
+
+    @Override // android.content.ContentProvider
+    public String getTypeAnonymous(Uri uri) {
+        return "application/octet-stream";
+    }
+
+    @Override // android.content.ContentProvider
+    public Uri insert(Uri uri, ContentValues contentValues) {
+        throw new UnsupportedOperationException("No external inserts");
+    }
+
+    @Override // android.content.ContentProvider
+    public boolean onCreate() {
+        return true;
+    }
+
+    @Override // android.content.ContentProvider
+    @SuppressLint({"UnknownNullness"})
+    public ParcelFileDescriptor openFile(Uri uri, String str) throws FileNotFoundException {
+        return ParcelFileDescriptor.open(((k) getLocalPathStrategy()).b(uri), modeToMode(str));
+    }
+
+    @Override // android.content.ContentProvider
+    public Cursor query(Uri uri, String[] strArr, String str, String[] strArr2, String str2) {
+        int i;
+        File b4 = ((k) getLocalPathStrategy()).b(uri);
+        String queryParameter = uri.getQueryParameter(DISPLAYNAME_FIELD);
+        if (strArr == null) {
+            strArr = COLUMNS;
+        }
+        String[] strArr3 = new String[strArr.length];
+        Object[] objArr = new Object[strArr.length];
+        int i4 = 0;
+        for (String str3 : strArr) {
+            if ("_display_name".equals(str3)) {
+                strArr3[i4] = "_display_name";
+                i = i4 + 1;
+                objArr[i4] = queryParameter == null ? b4.getName() : queryParameter;
+            } else if ("_size".equals(str3)) {
+                strArr3[i4] = "_size";
+                i = i4 + 1;
+                objArr[i4] = Long.valueOf(b4.length());
+            }
+            i4 = i;
+        }
+        String[] copyOf = copyOf(strArr3, i4);
+        Object[] copyOf2 = copyOf(objArr, i4);
+        MatrixCursor matrixCursor = new MatrixCursor(copyOf, 1);
+        matrixCursor.addRow(copyOf2);
+        return matrixCursor;
+    }
+
+    @Override // android.content.ContentProvider
+    public int update(Uri uri, ContentValues contentValues, String str, String[] strArr) {
+        throw new UnsupportedOperationException("No external updates");
+    }
+
+    public FileProvider(int i) {
+        this.mLock = new Object();
+        this.mResourceId = i;
+    }
+
+    private static Object[] copyOf(Object[] objArr, int i) {
+        Object[] objArr2 = new Object[i];
+        System.arraycopy(objArr, 0, objArr2, 0, i);
+        return objArr2;
+    }
+
+    @SuppressLint({"StreamFiles"})
+    public static Uri getUriForFile(Context context, String str, File file, String str2) {
+        return getUriForFile(context, str, file).buildUpon().appendQueryParameter(DISPLAYNAME_FIELD, str2).build();
+    }
+}

apk_decompiled/sources/androidx/core/graphics/drawable/IconCompat.java

@@ -0,0 +1,169 @@
+package androidx.core.graphics.drawable;
+
+import H.c;
+import H.e;
+import android.content.res.ColorStateList;
+import android.graphics.Bitmap;
+import android.graphics.PorterDuff;
+import android.net.Uri;
+import android.os.Parcelable;
+import androidx.versionedparcelable.CustomVersionedParcelable;
+
+/* loaded from: classes.dex */
+public class IconCompat extends CustomVersionedParcelable {
+
+    /* renamed from: k, reason: collision with root package name */
+    public static final PorterDuff.Mode f2783k = PorterDuff.Mode.SRC_IN;
+
+    /* renamed from: a, reason: collision with root package name */
+    public int f2784a;
+
+    /* renamed from: b, reason: collision with root package name */
+    public Object f2785b;
+
+    /* renamed from: c, reason: collision with root package name */
+    public byte[] f2786c;
+
+    /* renamed from: d, reason: collision with root package name */
+    public Parcelable f2787d;
+
+    /* renamed from: e, reason: collision with root package name */
+    public int f2788e;
+
+    /* renamed from: f, reason: collision with root package name */
+    public int f2789f;
+
+    /* renamed from: g, reason: collision with root package name */
+    public ColorStateList f2790g;
+    public PorterDuff.Mode h;
+    public String i;
+
+    /* renamed from: j, reason: collision with root package name */
+    public String f2791j;
+
+    public IconCompat() {
+        this.f2784a = -1;
+        this.f2786c = null;
+        this.f2787d = null;
+        this.f2788e = 0;
+        this.f2789f = 0;
+        this.f2790g = null;
+        this.h = f2783k;
+        this.i = null;
+    }
+
+    public static IconCompat a(int i) {
+        if (i == 0) {
+            throw new IllegalArgumentException("Drawable resource ID must not be 0");
+        }
+        IconCompat iconCompat = new IconCompat(2);
+        iconCompat.f2788e = i;
+        iconCompat.f2785b = "";
+        iconCompat.f2791j = "";
+        return iconCompat;
+    }
+
+    public final int b() {
+        int i = this.f2784a;
+        if (i == -1) {
+            return e.a(this.f2785b);
+        }
+        if (i == 2) {
+            return this.f2788e;
+        }
+        throw new IllegalStateException("called getResId() on " + this);
+    }
+
+    public final Uri c() {
+        int i = this.f2784a;
+        if (i == -1) {
+            return c.a(this.f2785b);
+        }
+        if (i == 4 || i == 6) {
+            return Uri.parse((String) this.f2785b);
+        }
+        throw new IllegalStateException("called getUri() on " + this);
+    }
+
+    public final String toString() {
+        String str;
+        if (this.f2784a == -1) {
+            return String.valueOf(this.f2785b);
+        }
+        StringBuilder sb = new StringBuilder("Icon(typ=");
+        switch (this.f2784a) {
+            case 1:
+                str = "BITMAP";
+                break;
+            case 2:
+                str = "RESOURCE";
+                break;
+            case 3:
+                str = "DATA";
+                break;
+            case 4:
+                str = "URI";
+                break;
+            case 5:
+                str = "BITMAP_MASKABLE";
+                break;
+            case 6:
+                str = "URI_MASKABLE";
+                break;
+            default:
+                str = "UNKNOWN";
+                break;
+        }
+        sb.append(str);
+        switch (this.f2784a) {
+            case 1:
+            case 5:
+                sb.append(" size=");
+                sb.append(((Bitmap) this.f2785b).getWidth());
+                sb.append("x");
+                sb.append(((Bitmap) this.f2785b).getHeight());
+                break;
+            case 2:
+                sb.append(" pkg=");
+                sb.append(this.f2791j);
+                sb.append(" id=");
+                sb.append(String.format("0x%08x", Integer.valueOf(b())));
+                break;
+            case 3:
+                sb.append(" len=");
+                sb.append(this.f2788e);
+                if (this.f2789f != 0) {
+                    sb.append(" off=");
+                    sb.append(this.f2789f);
+                    break;
+                }
+                break;
+            case 4:
+            case 6:
+                sb.append(" uri=");
+                sb.append(this.f2785b);
+                break;
+        }
+        if (this.f2790g != null) {
+            sb.append(" tint=");
+            sb.append(this.f2790g);
+        }
+        if (this.h != f2783k) {
+            sb.append(" mode=");
+            sb.append(this.h);
+        }
+        sb.append(")");
+        return sb.toString();
+    }
+
+    public IconCompat(int i) {
+        this.f2786c = null;
+        this.f2787d = null;
+        this.f2788e = 0;
+        this.f2789f = 0;
+        this.f2790g = null;
+        this.h = f2783k;
+        this.i = null;
+        this.f2784a = i;
+    }
+}

apk_decompiled/sources/androidx/core/graphics/drawable/IconCompatParcelizer.java

@@ -0,0 +1,162 @@
+package androidx.core.graphics.drawable;
+
+import D0.b;
+import D0.c;
+import android.content.res.ColorStateList;
+import android.graphics.PorterDuff;
+import android.os.Parcel;
+import android.os.Parcelable;
+import java.nio.charset.Charset;
+
+/* loaded from: classes.dex */
+public class IconCompatParcelizer {
+    /* JADX WARN: Can't fix incorrect switch cases order, some code will duplicate */
+    public static IconCompat read(b bVar) {
+        IconCompat iconCompat = new IconCompat();
+        int i = iconCompat.f2784a;
+        if (bVar.e(1)) {
+            i = ((c) bVar).f365e.readInt();
+        }
+        iconCompat.f2784a = i;
+        byte[] bArr = iconCompat.f2786c;
+        if (bVar.e(2)) {
+            Parcel parcel = ((c) bVar).f365e;
+            int readInt = parcel.readInt();
+            if (readInt < 0) {
+                bArr = null;
+            } else {
+                byte[] bArr2 = new byte[readInt];
+                parcel.readByteArray(bArr2);
+                bArr = bArr2;
+            }
+        }
+        iconCompat.f2786c = bArr;
+        iconCompat.f2787d = bVar.f(iconCompat.f2787d, 3);
+        int i4 = iconCompat.f2788e;
+        if (bVar.e(4)) {
+            i4 = ((c) bVar).f365e.readInt();
+        }
+        iconCompat.f2788e = i4;
+        int i5 = iconCompat.f2789f;
+        if (bVar.e(5)) {
+            i5 = ((c) bVar).f365e.readInt();
+        }
+        iconCompat.f2789f = i5;
+        iconCompat.f2790g = (ColorStateList) bVar.f(iconCompat.f2790g, 6);
+        String str = iconCompat.i;
+        if (bVar.e(7)) {
+            str = ((c) bVar).f365e.readString();
+        }
+        iconCompat.i = str;
+        String str2 = iconCompat.f2791j;
+        if (bVar.e(8)) {
+            str2 = ((c) bVar).f365e.readString();
+        }
+        iconCompat.f2791j = str2;
+        iconCompat.h = PorterDuff.Mode.valueOf(iconCompat.i);
+        switch (iconCompat.f2784a) {
+            case -1:
+                Parcelable parcelable = iconCompat.f2787d;
+                if (parcelable == null) {
+                    throw new IllegalArgumentException("Invalid icon");
+                }
+                iconCompat.f2785b = parcelable;
+                return iconCompat;
+            case 0:
+            default:
+                return iconCompat;
+            case 1:
+            case 5:
+                Parcelable parcelable2 = iconCompat.f2787d;
+                if (parcelable2 != null) {
+                    iconCompat.f2785b = parcelable2;
+                    return iconCompat;
+                }
+                byte[] bArr3 = iconCompat.f2786c;
+                iconCompat.f2785b = bArr3;
+                iconCompat.f2784a = 3;
+                iconCompat.f2788e = 0;
+                iconCompat.f2789f = bArr3.length;
+                return iconCompat;
+            case 2:
+            case 4:
+            case 6:
+                String str3 = new String(iconCompat.f2786c, Charset.forName("UTF-16"));
+                iconCompat.f2785b = str3;
+                if (iconCompat.f2784a == 2 && iconCompat.f2791j == null) {
+                    iconCompat.f2791j = str3.split(":", -1)[0];
+                }
+                return iconCompat;
+            case 3:
+                iconCompat.f2785b = iconCompat.f2786c;
+                return iconCompat;
+        }
+    }
+
+    public static void write(IconCompat iconCompat, b bVar) {
+        bVar.getClass();
+        iconCompat.i = iconCompat.h.name();
+        switch (iconCompat.f2784a) {
+            case -1:
+                iconCompat.f2787d = (Parcelable) iconCompat.f2785b;
+                break;
+            case 1:
+            case 5:
+                iconCompat.f2787d = (Parcelable) iconCompat.f2785b;
+                break;
+            case 2:
+                iconCompat.f2786c = ((String) iconCompat.f2785b).getBytes(Charset.forName("UTF-16"));
+                break;
+            case 3:
+                iconCompat.f2786c = (byte[]) iconCompat.f2785b;
+                break;
+            case 4:
+            case 6:
+                iconCompat.f2786c = iconCompat.f2785b.toString().getBytes(Charset.forName("UTF-16"));
+                break;
+        }
+        int i = iconCompat.f2784a;
+        if (-1 != i) {
+            bVar.h(1);
+            ((c) bVar).f365e.writeInt(i);
+        }
+        byte[] bArr = iconCompat.f2786c;
+        if (bArr != null) {
+            bVar.h(2);
+            int length = bArr.length;
+            Parcel parcel = ((c) bVar).f365e;
+            parcel.writeInt(length);
+            parcel.writeByteArray(bArr);
+        }
+        Parcelable parcelable = iconCompat.f2787d;
+        if (parcelable != null) {
+            bVar.h(3);
+            ((c) bVar).f365e.writeParcelable(parcelable, 0);
+        }
+        int i4 = iconCompat.f2788e;
+        if (i4 != 0) {
+            bVar.h(4);
+            ((c) bVar).f365e.writeInt(i4);
+        }
+        int i5 = iconCompat.f2789f;
+        if (i5 != 0) {
+            bVar.h(5);
+            ((c) bVar).f365e.writeInt(i5);
+        }
+        ColorStateList colorStateList = iconCompat.f2790g;
+        if (colorStateList != null) {
+            bVar.h(6);
+            ((c) bVar).f365e.writeParcelable(colorStateList, 0);
+        }
+        String str = iconCompat.i;
+        if (str != null) {
+            bVar.h(7);
+            ((c) bVar).f365e.writeString(str);
+        }
+        String str2 = iconCompat.f2791j;
+        if (str2 != null) {
+            bVar.h(8);
+            ((c) bVar).f365e.writeString(str2);
+        }
+    }
+}

apk_decompiled/sources/androidx/core/widget/RemoteViewsCompatService.java

@@ -0,0 +1,31 @@
+package androidx.core.widget;
+
+import U.s;
+import android.content.Intent;
+import android.widget.RemoteViewsService;
+import kotlin.Metadata;
+import kotlin.jvm.internal.Intrinsics;
+import kotlin.jvm.internal.SourceDebugExtension;
+
+@Metadata(d1 = {"\u0000\f\n\u0002\u0018\u0002\n\u0002\u0018\u0002\n\u0002\b\u0005\b\u0007\u0018\u00002\u00020\u0001:\u0002\u0004\u0005B\u0007¢\u0006\u0004\b\u0002\u0010\u0003¨\u0006\u0006"}, d2 = {"Landroidx/core/widget/RemoteViewsCompatService;", "Landroid/widget/RemoteViewsService;", "<init>", "()V", "U/r", "U/s", "core-remoteviews_release"}, k = 1, mv = {1, 8, 0}, xi = 48)
+@SourceDebugExtension({"SMAP\nRemoteViewsCompatService.kt\nKotlin\n*S Kotlin\n*F\n+ 1 RemoteViewsCompatService.kt\nandroidx/core/widget/RemoteViewsCompatService\n+ 2 fake.kt\nkotlin/jvm/internal/FakeKt\n*L\n1#1,319:1\n1#2:320\n*E\n"})
+/* loaded from: classes.dex */
+public final class RemoteViewsCompatService extends RemoteViewsService {
+
+    /* renamed from: a, reason: collision with root package name */
+    public static final /* synthetic */ int f2820a = 0;
+
+    @Override // android.widget.RemoteViewsService
+    public final RemoteViewsService.RemoteViewsFactory onGetViewFactory(Intent intent) {
+        Intrinsics.checkNotNullParameter(intent, "intent");
+        int intExtra = intent.getIntExtra("appWidgetId", -1);
+        if (intExtra == -1) {
+            throw new IllegalStateException("No app widget id was present in the intent");
+        }
+        int intExtra2 = intent.getIntExtra("androidx.core.widget.extra.view_id", -1);
+        if (intExtra2 != -1) {
+            return new s(this, intExtra, intExtra2);
+        }
+        throw new IllegalStateException("No view id was present in the intent");
+    }
+}