Unity Facebook login

using UnityEngine;
using UnityEngine.Events;
using System.Collections;
using System.Collections.Generic;

public class FacebookUserInfo {
    public string id = null;
    public string firstName = "Unknown";
    public string lastName = "";
    public string gender = "unknown";
    public Sprite profilePicture = null;
}

public class FacebookManager : MonoBehaviour {
    private static FacebookManager instance = null;

    // you can assign event handler methods in the inspector
    public UnityEvent loginStatusChangedEvent;
    public UnityEvent userInfoDownloadedEvent;
    public UnityEvent friendsInfoDownloadedEvent;

    public enum LoginStatusCode {
        LoggingOut,
        NotLoggedIn,
        AttemptingFBLogin,
        LoggedIn,
        WaitingForConnection
    }

    private static LoginStatusCode loginStatus = LoginStatusCode.WaitingForConnection;

    public static LoginStatusCode LoginStatus {
        private set {
            loginStatus = value;
            if (instance != null) {
                instance.OnLoginStatusChanged();
            }
        }
        get {
            return loginStatus;
        }
    }

    private static FacebookUserInfo currentUserFacebookUserInfo = new FacebookUserInfo();
    public static FacebookUserInfo CurrentUserFacebookUserInfo {
        get { return currentUserFacebookUserInfo; }
        private set { currentUserFacebookUserInfo = value; }
    }

    private static List<FacebookUserInfo> friendUserFacebookInfos = new List<FacebookUserInfo>();
    public static List<FacebookUserInfo> FriendUserFacebookInfos {
        get { return friendUserFacebookInfos; }
        private set { friendUserFacebookInfos = value; }
    }

    private static Dictionary<string, bool> userFacebookPermissions = new Dictionary<string, bool>();

    public static bool FriendsPermissionRequested {
        get {
            return userFacebookPermissions.ContainsKey("user_friends");
        }
        private set { ;}
    }

    public static bool FriendsPermissionGranted {
        get {
            return FriendsPermissionRequested && userFacebookPermissions["user_friends"] == true;
        }
        private set { ;}
    }
    public static bool PublishPermissionRequested {
        get {
            return userFacebookPermissions.ContainsKey("publish_actions");
        }
        private set { ;}
    }
    public static bool PublishPermissionGranted {
        get {
            return PublishPermissionRequested && userFacebookPermissions["publish_actions"] == true;
        }
        private set { ;}
    }

    private static bool Connected {
        get {
            return Application.internetReachability == NetworkReachability.ReachableViaLocalAreaNetwork
                || Application.internetReachability == NetworkReachability.ReachableViaCarrierDataNetwork;
        }
        set { ;}
    }

    void Awake() {
        if (instance != null) {
            Debug.LogError("More than one FacebookManager component in the scene! GameObject: \"" + gameObject.name + "\" Tag: \"" + gameObject.tag + "\"");
            Destroy(this);
        }
        else {
            instance = this;
        }
    }

    void Start() {
        #if UNITY_IPHONE || UNITY_ANDROID
        StartCoroutine(InitialiseFacebook());
        #else
        LoginStatus = LoginStatusCode.NotLoggedIn;
        #endif
    }

    void OnDestroy() {
        if (instance == this) {
            instance = null;
        }
    }

    void OnLoginStatusChanged() {
        loginStatusChangedEvent.Invoke();
    }

    IEnumerator InitialiseFacebook() {
        LoginStatus = LoginStatusCode.WaitingForConnection;
        // keep repeating until FB initialises
        while (!FB.IsInitialized) {
            if (Connected && LoginStatus != LoginStatusCode.AttemptingFBLogin) {
                LoginStatus = LoginStatusCode.AttemptingFBLogin;
                FB.Init(OnFBInitComplete, null, null);
                yield return StartCoroutine(WaitForSecondsUnscaled(10.0f));
            }
            else if (!Connected && LoginStatus != LoginStatusCode.WaitingForConnection) {
                LoginStatus = LoginStatusCode.WaitingForConnection;
            }
            else {
                yield return StartCoroutine(WaitForSecondsUnscaled(5.0f));
            }
        }
    }

    // use unscaled time so that it still works when game is paused
    IEnumerator WaitForSecondsUnscaled(float seconds) {
        float startTime = Time.realtimeSinceStartup;
        while (Time.realtimeSinceStartup - startTime < seconds) {
            yield return null;
        }
    }

    void OnFBInitComplete() {
        if (FB.IsLoggedIn) {
            LoginStatus = LoginStatusCode.LoggedIn;
            GetFBUserInfo();
        }
        else {
            LoginStatus = LoginStatusCode.NotLoggedIn;
        }
    }

    void GetFBUserInfo() {
        // Use an anonymous function in place of delegate
        // It is like calling FB.API("...", Facebook.HttpMethod.GET, DelegateMethodName)
        FB.API("/me/permissions", Facebook.HttpMethod.GET, (FBResult result) => {
            if (result.Error != null) {
                Debug.LogError("Error getting FB permissions: " + result.Error);
            }
            else {
                // use Facebook method supplied to deserialize the result
                // we don't need to know how they do it, just what data type is returned :)
                Dictionary<string, object> dataObjects = Facebook.MiniJSON.Json.Deserialize(result.Text) as Dictionary<string, object>;
                List<object> permissionObjects = dataObjects["data"] as List<object>;

                // lets store all the permission info in case we need to know what's been granted
                userFacebookPermissions = new Dictionary<string, bool>();

                foreach (object permissionObject in permissionObjects) {
                    Dictionary<string, object> permissionObjectDict = permissionObject as Dictionary<string, object>;
                    foreach (KeyValuePair<string, object> pair in permissionObjectDict) {
                        userFacebookPermissions.Add(pair.Key, System.Convert.ToBoolean(pair.Value));
                    }
                }

                // get the current user's info.
                // /me graph URL always points to current user
                StartCoroutine(GetFacebookUserInfo("/me", true));
            }
        });
    }

