package com.firemonkeys.cloudcellapi;

import android.app.Activity;
import android.content.Context;
import android.content.Intent;
import android.content.IntentSender;
import android.content.SharedPreferences;
import android.graphics.Bitmap;
import android.graphics.drawable.BitmapDrawable;
import android.graphics.drawable.Drawable;
import android.net.Uri;
import android.os.CancellationSignal;
import androidx.annotation.NonNull;
import androidx.core.content.ContextCompat;
import androidx.credentials.CredentialManager;
import androidx.credentials.CredentialManagerCallback;
import androidx.credentials.CustomCredential;
import androidx.credentials.GetCredentialRequest;
import androidx.credentials.GetCredentialResponse;
import androidx.credentials.exceptions.GetCredentialException;
import androidx.credentials.exceptions.NoCredentialException;
import com.firemonkeys.cloudcellapi.GooglePlayWorker;
import com.firemonkeys.cloudcellapi.util.GetInfo;
import com.google.android.gms.auth.api.identity.AuthorizationRequest;
import com.google.android.gms.auth.api.identity.AuthorizationResult;
import com.google.android.gms.auth.api.identity.Identity;
import com.google.android.gms.common.AccountPicker;
import com.google.android.gms.common.Scopes;
import com.google.android.gms.common.api.Scope;
import com.google.android.gms.common.images.ImageManager;
import com.google.android.gms.games.AnnotatedData;
import com.google.android.gms.games.AuthenticationResult;
import com.google.android.gms.games.PlayGames;
import com.google.android.gms.games.PlayGamesSdk;
import com.google.android.gms.games.Player;
import com.google.android.gms.tasks.OnCompleteListener;
import com.google.android.gms.tasks.OnFailureListener;
import com.google.android.gms.tasks.OnSuccessListener;
import com.google.android.gms.tasks.Task;
import com.google.android.libraries.identity.googleid.GetGoogleIdOption;
import com.google.android.libraries.identity.googleid.GoogleIdTokenCredential;
import com.google.firebase.perf.network.FirebasePerfHttpClient;
import java.io.ByteArrayOutputStream;
import java.io.File;
import java.util.ArrayList;
import org.apache.http.client.methods.HttpPost;
import org.apache.http.impl.client.DefaultHttpClient;
import org.apache.http.util.EntityUtils;

/* loaded from: classes2.dex */
public class GooglePlayWorker {
    private static final String CLASSNAME = "GooglePlayWorker";
    private static final int RC_ACHIEVEMENT_UI = 9003;
    private static final int RC_SIGN_IN = 9001;
    private static final int REQUEST_AUTHORIZE = 9004;
    private static final int REQUEST_CODE_PICK_ACCOUNT = 468725;
    private static final String WEB_CLIENT_ID = "1056053393768-2irtr6olub9uil5dsp16apf9p5f0ge0k.apps.googleusercontent.com";
    private static final String autoConnectPrefName = "AutoConnect";
    private static final Object lock = new Object();
    private static boolean m_bAlreadyStarted = false;
    private static boolean m_bDisablePopups = false;
    private static boolean m_bIsAuthenticated = false;
    private static boolean m_bIsInitialPhaseComplete = false;
    private static boolean m_bLoginChanged = false;
    private static boolean m_bLoginSilent = true;
    private static boolean m_bSignInFlow = false;
    private static long m_nLoginCallback = 0;
    private static long m_nShareCallback = 0;
    private static CredentialManager m_pCredentialManager = null;
    private static GoogleIdTokenCredential m_pGoogleIdTokenCredential = null;
    private static GooglePlayWorker m_pGooglePlayWorker = null;
    private static Player m_pPlayer = null;
    private static final String sharedPrefsFileName = "GooglePlayPrefs";

    /* JADX INFO: Access modifiers changed from: private */
    public native void LoadAvatarCallbackFunc(boolean z, byte[] bArr, long j);

    private native void LoadFriendVectorCallback(boolean z, String[] strArr, String[] strArr2, long j);

    /* JADX INFO: Access modifiers changed from: private */
    public native void LoadProfileCallback(boolean z, String[] strArr, long j);

    private native void LogoutCallback(long j);

    private native void NativeLoginCallback(String str, String str2, boolean z, long j);

    private native void ShareCallback(boolean z, boolean z2, long j);

    public static void onCreate(Context context) {
    }

