JD2022-TU1/main/phone_apps/JDCompanionApp/Assets/Scripts/Online/SessionService.cs

using uPromise;

using UbiServices;
using UnityEngine;
using LightJSON;
using System.Collections.Generic;

namespace Online
{
    public class SessionService
    {
        private readonly IHttpEngine httpEngine;
        private readonly string jmcsEnvironment;
        private readonly string applicationId;
        
        public struct Session
        {
            // main session objects
            public Facade UbiservicesFacade;
            public JmcsFacade JmcsFacade;

            // common fields, pre-extracted from Ubiservices objects
            public string UbiTicket;
            public string AuthorizationHeader;
            public string SessionId;
            public string ProfileId;
            public string Name;
        }

        private Session session;

        public SessionService(IHttpEngine httpEngine, string jmcsEnvironment, string applicationId)
        {
            this.httpEngine = httpEngine;
            this.jmcsEnvironment = jmcsEnvironment;
            this.applicationId = applicationId;

            session = new Session();
            session.UbiservicesFacade = new Facade();
        }

        public void Destroy()
        {
            session.UbiservicesFacade.Dispose();
            session.UbiservicesFacade = null;
        }

        // returns the player UbiTicket and JMCS token if possible
        public Promise<Session> Refresh()
        {
            return RefreshUbiservicesSession()
                .Then(session => RefreshJmcsSession());
        }

        private Promise<Session> RefreshUbiservicesSession()
        {
            // early exit if already logged in
            if (session.UbiservicesFacade.getAuthenticationClient().getSessionInfo().hasValidSession())
                return PromiseFactory.StartNewDeferred<Session>(dfd => dfd.Resolve(session));

            // make sure that the JMCS session will be recreated if we have to login to ubiservices again
            session.JmcsFacade = null;

            var deferred = new Deferred<Session>();

            // otherwise, try to create a new session
            var ubimobileToken = UbimobileToolkit.instance.ubimobileAccessToken_get();
            var credentials = new PlayerCredentials(ubimobileToken, CredentialsType.UbiMobile);

            var populationParams = new DynamicPopulationCustomParams();
            populationParams.addCustomDataSingleValue("environment", jmcsEnvironment.ToLower());
#if UNITY_ANDROID
            populationParams.addCustomDataSingleValue("Platform", "android");
#elif UNITY_IOS
            populationParams.addCustomDataSingleValue("Platform", "ios");
#else
#error Unsupported platform!
#endif

            var spaceParameterGroups = new Vector_String();
            spaceParameterGroups.Add("config-environment");

            var sessionResult = session.UbiservicesFacade.createSession(credentials, new EventsParams(), new NotificationParams(), populationParams, new Vector_String(), spaceParameterGroups);
            OnlineEngine.WaitForAsyncResult(sessionResult, () =>
            {
                if (sessionResult.hasSucceeded())
                {
                    // save credentials for future logins
                    UbimobileToolkit.instance.ubimobileAccessToken_save(ubimobileToken);

                    // duplicate common fields into the session object
                    var sessionInfo = session.UbiservicesFacade.getAuthenticationClient().getSessionInfo();
                    session.UbiTicket = sessionInfo.getTicketUtf8();
                    session.AuthorizationHeader = "Ubi_v1 " + session.UbiTicket;
                    session.SessionId = sessionInfo.getSessionId().getTextUtf8();
                    session.ProfileId = sessionInfo.getProfileId().getTextUtf8();
                    session.Name = sessionInfo.getNameOnPlatform();

                    Analytics.Statistics.GameLocalization();

                    deferred.Resolve(session);
                }
                else
                {
                    Debug.LogError("Failed to create a UbiServices session :/");
                    deferred.Reject();
                }
            });

            return deferred.Promise;
        }

        private Promise<Session> RefreshJmcsSession()
        {
            // early exit if already logged in
            if (session.JmcsFacade != null)
                return PromiseFactory.StartNewDeferred<Session>(dfd => dfd.Resolve(session));

            string jmcsUrlOverride = null;
            if (jmcsEnvironment.StartsWith("http://") || jmcsEnvironment.StartsWith("https://"))
                jmcsUrlOverride = jmcsEnvironment;

            return JmcsFacade.CreateSession(applicationId, session.UbiservicesFacade, httpEngine, jmcsUrlOverride)
                .Then(jmcsFacade =>
                {
                    // login succeeded; store login info in the session object
                    session.JmcsFacade = jmcsFacade;
                    return session;
                });
        }
        
        public Promise<JSON> ResolvePairingCode(string pairingCode)
        {
            return OnlineEngine.Session.Refresh()
                .Then(session => httpEngine.Execute(session.JmcsFacade.BuildRequest("sessions", 1, "/pairing-info?code=" + pairingCode)))
                .Then(response => response.Body);
        }

        public Promise<JSON> InitiatePunchPairing(string pairingCode, string localIp, ushort localPort)
        {
            return OnlineEngine.Session.Refresh()
                .Then(session => {
                    var request = session.JmcsFacade.BuildRequest("sessions", 1, "/initiate-punch-pairing");
                    request.Method = HttpMethod.Post;

                    request.PostData = new JSON(JSON.ValueType.OBJECT);
                    request.PostData["pairingCode"] = pairingCode;
                    request.PostData["mobileIP"] = localIp;
                    request.PostData["mobilePort"] = localPort;

                    return httpEngine.Execute(request);
                })
                .Then(response => response.Body);
        }
    }
}