package com.firemonkeys.cloudcellapi;

import android.app.Activity;
import android.app.UiModeManager;
import android.content.Intent;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.net.Uri;
import android.os.Bundle;
import com.facebook.AccessToken;
import com.facebook.CallbackManager;
import com.facebook.FacebookCallback;
import com.facebook.FacebookException;
import com.facebook.FacebookSdk;
import com.facebook.GraphRequest;
import com.facebook.GraphResponse;
import com.facebook.HttpMethod;
import com.facebook.Profile;
import com.facebook.ProfileTracker;
import com.facebook.internal.CallbackManagerImpl;
import com.facebook.login.DefaultAudience;
import com.facebook.login.LoginBehavior;
import com.facebook.login.LoginManager;
import com.facebook.login.LoginResult;
import com.facebook.share.Sharer;
import com.facebook.share.internal.ShareConstants;
import com.facebook.share.model.GameRequestContent;
import com.facebook.share.model.ShareContent;
import com.facebook.share.model.ShareLinkContent;
import com.facebook.share.widget.GameRequestDialog;
import com.facebook.share.widget.ShareDialog;
import com.firemonkeys.cloudcellapi.util.GetInfo;
import java.nio.ByteBuffer;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;
import org.json.JSONArray;
import org.json.JSONObject;

/* loaded from: classes2.dex */
public class FacebookWorker {
    private static String CLASSNAME = "FacebookWorker";
    private static final String MANAGE_PERMISSION_PREFIX = "manage";
    private static final String PUBLISH_PERMISSION_PREFIX = "publish";
    private static CallbackManager s_CallbackManager = CallbackManager.Factory.create();
    private static Set<String> OTHER_PUBLISH_PERMISSIONS = getOtherPublishPermissions();
    private static FacebookWorker s_pSingleton = null;
    private static int m_PermissionsRequested = 0;
    static long m_sCallback = 0;
    static long m_sUserPtr = 0;
    private ProfileTracker m_ProfileTracker = null;
    private ShareDialog m_ShareDialog = null;
    private GameRequestDialog m_InviteDialog = null;

    private native void FeedPostCallback(boolean z, long j, long j2);

    private native void FriendInviteCallback(boolean z, long j, long j2);

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

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

    private native void LoginCallback(String str, String str2, String str3, String str4, String str5, long j, long j2);

    private native void LogoutCallback(long j, long j2);

    private native void PermissionCheckCallback(boolean z, long j, long j2);

    private native void PermissionGrantCallback(boolean z, long j, long j2);

    private native void PhotoPostCallback(boolean z, long j, long j2);

    public FacebookWorker() {
        s_pSingleton = this;
    }

    public void Constructor(String str) {
        Logging.CC_TRACE(CLASSNAME, "Constructor called");
        Logging.CC_TRACE(CLASSNAME, "using version: " + FacebookSdk.getSdkVersion());
        if (str != FacebookSdk.getApplicationId()) {
            Logging.CC_TRACE(CLASSNAME, "Constructor current ApplicationId: " + FacebookSdk.getApplicationId() + ", setting to: " + str);
            FacebookSdk.setApplicationId(str);
        }
        if (FacebookSdk.isInitialized()) {
            return;
        }
        Logging.CC_TRACE(CLASSNAME, "Constructor Sdk isn't initialized!");
    }

    public void setAutoInitEnabled(boolean z) {
        if (z) {
            FacebookSdk.setAutoInitEnabled(true);
            FacebookSdk.fullyInitialize();
        } else {
            FacebookSdk.setAutoInitEnabled(false);
        }
    }

    public void setAutoLogAppEventsEnabled(boolean z) {
        FacebookSdk.setAutoLogAppEventsEnabled(z);
    }

