Add decompiled APK source code (JADX)

- 28,932 files
- Full Java source code
- Smali files
- Resources

Co-authored-by: Copilot <223556219+Copilot@users.noreply.github.com>

decompiled/sources/androidx/core/hardware/display/DisplayManagerCompat.java

@@ -0,0 +1,37 @@
+package androidx.core.hardware.display;
+
+import android.content.Context;
+import android.hardware.display.DisplayManager;
+import android.view.Display;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+/* loaded from: classes.dex */
+public final class DisplayManagerCompat {
+    public static final String DISPLAY_CATEGORY_PRESENTATION = "android.hardware.display.category.PRESENTATION";
+    private final Context mContext;
+
+    private DisplayManagerCompat(Context context) {
+        this.mContext = context;
+    }
+
+    @NonNull
+    public static DisplayManagerCompat getInstance(@NonNull Context context) {
+        return new DisplayManagerCompat(context);
+    }
+
+    @Nullable
+    public Display getDisplay(int i) {
+        return ((DisplayManager) this.mContext.getSystemService("display")).getDisplay(i);
+    }
+
+    @NonNull
+    public Display[] getDisplays() {
+        return ((DisplayManager) this.mContext.getSystemService("display")).getDisplays();
+    }
+
+    @NonNull
+    public Display[] getDisplays(@Nullable String str) {
+        return ((DisplayManager) this.mContext.getSystemService("display")).getDisplays();
+    }
+}

decompiled/sources/androidx/core/hardware/fingerprint/FingerprintManagerCompat.java

@@ -0,0 +1,229 @@
+package androidx.core.hardware.fingerprint;
+
+import android.content.Context;
+import android.hardware.fingerprint.FingerprintManager;
+import android.os.Handler;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+import androidx.annotation.RequiresPermission;
+import androidx.annotation.RestrictTo;
+import androidx.core.os.CancellationSignal;
+import java.security.Signature;
+import javax.crypto.Cipher;
+import javax.crypto.Mac;
+
+@RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+@Deprecated
+/* loaded from: classes.dex */
+public class FingerprintManagerCompat {
+    private final Context mContext;
+
+    public static abstract class AuthenticationCallback {
+        public void onAuthenticationError(int i, @NonNull CharSequence charSequence) {
+        }
+
+        public void onAuthenticationFailed() {
+        }
+
+        public void onAuthenticationHelp(int i, @NonNull CharSequence charSequence) {
+        }
+
+        public void onAuthenticationSucceeded(@NonNull AuthenticationResult authenticationResult) {
+        }
+    }
+
+    @NonNull
+    public static FingerprintManagerCompat from(@NonNull Context context) {
+        return new FingerprintManagerCompat(context);
+    }
+
+    private FingerprintManagerCompat(Context context) {
+        this.mContext = context;
+    }
+
+    @RequiresPermission("android.permission.USE_FINGERPRINT")
+    public boolean hasEnrolledFingerprints() {
+        FingerprintManager fingerprintManagerOrNull = getFingerprintManagerOrNull(this.mContext);
+        return fingerprintManagerOrNull != null && Api23Impl.hasEnrolledFingerprints(fingerprintManagerOrNull);
+    }
+
+    @RequiresPermission("android.permission.USE_FINGERPRINT")
+    public boolean isHardwareDetected() {
+        FingerprintManager fingerprintManagerOrNull = getFingerprintManagerOrNull(this.mContext);
+        return fingerprintManagerOrNull != null && Api23Impl.isHardwareDetected(fingerprintManagerOrNull);
+    }
+
+    @RequiresPermission("android.permission.USE_FINGERPRINT")
+    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP_PREFIX})
+    @Deprecated
+    public void authenticate(@Nullable CryptoObject cryptoObject, int i, @Nullable CancellationSignal cancellationSignal, @NonNull AuthenticationCallback authenticationCallback, @Nullable Handler handler) {
+        authenticate(cryptoObject, i, cancellationSignal != null ? (android.os.CancellationSignal) cancellationSignal.getCancellationSignalObject() : null, authenticationCallback, handler);
+    }
+
+    @RequiresPermission("android.permission.USE_FINGERPRINT")
+    public void authenticate(@Nullable CryptoObject cryptoObject, int i, @Nullable android.os.CancellationSignal cancellationSignal, @NonNull AuthenticationCallback authenticationCallback, @Nullable Handler handler) {
+        FingerprintManager fingerprintManagerOrNull = getFingerprintManagerOrNull(this.mContext);
+        if (fingerprintManagerOrNull != null) {
+            Api23Impl.authenticate(fingerprintManagerOrNull, wrapCryptoObject(cryptoObject), cancellationSignal, i, wrapCallback(authenticationCallback), handler);
+        }
+    }
+
+    @Nullable
+    @RequiresApi(23)
+    private static FingerprintManager getFingerprintManagerOrNull(@NonNull Context context) {
+        return Api23Impl.getFingerprintManagerOrNull(context);
+    }
+
+    @RequiresApi(23)
+    private static FingerprintManager.CryptoObject wrapCryptoObject(CryptoObject cryptoObject) {
+        return Api23Impl.wrapCryptoObject(cryptoObject);
+    }
+
+    @RequiresApi(23)
+    public static CryptoObject unwrapCryptoObject(FingerprintManager.CryptoObject cryptoObject) {
+        return Api23Impl.unwrapCryptoObject(cryptoObject);
+    }
+
+    @RequiresApi(23)
+    private static FingerprintManager.AuthenticationCallback wrapCallback(final AuthenticationCallback authenticationCallback) {
+        return new FingerprintManager.AuthenticationCallback() { // from class: androidx.core.hardware.fingerprint.FingerprintManagerCompat.1
+            @Override // android.hardware.fingerprint.FingerprintManager.AuthenticationCallback
+            public void onAuthenticationError(int i, CharSequence charSequence) {
+                AuthenticationCallback.this.onAuthenticationError(i, charSequence);
+            }
+
+            @Override // android.hardware.fingerprint.FingerprintManager.AuthenticationCallback
+            public void onAuthenticationHelp(int i, CharSequence charSequence) {
+                AuthenticationCallback.this.onAuthenticationHelp(i, charSequence);
+            }
+
+            @Override // android.hardware.fingerprint.FingerprintManager.AuthenticationCallback
+            public void onAuthenticationSucceeded(FingerprintManager.AuthenticationResult authenticationResult) {
+                AuthenticationCallback.this.onAuthenticationSucceeded(new AuthenticationResult(FingerprintManagerCompat.unwrapCryptoObject(Api23Impl.getCryptoObject(authenticationResult))));
+            }
+
+            @Override // android.hardware.fingerprint.FingerprintManager.AuthenticationCallback
+            public void onAuthenticationFailed() {
+                AuthenticationCallback.this.onAuthenticationFailed();
+            }
+        };
+    }
+
+    public static class CryptoObject {
+        private final Cipher mCipher;
+        private final Mac mMac;
+        private final Signature mSignature;
+
+        @Nullable
+        public Cipher getCipher() {
+            return this.mCipher;
+        }
+
+        @Nullable
+        public Mac getMac() {
+            return this.mMac;
+        }
+
+        @Nullable
+        public Signature getSignature() {
+            return this.mSignature;
+        }
+
+        public CryptoObject(@NonNull Signature signature) {
+            this.mSignature = signature;
+            this.mCipher = null;
+            this.mMac = null;
+        }
+
+        public CryptoObject(@NonNull Cipher cipher) {
+            this.mCipher = cipher;
+            this.mSignature = null;
+            this.mMac = null;
+        }
+
+        public CryptoObject(@NonNull Mac mac) {
+            this.mMac = mac;
+            this.mCipher = null;
+            this.mSignature = null;
+        }
+    }
+
+    public static final class AuthenticationResult {
+        private final CryptoObject mCryptoObject;
+
+        @NonNull
+        public CryptoObject getCryptoObject() {
+            return this.mCryptoObject;
+        }
+
+        public AuthenticationResult(@NonNull CryptoObject cryptoObject) {
+            this.mCryptoObject = cryptoObject;
+        }
+    }
+
+    @RequiresApi(23)
+    public static class Api23Impl {
+        private Api23Impl() {
+        }
+
+        @RequiresPermission("android.permission.USE_FINGERPRINT")
+        public static boolean hasEnrolledFingerprints(Object obj) {
+            return ((FingerprintManager) obj).hasEnrolledFingerprints();
+        }
+
+        @RequiresPermission("android.permission.USE_FINGERPRINT")
+        public static boolean isHardwareDetected(Object obj) {
+            return ((FingerprintManager) obj).isHardwareDetected();
+        }
+
+        @RequiresPermission("android.permission.USE_FINGERPRINT")
+        public static void authenticate(Object obj, Object obj2, android.os.CancellationSignal cancellationSignal, int i, Object obj3, Handler handler) {
+            ((FingerprintManager) obj).authenticate((FingerprintManager.CryptoObject) obj2, cancellationSignal, i, (FingerprintManager.AuthenticationCallback) obj3, handler);
+        }
+
+        public static FingerprintManager.CryptoObject getCryptoObject(Object obj) {
+            return ((FingerprintManager.AuthenticationResult) obj).getCryptoObject();
+        }
+
+        public static FingerprintManager getFingerprintManagerOrNull(Context context) {
+            if (context.getPackageManager().hasSystemFeature("android.hardware.fingerprint")) {
+                return (FingerprintManager) context.getSystemService(FingerprintManager.class);
+            }
+            return null;
+        }
+
+        public static FingerprintManager.CryptoObject wrapCryptoObject(CryptoObject cryptoObject) {
+            if (cryptoObject == null) {
+                return null;
+            }
+            if (cryptoObject.getCipher() != null) {
+                return new FingerprintManager.CryptoObject(cryptoObject.getCipher());
+            }
+            if (cryptoObject.getSignature() != null) {
+                return new FingerprintManager.CryptoObject(cryptoObject.getSignature());
+            }
+            if (cryptoObject.getMac() != null) {
+                return new FingerprintManager.CryptoObject(cryptoObject.getMac());
+            }
+            return null;
+        }
+
+        public static CryptoObject unwrapCryptoObject(Object obj) {
+            FingerprintManager.CryptoObject cryptoObject = (FingerprintManager.CryptoObject) obj;
+            if (cryptoObject == null) {
+                return null;
+            }
+            if (cryptoObject.getCipher() != null) {
+                return new CryptoObject(cryptoObject.getCipher());
+            }
+            if (cryptoObject.getSignature() != null) {
+                return new CryptoObject(cryptoObject.getSignature());
+            }
+            if (cryptoObject.getMac() != null) {
+                return new CryptoObject(cryptoObject.getMac());
+            }
+            return null;
+        }
+    }
+}