Пример #1
0
        /// <summary>
        /// Make a list with every friends score
        /// </summary>
        /// <param name="data"></param>
        private void LoadScoreIntoData(LeaderboardScoreData data) {
            IScore[] scores = data.Scores;
            List<string> usersID = new List<string>();
            this.users = new List<GoogleplayUser>();

            foreach (IScore score in scores) {
                usersID.Add(score.userID);
            }

            //Get user info for each score
            Social.LoadUsers(usersID.ToArray(), (users) => {
                for (int i = 0; i < scores.Length; i++) {
                    IUserProfile user = FindUser(users, scores[i].userID);
                    this.users.Add(new GoogleplayUser(user.userName,
                                                  Int32.Parse(user.id),
                                                  Sprite.Create(user.image, new Rect(0, 0, user.image.width, user.image.height), new Vector2(0.5f, 0.5f)),
                                                  (int)scores[i].value));
                }

                this.isLoaded = true;
            });
        }
        internal bool SetFromData(LeaderboardScoreData data)
        {
            if (data.Valid)
            {
                Debug.Log("Setting leaderboard from: " + data);
                SetMaxRange(data.ApproximateCount);
                SetTitle(data.Title);
                SetLocalUserScore((PlayGamesScore)data.PlayerScore);
                foreach (IScore score in data.Scores)
                {
                    AddScore((PlayGamesScore)score);
                }
                mLoading = data.Scores.Length == 0 || HasAllScores();
            }

            return data.Valid;
        }
Пример #3
0
        internal void HandleLoadingScores(PlayGamesLeaderboard board,
            LeaderboardScoreData scoreData, Action<bool> callback)
        {
            bool ok = board.SetFromData(scoreData);
            if (ok && !board.HasAllScores() && scoreData.NextPageToken != null)
            {
                int rowCount = board.range.count - board.ScoreCount;

                // need to load more scores
                mClient.LoadMoreScores(scoreData.NextPageToken, rowCount,
                    (nextScoreData) =>
                    HandleLoadingScores(board, nextScoreData, callback));
            }
            else
            {
                callback(ok);
            }
        }
        internal void HandleFetchScorePage(LeaderboardScoreData data,
            ScorePageToken token,
            FetchScorePageResponse rsp, Action<LeaderboardScoreData> callback)
        {
            data.Status = (ResponseStatus)rsp.GetStatus();
            // add the scores that match the criteria
            if (rsp.GetStatus() != Status.ResponseStatus.VALID &&
                rsp.GetStatus() != Status.ResponseStatus.VALID_BUT_STALE)
            {
                callback(data);
            }

            NativeScorePage page = rsp.GetScorePage();

            if (!page.Valid())
            {
                callback(data);
            }

            if (page.HasNextScorePage())
            {
                data.NextPageToken = new ScorePageToken(
                                               page.GetNextScorePageToken(),
                                               token.LeaderboardId,
                                               token.Collection,
                                               token.TimeSpan);

            }
            if (page.HasPrevScorePage())
            {
                data.PrevPageToken = new ScorePageToken(
                    page.GetPreviousScorePageToken(),
                    token.LeaderboardId,
                    token.Collection,
                    token.TimeSpan);
            }

            foreach (NativeScoreEntry ent in page)
            {
                data.AddScore(ent.AsScore(data.Id));
            }

            callback(data);
        }
        /// <summary>
        /// Loads the score page. This is used to page through the rows
        /// of leaderboard scores.
        /// </summary>
        /// <param name="data">Data - partially completed result data, can be null</param>
        /// <param name="maxResults">Max results to return</param>
        /// <param name="token">Token to use for getting the score page,</param>
        /// <param name="callback">Callback.</param>
        public void LoadScorePage(LeaderboardScoreData data,
            int maxResults, ScorePageToken token,
            Action<LeaderboardScoreData> callback)
        {

            if (data == null)
            {
                data = new LeaderboardScoreData(token.LeaderboardId);
            }

            NativeScorePageToken nativeToken = (NativeScorePageToken)token.InternalObject;
            C.LeaderboardManager_FetchScorePage(mServices.AsHandle(),
                Types.DataSource.CACHE_OR_NETWORK,
                nativeToken.AsPointer(),
                (uint)maxResults,
                InternalFetchScorePage,
                Callbacks.ToIntPtr<FetchScorePageResponse>((rsp) => {
                    HandleFetchScorePage(data, token, rsp, callback);
                }, FetchScorePageResponse.FromPointer)
            );
        }
        internal void HandleFetchScoreSummary(LeaderboardScoreData data,
            FetchScoreSummaryResponse response,
            string selfPlayerId, int maxResults,
            ScorePageToken token, Action<LeaderboardScoreData> callback)
        {
            if (response.GetStatus() != Status.ResponseStatus.VALID &&
                response.GetStatus() != Status.ResponseStatus.VALID_BUT_STALE)
            {
                Logger.w("Error returned from fetchScoreSummary: " + response);
                data.Status = (ResponseStatus)response.GetStatus();
                callback(data);
                return;
            }

            NativeScoreSummary summary = response.GetScoreSummary();
            data.ApproximateCount = summary.ApproximateResults();
            data.PlayerScore = summary.LocalUserScore().AsScore(data.Id, selfPlayerId);


            // if the maxResults is 0, no scores are needed, so we are done.
            if (maxResults <= 0)
            {
                callback(data);
                return;
            }

            LoadScorePage(data, maxResults, token, callback);
        }
        /// <summary>
        /// Handles the fetch of a specific leaderboard definition.  This
        /// is called with the expectation that the leaderboard summary and
        /// scores are also needed.
        /// </summary>
        /// <param name="token">token for the current fetching request.</param>
        /// <param name="response">Response.</param>
        /// <param name="selfPlayerId">Self player identifier.</param>
        /// <param name="maxResults">Number of scores to return.</param>
        /// <param name="callback">Callback.</param>
        internal void HandleFetch(ScorePageToken token,
            FetchResponse response,
            string selfPlayerId,
            int maxResults,
            Action<LeaderboardScoreData> callback)
        {

            LeaderboardScoreData data =
                new LeaderboardScoreData(
                    token.LeaderboardId, (ResponseStatus)response.GetStatus());

            if (response.GetStatus() != Status.ResponseStatus.VALID &&
                response.GetStatus() != Status.ResponseStatus.VALID_BUT_STALE)
            {
                Logger.w("Error returned from fetch: " + response.GetStatus());
                callback(data);
                return;
            }

            data.Title = response.Leaderboard().Title();
            data.Id = token.LeaderboardId;

            // now fetch the summary of the leaderboard.

            C.LeaderboardManager_FetchScoreSummary(mServices.AsHandle(),
                Types.DataSource.CACHE_OR_NETWORK,
                token.LeaderboardId,
                (Types.LeaderboardTimeSpan)token.TimeSpan,
                (Types.LeaderboardCollection)token.Collection,
                InternalFetchSummaryCallback,
                Callbacks.ToIntPtr<FetchScoreSummaryResponse>((rsp) =>
                    HandleFetchScoreSummary(data, rsp, selfPlayerId, maxResults, token, callback),
                FetchScoreSummaryResponse.FromPointer)
            );
        }