    public static boolean handleActivityResult(int i, int i2, Intent intent) {
        if (!FacebookSdk.isInitialized()) {
            return false;
        }
        Logging.CC_TRACE(CLASSNAME, "handleActivityResult");
        if (s_CallbackManager.onActivityResult(i, i2, intent)) {
            return true;
        }
        Logging.CC_TRACE(CLASSNAME, "handleActivityResult unhandled");
        if (i2 == 0 && m_sCallback != 0 && m_sUserPtr != 0) {
            if (i == CallbackManagerImpl.RequestCodeOffset.AppInvite.toRequestCode() || i == CallbackManagerImpl.RequestCodeOffset.GameRequest.toRequestCode()) {
                Logging.CC_ERROR(CLASSNAME, "Cancel called on friend invite, manually calling back");
                s_pSingleton.OnFriendInviteFailure(m_sCallback, m_sUserPtr);
                return true;
            }
            if (i == CallbackManagerImpl.RequestCodeOffset.Share.toRequestCode()) {
                Logging.CC_ERROR(CLASSNAME, "Cancel called on share, manually calling back");
                s_pSingleton.OnFeedPostFailure(m_sCallback, m_sUserPtr);
                return true;
            }
        }
        return false;
    }

    public boolean GetSessionValid() {
        return !GetAccessToken().isEmpty();
    }

    public String GetAccessToken() {
        AccessToken currentAccessToken = AccessToken.getCurrentAccessToken();
        return currentAccessToken != null ? currentAccessToken.getToken() : "";
    }

    /* JADX INFO: Access modifiers changed from: private */
    public static boolean isPublishPermission(String str) {
        return str != null && (str.startsWith(PUBLISH_PERMISSION_PREFIX) || str.startsWith(MANAGE_PERMISSION_PREFIX) || OTHER_PUBLISH_PERMISSIONS.contains(str));
    }

    private static List<String> GetReadPermissions(String[] strArr) {
        ArrayList arrayList = new ArrayList();
        for (int i = 0; i < strArr.length; i++) {
            if (!isPublishPermission(strArr[i])) {
                arrayList.add(strArr[i]);
            }
        }
        return arrayList;
    }

    private static List<String> GetPublishPermissions(String[] strArr) {
        ArrayList arrayList = new ArrayList();
        for (int i = 0; i < strArr.length; i++) {
            if (isPublishPermission(strArr[i])) {
                arrayList.add(strArr[i]);
            }
        }
        return arrayList;
    }

    private static Set<String> getOtherPublishPermissions() {
        return Collections.unmodifiableSet(new HashSet<String>() { // from class: com.firemonkeys.cloudcellapi.FacebookWorker.1
            {
                add("ads_management");
                add("create_event");
                add("rsvp_event");
            }
        });
    }

    public boolean IsNativeAppInstalled() {
        return GetInfo.DoesPackageExist("com.facebook.katana");
    }

    public void Login(final String[] strArr, boolean z, final long j, final long j2) {
        Logging.CC_TRACE(CLASSNAME, "Login called");
        if (!z && GetSessionValid() && AccessToken.getCurrentAccessToken().getPermissions().containsAll(Collections.unmodifiableSet(new HashSet(Arrays.asList(strArr))))) {
            OnLoginSuccess(j, j2);
            return;
        }
        Activity GetActivity = CC_Activity.GetActivity();
        LoginManager loginManager = LoginManager.getInstance();
        if (((UiModeManager) GetActivity.getSystemService("uimode")).getCurrentModeType() == 4) {
            loginManager.setLoginBehavior(LoginBehavior.DEVICE_AUTH);
        } else {
            loginManager.setLoginBehavior(LoginBehavior.NATIVE_WITH_FALLBACK);
        }
        loginManager.setDefaultAudience(DefaultAudience.EVERYONE);
        loginManager.registerCallback(s_CallbackManager, new FacebookCallback<LoginResult>() { // from class: com.firemonkeys.cloudcellapi.FacebookWorker.2
            @Override // com.facebook.FacebookCallback
            public void onSuccess(LoginResult loginResult) {
                Logging.CC_TRACE(FacebookWorker.CLASSNAME, "Login succeeded");
                FacebookWorker.this.OnLoginSuccess(j, j2);
            }

            @Override // com.facebook.FacebookCallback
            public void onCancel() {
                Logging.CC_TRACE(FacebookWorker.CLASSNAME, "Login cancelled");
                FacebookWorker.this.OnLoginFailure(j, j2);
            }

            @Override // com.facebook.FacebookCallback
            public void onError(FacebookException facebookException) {
                Logging.CC_ERROR(FacebookWorker.CLASSNAME, "Login failed. Error: " + facebookException.toString());
                FacebookWorker.this.OnLoginFailure(j, j2);
            }
        });
        if (this.m_ProfileTracker != null) {
            Logging.CC_TRACE(CLASSNAME, "Login profile tracker still running? Killing it.");
            this.m_ProfileTracker.stopTracking();
            this.m_ProfileTracker = null;
        }
        GetActivity.runOnUiThread(new Runnable() { // from class: com.firemonkeys.cloudcellapi.FacebookWorker.3
            @Override // java.lang.Runnable
            public void run() {
                ArrayList arrayList = new ArrayList();
                int i = 0;
                while (true) {
                    String[] strArr2 = strArr;
                    if (i < strArr2.length) {
                        if (!FacebookWorker.isPublishPermission(strArr2[i])) {
                            arrayList.add(strArr[i]);
                        }
                        i++;
                    } else {
                        Logging.CC_TRACE(FacebookWorker.CLASSNAME, "Logging in with permissions: " + arrayList.toString());
                        LoginManager.getInstance().logInWithReadPermissions(CC_Activity.GetActivity(), arrayList);
                        return;
                    }
                }
            }
        });
    }