    public Player GetCurrentPlayer() {
        Player player;
        if (!m_bIsAuthenticated || (player = m_pPlayer) == null) {
            return null;
        }
        return player;
    }

    public boolean GetSessionValid() {
        return m_bIsAuthenticated;
    }

    public boolean IsInitialPhaseComplete() {
        return m_bIsInitialPhaseComplete;
    }

    public GooglePlayWorker() {
        Logging.CC_TRACE(CLASSNAME, "GooglePlusWorker()");
        m_pGooglePlayWorker = this;
    }

    public void Constructor(String str, boolean z) {
        Logging.CC_TRACE(CLASSNAME, "Constructor");
        InitializeClient(str, z);
        if (m_bAlreadyStarted) {
            Connect();
        }
    }

    private void InitializeClient(String str, boolean z) {
        Logging.CC_TRACE(CLASSNAME, "Initializing Google Credentials");
        Context applicationContext = CC_Component.GetActivity().getApplicationContext();
        m_bDisablePopups = z;
        PlayGamesSdk.initialize(applicationContext);
    }

    public static void onStart() {
        Logging.CC_TRACE(CLASSNAME, "onStart");
        Connect();
        ClearTempDirectory();
        m_bAlreadyStarted = true;
    }

    public static void onStop() {
        Logging.CC_TRACE(CLASSNAME, "onStop");
    }

    private static boolean GetAutoConnect() {
        return CC_Component.GetActivity().getApplicationContext().getSharedPreferences(sharedPrefsFileName, 0).getBoolean(autoConnectPrefName, true);
    }

    private static void SetAutoConnect(boolean z) {
        SharedPreferences.Editor edit = CC_Component.GetActivity().getApplicationContext().getSharedPreferences(sharedPrefsFileName, 0).edit();
        edit.putBoolean(autoConnectPrefName, z);
        edit.apply();
    }

