internal ScorePageToken(object internalObject, string id, LeaderboardCollection collection, LeaderboardTimeSpan timespan) { mInternalObject = internalObject; mId = id; mCollection = collection; mTimespan = timespan; }
internal void ShowUI(string leaderboardId, LeaderboardTimeSpan span, Action<Status.UIStatus> callback) { Misc.CheckNotNull(callback); C.LeaderboardManager_ShowUI(mServices.AsHandle(), leaderboardId, (Types.LeaderboardTimeSpan)span, Callbacks.InternalShowUICallback, Callbacks.ToIntPtr(callback)); }
/// <summary> /// Loads the scores using the provided parameters. /// </summary> /// <param name="leaderboardId">Leaderboard identifier.</param> /// <param name="start">Start either top scores, or player centered.</param> /// <param name="rowCount">Row count. the number of rows to return.</param> /// <param name="collection">Collection. social or public</param> /// <param name="timeSpan">Time span. daily, weekly, all-time</param> /// <param name="callback">Callback.</param> public void LoadScores(string leaderboardId, LeaderboardStart start, int rowCount, LeaderboardCollection collection, LeaderboardTimeSpan timeSpan, Action <LeaderboardScoreData> callback) { if (!IsAuthenticated()) { GooglePlayGames.OurUtils.Logger.e("LoadScores can only be called after authentication."); callback(new LeaderboardScoreData(leaderboardId, ResponseStatus.NotAuthorized)); return; } mClient.LoadScores(leaderboardId, start, rowCount, collection, timeSpan, callback); }
/// <summary> /// Loads the score data for the given leaderboard. /// </summary> /// <param name="leaderboardId">Leaderboard identifier.</param> /// <param name="start">Start indicating the top scores or player centric</param> /// <param name="rowCount">Row count.</param> /// <param name="collection">Collection to display.</param> /// <param name="timeSpan">Time span.</param> /// <param name="callback">Callback to invoke when complete.</param> public void LoadScores( string leaderboardId, LeaderboardStart start, int rowCount, LeaderboardCollection collection, LeaderboardTimeSpan timeSpan, Action <LeaderboardScoreData> callback) { LogUsage(); if (callback != null) { callback(new LeaderboardScoreData( leaderboardId, ResponseStatus.LicenseCheckFailed)); } }
///<summary></summary> /// <seealso cref="GooglePlayGames.BasicApi.IPlayGamesClient.ShowLeaderboardUI"/> public void ShowLeaderboardUI(string leaderboardId, LeaderboardTimeSpan span, Action <UIStatus> callback) { if (!IsAuthenticated()) { InvokeCallbackOnGameThread(callback, UIStatus.NotAuthorized); return; } if (leaderboardId == null) { AndroidHelperFragment.ShowAllLeaderboardsUI(AsOnGameThreadCallback(callback)); } else { AndroidHelperFragment.ShowLeaderboardUI(leaderboardId, span, AsOnGameThreadCallback(callback)); } }
private void FetchCurrentUserScore(string id, LeaderboardTimeSpan timeSpan) { if (!userSignedIn || leaderboardUserLoadState != LeaderboardLoadState.DoneLoading) { return; } leaderboardUserLoadState = LeaderboardLoadState.LoadingValues; curUserLeaderboardItem.cachedGo.SetActive(false); // Hide current result while loading. curUserLeaderboard = PlayGamesPlatform.Instance.CreateLeaderboard(); curUserLeaderboard.id = id; curUserLeaderboard.range = new Range(int.MaxValue, 0); // We are only getting our local value. So this range doesn't matter. curUserLeaderboard.SetUserFilter(curUserFilter); curUserLeaderboard.timeScope = TimeSpanToTimeScope(timeSpan); curUserLeaderboard.LoadScores(OnLoadedCurrentUserScore); }
public void OnNewLeaderboardTimeFrame() { LeaderboardTimeSpan newSpan = (LeaderboardTimeSpan)(leaderboardTimeFrame.selectionIndex + 1); // Enum starts at 1. if (leaderboardTimeSpanSetting == newSpan) { return; // No need to refresh if the setting didn't change. } leaderboardTimeSpanSetting = newSpan; if (!userSignedIn || leaderboardIsLoading || leaderboardData == null) { return; } ReloadCurrentLeaderboard(); }
private void getUserScore(LeaderboardCollection collection, LeaderboardTimeSpan interval) { #if UNITY_ANDROID PlayGamesPlatform.Instance.LoadScores(GPGSIds.leaderboard_magnet_balls_pro, LeaderboardStart.PlayerCentered, 1, collection, interval, (data) => { if (data.Scores.Length > 0) { if (UserScoreInited != null) { UserScoreInited(data.PlayerScore, collection, interval); } } } ); #endif }
///<summary></summary> /// <seealso cref="GooglePlayGames.BasicApi.IPlayGamesClient.LoadScores"/> public void LoadScores(string leaderboardId, LeaderboardStart start, int rowCount, LeaderboardCollection collection, LeaderboardTimeSpan timeSpan, Action <LeaderboardScoreData> callback) { using (var client = getLeaderboardsClient()) { string loadScoresMethod = start == LeaderboardStart.TopScores ? "loadTopScores" : "loadPlayerCenteredScores"; using (var task = client.Call <AndroidJavaObject>( loadScoresMethod, leaderboardId, AndroidJavaConverter.ToLeaderboardVariantTimeSpan(timeSpan), AndroidJavaConverter.ToLeaderboardVariantCollection(collection), rowCount)) { AndroidTaskUtils.AddOnSuccessListener <AndroidJavaObject>( task, annotatedData => { using (var leaderboardScores = annotatedData.Call <AndroidJavaObject>("get")) { InvokeCallbackOnGameThread(callback, CreateLeaderboardScoreData( leaderboardId, collection, timeSpan, annotatedData.Call <bool>("isStale") ? ResponseStatus.SuccessWithStale : ResponseStatus.Success, leaderboardScores)); leaderboardScores.Call("release"); } }); AndroidTaskUtils.AddOnFailureListener( task, exception => { Debug.Log("LoadScores failed"); InvokeCallbackOnGameThread(callback, new LeaderboardScoreData(leaderboardId, ResponseStatus.InternalError)); }); } } }
// Initialize Play Services variables upon login. private void InitializeServicesVariables() { if (initPlayServices) { return; } initPlayServices = true; highestSubmittedScores = new Dictionary <string, long>(); leaderboardData = null; curLeaderboardIndex = 0; leaderboardListLoadState = LeaderboardLoadState.DoneLoading; leaderboardUserLoadState = LeaderboardLoadState.DoneLoading; leaderboardCollectionSetting = LeaderboardCollection.Public; leaderboardTimeSpanSetting = LeaderboardTimeSpan.AllTime; // Initialize data instances for each entry in a page. leaderboardResults = new LeaderboardResult[LEADERBOARD_ENTRIES_PER_PAGE]; leaderboardListUi = new LeaderboardItemUI[LEADERBOARD_ENTRIES_PER_PAGE]; leaderboardPageCount = 0; curUserFilter = new string[1] { PlayGamesPlatform.Instance.localUser.id }; // Configure dropdowns for leaderboards. leaderboardTimeFrame.ForceItems("Today", "This Week", "All Time"); leaderboardCollection.ForceItems("Global", "Friends"); leaderboardTimeFrame.SelectItem(2); // All Time. leaderboardCollection.SelectItem(0); // Global. for (int i = 0; i < LEADERBOARD_ENTRIES_PER_PAGE; i++) { leaderboardResults[i] = new LeaderboardResult(); leaderboardListUi[i] = SetupLeaderboardListItem(leaderboardListStart); leaderboardListUi[i].cachedGo.SetActive(false); } curUserLeaderboardItem = SetupLeaderboardListItem(leaderboardCurPlayerStart); curUserLeaderboardItem.cachedGo.SetActive(false); }
public void ShowLeaderboardUI(string leaderboardId, LeaderboardTimeSpan span, Action <UIStatus> cb) { if (IsAuthenticated()) { Action <CommonErrorStatus.UIStatus> callback = Callbacks.NoopUICallback; if (cb != null) { callback = delegate(CommonErrorStatus.UIStatus result) { cb((UIStatus)result); }; } callback = AsOnGameThreadCallback(callback); if (leaderboardId == null) { GameServices().LeaderboardManager().ShowAllUI(callback); } else { GameServices().LeaderboardManager().ShowUI(leaderboardId, span, callback); } } }
public static void ShowLeaderboardUI(string leaderboardId, LeaderboardTimeSpan timeSpan, Action <UIStatus> cb) { using (var helperFragment = new AndroidJavaClass(HelperFragmentClass)) using (var task = helperFragment.CallStatic <AndroidJavaObject>("showLeaderboardUi", GetActivity(), leaderboardId, AndroidJavaConverter.ToLeaderboardVariantTimeSpan(timeSpan))) { AndroidTaskUtils.AddOnSuccessListener <int>( task, uiCode => { Logger.d("ShowLeaderboardUI result " + uiCode); cb.Invoke((UIStatus)uiCode); }); AndroidTaskUtils.AddOnFailureListener( task, exception => { Logger.e("ShowLeaderboardUI failed with exception"); cb.Invoke(UIStatus.InternalError); }); } }
internal void ShowUI(string leaderboardId, LeaderboardTimeSpan span, Action <CommonErrorStatus.UIStatus> callback) { Misc.CheckNotNull(callback); GooglePlayGames.Native.Cwrapper.LeaderboardManager.LeaderboardManager_ShowUI(mServices.AsHandle(), leaderboardId, (Types.LeaderboardTimeSpan)span, Callbacks.InternalShowUICallback, Callbacks.ToIntPtr(callback)); }
/// <summary> /// Loads the leaderboard data. This is the "top level" call /// to load leaderboard data. A token for fetching scores is created /// based on the parameters. /// </summary> /// <param name="leaderboardId">Leaderboard identifier.</param> /// <param name="start">Start of scores location</param> /// <param name="rowCount">Row count.</param> /// <param name="collection">Collection social or public</param> /// <param name="timeSpan">Time span of leaderboard</param> /// <param name="playerId">Player identifier.</param> /// <param name="callback">Callback.</param> public void LoadLeaderboardData(string leaderboardId, LeaderboardStart start, int rowCount, LeaderboardCollection collection, LeaderboardTimeSpan timeSpan, string playerId, Action<LeaderboardScoreData> callback) { //Create a token we'll use to load scores later. NativeScorePageToken nativeToken = new NativeScorePageToken( C.LeaderboardManager_ScorePageToken( mServices.AsHandle(), leaderboardId, (Types.LeaderboardStart)start, (Types.LeaderboardTimeSpan)timeSpan, (Types.LeaderboardCollection)collection)); ScorePageToken token = new ScorePageToken(nativeToken, leaderboardId, collection, timeSpan); // First fetch the leaderboard to get the title C.LeaderboardManager_Fetch(mServices.AsHandle(), Types.DataSource.CACHE_OR_NETWORK, leaderboardId, InternalFetchCallback, Callbacks.ToIntPtr<FetchResponse>((rsp) => HandleFetch(token, rsp, playerId, rowCount, callback), FetchResponse.FromPointer)); }
private void FetchLeaderboardFromTop(string id, LeaderboardCollection collection, LeaderboardTimeSpan timeSpan) { if (!userSignedIn) { return; } leaderboardListLoadState = LeaderboardLoadState.LoadingValues; leaderboardCurPage = 1; leaderboardPageCount = 1; SetLeaderboardListLoading(true); PlayGamesPlatform.Instance.LoadScores(id, LeaderboardStart.TopScores, LEADERBOARD_ENTRIES_PER_PAGE, collection, timeSpan, OnLoadedTopLeaderboards); }
public void LoadScores(string leaderboardId, LeaderboardStart start, int rowCount, LeaderboardCollection collection, LeaderboardTimeSpan timeSpan, Action <LeaderboardScoreData> callback) { callback = AsOnGameThreadCallback(callback); GameServices().LeaderboardManager().LoadLeaderboardData(leaderboardId, start, rowCount, collection, timeSpan, mUser.id, callback); }
/// <summary> /// Shows the leaderboard UI and calls the specified callback upon /// completion. /// </summary> /// <param name="lbId">leaderboard ID, can be null meaning all leaderboards.</param> /// <param name="span">Timespan to display scores in the leaderboard.</param> /// <param name="callback">Callback to call. If null, nothing is called.</param> public void ShowLeaderboardUI(string lbId, LeaderboardTimeSpan span, Action<UIStatus> callback) { if (!IsAuthenticated()) { GooglePlayGames.OurUtils.Logger.e("ShowLeaderboardUI can only be called after authentication."); callback(UIStatus.NotAuthorized); return; } GooglePlayGames.OurUtils.Logger.d("ShowLeaderboardUI, lbId=" + lbId + " callback is " + callback); mClient.ShowLeaderboardUI(lbId, span, callback); }
public void ShowLeaderboardUI(string leaderboardId, LeaderboardTimeSpan span, System.Action <UIStatus> callback) { throw new System.NotImplementedException(); }
public void LoadScores(string leaderboardId, LeaderboardStart start, int rowCount, LeaderboardCollection collection, LeaderboardTimeSpan timeSpan, System.Action <LeaderboardScoreData> callback) { throw new System.NotImplementedException(); }
public static void GetUserScore(LeaderboardCollection collection, LeaderboardTimeSpan interval) { main.getUserScore(collection, interval); }
public void LoadLeaderboardData(string leaderboardId, LeaderboardStart start, int rowCount, LeaderboardCollection collection, LeaderboardTimeSpan timeSpan, string playerId, Action <LeaderboardScoreData> callback) { NativeScorePageToken internalObject = new NativeScorePageToken(GooglePlayGames.Native.Cwrapper.LeaderboardManager.LeaderboardManager_ScorePageToken(mServices.AsHandle(), leaderboardId, (Types.LeaderboardStart)start, (Types.LeaderboardTimeSpan)timeSpan, (Types.LeaderboardCollection)collection)); ScorePageToken token = new ScorePageToken(internalObject, leaderboardId, collection, timeSpan); GooglePlayGames.Native.Cwrapper.LeaderboardManager.LeaderboardManager_Fetch(mServices.AsHandle(), Types.DataSource.CACHE_OR_NETWORK, leaderboardId, InternalFetchCallback, Callbacks.ToIntPtr(delegate(FetchResponse rsp) { HandleFetch(token, rsp, playerId, rowCount, callback); }, FetchResponse.FromPointer)); }
private LeaderboardScoreData CreateLeaderboardScoreData( string leaderboardId, LeaderboardCollection collection, LeaderboardTimeSpan timespan, ResponseStatus status, AndroidJavaObject leaderboardScoresJava) { LeaderboardScoreData leaderboardScoreData = new LeaderboardScoreData(leaderboardId, status); using (var scoresBuffer = leaderboardScoresJava.Call <AndroidJavaObject>("getScores")) { int count = scoresBuffer.Call <int>("getCount"); for (int i = 0; i < count; ++i) { using (var leaderboardScore = scoresBuffer.Call <AndroidJavaObject>("get", i)) { long timestamp = leaderboardScore.Call <long>("getTimestampMillis"); System.DateTime date = AndroidJavaConverter.ToDateTime(timestamp); ulong rank = (ulong)leaderboardScore.Call <long>("getRank"); string scoreHolderId = ""; using (var scoreHolder = leaderboardScore.Call <AndroidJavaObject>("getScoreHolder")) { scoreHolderId = scoreHolder.Call <string>("getPlayerId"); } ulong score = (ulong)leaderboardScore.Call <long>("getRawScore"); string metadata = leaderboardScore.Call <string>("getScoreTag"); leaderboardScoreData.AddScore(new PlayGamesScore(date, leaderboardId, rank, scoreHolderId, score, metadata)); } } leaderboardScoreData.NextPageToken = new ScorePageToken(scoresBuffer, leaderboardId, collection, timespan, ScorePageDirection.Forward); leaderboardScoreData.NextPageToken = new ScorePageToken(scoresBuffer, leaderboardId, collection, timespan, ScorePageDirection.Backward); } using (var leaderboard = leaderboardScoresJava.Call <AndroidJavaObject>("getLeaderboard")) using (var variants = leaderboard.Call <AndroidJavaObject>("getVariants")) using (var variant = variants.Call <AndroidJavaObject>("get", 0)) { leaderboardScoreData.Title = leaderboard.Call <string>("getDisplayName"); if (variant.Call <bool>("hasPlayerInfo")) { System.DateTime date = AndroidJavaConverter.ToDateTime(0); ulong rank = (ulong)variant.Call <long>("getPlayerRank"); string scoreHolderId = "me"; ulong score = (ulong)variant.Call <long>("getRawPlayerScore"); string metadata = variant.Call <string>("getPlayerScoreTag"); leaderboardScoreData.PlayerScore = new PlayGamesScore(date, leaderboardId, rank, scoreHolderId, score, metadata); } leaderboardScoreData.ApproximateCount = (ulong)variant.Call <long>("getNumScores"); } return(leaderboardScoreData); }
internal ScorePageToken(object internalObject, string id, LeaderboardCollection collection, LeaderboardTimeSpan timespan) { this.mInternalObject = internalObject; this.mId = id; this.mCollection = collection; this.mTimespan = timespan; }
public void ShowLeaderboardUI(string leaderboardId, LeaderboardTimeSpan span, Action <UIStatus> callback) { LogUsage(); callback?.Invoke(UIStatus.VersionUpdateRequired); }
/// <summary> /// Shows the leaderboard UI /// </summary> /// <param name="leaderboardId">Leaderboard identifier.</param> /// <param name="span">Timespan to display.</param> /// <param name="callback">Callback to invoke when complete.</param> public void ShowLeaderboardUI( string leaderboardId, LeaderboardTimeSpan span, Action<UIStatus> callback) { LogUsage(); if (callback != null) { callback.Invoke(UIStatus.VersionUpdateRequired); } }
/// <summary> /// Loads the scores using the provided parameters. /// </summary> /// <param name="leaderboardId">Leaderboard identifier.</param> /// <param name="start">Start either top scores, or player centered.</param> /// <param name="rowCount">Row count. the number of rows to return.</param> /// <param name="collection">Collection. social or public</param> /// <param name="timeSpan">Time span. daily, weekly, all-time</param> /// <param name="callback">Callback.</param> public void LoadScores(string leaderboardId, LeaderboardStart start, int rowCount, LeaderboardCollection collection, LeaderboardTimeSpan timeSpan, Action<LeaderboardScoreData> callback) { if (!IsAuthenticated()) { GooglePlayGames.OurUtils.Logger.e("LoadScores can only be called after authentication."); callback(new LeaderboardScoreData(leaderboardId, ResponseStatus.NotAuthorized)); return; } mClient.LoadScores(leaderboardId, start, rowCount, collection, timeSpan, callback); }
/// <summary> /// Loads the score data for the given leaderboard. /// </summary> /// <param name="leaderboardId">Leaderboard identifier.</param> /// <param name="start">Start indicating the top scores or player centric</param> /// <param name="rowCount">Row count.</param> /// <param name="collection">Collection to display.</param> /// <param name="timeSpan">Time span.</param> /// <param name="callback">Callback to invoke when complete.</param> public void LoadScores( string leaderboardId, LeaderboardStart start, int rowCount, LeaderboardCollection collection, LeaderboardTimeSpan timeSpan, Action<LeaderboardScoreData> callback) { LogUsage(); if (callback != null) { callback(new LeaderboardScoreData( leaderboardId, ResponseStatus.LicenseCheckFailed)); } }
private void Main_UserScoreInited(IScore score, LeaderboardCollection collection, LeaderboardTimeSpan interval) { int best = (int)score.value; switch (interval) { case LeaderboardTimeSpan.Daily: PlayGameServiceManager.GetUserScore(LeaderboardCollection.Public, LeaderboardTimeSpan.Weekly); GameData.DailyBest = best; GameData.DailyRank = score.rank; if (DailyScoreInited != null) { DailyScoreInited(score); } break; case LeaderboardTimeSpan.Weekly: PlayGameServiceManager.GetUserScore(LeaderboardCollection.Public, LeaderboardTimeSpan.AllTime); GameData.WeeklyBest = best; GameData.WeeklyRank = score.rank; if (WeeklyScoreInited != null) { WeeklyScoreInited(score); } break; case LeaderboardTimeSpan.AllTime: GameData.OverallBest = best; GameData.OverallRank = score.rank; if (OverallScoreInited != null) { OverallScoreInited(score); } break; } }
public virtual void ShowLeaderboardUI(string leaderboardId, LeaderboardTimeSpan span, Action <UIStatus> callback) { throw new NotSupportedException("unsupported"); }