    public void Logout(long j, long j2) {
        Logging.CC_TRACE(CLASSNAME, "Logout called");
        LoginManager.getInstance().logOut();
        Logging.CC_TRACE(CLASSNAME, "Facebook account is logged out");
        OnLogout(j, j2);
    }

    public void PermissionCheck(String[] strArr, long j, long j2) {
        Logging.CC_TRACE(CLASSNAME, "PermissionCheck called");
        AccessToken currentAccessToken = AccessToken.getCurrentAccessToken();
        if (!GetSessionValid() || currentAccessToken == null) {
            Logging.CC_ERROR(CLASSNAME, "Facebook account is not logged in!");
            OnPermissionCheckFailure(j, j2);
            return;
        }
        Set<String> permissions = currentAccessToken.getPermissions();
        for (int i = 0; i < strArr.length; i++) {
            if (!permissions.contains(strArr[i])) {
                Logging.CC_ERROR(CLASSNAME, "Facebook permission check failed, missing permission: " + strArr[i]);
                OnPermissionCheckFailure(j, j2);
                return;
            }
        }
        OnPermissionCheckSuccess(j, j2);
    }

    public void PermissionGrant(String[] strArr, final long j, final long j2) {
        Logging.CC_TRACE(CLASSNAME, "PermissionGrant called");
        final List<String> GetReadPermissions = GetReadPermissions(strArr);
        final List<String> GetPublishPermissions = GetPublishPermissions(strArr);
        if (!GetSessionValid()) {
            Logging.CC_TRACE(CLASSNAME, "Facebook account is not logged in!");
            OnPermissionGrantFailure(j, j2);
            return;
        }
        AccessToken currentAccessToken = AccessToken.getCurrentAccessToken();
        Set<String> permissions = currentAccessToken.getPermissions();
        if (permissions.containsAll(GetReadPermissions) && permissions.containsAll(GetPublishPermissions) && !currentAccessToken.isDataAccessExpired()) {
            OnPermissionGrantSuccess(j, j2);
            return;
        }
        final LoginManager loginManager = LoginManager.getInstance();
        loginManager.registerCallback(s_CallbackManager, new FacebookCallback<LoginResult>() { // from class: com.firemonkeys.cloudcellapi.FacebookWorker.4
            @Override // com.facebook.FacebookCallback
            public void onSuccess(LoginResult loginResult) {
                Logging.CC_TRACE(FacebookWorker.CLASSNAME, "PermissionGrant successfully with result");
                int i = FacebookWorker.m_PermissionsRequested - 1;
                FacebookWorker.m_PermissionsRequested = i;
                if (i == 0) {
                    FacebookWorker.this.OnPermissionGrantSuccess(j, j2);
                }
            }

            @Override // com.facebook.FacebookCallback
            public void onCancel() {
                Logging.CC_TRACE(FacebookWorker.CLASSNAME, "PermissionGrant cancelled");
                int i = FacebookWorker.m_PermissionsRequested - 1;
                FacebookWorker.m_PermissionsRequested = i;
                if (i == 0) {
                    FacebookWorker.this.OnPermissionGrantFailure(j, j2);
                }
            }

            @Override // com.facebook.FacebookCallback
            public void onError(FacebookException facebookException) {
                Logging.CC_ERROR(FacebookWorker.CLASSNAME, "PermissionGrant failed. Error: " + facebookException.toString());
                int i = FacebookWorker.m_PermissionsRequested + (-1);
                FacebookWorker.m_PermissionsRequested = i;
                if (i == 0) {
                    FacebookWorker.this.OnPermissionGrantFailure(j, j2);
                }
            }
        });
        CC_Activity.GetActivity().runOnUiThread(new Runnable() { // from class: com.firemonkeys.cloudcellapi.FacebookWorker.5
            @Override // java.lang.Runnable
            public void run() {
                if (AccessToken.getCurrentAccessToken().isDataAccessExpired()) {
                    loginManager.reauthorizeDataAccess(CC_Activity.GetActivity());
                    return;
                }
                FacebookWorker.m_PermissionsRequested = (!GetReadPermissions.isEmpty() ? 1 : 0) + (!GetPublishPermissions.isEmpty() ? 1 : 0);
                if (!GetReadPermissions.isEmpty()) {
                    Logging.CC_TRACE(FacebookWorker.CLASSNAME, "Logging in with read permissions: " + GetReadPermissions.toString());
                    LoginManager.getInstance().logInWithReadPermissions(CC_Activity.GetActivity(), GetReadPermissions);
                }
                if (GetPublishPermissions.isEmpty()) {
                    return;
                }
                Logging.CC_TRACE(FacebookWorker.CLASSNAME, "Logging in with publish permissions: " + GetPublishPermissions.toString());
                LoginManager.getInstance().logInWithPublishPermissions(CC_Activity.GetActivity(), GetPublishPermissions);
            }
        });
    }

