com.beanbag.huaweiads 0.0.1

package/Runtime/Scripts/Game/HMSGameServiceManager.cs

@@ -0,0 +1,314 @@
+using HuaweiMobileServices.Base;
+using HuaweiMobileServices.Game;
+using HuaweiMobileServices.Id;
+using HuaweiMobileServices.Utils;
+using System;
+using UnityEngine;
+using static HuaweiConstants.HMSResponses;
+
+namespace HmsPlugin
+{
+    public class HMSGameServiceManager : HMSManagerSingleton<HMSGameServiceManager>, ICheckUpdateCallback
+    {
+        private const string TAG = "[HMS] HMSGameServiceManager";
+        public Action<Player> OnGetPlayerInfoSuccess { get; set; }
+        public Action<HMSException> OnGetPlayerInfoFailure { get; set; }
+        public Action<string> OnSubmitPlayerEventSuccess { get; set; }
+        public Action<HMSException> OnSubmitPlayerEventFailure { get; set; }
+        public Action<PlayerExtraInfo> OnGetPlayerExtraInfoSuccess { get; set; }
+        public Action<HMSException> OnGetPlayerExtraInfoFailure { get; set; }
+        public Action<AuthAccount> SignInSuccess { get; set; }
+        public Action<HMSException> SignInFailure { get; set; }
+        public Action<OnAppUpdateInfoRes> OnAppUpdateInfo { get; set; }
+        public Action<int> OnGetUserPlayStateSuccess { get; set; }
+        public Action<HMSException> OnGetUserPlayStateFailure { get; set; }
+        public Action<bool> OnIsAllowContinuePlayGamesSuccess { get; set; }
+        public Action<HMSException> OnIsAllowContinuePlayGamesFailure { get; set; }
+        public Action<HuaweiMobileServices.Utils.Void> GameInitSuccess { get; set; }
+
+        private AccountAuthService authService;
+        private AccountAuthParams authParams;
+        private IBuoyClient buoyClient;
+        private IPlayersClient playersClient;
+        private IArchivesClient archivesClient;
+        private IAppUpdateClient appUpdateClient;
+
+        private bool forceUpdate;
+        private bool showUpdateDialog;
+
+        public HMSGameServiceManager()
+        {
+            HMSManagerStart.Start(OnAwake, TAG);
+        }
+
+        private void OnAwake()
+        {
+            HuaweiMobileServicesUtil.SetApplication();
+            if (HMSGameServiceSettings.Instance.Settings.GetBool(HMSGameServiceSettings.InitializeOnStart))
+                Init();
+            else
+                Debug.LogWarning($"{TAG} initOnStart is disable for GameService. Are you getting init first error? Call HMSGameServiceManager.Instance.Init() by yourself.");
+        }
+
+        public void Init(IAntiAddictionCallback antiAddictionCallback = null, AuthAccount authAccount = null)
+        {
+            Debug.Log($"{TAG}: HMS GAMES init");
+
+            if (authAccount != null) 
+            {
+                archivesClient = HMSSaveGameManager.Instance.GetArchivesClient();
+                InitJosApps(authAccount, antiAddictionCallback);
+                return;
+            }
+            authService = HMSAccountKitManager.Instance.GetGameAuthService();
+            ITask<AuthAccount> taskAuthHuaweiId = authService.SilentSignIn();
+            taskAuthHuaweiId.AddOnSuccessListener((result) =>
+            {
+                archivesClient = HMSSaveGameManager.Instance.GetArchivesClient();
+                InitJosApps(result, antiAddictionCallback);
+                SignInSuccess?.Invoke(result);
+                Debug.Log($"{TAG} HMS GAMES: SilentSignIn Success");
+
+            }).AddOnFailureListener((exception) =>
+            {
+                Debug.LogError($"{TAG} HMS GAMES: The app has not been authorized");
+                authService.StartSignIn((auth) => { InitJosApps(auth, antiAddictionCallback); SignInSuccess?.Invoke(auth); }, (exc) => SignInFailure?.Invoke(exc));
+                InitGameManagers();
+            });
+        }
+
+        private void InitJosApps(AuthAccount result, IAntiAddictionCallback antiAddictionCallback = null)
+        {
+            authParams = new AccountAuthParamsHelper(AccountAuthParams.DEFAULT_AUTH_REQUEST_PARAM_GAME).CreateParams();
+
+            AppParams appParams = (antiAddictionCallback != null) 
+                ? new AppParams(authParams, new AntiAddictionCallWrapper(antiAddictionCallback)) 
+                : new AppParams(authParams);
+
+            HMSAccountKitManager.Instance.HuaweiId = result;
+            Debug.Log($"{TAG} HMS GAMES: Setted app");
+            IJosAppsClient josAppsClient = JosApps.GetJosAppsClient();
+            Debug.Log($"{TAG} HMS GAMES: jossClient");
+            var init = josAppsClient.Init(appParams);
+
+            init.AddOnSuccessListener((aVoid) => 
+            {
+                GameInitSuccess?.Invoke(aVoid);
+            });
+
+            Debug.Log($"{TAG} HMS GAMES: jossClient init");
+            InitGameManagers();
+        }
+
+        public void InitGameManagers()
+        {
+            HMSSaveGameManager.Instance.SavedGameAuth();
+            HMSLeaderboardManager.Instance.rankingsClient = Games.GetRankingsClient();
+            HMSAchievementsManager.Instance.achievementsClient = Games.GetAchievementsClient();
+
+            playersClient = Games.GetPlayersClient();
+            archivesClient = Games.GetArchiveClient();
+            buoyClient = Games.GetBuoyClient();
+            appUpdateClient = JosApps.GetAppUpdateClient();
+            CheckAppUpdate(true, false);
+        }
+
+        public void CheckAppUpdate(bool showAppUpdate, bool forceAppUpdate)
+        {
+            if (appUpdateClient != null)
+            {
+                showUpdateDialog = showAppUpdate;
+                forceUpdate = forceAppUpdate;
+                appUpdateClient.CheckAppUpdate(this);
+            }
+            else
+            {
+                Debug.LogError($"{TAG} CheckAppUpdate AppUpdateClient is null.");
+            }
+        }
+
+        public void ShowFloatWindow()
+        {
+            if (buoyClient != null)
+                buoyClient.ShowFloatWindow();
+            else
+                Debug.LogError($"{TAG} ShowFloatWindow BuoyClient is null.");
+        }
+
+        public void HideFloatWindow()
+        {
+            if (buoyClient != null)
+                buoyClient.HideFloatWindow();
+            else
+                Debug.LogError($"{TAG} HideFloatWindow BuoyClient is null.");
+        }
+
+        public void GetPlayerInfo()
+        {
+            if (HMSAccountKitManager.Instance.HuaweiId != null)
+            {
+                ITask<Player> task = playersClient.GamePlayer;
+                task.AddOnSuccessListener((result) =>
+                {
+                    Debug.Log($"{TAG} GetPlayerInfo Success");
+                    OnGetPlayerInfoSuccess?.Invoke(result);
+
+                }).AddOnFailureListener((exception) =>
+                {
+                    Debug.LogError($"{TAG}: GetPlayerInfo failed. CauseMessage: " + exception.WrappedCauseMessage + ", ExceptionMessage: " + exception.WrappedExceptionMessage);
+                    OnGetPlayerInfoFailure?.Invoke(exception);
+                });
+            }
+            else
+            {
+                Debug.LogError($"{TAG}: GetPlayerInfo failed. HMSAccountKitManager.Instance.HuaweiId is null");
+                OnGetPlayerInfoFailure?.Invoke(new HMSException($"{TAG}: GetPlayerInfo failed. HMSAccountKitManager.Instance.HuaweiId is null"));
+            }
+        }
+
+        public void SubmitPlayerEvent(string playerId, string eventId, string eventType)
+        {
+            if (HMSAccountKitManager.Instance.HuaweiId != null)
+            {
+                var task = playersClient.SubmitPlayerEvent(playerId, eventId, eventType);
+                task.AddOnSuccessListener((result) =>
+                {
+                    Debug.Log($"{TAG} SubmitPlayerEvent Success");
+                    OnSubmitPlayerEventSuccess?.Invoke(result);
+                }).AddOnFailureListener((exception) =>
+                {
+                    Debug.LogError($"{TAG}: SubmitPlayerEvent failed. CauseMessage: " + exception.WrappedCauseMessage + ", ExceptionMessage: " + exception.WrappedExceptionMessage);
+                    OnSubmitPlayerEventFailure?.Invoke(exception);
+                });
+            }
+            else
+            {
+                Debug.LogError($"{TAG}: SubmitPlayerEvent failed. HMSAccountKitManager.Instance.HuaweiId is null");
+                OnGetPlayerInfoFailure?.Invoke(new HMSException($"{TAG}: SubmitPlayerEvent failed. HMSAccountKitManager.Instance.HuaweiId is null"));
+            }
+        }
+
+        public void GetPlayerExtraInfo(string transactionId)
+        {
+            if (HMSAccountKitManager.Instance.HuaweiId != null)
+            {
+                var task = playersClient.GetPlayerExtraInfo(transactionId);
+                task.AddOnSuccessListener((result) =>
+                {
+                    Debug.Log($"{TAG}: GetPlayerExtraInfo Success");
+                    OnGetPlayerExtraInfoSuccess?.Invoke(result);
+                }).AddOnFailureListener((exception) =>
+                {
+                    Debug.LogError($"{TAG}: GetPlayerExtraInfo failed. CauseMessage: " + exception.WrappedCauseMessage + ", ExceptionMessage: " + exception.WrappedExceptionMessage);
+                    OnGetPlayerExtraInfoFailure?.Invoke(exception);
+                });
+            }
+            else
+            {
+                Debug.LogError($"{TAG}: GetPlayerExtraInfo failed. HMSAccountKitManager.Instance.HuaweiId is null");
+                OnGetPlayerInfoFailure?.Invoke(new HMSException("GetPlayerExtraInfo failed. HMSAccountKitManager.Instance.HuaweiId is null"));
+            }
+        }
+
+        public void GetUserPlayState()
+        {
+            if (HMSAccountKitManager.Instance.HuaweiId != null)
+            {
+                var task = playersClient.UserPlayState;
+                task.AddOnSuccessListener((result) =>
+                {
+                    Debug.Log($"{TAG}: GetUserPlayState Success");
+                    OnGetUserPlayStateSuccess?.Invoke(result);
+                }).AddOnFailureListener((exception) =>
+                {
+                    Debug.LogError($"{TAG}: GetUserPlayState failed. CauseMessage: " + exception.WrappedCauseMessage + ", ExceptionMessage: " + exception.WrappedExceptionMessage);
+                    OnGetUserPlayStateFailure?.Invoke(exception);
+                });
+            }
+            else
+            {
+                Debug.LogError($"{TAG}: GetUserPlayState failed. HMSAccountKitManager.Instance.HuaweiId is null");
+                OnGetUserPlayStateFailure?.Invoke(new HMSException("GetUserPlayState failed. HMSAccountKitManager.Instance.HuaweiId is null"));
+            }
+        }
+
+        public void IsAllowContinuePlayGames()
+        {
+            if (HMSAccountKitManager.Instance.HuaweiId != null)
+            {
+                var task = playersClient.IsAllowContinuePlayGames;
+                task.AddOnSuccessListener((result) =>
+                {
+                    Debug.Log($"{TAG}: IsAllowContinuePlayGames Success");
+                    OnIsAllowContinuePlayGamesSuccess?.Invoke(result);
+                }).AddOnFailureListener((exception) =>
+                {
+                    Debug.LogError($"{TAG}: IsAllowContinuePlayGames failed. CauseMessage: " + exception.WrappedCauseMessage + ", ExceptionMessage: " + exception.WrappedExceptionMessage);
+                    OnIsAllowContinuePlayGamesFailure?.Invoke(exception);
+                });
+            }
+            else
+            {
+                Debug.LogError($"{TAG}: IsAllowContinuePlayGames failed. HMSAccountKitManager.Instance.HuaweiId is null");
+                OnIsAllowContinuePlayGamesFailure?.Invoke(new HMSException("IsAllowContinuePlayGames failed. HMSAccountKitManager.Instance.HuaweiId is null"));
+            }
+        }
+        public void OnUpdateInfo(AndroidIntent intent)
+        {
+            int status = intent.GetIntExtra("status");
+            int rtnCode = intent.GetIntExtra("failcause");
+            string rtnMessage = intent.GetStringExtra("failreason");
+            bool isExit = intent.GetBoolExtra("compulsoryUpdateCancel", false);
+            int buttonStatus = intent.GetIntExtra("buttonstatus");
+
+            var apkUpgradeInfo = intent.Intent.Call<AndroidJavaObject>("getSerializableExtra", "updatesdk_update_info");
+            if (apkUpgradeInfo != null && showUpdateDialog)
+            {
+                appUpdateClient.ShowUpdateDialog(apkUpgradeInfo, forceUpdate);
+            }
+            OnAppUpdateInfo?.Invoke(new OnAppUpdateInfoRes(status, rtnCode, rtnMessage, isExit, buttonStatus));
+
+            try
+            {
+                Debug.Log($"{TAG} OnUpdateInfo, status: {(AppUpdateStatusCode)status}," +
+                    $" rtnCode: {(AppUpdateRtnCode)rtnCode}, rtnMessage: {rtnMessage}, buttonStatus: {(AppUpdateButtonStatus)buttonStatus}, isExit: {isExit}");
+            }
+            catch(Exception e)
+            {
+                Debug.LogError($"{TAG} Failed to parse status, rtnCode, or buttonStatus as their respective enums exception:{e.Message}");
+            }
+        }
+        public void OnMarketInstallInfo(AndroidIntent intent)
+        {
+            Debug.Log($"{TAG}: OnMarketInstallInfo Called");
+        }
+
+        public void OnMarketStoreError(int responseCode)
+        {
+            Debug.LogError($"{TAG} OnMarketStoreError. Response Code:{responseCode}");
+        }
+
+        public void OnUpdateStoreError(int responseCode)
+        {
+            Debug.LogError($"{TAG} OnUpdateStoreError. Response Code:{responseCode}");
+        }
+
+        public class OnAppUpdateInfoRes
+        {
+            public OnAppUpdateInfoRes(int status, int rtnCode, string rtnMessage, bool isExit, int buttonStatus)
+            {
+                Status = status;
+                RtnCode = rtnCode;
+                RtnMessage = rtnMessage;
+                IsExit = isExit;
+                ButtonStatus = buttonStatus;
+            }
+
+            public int Status { get; set; }
+            public int RtnCode { get; set; }
+            public string RtnMessage { get; set; }
+            public bool IsExit { get; set; }
+            public int ButtonStatus { get; set; }
+        }
+    }
+}