    private static void Connect() {
        Logging.CC_TRACE(CLASSNAME, "Connect()");
        m_bSignInFlow = false;
        if (!GetAutoConnect()) {
            Logging.CC_TRACE(CLASSNAME, "Autoconnecting to googleplay disabled by user");
            CompleteInitialPhase();
        } else if (!m_bSignInFlow) {
            m_bLoginSilent = true;
            Logging.CC_TRACE(CLASSNAME, "SignIn with googleplay silently");
            SignInSilently();
        } else {
            Logging.CC_TRACE(CLASSNAME, "This should not happen: " + m_bSignInFlow);
        }
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static void SignInSilently() {
        SignInToPlayGames();
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static void GoogleSignIn(boolean z) {
        Logging.CC_TRACE(CLASSNAME, "GoogleSignIn called! with isAuthorizedAccAvlbe: " + z);
        if (m_pGoogleIdTokenCredential != null) {
            m_pGooglePlayWorker.onGoogleSignInConnected();
            m_bSignInFlow = false;
            return;
        }
        m_bSignInFlow = true;
        m_pCredentialManager.getCredentialAsync(CC_Component.GetActivity(), new GetCredentialRequest.Builder().addCredentialOption(new GetGoogleIdOption.Builder().setFilterByAuthorizedAccounts(z).setAutoSelectEnabled(true).setServerClientId(WEB_CLIENT_ID).build()).build(), (CancellationSignal) null, ContextCompat.getMainExecutor(CC_Component.GetActivity()), new AnonymousClass1(z));
    }

    /* renamed from: com.firemonkeys.cloudcellapi.GooglePlayWorker$1, reason: invalid class name */
    public class AnonymousClass1 implements CredentialManagerCallback<GetCredentialResponse, GetCredentialException> {
        final /* synthetic */ boolean val$isAuthorizedAccAvlbe;

        public AnonymousClass1(boolean z) {
            this.val$isAuthorizedAccAvlbe = z;
        }

        @Override // androidx.credentials.CredentialManagerCallback
        public void onResult(GetCredentialResponse getCredentialResponse) {
            Logging.CC_TRACE(GooglePlayWorker.CLASSNAME, "In getCredentialAsync: ");
            if ((getCredentialResponse.getCredential() instanceof CustomCredential) && getCredentialResponse.getCredential().getType().equals(GoogleIdTokenCredential.TYPE_GOOGLE_ID_TOKEN_CREDENTIAL)) {
                GooglePlayWorker.m_pGoogleIdTokenCredential = GoogleIdTokenCredential.createFrom(getCredentialResponse.getCredential().getData());
                String idToken = GooglePlayWorker.m_pGoogleIdTokenCredential.getIdToken();
                String displayName = GooglePlayWorker.m_pGoogleIdTokenCredential.getDisplayName();
                Logging.CC_TRACE(GooglePlayWorker.CLASSNAME, "Google ID Token: " + idToken);
                Logging.CC_TRACE(GooglePlayWorker.CLASSNAME, "Signed in as: " + displayName);
                GooglePlayWorker.m_pGooglePlayWorker.onGoogleSignInConnected();
                GooglePlayWorker.m_bSignInFlow = false;
                ArrayList arrayList = new ArrayList();
                arrayList.add(new Scope(Scopes.PROFILE));
                Identity.getAuthorizationClient(CC_Component.GetActivity().getApplicationContext()).authorize(AuthorizationRequest.builder().setRequestedScopes(arrayList).build()).addOnSuccessListener(new OnSuccessListener() { // from class: com.firemonkeys.cloudcellapi.GooglePlayWorker$1$$ExternalSyntheticLambda0
                    @Override // com.google.android.gms.tasks.OnSuccessListener
                    public final void onSuccess(Object obj) {
                        GooglePlayWorker.AnonymousClass1.lambda$onResult$0((AuthorizationResult) obj);
                    }
                }).addOnFailureListener(new OnFailureListener() { // from class: com.firemonkeys.cloudcellapi.GooglePlayWorker$1$$ExternalSyntheticLambda1
                    @Override // com.google.android.gms.tasks.OnFailureListener
                    public final void onFailure(Exception exc) {
                        GooglePlayWorker.AnonymousClass1.lambda$onResult$1(exc);
                    }
                });
            }
        }

        /* JADX INFO: Access modifiers changed from: private */
        public static /* synthetic */ void lambda$onResult$0(AuthorizationResult authorizationResult) {
            if (authorizationResult.hasResolution()) {
                try {
                    CC_Component.GetActivity().startIntentSenderForResult(authorizationResult.getPendingIntent().getIntentSender(), GooglePlayWorker.REQUEST_AUTHORIZE, null, 0, 0, 0, null);
                } catch (IntentSender.SendIntentException e) {
                    Logging.CC_TRACE(GooglePlayWorker.CLASSNAME, "Couldn't start Authorization UI: " + e.getLocalizedMessage());
                }
            } else {
                Logging.CC_TRACE(GooglePlayWorker.CLASSNAME, "Access already granted ");
            }
            GooglePlayWorker.SignInToPlayGames();
        }

        /* JADX INFO: Access modifiers changed from: private */
        public static /* synthetic */ void lambda$onResult$1(Exception exc) {
            Logging.CC_TRACE(GooglePlayWorker.CLASSNAME, "Failed to authorize: " + exc);
        }

        @Override // androidx.credentials.CredentialManagerCallback
        public void onError(@NonNull GetCredentialException getCredentialException) {
            Logging.CC_TRACE(GooglePlayWorker.CLASSNAME, "Sign-in failed: " + getCredentialException.getMessage());
            if ((getCredentialException instanceof NoCredentialException) || this.val$isAuthorizedAccAvlbe) {
                GooglePlayWorker.GoogleSignIn(false);
            } else {
                GooglePlayWorker.CompleteInitialPhase();
                GooglePlayWorker.m_pGooglePlayWorker.onGoogleSignInFailed(true);
            }
        }
    }

    public static boolean handleActivityResult(int i, int i2, Intent intent) {
        if (i2 == -1) {
            Logging.CC_TRACE(CLASSNAME, "handleActivityResult: requestCode: " + i + " resultCode: RESULT_OK");
        } else if (i2 == 0) {
            Logging.CC_TRACE(CLASSNAME, "handleActivityResult: requestCode: " + i + " resultCode: RESULT_CANCELED");
        } else {
            Logging.CC_TRACE(CLASSNAME, "handleActivityResult: requestCode: " + i + " resultCode: " + i2);
        }
        GooglePlayWorker googlePlayWorker = m_pGooglePlayWorker;
        if (googlePlayWorker == null) {
            return false;
        }
        if (i != 9001) {
            if (i == REQUEST_AUTHORIZE) {
                Logging.CC_TRACE(CLASSNAME, "REQUEST_AUTHORIZE : Received");
            }
            if (i == REQUEST_CODE_PICK_ACCOUNT && i2 == -1) {
                DoResetAchievements();
            }
            return true;
        }
        boolean z = i2 == 0;
        if (i2 == -1) {
            Logging.CC_TRACE(CLASSNAME, "handleActivityResult:signin complete");
            SignInSilently();
        } else if (z) {
            googlePlayWorker.onGoogleSignInFailed(true);
        }
        return true;
    }

    public void Login(final long j, final boolean z) {
        Logging.CC_TRACE(CLASSNAME, "Google Login... Silent:" + z + " callback: " + j);
        CC_Component.GetActivity().runOnUiThread(new Runnable() { // from class: com.firemonkeys.cloudcellapi.GooglePlayWorker.2
            @Override // java.lang.Runnable
            public void run() {
                synchronized (GooglePlayWorker.lock) {
                    GooglePlayWorker.m_nLoginCallback = j;
                }
                GooglePlayWorker.m_bLoginSilent = z;
                GooglePlayWorker.m_bSignInFlow = true;
                Logging.CC_TRACE(GooglePlayWorker.CLASSNAME, "Calling SignInSilently");
                GooglePlayWorker.SignInSilently();
            }
        });
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void onGoogleSignInConnected() {
        Logging.CC_TRACE(CLASSNAME, "onGoogleSignInConnected , id: " + m_pGoogleIdTokenCredential.getIdToken() + ", name:" + m_pGoogleIdTokenCredential.getDisplayName());
        SetAutoConnect(true);
        LoadCurrentPlayer();
        CompleteInitialPhase();
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void onGoogleSignInFailed(boolean z) {
        m_pGoogleIdTokenCredential = null;
        m_bSignInFlow = false;
        if (z) {
            SetAutoConnect(false);
        }
        LoginCallback("", "", z);
        CompleteInitialPhase();
    }

    private void onGooglePlayConnected() {
        if (m_pGoogleIdTokenCredential == null) {
            Logging.CC_TRACE(CLASSNAME, "onConnected null user, disconnecting");
            LoginCallback("", "", false);
            CompleteInitialPhase();
            return;
        }
        Logging.CC_TRACE(CLASSNAME, "onConnected google plus id:" + GetGooglePlayId() + " name:" + GetDisplayName());
        SetAutoConnect(true);
        LoadCurrentPlayer();
    }

    public void LoginCallback(String str, String str2, boolean z) {
        synchronized (lock) {
            try {
                Logging.CC_TRACE(CLASSNAME, "LoginCallback person id:" + str + " name:" + str2 + " m_nLoginCallback: " + m_nLoginCallback);
                if (m_nLoginCallback != 0) {
                    Logging.CC_TRACE(CLASSNAME, "LoginCallback calling native callback");
                    NativeLoginCallback(str, str2, z, m_nLoginCallback);
                } else {
                    Logging.CC_TRACE(CLASSNAME, "LoginCallback no native callback");
                    m_bLoginChanged = true;
                }
                m_nLoginCallback = 0L;
                m_bSignInFlow = false;
            } catch (Throwable th) {
                throw th;
            }
        }
    }

    private void signOutAndClearDefaultAccount() {
        Logging.CC_TRACE(CLASSNAME, "signOutAndClearDefaultAccount");
        m_bIsAuthenticated = false;
        m_pPlayer = null;
    }

    public void Logout(long j) {
        Logging.CC_TRACE(CLASSNAME, "LOGOUT check remove connected account()");
        signOutAndClearDefaultAccount();
        m_pGoogleIdTokenCredential = null;
        SetAutoConnect(false);
        LogoutCallback(j);
    }

    public static void SignInToPlayGames() {
        Logging.CC_TRACE(CLASSNAME, "Inside SignInToPlayGames :" + m_bLoginSilent);
        m_bSignInFlow = true;
        if (m_bLoginSilent) {
            PlayGames.getGamesSignInClient(CC_Component.GetActivity()).isAuthenticated().addOnCompleteListener(new OnCompleteListener() { // from class: com.firemonkeys.cloudcellapi.GooglePlayWorker$$ExternalSyntheticLambda1
                @Override // com.google.android.gms.tasks.OnCompleteListener
                public final void onComplete(Task task) {
                    GooglePlayWorker.lambda$SignInToPlayGames$0(task);
                }
            });
        } else {
            PlayGames.getGamesSignInClient(CC_Component.GetActivity()).signIn().addOnCompleteListener(new OnCompleteListener() { // from class: com.firemonkeys.cloudcellapi.GooglePlayWorker$$ExternalSyntheticLambda2
                @Override // com.google.android.gms.tasks.OnCompleteListener
                public final void onComplete(Task task) {
                    GooglePlayWorker.lambda$SignInToPlayGames$2(task);
                }
            }).addOnFailureListener(new OnFailureListener() { // from class: com.firemonkeys.cloudcellapi.GooglePlayWorker$$ExternalSyntheticLambda3
                @Override // com.google.android.gms.tasks.OnFailureListener
                public final void onFailure(Exception exc) {
                    GooglePlayWorker.lambda$SignInToPlayGames$3(exc);
                }
            });
        }
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static /* synthetic */ void lambda$SignInToPlayGames$0(Task task) {
        if (task.isSuccessful() && ((AuthenticationResult) task.getResult()).isAuthenticated()) {
            m_bIsAuthenticated = true;
            Logging.CC_TRACE(CLASSNAME, "PlayGames Authentication : Success");
            OnPlayGamesLoggedIn();
        } else {
            OnPlayGamesLoginFailed();
            Logging.CC_TRACE(CLASSNAME, "PlayGames Authentication : Failed");
        }
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static /* synthetic */ void lambda$SignInToPlayGames$2(Task task) {
        if (task.isSuccessful()) {
            Logging.CC_TRACE(CLASSNAME, "PlayGames SignIn : Success");
            PlayGames.getGamesSignInClient(CC_Component.GetActivity()).isAuthenticated().addOnCompleteListener(new OnCompleteListener() { // from class: com.firemonkeys.cloudcellapi.GooglePlayWorker$$ExternalSyntheticLambda0
                @Override // com.google.android.gms.tasks.OnCompleteListener
                public final void onComplete(Task task2) {
                    GooglePlayWorker.lambda$SignInToPlayGames$1(task2);
                }
            });
        }
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static /* synthetic */ void lambda$SignInToPlayGames$1(Task task) {
        if (task.isSuccessful() && ((AuthenticationResult) task.getResult()).isAuthenticated()) {
            m_bIsAuthenticated = true;
            Logging.CC_TRACE(CLASSNAME, "PlayGames Authentication : Success");
            OnPlayGamesLoggedIn();
            m_pGooglePlayWorker.LoginCallback("", "", false);
            return;
        }
        OnPlayGamesLoginFailed();
        Logging.CC_TRACE(CLASSNAME, "PlayGames Authentication : Failed");
        m_pGooglePlayWorker.LoginCallback("", "", true);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static /* synthetic */ void lambda$SignInToPlayGames$3(Exception exc) {
        Logging.CC_TRACE(CLASSNAME, "PlayGames SignIn Exception: " + exc);
    }

    public static void OnPlayGamesLoggedIn() {
        SetAutoConnect(true);
        LoadCurrentPlayer();
        CompleteInitialPhase();
    }

    public static void OnPlayGamesLoginFailed() {
        m_bSignInFlow = false;
        SetAutoConnect(false);
        CompleteInitialPhase();
    }

    public static void LoadCurrentPlayer() {
        Logging.CC_TRACE(CLASSNAME, "LoadCurrentPlayer");
        CC_Component.GetActivity().runOnUiThread(new AnonymousClass3());
    }

    /* renamed from: com.firemonkeys.cloudcellapi.GooglePlayWorker$3, reason: invalid class name */
    public class AnonymousClass3 implements Runnable {
        @Override // java.lang.Runnable
        public void run() {
            PlayGames.getPlayersClient(CC_Component.GetActivity()).getCurrentPlayer().addOnSuccessListener(new OnSuccessListener() { // from class: com.firemonkeys.cloudcellapi.GooglePlayWorker$3$$ExternalSyntheticLambda0
                @Override // com.google.android.gms.tasks.OnSuccessListener
                public final void onSuccess(Object obj) {
                    GooglePlayWorker.AnonymousClass3.lambda$run$0((Player) obj);
                }
            }).addOnFailureListener(new OnFailureListener() { // from class: com.firemonkeys.cloudcellapi.GooglePlayWorker$3$$ExternalSyntheticLambda1
                @Override // com.google.android.gms.tasks.OnFailureListener
                public final void onFailure(Exception exc) {
                    GooglePlayWorker.AnonymousClass3.lambda$run$1(exc);
                }
            });
        }

        /* JADX INFO: Access modifiers changed from: private */
        public static /* synthetic */ void lambda$run$0(Player player) {
            Logging.CC_TRACE(GooglePlayWorker.CLASSNAME, player.getPlayerId() + "  " + player.getDisplayName());
            GooglePlayWorker.m_pPlayer = player;
            GooglePlayWorker.m_bLoginChanged = true;
            GooglePlayWorker.m_bSignInFlow = false;
            GooglePlayWorker.CompleteInitialPhase();
        }

        /* JADX INFO: Access modifiers changed from: private */
        public static /* synthetic */ void lambda$run$1(Exception exc) {
            Logging.CC_TRACE(GooglePlayWorker.CLASSNAME, "getCurrentPlayer Failed to get current player: " + exc);
            GooglePlayWorker.m_bSignInFlow = false;
            GooglePlayWorker.CompleteInitialPhase();
        }
    }

    public void LoadProfile(final String str, final long j) {
        Logging.CC_TRACE(CLASSNAME, "LoadProfile -" + str);
        if (m_pGoogleIdTokenCredential == null) {
            Logging.CC_TRACE(CLASSNAME, "GoogleApiClient null");
            LoadProfileCallback(false, new String[0], j);
        } else {
            CC_Component.GetActivity().runOnUiThread(new Runnable() { // from class: com.firemonkeys.cloudcellapi.GooglePlayWorker.4
                @Override // java.lang.Runnable
                public void run() {
                    PlayGames.getPlayersClient(CC_Component.GetActivity()).loadPlayer(str).addOnCompleteListener(new OnCompleteListener<AnnotatedData<Player>>() { // from class: com.firemonkeys.cloudcellapi.GooglePlayWorker.4.1
                        @Override // com.google.android.gms.tasks.OnCompleteListener
                        public void onComplete(@NonNull Task<AnnotatedData<Player>> task) {
                            String[] strArr = null;
                            boolean z = false;
                            if (task.isSuccessful()) {
                                Player player = task.getResult().get();
                                if (player != null) {
                                    try {
                                        strArr = new String[]{player.getPlayerId(), player.getDisplayName(), player.getIconImageUri().toString()};
                                        Logging.CC_TRACE(GooglePlayWorker.CLASSNAME, "onPlayerLoaded display name: " + player.getDisplayName() + " icon image uri: " + player.getIconImageUri().toString());
                                        z = true;
                                    } catch (Exception e) {
                                        Logging.CC_ERROR(GooglePlayWorker.CLASSNAME, "onPlayerLoaded exception, message: " + e.toString());
                                        e.printStackTrace();
                                    }
                                }
                                StringBuilder sb = new StringBuilder();
                                sb.append("onPlayerLoaded  ");
                                sb.append(z ? "SUCCESS" : "FAIL");
                                Logging.CC_TRACE(GooglePlayWorker.CLASSNAME, sb.toString());
                                synchronized (GooglePlayWorker.lock) {
                                    try {
                                        AnonymousClass4 anonymousClass4 = AnonymousClass4.this;
                                        long j2 = j;
                                        if (j2 != 0) {
                                            GooglePlayWorker.this.LoadProfileCallback(z, strArr, j2);
                                        }
                                    } finally {
                                    }
                                }
                                return;
                            }
                            Logging.CC_TRACE(GooglePlayWorker.CLASSNAME, "task failed: " + task.getException().getLocalizedMessage());
                            synchronized (GooglePlayWorker.lock) {
                                try {
                                    AnonymousClass4 anonymousClass42 = AnonymousClass4.this;
                                    long j3 = j;
                                    if (j3 != 0) {
                                        GooglePlayWorker.this.LoadProfileCallback(false, null, j3);
                                    }
                                } finally {
                                }
                            }
                        }
                    });
                }
            });
        }
    }

    public void LoadAvatar(final String str, final long j) {
        Logging.CC_TRACE(CLASSNAME, "LoadAvatar -" + str);
        final Activity GetActivity = CC_Component.GetActivity();
        GetActivity.runOnUiThread(new Runnable() { // from class: com.firemonkeys.cloudcellapi.GooglePlayWorker.5
            @Override // java.lang.Runnable
            public void run() {
                ImageManager.create(GetActivity.getApplicationContext()).loadImage(new ImageManager.OnImageLoadedListener() { // from class: com.firemonkeys.cloudcellapi.GooglePlayWorker.5.1
                    @Override // com.google.android.gms.common.images.ImageManager.OnImageLoadedListener
                    public void onImageLoaded(Uri uri, Drawable drawable, boolean z) {
                        byte[] bArr;
                        boolean z2;
                        if (drawable != null && z) {
                            try {
                                Bitmap bitmap = ((BitmapDrawable) drawable).getBitmap();
                                ByteArrayOutputStream byteArrayOutputStream = new ByteArrayOutputStream();
                                bitmap.compress(Bitmap.CompressFormat.PNG, 100, byteArrayOutputStream);
                                bArr = byteArrayOutputStream.toByteArray();
                                z2 = true;
                            } catch (Exception e) {
                                Logging.CC_ERROR(GooglePlayWorker.CLASSNAME, "LoadAvatar, '" + e.getMessage() + "' Cause: " + e.getCause());
                            }
                            Logging.CC_TRACE(GooglePlayWorker.CLASSNAME, "onImageLoaded - Finish");
                            AnonymousClass5 anonymousClass5 = AnonymousClass5.this;
                            GooglePlayWorker.this.LoadAvatarCallbackFunc(z2, bArr, j);
                        }
                        bArr = null;
                        z2 = false;
                        Logging.CC_TRACE(GooglePlayWorker.CLASSNAME, "onImageLoaded - Finish");
                        AnonymousClass5 anonymousClass52 = AnonymousClass5.this;
                        GooglePlayWorker.this.LoadAvatarCallbackFunc(z2, bArr, j);
                    }
                }, Uri.parse(str));
            }
        });
    }

    public void LoadFriendVector(long j) {
        Logging.CC_TRACE(CLASSNAME, "LoadFriendVector");
        Logging.CC_TRACE(CLASSNAME, "LoadFriendVector not supported by Google Play");
        LoadFriendVectorCallback(false, new String[0], new String[0], j);
    }

    public void LoadFriendVectorConnected(long j) {
        Logging.CC_TRACE(CLASSNAME, "LoadFriendVectorConnected");
        Logging.CC_TRACE(CLASSNAME, "LoadFriendVectorConnected not supported by Google Play");
        LoadFriendVectorCallback(false, new String[0], new String[0], j);
    }

    public void Share(String str, String str2, String str3, String str4, String str5, String str6, byte[] bArr, String str7, String str8, String str9, final long j) {
        CC_Component.GetActivity().runOnUiThread(new Runnable() { // from class: com.firemonkeys.cloudcellapi.GooglePlayWorker.6
            @Override // java.lang.Runnable
            public void run() {
                synchronized (GooglePlayWorker.lock) {
                    GooglePlayWorker.m_nShareCallback = j;
                }
                Logging.CC_TRACE(GooglePlayWorker.CLASSNAME, "Share not supported by Google Play");
                GooglePlayWorker.ShareCallback(false, false);
            }
        });
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static void ShareCallback(boolean z, boolean z2) {
        synchronized (lock) {
            try {
                Logging.CC_TRACE(CLASSNAME, "ShareCallback. Success: " + z);
                long j = m_nShareCallback;
                if (j != 0) {
                    m_pGooglePlayWorker.ShareCallback(z, z2, j);
                    m_nShareCallback = 0L;
                }
            } catch (Throwable th) {
                throw th;
            }
        }
    }

    public void UnlockAchievement(String str) {
        Logging.CC_INFO(CLASSNAME, "Attempting to unlock Achievement:" + str);
        PlayGames.getAchievementsClient(CC_Component.GetActivity()).unlock(str);
        Logging.CC_TRACE(CLASSNAME, "getAchievementsClient unlock() called. AchievementId:" + str);
    }

    public void ShowAchievements() {
        PlayGames.getAchievementsClient(CC_Component.GetActivity()).getAchievementsIntent().addOnSuccessListener(new OnSuccessListener<Intent>() { // from class: com.firemonkeys.cloudcellapi.GooglePlayWorker.7
            @Override // com.google.android.gms.tasks.OnSuccessListener
            public void onSuccess(Intent intent) {
                CC_Component.GetActivity().startActivityForResult(intent, GooglePlayWorker.RC_ACHIEVEMENT_UI);
            }
        });
    }

    public void ResetAchievements() {
        Logging.CC_TRACE(CLASSNAME, "Resetting achievements...");
        if (m_pCredentialManager == null) {
            return;
        }
        CC_Component.GetActivity().startActivityForResult(AccountPicker.newChooseAccountIntent(null, null, new String[]{"com.google"}, false, null, null, null, null), REQUEST_CODE_PICK_ACCOUNT);
    }

    public static void DoResetAchievements() {
        Logging.CC_TRACE(CLASSNAME, "Actually resetting achievements...");
        new Thread(new Runnable() { // from class: com.firemonkeys.cloudcellapi.GooglePlayWorker.8
            @Override // java.lang.Runnable
            public void run() {
                try {
                    String idToken = GooglePlayWorker.m_pGoogleIdTokenCredential.getIdToken();
                    Logging.CC_TRACE(GooglePlayWorker.CLASSNAME, "ResetAchievements AccessToken:" + idToken);
                    Logging.CC_TRACE(GooglePlayWorker.CLASSNAME, EntityUtils.toString(FirebasePerfHttpClient.execute(new DefaultHttpClient(), new HttpPost("https://www.googleapis.com/games/v1management/achievements/reset?access_token=" + idToken)).getEntity()));
                } catch (Exception e) {
                    Logging.CC_ERROR(GooglePlayWorker.CLASSNAME, "ResetAchievements exception.");
                    e.printStackTrace();
                }
            }
        }).start();
    }

    public boolean GetLoginInProgress() {
        Logging.CC_TRACE(CLASSNAME, "GetLoginInProgress() - m_pGoogleSignApiClient.isConnecting: " + m_bSignInFlow);
        return m_bIsAuthenticated && m_bSignInFlow;
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static void CompleteInitialPhase() {
        synchronized (lock) {
            Logging.CC_TRACE(CLASSNAME, "Complete Initial Phase");
            m_bIsInitialPhaseComplete = true;
        }
    }

    public boolean GetSessionChanged() {
        boolean z;
        synchronized (lock) {
            z = m_bLoginChanged;
            m_bLoginChanged = false;
        }
        return z;
    }

    public String GetDisplayName() {
        Player GetCurrentPlayer = GetCurrentPlayer();
        return GetCurrentPlayer != null ? GetCurrentPlayer.getDisplayName() : "";
    }

    public String GetGooglePlusId() {
        Player GetCurrentPlayer = GetCurrentPlayer();
        return GetCurrentPlayer != null ? GetCurrentPlayer.getPlayerId() : "";
    }

    public String GetGooglePlusName() {
        Player GetCurrentPlayer = GetCurrentPlayer();
        return GetCurrentPlayer != null ? GetCurrentPlayer.getDisplayName() : "";
    }

    public String GetGooglePlayId() {
        Player GetCurrentPlayer = GetCurrentPlayer();
        String playerId = GetCurrentPlayer != null ? GetCurrentPlayer.getPlayerId() : "";
        return playerId != null ? playerId : "";
    }

    public String GetGooglePlayName() {
        Player GetCurrentPlayer = GetCurrentPlayer();
        String displayName = GetCurrentPlayer != null ? GetCurrentPlayer.getDisplayName() : "";
        return displayName != null ? displayName : "";
    }

    public boolean IsNativeAppInstalled() {
        return GetInfo.DoesPackageExist("com.google.android.apps.plus");
    }

    private static void ClearTempDirectory() {
        PurgeDirectory(GetTempDirectory());
    }

    private static void PurgeDirectory(File file) {
        File[] listFiles;
        if (file == null || (listFiles = file.listFiles()) == null) {
            return;
        }
        for (File file2 : listFiles) {
            file2.delete();
        }
    }

    private static File GetTempDirectory() {
        File cacheDir = CC_Component.GetActivity().getApplicationContext().getCacheDir();
        if (cacheDir != null) {
            File file = new File(cacheDir.getAbsolutePath() + "/GooglePlusShareTemp/");
            if (file.exists() || file.mkdirs()) {
                return file;
            }
        }
        Logging.CC_ERROR(CLASSNAME, "Failed to create the temp directory");
        return null;
    }
}