    public void LoadFriendVector(final long j, final long j2) {
        Logging.CC_TRACE(CLASSNAME, "LoadFriendVector called");
        if (!GetSessionValid()) {
            Logging.CC_TRACE(CLASSNAME, "Facebook account is not logged in!");
            OnLoadFriendFailure(j, j2);
        } else {
            CC_Activity.GetActivity().runOnUiThread(new Runnable() { // from class: com.firemonkeys.cloudcellapi.FacebookWorker.6
                @Override // java.lang.Runnable
                public void run() {
                    AccessToken currentAccessToken = AccessToken.getCurrentAccessToken();
                    Bundle bundle = new Bundle();
                    bundle.putInt("limit", 100);
                    new GraphRequest(currentAccessToken, "/me/friends", bundle, HttpMethod.GET, new GraphRequest.Callback() { // from class: com.firemonkeys.cloudcellapi.FacebookWorker.6.1
                        List<String> sFacebookIdArray = new ArrayList();
                        List<String> sNameArray = new ArrayList();

                        @Override // com.facebook.GraphRequest.Callback
                        public void onCompleted(GraphResponse graphResponse) {
                            try {
                                JSONObject jSONObject = graphResponse.getJSONObject();
                                if (jSONObject != null) {
                                    Logging.CC_TRACE(FacebookWorker.CLASSNAME, "Facebook friends request received");
                                    JSONArray jSONArray = jSONObject.getJSONArray("data");
                                    if (jSONArray != null) {
                                        Logging.CC_TRACE(FacebookWorker.CLASSNAME, "Facebook friends request received data: " + jSONArray.toString());
                                        for (int i = 0; i < jSONArray.length(); i++) {
                                            JSONObject optJSONObject = jSONArray.optJSONObject(i);
                                            if (optJSONObject != null) {
                                                this.sFacebookIdArray.add(optJSONObject.optString("id", ""));
                                                this.sNameArray.add(optJSONObject.optString("name", ""));
                                            }
                                        }
                                    }
                                    GraphRequest requestForPagedResults = graphResponse.getRequestForPagedResults(GraphResponse.PagingDirection.NEXT);
                                    if (requestForPagedResults != null) {
                                        Logging.CC_TRACE(FacebookWorker.CLASSNAME, "Requesting next friends page");
                                        requestForPagedResults.setCallback(this);
                                        requestForPagedResults.executeAsync();
                                        return;
                                    }
                                    Logging.CC_TRACE(FacebookWorker.CLASSNAME, "Calling back");
                                    FacebookWorker facebookWorker = FacebookWorker.this;
                                    List<String> list = this.sFacebookIdArray;
                                    String[] strArr = (String[]) list.toArray(new String[list.size()]);
                                    List<String> list2 = this.sNameArray;
                                    String[] strArr2 = (String[]) list2.toArray(new String[list2.size()]);
                                    AnonymousClass6 anonymousClass6 = AnonymousClass6.this;
                                    facebookWorker.OnLoadFriendSuccess(strArr, strArr2, j, j2);
                                    return;
                                }
                                Logging.CC_ERROR(FacebookWorker.CLASSNAME, "Facebook friends request failed. Error: " + graphResponse.getError());
                                AnonymousClass6 anonymousClass62 = AnonymousClass6.this;
                                FacebookWorker.this.OnLoadFriendFailure(j, j2);
                            } catch (Exception e) {
                                Logging.CC_ERROR(FacebookWorker.CLASSNAME, "Facebook friends request failed. Exception: " + e.getMessage());
                                AnonymousClass6 anonymousClass63 = AnonymousClass6.this;
                                FacebookWorker.this.OnLoadFriendFailure(j, j2);
                            }
                        }
                    }).executeAsync();
                }
            });
        }
    }