package/Runtime/Scripts/Game/HMSGameServiceManager.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 3227e30071c50a747bd50c7380698507
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Scripts/Game/HMSLeaderboardEntry.cs

@@ -0,0 +1,14 @@
+namespace HmsPlugin
+{
+    public class HMSLeaderboardEntry
+    {
+        public string Id { get; set; }
+        public string Name { get; set; }
+
+        public HMSLeaderboardEntry(string id, string name)
+        {
+            Id = id;
+            Name = name;
+        }
+    }
+}

package/Runtime/Scripts/Game/HMSLeaderboardEntry.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 8641d87efaa9a254daafdb145a73e506
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Scripts/Game/HMSLeaderboardManager.cs

@@ -0,0 +1,272 @@
+using HuaweiMobileServices.Base;
+using HuaweiMobileServices.Game;
+using HuaweiMobileServices.Utils;
+using System;
+using System.Collections.Generic;
+using UnityEngine;
+
+namespace HmsPlugin
+{
+    public class HMSLeaderboardManager : HMSEditorSingleton<HMSLeaderboardManager>
+    {
+
+        public IRankingsClient rankingsClient;
+
+        public Action<int> OnIsUserScoreShownOnLeaderboardsSuccess { get; set; }
+        public Action<HMSException> OnIsUserScoreShownOnLeaderboardsFailure { get; set; }
+
+        public Action<int> OnSetUserScoreShownOnLeaderboardsSuccess { get; set; }
+        public Action<HMSException> OnSetUserScoreShownOnLeaderboardsFailure { get; set; }
+
+        public Action OnShowLeaderboardsSuccess { get; set; }
+        public Action<HMSException> OnShowLeaderboardsFailure { get; set; }
+
+        public Action<IList<Ranking>> OnGetLeaderboardsDataSuccess { get; set; }
+        public Action<HMSException> OnGetLeaderboardsDataFailure { get; set; }
+
+        public Action<Ranking> OnGetLeaderboardDataSuccess { get; set; }
+        public Action<HMSException> OnGetLeaderboardDataFailure { get; set; }
+
+        public Action<RankingScores> OnGetScoresFromLeaderboardSuccess { get; set; }
+        public Action<HMSException> OnGetScoresFromLeaderboardFailure { get; set; }
+
+        public Action<ScoreSubmissionInfo> OnSubmitScoreSuccess { get; set; }
+        public Action<HMSException> OnSubmitScoreFailure { get; set; }
+
+        public Action<RankingScores> OnGetPlayerCenteredRankingScoresSuccess { get; set; }
+        public Action<HMSException> OnGetPlayerCenteredRankingScoresFailure { get; set; }
+
+        public Action<RankingScores> OnGetMoreScoresFromLeaderboardSuccess { get; set; }
+        public Action<HMSException> OnGetMoreScoresFromLeaderboardFailure { get; set; }
+
+        public Action OnGetRankingsSuccess { get; set; }
+        public Action<HMSException> OnGetRankingsFailure { get; set; }
+
+        public void IsUserScoreShownOnLeaderboards()
+        {
+            ITask<int> task = rankingsClient.GetRankingSwitchStatus();
+            task.AddOnSuccessListener((result) =>
+            {
+                Debug.Log("[HMSLeaderboardManager] isUserScoreShownOnLeaderboards SUCCESS" + result);
+                OnIsUserScoreShownOnLeaderboardsSuccess?.Invoke(result);
+
+            }).AddOnFailureListener((exception) =>
+            {
+                Debug.LogError("[HMSLeaderboardManager]: IsUserScoreShownOnLeaderboards failed. CauseMessage: " + exception.WrappedCauseMessage + ", ExceptionMessage: " + exception.WrappedExceptionMessage);
+                OnIsUserScoreShownOnLeaderboardsFailure?.Invoke(exception);
+            });
+
+        }
+
+        public void SetUserScoreShownOnLeaderboards(int active)
+        {
+            ITask<int> task = rankingsClient.SetRankingSwitchStatus(active);
+            task.AddOnSuccessListener((result) =>
+            {
+                Debug.Log("[HMSLeaderboardManager] SetUserScoreShownOnLeaderboards SUCCESS" + result);
+                OnSetUserScoreShownOnLeaderboardsSuccess?.Invoke(result);
+
+            }).AddOnFailureListener((exception) =>
+            {
+                Debug.LogError("[HMSLeaderboardManager]: SetUserScoreShownOnLeaderboards failed. CauseMessage: " + exception.WrappedCauseMessage + ", ExceptionMessage: " + exception.WrappedExceptionMessage);
+                OnSetUserScoreShownOnLeaderboardsFailure?.Invoke(exception);
+            });
+        }
+
+        public void SubmitRankingScore(string leaderboardId, long score)
+        {
+            Debug.Log("[HMSLeaderboardManager] SubmitRankingScore");
+            rankingsClient.SubmitRankingScore(leaderboardId, score);
+        }
+
+        public void SubmitRankingScore(string leaderboardId, long score, string scoreTips)
+        {
+            Debug.Log("[HMSLeaderboardManager] SubmitRankingScore");
+            rankingsClient.SubmitRankingScore(leaderboardId, score, scoreTips);
+        }
+
+        public void SubmitScore(string leaderboardId, long score)
+        {
+            ITask<ScoreSubmissionInfo> task = rankingsClient.SubmitScoreWithResult(leaderboardId, score);
+            task.AddOnSuccessListener((scoreInfo) =>
+            {
+                Debug.Log("[HMSLeaderboardManager] SubmitScore SUCCESS");
+                OnSubmitScoreSuccess?.Invoke(scoreInfo);
+            }).AddOnFailureListener((error) =>
+            {
+                Debug.LogError("[HMSLeaderboardManager]: SubmitScore failed. CauseMessage: " + error.WrappedCauseMessage + ", ExceptionMessage: " + error.WrappedExceptionMessage);
+                OnSubmitScoreFailure?.Invoke(error);
+            });
+        }
+
+        public void SubmitScore(string leaderboardId, long score, string scoreTips)
+        {
+            ITask<ScoreSubmissionInfo> task = rankingsClient.SubmitScoreWithResult(leaderboardId, score, scoreTips);
+            task.AddOnSuccessListener((scoreInfo) =>
+            {
+                Debug.Log("[HMSLeaderboardManager] SubmitScore SUCCESS");
+                OnSubmitScoreSuccess?.Invoke(scoreInfo);
+            }).AddOnFailureListener((error) =>
+            {
+                Debug.LogError("[HMSLeaderboardManager]: SubmitScore failed. CauseMessage: " + error.WrappedCauseMessage + ", ExceptionMessage: " + error.WrappedExceptionMessage);
+                OnSubmitScoreFailure?.Invoke(error);
+            });
+        }
+
+        public void ShowLeaderboards()
+        {
+            rankingsClient.ShowTotalRankings(() =>
+            {
+                Debug.Log("[HMSLeaderboardManager] ShowLeaderboards SUCCESS");
+                OnShowLeaderboardsSuccess?.Invoke();
+
+            }, (exception) =>
+            {
+                Debug.LogError("[HMSLeaderboardManager]: ShowLeaderboards failed. CauseMessage: " + exception.WrappedCauseMessage + ", ExceptionMessage: " + exception.WrappedExceptionMessage);
+                OnShowLeaderboardsFailure?.Invoke(exception);
+            });
+        }
+
+        public void GetLeaderboardsData()
+        {
+            ITask<IList<Ranking>> task = rankingsClient.GetRankingSummary(true);
+            task.AddOnSuccessListener((result) =>
+            {
+                Debug.Log("[HMSLeaderboardManager] GetLeaderboardsData SUCCESS");
+                OnGetLeaderboardsDataSuccess?.Invoke(result);
+            }).AddOnFailureListener((exception) =>
+            {
+                Debug.LogError("[HMSLeaderboardManager]: GetLeaderboardsData failed. CauseMessage: " + exception.WrappedCauseMessage + ", ExceptionMessage: " + exception.WrappedExceptionMessage);
+                OnGetLeaderboardsDataFailure?.Invoke(exception);
+            });
+        }
+
+        public void GetLeaderboardData(string leaderboardId)
+        {
+            ITask<Ranking> task = rankingsClient.GetRankingSummary(leaderboardId, true);
+            task.AddOnSuccessListener((result) =>
+            {
+                Debug.Log("[HMSLeaderboardManager] GetLeaderboardsData SUCCESS");
+                OnGetLeaderboardDataSuccess?.Invoke(result);
+
+            }).AddOnFailureListener((exception) =>
+            {
+                Debug.LogError("[HMSLeaderboardManager]: GetLeaderboardData failed. CauseMessage: " + exception.WrappedCauseMessage + ", ExceptionMessage: " + exception.WrappedExceptionMessage);
+                OnGetLeaderboardDataFailure?.Invoke(exception);
+            });
+        }
+
+        public void GetScoresFromLeaderboard(string leaderboardId, int timeDimension, int maxResults, bool isRealTime)
+        {
+            ITask<RankingScores> task =
+                rankingsClient.GetRankingTopScores(leaderboardId, timeDimension, maxResults, isRealTime);
+
+            task.AddOnSuccessListener((result) =>
+            {
+                Debug.Log("[HMSLeaderboardManager] GetScoresFromLeaderboard SUCCESS");
+                OnGetScoresFromLeaderboardSuccess?.Invoke(result);
+
+            }).AddOnFailureListener((exception) =>
+            {
+                Debug.LogError("[HMSLeaderboardManager]: GetScoresFromLeaderboard failed. CauseMessage: " + exception.WrappedCauseMessage + ", ExceptionMessage: " + exception.WrappedExceptionMessage);
+                OnGetScoresFromLeaderboardFailure?.Invoke(exception);
+            });
+        }
+
+        public void GetScoresFromLeaderboard(string leaderboardId, int timeDimension, int maxResults, int offsetPlayerRank, int pageDirection)
+        {
+            ITask<RankingScores> task =
+                rankingsClient.GetRankingTopScores(leaderboardId, timeDimension, maxResults, offsetPlayerRank, pageDirection);
+
+            task.AddOnSuccessListener((result) =>
+            {
+                Debug.Log("[HMSLeaderboardManager] GetScoresFromLeaderboard SUCCESS");
+                OnGetScoresFromLeaderboardSuccess?.Invoke(result);
+
+            }).AddOnFailureListener((exception) =>
+            {
+                Debug.LogError("[HMSLeaderboardManager]: GetScoresFromLeaderboard failed. CauseMessage: " + exception.WrappedCauseMessage + ", ExceptionMessage: " + exception.WrappedExceptionMessage);
+                OnGetScoresFromLeaderboardFailure?.Invoke(exception);
+            });
+        }
+
+        public void GetMoreScoresFromLeaderboard(string leaderboardId, long offsetPlayerRank, int maxResults, int pageDirection, int timeDimention)
+        {
+            var task = rankingsClient.GetMoreRankingScores(leaderboardId, offsetPlayerRank, maxResults, pageDirection, timeDimention);
+
+            task.AddOnSuccessListener((result) =>
+            {
+                Debug.Log("[HMSLeaderboardManager] GetMoreScoresFromLeaderboard SUCCESS");
+                OnGetMoreScoresFromLeaderboardSuccess?.Invoke(result);
+
+            }).AddOnFailureListener((exception) =>
+            {
+                Debug.LogError("[HMSLeaderboardManager]: GetMoreScoresFromLeaderboard failed. CauseMessage: " + exception.WrappedCauseMessage + ", ExceptionMessage: " + exception.WrappedExceptionMessage);
+                OnGetMoreScoresFromLeaderboardFailure?.Invoke(exception);
+            });
+        }
+
+        public void GetPlayerCenteredRankingScores(string leaderboardId, int timeDimension, int maxResults, bool isRealTime)
+        {
+            var task = rankingsClient.GetPlayerCenteredRankingScores(leaderboardId, timeDimension, maxResults, isRealTime);
+
+            task.AddOnSuccessListener((result) =>
+            {
+                Debug.Log("[HMSLeaderboardManager] GetPlayerCenteredRankingScores SUCCESS");
+                OnGetPlayerCenteredRankingScoresSuccess?.Invoke(result);
+            }).AddOnFailureListener((exception) =>
+            {
+                Debug.LogError("[HMSLeaderboardManager]: GetPlayerCenteredRankingScores failed. CauseMessage: " + exception.WrappedCauseMessage + ", ExceptionMessage: " + exception.WrappedExceptionMessage);
+                OnGetPlayerCenteredRankingScoresFailure?.Invoke(exception);
+            });
+        }
+
+        public void GetPlayerCenteredRankingScores(string leaderboardId, int timeDimension, int maxResults, long offsetPlayerRank, int pageDirection)
+        {
+            var task = rankingsClient.GetPlayerCenteredRankingScores(leaderboardId, timeDimension, maxResults, offsetPlayerRank, pageDirection);
+
+            task.AddOnSuccessListener((result) =>
+            {
+                Debug.Log("[HMSLeaderboardManager] GetPlayerCenteredRankingScores SUCCESS");
+                Debug.LogWarning("[HMSLeaderboardManager] " + result == null ? "null" : "not null");
+                Debug.LogWarning("[HMSLeaderboardManager]" + result.Ranking.RankingDisplayName + ", Count: " + result.RankingScore.Count);
+                if (result.RankingScore.Count > 0)
+                {
+                    Debug.LogWarning("Name: " + result.RankingScore[0].DisplayRank);
+                    Debug.LogWarning("Score: " + result.RankingScore[0].PlayerRawScore);
+                }
+                OnGetPlayerCenteredRankingScoresSuccess?.Invoke(result);
+            }).AddOnFailureListener((exception) =>
+            {
+                Debug.LogError("[HMSLeaderboardManager]: GetPlayerCenteredRankingScores failed. CauseMessage: " + exception.WrappedCauseMessage + ", ExceptionMessage: " + exception.WrappedExceptionMessage);
+                OnGetPlayerCenteredRankingScoresFailure?.Invoke(exception);
+            });
+        }
+
+        public void GetRankings(string leaderboardId)
+        {
+            rankingsClient.GetRankingIntent(leaderboardId, () =>
+             {
+                 Debug.Log("[HMSLeaderboardManager] GetRankings SUCCESS");
+                 OnGetRankingsSuccess?.Invoke();
+             }, (exception) =>
+             {
+                 Debug.LogError("[HMSLeaderboardManager]: GetRankings failed. CauseMessage: " + exception.WrappedCauseMessage + ", ExceptionMessage: " + exception.WrappedExceptionMessage);
+                 OnGetRankingsFailure?.Invoke(exception);
+             });
+        }
+
+        public void GetRankings(string leaderboardId, int timeDimension)
+        {
+            rankingsClient.GetRankingIntent(leaderboardId, timeDimension, () =>
+             {
+                 Debug.Log("[HMSLeaderboardManager] GetRankings SUCCESS");
+                 OnGetRankingsSuccess?.Invoke();
+             }, (exception) =>
+             {
+                 Debug.LogError("[HMSLeaderboardManager]: GetRankings failed. CauseMessage: " + exception.WrappedCauseMessage + ", ExceptionMessage: " + exception.WrappedExceptionMessage);
+                 OnGetRankingsFailure?.Invoke(exception);
+             });
+        }
+    }
+}

package/Runtime/Scripts/Game/HMSLeaderboardManager.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: e69b1140624374c439321028344c4bab
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: