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/com/firemonkeys/cloudcellapi/FacebookWorker.java

@@ -0,0 +1,731 @@
+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);
+    }
+}