    public void LoadAvatarUrl(final long j, final String str, final boolean z) {
        Logging.CC_TRACE(CLASSNAME, "LoadAvatarUrl called");
        CC_Activity.GetActivity().runOnUiThread(new Runnable() { // from class: com.firemonkeys.cloudcellapi.FacebookWorker.7
            @Override // java.lang.Runnable
            public void run() {
                AccessToken.getCurrentAccessToken();
                String str2 = "/" + str + "/picture?redirect=false&fields=url";
                if (z) {
                    str2 = str2 + "&breaking_change=profile_picture";
                }
                new GraphRequest(null, str2, null, HttpMethod.GET, new GraphRequest.Callback() { // from class: com.firemonkeys.cloudcellapi.FacebookWorker.7.1
                    @Override // com.facebook.GraphRequest.Callback
                    public void onCompleted(GraphResponse graphResponse) {
                        try {
                            JSONObject jSONObject = graphResponse.getJSONObject();
                            if (jSONObject != null) {
                                Logging.CC_TRACE(FacebookWorker.CLASSNAME, "Facebook LoadAvatarUrl response received");
                                String string = jSONObject.getJSONObject("data").getString("url");
                                if (!string.isEmpty()) {
                                    AnonymousClass7 anonymousClass7 = AnonymousClass7.this;
                                    FacebookWorker.this.OnLoadAvatarUrlSuccess(string, j);
                                } else {
                                    AnonymousClass7 anonymousClass72 = AnonymousClass7.this;
                                    FacebookWorker.this.OnLoadAvatarUrlFailure(j);
                                }
                            } else {
                                Logging.CC_TRACE(FacebookWorker.CLASSNAME, "Facebook LoadAvatarUrl GraphRequest returned a null responseJson: " + graphResponse.toString());
                                AnonymousClass7 anonymousClass73 = AnonymousClass7.this;
                                FacebookWorker.this.OnLoadAvatarUrlFailure(j);
                            }
                        } catch (Exception e) {
                            Logging.CC_ERROR(FacebookWorker.CLASSNAME, "Facebook LoadAvatarUrl request failed. Exception: " + e.getMessage());
                            AnonymousClass7 anonymousClass74 = AnonymousClass7.this;
                            FacebookWorker.this.OnLoadAvatarUrlFailure(j);
                        }
                    }
                }).executeAsync();
            }
        });
    }

