package androidx.credentials.provider;

import androidx.annotation.RestrictTo;
import java.util.LinkedHashMap;
import java.util.Objects;
import kotlin.TuplesKt;
import kotlin.collections.MapsKt__MapsKt;
import kotlin.jvm.internal.DefaultConstructorMarker;
import kotlin.jvm.internal.Intrinsics;

/* loaded from: classes.dex */
public final class AuthenticationError {

    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP})
    public static final String EXTRA_BIOMETRIC_AUTH_ERROR = "androidx.credentials.provider.BIOMETRIC_AUTH_ERROR_CODE";

    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP})
    public static final String EXTRA_BIOMETRIC_AUTH_ERROR_FALLBACK = "BIOMETRIC_AUTH_ERROR_CODE";

    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP})
    public static final String EXTRA_BIOMETRIC_AUTH_ERROR_MESSAGE = "androidx.credentials.provider.BIOMETRIC_AUTH_ERROR_MESSAGE";

    @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP})
    public static final String EXTRA_BIOMETRIC_AUTH_ERROR_MESSAGE_FALLBACK = "BIOMETRIC_AUTH_ERROR_MESSAGE";
    private static final LinkedHashMap<Integer, Integer> biometricFrameworkToJetpackErrorMap;
    private final int errorCode;
    private final CharSequence errorMsg;
    public static final Companion Companion = new Companion(null);
    private static final String TAG = "AuthenticationError";

    /* JADX WARN: Multi-variable type inference failed */
    public AuthenticationError(int i) {
        this(i, null, 2, 0 == true ? 1 : 0);
    }

    public final int getErrorCode() {
        return this.errorCode;
    }

    public final CharSequence getErrorMsg() {
        return this.errorMsg;
    }

    public AuthenticationError(int i, CharSequence charSequence) {
        this.errorCode = i;
        this.errorMsg = charSequence;
    }

    public /* synthetic */ AuthenticationError(int i, CharSequence charSequence, int i2, DefaultConstructorMarker defaultConstructorMarker) {
        this(i, (i2 & 2) != 0 ? null : charSequence);
    }

    public static final class Companion {
        public /* synthetic */ Companion(DefaultConstructorMarker defaultConstructorMarker) {
            this();
        }

        @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP})
        public final AuthenticationError createFrom$credentials_release(int i, CharSequence uiErrorMessage) {
            Intrinsics.checkNotNullParameter(uiErrorMessage, "uiErrorMessage");
            return createFrom$credentials_release$default(this, i, uiErrorMessage, false, 4, null);
        }

        private Companion() {
        }

        public final String getTAG$credentials_release() {
            return AuthenticationError.TAG;
        }

        public final LinkedHashMap<Integer, Integer> getBiometricFrameworkToJetpackErrorMap$credentials_release() {
            return AuthenticationError.biometricFrameworkToJetpackErrorMap;
        }

        public final int convertFrameworkBiometricErrorToJetpack$credentials_release(int i) {
            if (getBiometricFrameworkToJetpackErrorMap$credentials_release().containsKey(Integer.valueOf(i))) {
                Integer num = getBiometricFrameworkToJetpackErrorMap$credentials_release().get(Integer.valueOf(i));
                Intrinsics.checkNotNull(num);
                Intrinsics.checkNotNullExpressionValue(num, "{\n                biomet…workCode]!!\n            }");
                return num.intValue();
            }
            getTAG$credentials_release();
            StringBuilder sb = new StringBuilder();
            sb.append("Unexpected error code, ");
            sb.append(i);
            sb.append(", ");
            return i;
        }

        public static /* synthetic */ AuthenticationError createFrom$credentials_release$default(Companion companion, int i, CharSequence charSequence, boolean z, int i2, Object obj) {
            if ((i2 & 4) != 0) {
                z = true;
            }
            return companion.createFrom$credentials_release(i, charSequence, z);
        }

        @RestrictTo({RestrictTo.Scope.LIBRARY_GROUP})
        public final AuthenticationError createFrom$credentials_release(int i, CharSequence uiErrorMessage, boolean z) {
            Intrinsics.checkNotNullParameter(uiErrorMessage, "uiErrorMessage");
            if (z) {
                i = convertFrameworkBiometricErrorToJetpack$credentials_release(i);
            }
            return new AuthenticationError(i, uiErrorMessage);
        }
    }

    static {
        LinkedHashMap<Integer, Integer> linkedMapOf;
        linkedMapOf = MapsKt__MapsKt.linkedMapOf(TuplesKt.to(5, 5), TuplesKt.to(12, 12), TuplesKt.to(1, 1), TuplesKt.to(7, 7), TuplesKt.to(9, 9), TuplesKt.to(11, 11), TuplesKt.to(14, 14), TuplesKt.to(4, 4), TuplesKt.to(15, 15), TuplesKt.to(3, 3), TuplesKt.to(2, 2), TuplesKt.to(10, 10), TuplesKt.to(8, 8));
        biometricFrameworkToJetpackErrorMap = linkedMapOf;
    }

    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }
        if (!(obj instanceof AuthenticationError)) {
            return false;
        }
        AuthenticationError authenticationError = (AuthenticationError) obj;
        return this.errorCode == authenticationError.errorCode && Intrinsics.areEqual(this.errorMsg, authenticationError.errorMsg);
    }

    public int hashCode() {
        return Objects.hash(Integer.valueOf(this.errorCode), this.errorMsg);
    }
}