Primer paso de la investigacion. Se aportan el .apk, las carpetas con el apk extraido y el apk descompilado. El archivo API_DOCUMENTATION.md es un archivo donde se anotaran los descubrimientos del funcionamiento de la API, y los .py son scripts para probar la funcionalidad de la API con los métodos que vayamos encontrando. Finalmente, los archivos .js son scripts de Frida para extraer informacion de la APP durante la ejecucion.

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");
+    }
+}