    public void FeedPost(final String str, final String str2, final String str3, final String str4, final String str5, String str6, boolean z, final long j, final long j2) {
        String str7 = CLASSNAME;
        StringBuilder sb = new StringBuilder();
        sb.append("FeedPost called with: [ShowDialog=");
        sb.append(z ? "TRUE]" : "FALSE]");
        Logging.CC_TRACE(str7, sb.toString());
        m_sCallback = j;
        m_sUserPtr = j2;
        if (z) {
            if (this.m_ShareDialog == null) {
                this.m_ShareDialog = new ShareDialog(CC_Activity.GetActivity());
            }
            this.m_ShareDialog.registerCallback(s_CallbackManager, new FacebookCallback<Sharer.Result>() { // from class: com.firemonkeys.cloudcellapi.FacebookWorker.8
                @Override // com.facebook.FacebookCallback
                public void onSuccess(Sharer.Result result) {
                    Logging.CC_TRACE(FacebookWorker.CLASSNAME, "FeedPost successfully with postId: " + result.getPostId());
                    FacebookWorker.this.OnFeedPostSuccess(j, j2);
                }

                @Override // com.facebook.FacebookCallback
                public void onCancel() {
                    Logging.CC_TRACE(FacebookWorker.CLASSNAME, "FeedPost cancelled");
                    FacebookWorker.this.OnFeedPostFailure(j, j2);
                }

                @Override // com.facebook.FacebookCallback
                public void onError(FacebookException facebookException) {
                    Logging.CC_ERROR(FacebookWorker.CLASSNAME, "FeedPost failed. Error: " + facebookException.toString());
                    FacebookWorker.this.OnFeedPostFailure(j, j2);
                }
            });
            if (ShareDialog.canShow((Class<? extends ShareContent<?, ?>>) ShareLinkContent.class)) {
                this.m_ShareDialog.show(new ShareLinkContent.Builder().setContentUrl(Uri.parse(str4)).build());
                return;
            }
            return;
        }
        CC_Activity.GetActivity().runOnUiThread(new Runnable() { // from class: com.firemonkeys.cloudcellapi.FacebookWorker.9
            @Override // java.lang.Runnable
            public void run() {
                try {
                    GraphRequest.newPostRequest(AccessToken.getCurrentAccessToken(), "me/feed", new JSONObject().put("name", str).put(ShareConstants.FEED_CAPTION_PARAM, str2).put("description", str3).put("link", str4).put("picture", str5), new GraphRequest.Callback() { // from class: com.firemonkeys.cloudcellapi.FacebookWorker.9.1
                        @Override // com.facebook.GraphRequest.Callback
                        public void onCompleted(GraphResponse graphResponse) {
                            if (graphResponse.getError() != null) {
                                Logging.CC_TRACE(FacebookWorker.CLASSNAME, "FeedPost Error:" + graphResponse.getError());
                                AnonymousClass9 anonymousClass9 = AnonymousClass9.this;
                                FacebookWorker.this.OnFeedPostFailure(j, j2);
                                return;
                            }
                            AnonymousClass9 anonymousClass92 = AnonymousClass9.this;
                            FacebookWorker.this.OnFeedPostSuccess(j, j2);
                        }
                    }).executeAsync();
                } catch (Exception e) {
                    Logging.CC_ERROR(FacebookWorker.CLASSNAME, "FeedPost() Exception:" + e.getMessage());
                    FacebookWorker.this.OnFeedPostFailure(j, j2);
                }
            }
        });
    }

    public void PhotoPost(final String str, byte[] bArr, final long j, final long j2) {
        Logging.CC_TRACE(CLASSNAME, String.format("PhotoPost called [caption: %s] [imagelen: %x]", str, Integer.valueOf(bArr.length)));
        if (bArr.length == 0) {
            Logging.CC_ERROR(CLASSNAME, "Image is invalid");
        }
        final Bitmap decodeByteArray = BitmapFactory.decodeByteArray(bArr, 0, bArr.length);
        CC_Activity.GetActivity().runOnUiThread(new Runnable() { // from class: com.firemonkeys.cloudcellapi.FacebookWorker.10
            @Override // java.lang.Runnable
            public void run() {
                try {
                    GraphRequest.newUploadPhotoRequest(AccessToken.getCurrentAccessToken(), "me/photos", decodeByteArray, str, (Bundle) null, new GraphRequest.Callback() { // from class: com.firemonkeys.cloudcellapi.FacebookWorker.10.1
                        @Override // com.facebook.GraphRequest.Callback
                        public void onCompleted(GraphResponse graphResponse) {
                            if (graphResponse.getError() != null) {
                                Logging.CC_TRACE(FacebookWorker.CLASSNAME, "PhotoPost Error:" + graphResponse.getError());
                                AnonymousClass10 anonymousClass10 = AnonymousClass10.this;
                                FacebookWorker.this.OnPhotoPostFailure(j, j2);
                                return;
                            }
                            AnonymousClass10 anonymousClass102 = AnonymousClass10.this;
                            FacebookWorker.this.OnPhotoPostSuccess(j, j2);
                        }
                    }).executeAsync();
                } catch (Exception e) {
                    Logging.CC_ERROR(FacebookWorker.CLASSNAME, "PhotoPost() Exception:" + e.getMessage());
                    FacebookWorker.this.OnPhotoPostFailure(j, j2);
                }
            }
        });
    }