    void OnFriendsDownloaded(FBResult result) {
        if (result.Error != null) {
            Debug.LogError("Error getting FB friends: " + result.Error);
        }
        else {
            Dictionary<string, object> responseObject = Facebook.MiniJSON.Json.Deserialize(result.Text) as Dictionary<string, object>;
            StartCoroutine(GetFriendsFacebookUserInfo(responseObject["data"] as List<object>));
        }
    }

    IEnumerator GetFriendsFacebookUserInfo(List<object> responseDataObjects) {
        int numFriends = responseDataObjects.Count;
        foreach (object friendDataObject in responseDataObjects) {
            Dictionary<string, object> friendDataObjectDict = friendDataObject as Dictionary<string, object>;
            // get one friend info at a time
            yield return StartCoroutine(GetFacebookUserInfo("/" + friendDataObjectDict["id"].ToString(), false));
            if (FriendUserFacebookInfos.Count == numFriends) {
                friendsInfoDownloadedEvent.Invoke();
            }
        }
    }

    IEnumerator GetFacebookUserInfo(string graphURL, bool currentUser) {
        bool finishedGettingInfo = false;

        FacebookUserInfo userInfo = new FacebookUserInfo();

        // get user info
        FB.API(graphURL, Facebook.HttpMethod.GET, (FBResult userInfoResult) => {
            if (userInfoResult.Error != null) {
                Debug.LogError("Error getting FB friend info: " + userInfoResult.Error);
            }
            else {
                Dictionary<string, object> userInfoObjects = Facebook.MiniJSON.Json.Deserialize(userInfoResult.Text) as Dictionary<string, object>;
                userInfo.id = userInfoObjects["id"].ToString();
                userInfo.firstName = userInfoObjects["first_name"].ToString();
                userInfo.lastName = userInfoObjects["last_name"].ToString();
                userInfo.gender = userInfoObjects["gender"].ToString();
            }
            finishedGettingInfo = true;
        });

        // wait until info got
        while (!finishedGettingInfo) {
            yield return null;
        }

        // if we successfully got info and id, get the profile picture
        if (userInfo.id != null) {
            bool finishedGettingPictureURL = false;
            string pictureURL = null;

            // get profile picture url
            FB.API(FacebookUtil.GetPictureURL(userInfo.id, 128, 128), Facebook.HttpMethod.GET, (FBResult pictureResult) => {
                if (pictureResult.Error != null) {
                    Debug.LogError("Error getting FB friend picture: " + pictureResult.Error);
                }
                else {
                    pictureURL = FacebookUtil.DeserializePictureURLString(pictureResult.Text);
                }
                finishedGettingPictureURL = true;
            });

            // wait for it...
            while (!finishedGettingPictureURL) {
                yield return null;
            }

            // get profile picture
            if (pictureURL != null) {
                WWW www = new WWW(pictureURL);
                yield return www;
                userInfo.profilePicture = Sprite.Create(www.texture,
                                                    new Rect(0, 0, 128, 128),
                                                    new Vector2(0.5f, 0.5f));
            }
        }

        // if we're getting this user's info
        if (currentUser) {
            CurrentUserFacebookUserInfo = userInfo;
            userInfoDownloadedEvent.Invoke();
            // now get friend user info
            if (FriendsPermissionGranted) {
                FB.API("/v2.1/me/friends", Facebook.HttpMethod.GET, OnFriendsDownloaded);
            }
        }
        else {
            // otherwise we were getting a friend's info. add it.
            FriendUserFacebookInfos.Add(userInfo);
        }
    }

    public static void TryFBLogin() {
        if (instance != null) {
            #if UNITY_IPHONE || UNITY_ANDROID
            if (FB.IsInitialized && !FB.IsLoggedIn && LoginStatus == LoginStatusCode.NotLoggedIn) {
                LoginStatus = LoginStatusCode.AttemptingFBLogin;
                // just asking for some basic permissions. you can add more as required.
                FB.Login("public_profile,user_friends", instance.OnFBLoginAttempted);
            }
            #endif
        }
    }

    void OnFBLoginAttempted(FBResult fbResult) {
        if (FB.IsLoggedIn) {
            LoginStatus = LoginStatusCode.LoggedIn;
            GetFBUserInfo();
        }
        else {
            LoginStatus = LoginStatusCode.NotLoggedIn;
        }
    }

    public static void LogoutUser() {
        if (instance != null && LoginStatus == LoginStatusCode.LoggedIn) {
            instance.StartCoroutine(instance.DoLogout());
        }
    }

    IEnumerator DoLogout() {
        while (LoginStatus == LoginStatusCode.AttemptingFBLogin) {
            yield return null;
        }

        LoginStatus = LoginStatusCode.LoggingOut;
        yield return null;

        // add any other cleanup code you need

        CurrentUserFacebookUserInfo = new FacebookUserInfo();
        FriendUserFacebookInfos = new List<FacebookUserInfo>();

        if (FB.IsLoggedIn) {
            FB.Logout();
        }

        LoginStatus = LoginStatusCode.NotLoggedIn;
    }
}