    public void FriendInvite(String str, String str2, final long j, final long j2) {
        Logging.CC_TRACE(CLASSNAME, "FriendInvite() Title: " + str + ", Message: " + str2);
        if (this.m_InviteDialog == null) {
            this.m_InviteDialog = new GameRequestDialog(CC_Activity.GetActivity());
        }
        m_sCallback = j;
        m_sUserPtr = j2;
        this.m_InviteDialog.registerCallback(s_CallbackManager, new FacebookCallback<GameRequestDialog.Result>() { // from class: com.firemonkeys.cloudcellapi.FacebookWorker.11
            @Override // com.facebook.FacebookCallback
            public void onSuccess(GameRequestDialog.Result result) {
                Logging.CC_TRACE(FacebookWorker.CLASSNAME, "FriendInvite successfully with PostId: " + result.getRequestId());
                FacebookWorker.this.OnFriendInviteSuccess(j, j2);
            }

            @Override // com.facebook.FacebookCallback
            public void onCancel() {
                Logging.CC_TRACE(FacebookWorker.CLASSNAME, "PermissionGrant cancelled");
                FacebookWorker.this.OnFriendInviteFailure(j, j2);
            }

            @Override // com.facebook.FacebookCallback
            public void onError(FacebookException facebookException) {
                Logging.CC_ERROR(FacebookWorker.CLASSNAME, "PermissionGrant failed. Error: " + facebookException.toString());
                FacebookWorker.this.OnFriendInviteFailure(j, j2);
            }
        });
        if (GameRequestDialog.canShow()) {
            this.m_InviteDialog.show(new GameRequestContent.Builder().setTitle(str).setMessage(str2).setFilters(GameRequestContent.Filters.APP_NON_USERS).build());
        }
    }

    public class AvatarInfo {
        byte[] data;
        int nChannels;
        int nHeight;
        int nWidth;

        public AvatarInfo() {
        }
    }

    public AvatarInfo DecodeAvatar(byte[] bArr, int i) {
        AvatarInfo avatarInfo = new AvatarInfo();
        Bitmap decodeByteArray = BitmapFactory.decodeByteArray(bArr, 0, i);
        if (decodeByteArray != null) {
            int byteCount = decodeByteArray.getByteCount();
            avatarInfo.nWidth = decodeByteArray.getWidth();
            avatarInfo.nHeight = decodeByteArray.getHeight();
            avatarInfo.nChannels = byteCount / (decodeByteArray.getWidth() * decodeByteArray.getHeight());
            ByteBuffer allocate = ByteBuffer.allocate(byteCount);
            decodeByteArray.copyPixelsToBuffer(allocate);
            avatarInfo.data = allocate.array();
            decodeByteArray.recycle();
        }
        return avatarInfo;
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void OnLoginSuccess(final long j, final long j2) {
        AccessToken currentAccessToken = AccessToken.getCurrentAccessToken();
        if (currentAccessToken == null) {
            Logging.CC_ERROR(CLASSNAME, "Facebook login failed. Token invalid!");
            OnLoginFailure(j, j2);
            return;
        }
        Profile currentProfile = Profile.getCurrentProfile();
        if (currentProfile == null) {
            if (this.m_ProfileTracker == null) {
                Logging.CC_TRACE(CLASSNAME, "Profile is empty after login. Waiting until profile is fully loaded.");
                ProfileTracker profileTracker = new ProfileTracker() { // from class: com.firemonkeys.cloudcellapi.FacebookWorker.12
                    @Override // com.facebook.ProfileTracker
                    public void onCurrentProfileChanged(Profile profile, Profile profile2) {
                        if (profile2 != null) {
                            Logging.CC_TRACE(FacebookWorker.CLASSNAME, "Profile loaded");
                            FacebookWorker.this.OnLoginSuccess(j, j2);
                        } else {
                            FacebookWorker.this.OnLoginFailure(j, j2);
                        }
                    }
                };
                this.m_ProfileTracker = profileTracker;
                profileTracker.startTracking();
                return;
            }
            Logging.CC_TRACE(CLASSNAME, "Facebook login failed. Profile invalid!");
            OnLoginFailure(j, j2);
        }
        ProfileTracker profileTracker2 = this.m_ProfileTracker;
        if (profileTracker2 != null) {
            profileTracker2.stopTracking();
            this.m_ProfileTracker = null;
        }
        String str = CLASSNAME;
        StringBuilder sb = new StringBuilder();
        sb.append("Facebook login succeeded. Token Id: ");
        sb.append(currentAccessToken.getUserId());
        sb.append(", Profile Name: ");
        sb.append(currentProfile != null ? currentProfile.getName() : "ERROR");
        Logging.CC_TRACE(str, sb.toString());
        LoginCallback(currentAccessToken.getUserId(), currentProfile.getName(), currentProfile.getFirstName(), currentProfile.getMiddleName(), currentProfile.getLastName(), j, j2);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void OnLoginFailure(long j, long j2) {
        Logging.CC_TRACE(CLASSNAME, "Facebook login failed");
        LoginCallback("0", "", "", "", "", j, j2);
    }

    private void OnLogout(long j, long j2) {
        Logging.CC_TRACE(CLASSNAME, "Facebook logged out");
        LogoutCallback(j, j2);
    }

    private void OnPermissionCheckSuccess(long j, long j2) {
        Logging.CC_TRACE(CLASSNAME, "Facebook permission check succeeded");
        PermissionCheckCallback(true, j, j2);
    }

    private void OnPermissionCheckFailure(long j, long j2) {
        Logging.CC_TRACE(CLASSNAME, "Facebook permission check failed!");
        PermissionCheckCallback(false, j, j2);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void OnPermissionGrantSuccess(long j, long j2) {
        Logging.CC_TRACE(CLASSNAME, "Facebook permission grant succeeded");
        PermissionGrantCallback(true, j, j2);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void OnPermissionGrantFailure(long j, long j2) {
        Logging.CC_TRACE(CLASSNAME, "Facebook permission grant failed!");
        PermissionGrantCallback(false, j, j2);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void OnLoadFriendSuccess(String[] strArr, String[] strArr2, long j, long j2) {
        Logging.CC_TRACE(CLASSNAME, "Facebook loaded friends successfully");
        LoadFriendVectorCallback(true, strArr, strArr2, j, j2);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void OnLoadFriendFailure(long j, long j2) {
        Logging.CC_TRACE(CLASSNAME, "Facebook friend load failed!");
        LoadFriendVectorCallback(false, null, null, j, j2);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void OnLoadAvatarUrlSuccess(String str, long j) {
        LoadAvatarUrlCallback(true, str, j);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void OnLoadAvatarUrlFailure(long j) {
        LoadAvatarUrlCallback(false, null, j);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void OnFeedPostSuccess(long j, long j2) {
        Logging.CC_TRACE(CLASSNAME, "Posted to feed successfully");
        m_sCallback = 0L;
        m_sUserPtr = 0L;
        FeedPostCallback(true, j, j2);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void OnFeedPostFailure(long j, long j2) {
        Logging.CC_TRACE(CLASSNAME, "Posting to feed failed!");
        m_sCallback = 0L;
        m_sUserPtr = 0L;
        FeedPostCallback(false, j, j2);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void OnPhotoPostSuccess(long j, long j2) {
        Logging.CC_TRACE(CLASSNAME, "Posted photo successfully");
        PhotoPostCallback(true, j, j2);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void OnPhotoPostFailure(long j, long j2) {
        Logging.CC_TRACE(CLASSNAME, "Photo post failed!");
        PhotoPostCallback(false, j, j2);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void OnFriendInviteSuccess(long j, long j2) {
        Logging.CC_TRACE(CLASSNAME, "Invited friends successfully");
        m_sCallback = 0L;
        m_sUserPtr = 0L;
        FriendInviteCallback(true, j, j2);
    }

    /* JADX INFO: Access modifiers changed from: private */
    public void OnFriendInviteFailure(long j, long j2) {
        Logging.CC_TRACE(CLASSNAME, "Invite friends failed!");
        m_sCallback = 0L;
        m_sUserPtr = 0L;
        FriendInviteCallback(false, j, j2);
    }
}