public void Rematch(TurnBasedMatch match, Action <bool, TurnBasedMatch> callback)
{
callback = ToOnGameThread(callback);
FindEqualVersionMatch(match, (success, foundMatch) =>
{
if (!success)
{
callback(false, null);
return;
}
using (var task = mClient.Call <AndroidJavaObject>("rematch", match.MatchId))
{
AndroidTaskUtils.AddOnSuccessListener <AndroidJavaObject>(
task,
turnBasedMatch =>
callback(true, AndroidJavaConverter.ToTurnBasedMatch(turnBasedMatch)));
AndroidTaskUtils.AddOnFailureListener(
task,
e => callback(false, null));
}
});
}
private void FindInvitationWithId(string invitationId, Action <Invitation> callback)
{
using (var task = mClient.Call <AndroidJavaObject>("loadMatchesByStatus", new int[] { 0, 1, 2, 3 }))
{
AndroidTaskUtils.AddOnSuccessListener <AndroidJavaObject>(
task,
annotatedData =>
{
using (var matchesResponse = annotatedData.Call <AndroidJavaObject>("get"))
using (var invitationsBuffer = matchesResponse.Call <AndroidJavaObject>("getInvitations"))
{
int count = invitationsBuffer.Call <int>("getCount");
for (int i = 0; i < count; ++i)
{
Invitation invitation =
AndroidJavaConverter.ToInvitation(
invitationsBuffer.Call <AndroidJavaObject>("get", (int)i));
if (invitation.InvitationId == invitationId)
{
callback(invitation);
return;
}
}
}
callback(null);
});
AndroidTaskUtils.AddOnFailureListener(task, e => callback(null));
}
}
internal static TurnBasedMatch ToTurnBasedMatch(AndroidJavaObject turnBasedMatch)
{
if (turnBasedMatch == null)
{
return(null);
}
string matchId = turnBasedMatch.Call <string>("getMatchId");
byte[] data = turnBasedMatch.Call <byte[]>("getData");
bool canRematch = turnBasedMatch.Call <bool>("canRematch");
uint availableAutomatchSlots = (uint)turnBasedMatch.Call <int>("getAvailableAutoMatchSlots");
string selfParticipantId = turnBasedMatch.Call <string>("getCreatorId");
List <Participant> participants = ToParticipantList(turnBasedMatch);
string pendingParticipantId = turnBasedMatch.Call <string>("getPendingParticipantId");
TurnBasedMatch.MatchStatus turnStatus = ToMatchStatus(turnBasedMatch.Call <int>("getStatus"));
TurnBasedMatch.MatchTurnStatus matchStatus =
AndroidJavaConverter.ToMatchTurnStatus(turnBasedMatch.Call <int>("getTurnStatus"));
uint variant = (uint)turnBasedMatch.Call <int>("getVariant");
uint version = (uint)turnBasedMatch.Call <int>("getVersion");
DateTime creationTime = AndroidJavaConverter.ToDateTime(turnBasedMatch.Call <long>("getCreationTimestamp"));
DateTime lastUpdateTime =
AndroidJavaConverter.ToDateTime(turnBasedMatch.Call <long>("getLastUpdatedTimestamp"));
return(new TurnBasedMatch(matchId, data, canRematch, selfParticipantId, participants,
availableAutomatchSlots, pendingParticipantId, matchStatus, turnStatus, variant, version, creationTime,
lastUpdateTime));
}
public void CreateQuickMatch(uint minOpponents, uint maxOpponents, uint variant,
ulong exclusiveBitmask, Action <bool, TurnBasedMatch> callback)
{
callback = ToOnGameThread(callback);
using (var matchConfigClass =
new AndroidJavaClass("com.google.android.gms.games.multiplayer.turnbased.TurnBasedMatchConfig"))
using (var matchConfigBuilder = matchConfigClass.CallStatic <AndroidJavaObject>("builder"))
using (var autoMatchCriteria = matchConfigClass.CallStatic <AndroidJavaObject>("createAutoMatchCriteria",
(int)minOpponents, (int)maxOpponents, (long)exclusiveBitmask))
{
matchConfigBuilder.Call <AndroidJavaObject>("setAutoMatchCriteria", autoMatchCriteria);
if (variant != 0)
{
matchConfigBuilder.Call <AndroidJavaObject>("setVariant", (int)variant);
}
using (var matchConfig = matchConfigBuilder.Call <AndroidJavaObject>("build"))
using (var task = mClient.Call <AndroidJavaObject>("createMatch", matchConfig))
{
AndroidTaskUtils.AddOnSuccessListener <AndroidJavaObject>(
task,
turnBasedMatch =>
callback(true, AndroidJavaConverter.ToTurnBasedMatch(turnBasedMatch)));
AndroidTaskUtils.AddOnFailureListener(task, e => callback(false, null));
}
}
}
public void GetMatch(string matchId, Action <bool, TurnBasedMatch> callback)
{
callback = ToOnGameThread(callback);
using (var task = mClient.Call <AndroidJavaObject>("loadMatch", matchId))
{
AndroidTaskUtils.AddOnSuccessListener <AndroidJavaObject>(
task,
annotatedData =>
{
using (var turnBasedMatch = annotatedData.Call <AndroidJavaObject>("get"))
{
if (turnBasedMatch == null)
{
OurUtils.Logger.e(string.Format("Could not find match {0}", matchId));
callback(false, null);
}
else
{
callback(true, AndroidJavaConverter.ToTurnBasedMatch(turnBasedMatch));
}
}
});
AndroidTaskUtils.AddOnFailureListener(task, e => callback(false, null));
}
}
public void GetAllInvitations(Action <Invitation[]> callback)
{
callback = ToOnGameThread(callback);
using (var task = mClient.Call <AndroidJavaObject>("loadMatchesByStatus", new int[] { 0, 1, 2, 3 }))
{
AndroidTaskUtils.AddOnSuccessListener <AndroidJavaObject>(
task,
annotatedData =>
{
using (var matchesResponse = annotatedData.Call <AndroidJavaObject>("get"))
using (var invitationsBuffer = matchesResponse.Call <AndroidJavaObject>("getInvitations"))
{
int count = invitationsBuffer.Call <int>("getCount");
Invitation[] invitations = new Invitation[count];
for (int i = 0; i < count; i++)
{
using (var invitation = invitationsBuffer.Call <AndroidJavaObject>("get", (int)i))
{
invitations[i] = AndroidJavaConverter.ToInvitation(invitation);
}
}
callback(invitations);
}
});
AndroidTaskUtils.AddOnFailureListener(task, e => callback(null));
}
}
private void handleParticipantStatusChanged(AndroidJavaObject room, AndroidJavaObject participantIds)
{
mParent.mRoom = room;
int size = participantIds.Get <int>("size");
for (int i = 0; i < size; i++)
{
String participantId = participantIds.Call <String>("get", i);
Participant participant =
AndroidJavaConverter.ToParticipant(
mParent.mRoom.Call <AndroidJavaObject>("getParticipant", participantId));
if (participant.Status != Participant.ParticipantStatus.Declined &&
participant.Status != Participant.ParticipantStatus.Left)
{
continue;
}
mListener.OnParticipantLeft(participant);
var roomStatus = mParent.GetRoomStatus();
if (roomStatus != RoomStatus.Connecting && roomStatus != RoomStatus.AutoMatching)
{
mParent.LeaveRoom();
}
}
}
public static void ShowInvitationInboxUI(Action <UIStatus, Invitation> cb)
{
using (var helperFragment = new AndroidJavaClass(HelperFragmentClass))
using (var task = helperFragment.CallStatic <AndroidJavaObject>("showInvitationInboxUI",
AndroidHelperFragment.GetActivity()))
{
AndroidTaskUtils.AddOnSuccessListener <AndroidJavaObject>(
task,
result =>
{
int status = result.Get <int>("status");
if ((UIStatus)status != UIStatus.Valid)
{
cb.Invoke((UIStatus)status, null);
return;
}
using (var invitation = result.Get <AndroidJavaObject>("invitation"))
{
cb.Invoke((UIStatus)status, AndroidJavaConverter.ToInvitation(invitation));
}
});
AndroidTaskUtils.AddOnFailureListener(
task,
exception =>
{
Debug.Log("ShowInvitationInboxUI failed with exception");
cb.Invoke(UIStatus.InternalError, null);
});
}
}
public void GetAllInvitations(Action <Invitation[]> callback)
{
callback = ToOnGameThread(callback);
using (var task = mInvitationsClient.Call <AndroidJavaObject>("loadInvitations"))
{
AndroidTaskUtils.AddOnSuccessListener <AndroidJavaObject>(
task,
annotatedData =>
{
using (var invitationBuffer = annotatedData.Call <AndroidJavaObject>("get"))
{
int count = invitationBuffer.Call <int>("getCount");
Invitation[] invitations = new Invitation[count];
for (int i = 0; i < count; i++)
{
using (var invitationObject = invitationBuffer.Call <AndroidJavaObject>("get", i))
{
invitations[i] = AndroidJavaConverter.ToInvitation(invitationObject);
}
}
callback(invitations);
}
});
AndroidTaskUtils.AddOnFailureListener(
task,
exception => callback(null));
}
}
public void CreateWithInvitationScreen(uint minOpponents, uint maxOpponents, uint variant,
Action <UIStatus, TurnBasedMatch> callback)
{
callback = ToOnGameThread(callback);
AndroidHelperFragment.ShowTbmpSelectOpponentsUI(minOpponents, maxOpponents,
(status, result) =>
{
if (status != UIStatus.Valid)
{
callback(status, null);
return;
}
using (var matchConfigClass =
new AndroidJavaClass("com.google.android.gms.games.multiplayer.turnbased.TurnBasedMatchConfig"))
using (var matchConfigBuilder = matchConfigClass.CallStatic <AndroidJavaObject>("builder"))
{
if (result.MinAutomatchingPlayers > 0)
{
using (var autoMatchCriteria = matchConfigClass.CallStatic <AndroidJavaObject>(
"createAutoMatchCriteria", result.MinAutomatchingPlayers,
result.MaxAutomatchingPlayers, /* exclusiveBitMask= */ (long)0))
using (matchConfigBuilder.Call <AndroidJavaObject>("setAutoMatchCriteria",
autoMatchCriteria))
;
}
if (variant != 0)
{
using (matchConfigBuilder.Call <AndroidJavaObject>("setVariant", (int)variant));
}
using (var invitedPlayersObject = new AndroidJavaObject("java.util.ArrayList"))
{
for (int i = 0; i < result.PlayerIdsToInvite.Count; ++i)
{
invitedPlayersObject.Call <bool>("add", result.PlayerIdsToInvite[i]);
}
using (matchConfigBuilder.Call <AndroidJavaObject>("addInvitedPlayers", invitedPlayersObject)
);
}
using (var matchConfig = matchConfigBuilder.Call <AndroidJavaObject>("build"))
using (var task = mClient.Call <AndroidJavaObject>("createMatch", matchConfig))
{
AndroidTaskUtils.AddOnSuccessListener <AndroidJavaObject>(
task,
turnBasedMatch =>
callback(UIStatus.Valid, AndroidJavaConverter.ToTurnBasedMatch(turnBasedMatch)));
AndroidTaskUtils.AddOnFailureListener(
task,
exception => callback(UIStatus.InternalError, null));
}
}
});
}
///<summary></summary>
/// <seealso cref="GooglePlayGames.BasicApi.IPlayGamesClient.LoadAchievements"/>
public void LoadAchievements(Action <Achievement[]> callback)
{
using (var achievementsClient = getAchievementsClient())
using (var task = achievementsClient.Call <AndroidJavaObject>("load", /* forceReload= */ false))
{
AndroidTaskUtils.AddOnSuccessListener <AndroidJavaObject>(
task,
annotatedData =>
{
using (var achievementBuffer = annotatedData.Call <AndroidJavaObject>("get"))
{
int count = achievementBuffer.Call <int>("getCount");
Achievement[] result = new Achievement[count];
for (int i = 0; i < count; ++i)
{
Achievement achievement = new Achievement();
using (var javaAchievement = achievementBuffer.Call <AndroidJavaObject>("get", i))
{
achievement.Id = javaAchievement.Call <string>("getAchievementId");
achievement.Description = javaAchievement.Call <string>("getDescription");
achievement.Name = javaAchievement.Call <string>("getName");
achievement.Points = javaAchievement.Call <ulong>("getXpValue");
long timestamp = javaAchievement.Call <long>("getLastUpdatedTimestamp");
achievement.LastModifiedTime = AndroidJavaConverter.ToDateTime(timestamp);
achievement.RevealedImageUrl = javaAchievement.Call <string>("getRevealedImageUrl");
achievement.UnlockedImageUrl = javaAchievement.Call <string>("getUnlockedImageUrl");
achievement.IsIncremental =
javaAchievement.Call <int>("getType") == 1 /* TYPE_INCREMENTAL */;
if (achievement.IsIncremental)
{
achievement.CurrentSteps = javaAchievement.Call <int>("getCurrentSteps");
achievement.TotalSteps = javaAchievement.Call <int>("getTotalSteps");
}
int state = javaAchievement.Call <int>("getState");
achievement.IsUnlocked = state == 0 /* STATE_UNLOCKED */;
achievement.IsRevealed = state == 1 /* STATE_REVEALED */;
}
result[i] = achievement;
}
achievementBuffer.Call("release");
InvokeCallbackOnGameThread(callback, result);
}
});
AndroidTaskUtils.AddOnFailureListener(
task,
exception =>
{
Debug.Log("LoadAchievements failed");
InvokeCallbackOnGameThread(callback, new Achievement[0]);
});
}
}
private LeaderboardScoreData CreateLeaderboardScoreData(
string leaderboardId,
LeaderboardCollection collection,
LeaderboardTimeSpan timespan,
ResponseStatus status,
AndroidJavaObject leaderboardScoresJava)
{
LeaderboardScoreData leaderboardScoreData = new LeaderboardScoreData(leaderboardId, status);
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.PrevPageToken = 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");
ulong score = (ulong)variant.Call <long>("getRawPlayerScore");
string metadata = variant.Call <string>("getPlayerScoreTag");
leaderboardScoreData.PlayerScore = new PlayGamesScore(date, leaderboardId,
rank, mUser.id, score, metadata);
}
leaderboardScoreData.ApproximateCount = (ulong)variant.Call <long>("getNumScores");
}
return(leaderboardScoreData);
}
public void onPeersDisconnected(AndroidJavaObject room, AndroidJavaObject participantIds)
{
if (mParent.GetRoomStatus() == RoomStatus.Active)
{
mParent.mRoom = room;
mParent.mListener.OnPeersDisconnected(AndroidJavaConverter.ToStringList(participantIds).ToArray());
}
else
{
handleConnectedSetChanged(room);
}
}
private void InternalSend(List <string> recipientEndpointIds, byte[] payload)
{
Misc.CheckNotNull(recipientEndpointIds);
Misc.CheckNotNull(payload);
using (var payloadClass = new AndroidJavaClass("com.google.android.gms.nearby.connection.Payload"))
using (var payloadObject = payloadClass.CallStatic <AndroidJavaObject>("fromBytes", payload))
using (var task = mClient.Call <AndroidJavaObject>("sendPayload",
AndroidJavaConverter.ToJavaStringList(recipientEndpointIds),
payloadObject))
;
}
private List <TurnBasedMatch> CreateTurnBasedMatchList(AndroidJavaObject turnBasedMatchBuffer)
{
List <TurnBasedMatch> turnBasedMatches = new List <TurnBasedMatch>();
int count = turnBasedMatchBuffer.Call <int>("getCount");
for (int i = 0; i < count; ++i)
{
TurnBasedMatch match =
AndroidJavaConverter.ToTurnBasedMatch(turnBasedMatchBuffer.Call <AndroidJavaObject>("get", (int)i));
turnBasedMatches.Add(match);
}
return(turnBasedMatches);
}
internal static IUserProfile[] playersBufferToArray(AndroidJavaObject playersBuffer)
{
int count = playersBuffer.Call <int>("getCount");
IUserProfile[] users = new IUserProfile[count];
for (int i = 0; i < count; ++i)
{
using (var player = playersBuffer.Call <AndroidJavaObject>("get", i)) {
users[i] = AndroidJavaConverter.ToPlayerProfile(player);
}
}
playersBuffer.Call("release");
return(users);
}
///<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));
});
}
}
}
internal static Invitation ToInvitation(AndroidJavaObject invitation)
{
string invitationId = invitation.Call <string>("getInvitationId");
int invitationType = invitation.Call <int>("getInvitationType");
int variant = invitation.Call <int>("getVariant");
long creationTimestamp = invitation.Call <long>("getCreationTimestamp");
System.DateTime creationTime = AndroidJavaConverter.ToDateTime(creationTimestamp);
using (var participant = invitation.Call <AndroidJavaObject>("getInviter"))
{
return(new Invitation(
AndroidJavaConverter.FromInvitationType(invitationType),
invitationId,
AndroidJavaConverter.ToParticipant(participant),
variant,
creationTime));
}
}
public Participant GetParticipant(string participantId)
{
if (GetRoomStatus() != RoomStatus.Active)
{
return(null);
}
try
{
using (var participant = mRoom.Call <AndroidJavaObject>("getParticipant", participantId))
{
return(AndroidJavaConverter.ToParticipant(participant));
}
}
catch (Exception e)
{
return(null);
}
}
internal static List <Participant> ToParticipantList(AndroidJavaObject turnBasedMatch)
{
using (var participantsObject = turnBasedMatch.Call <AndroidJavaObject>("getParticipantIds"))
{
List <Participant> participants = new List <Participant>();
int size = participantsObject.Call <int>("size");
for (int i = 0; i < size; i++)
{
string participantId = participantsObject.Call <string>("get", i);
using (var participantObject =
turnBasedMatch.Call <AndroidJavaObject>("getParticipant", participantId))
{
participants.Add(AndroidJavaConverter.ToParticipant(participantObject));
}
}
return(participants);
}
}
private void FindInvitation(string invitationId, Action <bool> fail, Action <Invitation> callback)
{
using (var task = mInvitationsClient.Call <AndroidJavaObject>("loadInvitations"))
{
AndroidTaskUtils.AddOnSuccessListener <AndroidJavaObject>(
task,
annotatedData =>
{
using (var invitationBuffer = annotatedData.Call <AndroidJavaObject>("get"))
{
int count = invitationBuffer.Call <int>("getCount");
for (int i = 0; i < count; i++)
{
Invitation invitation;
using (var invitationObject = invitationBuffer.Call <AndroidJavaObject>("get", i))
{
invitation = AndroidJavaConverter.ToInvitation(invitationObject);
}
if (invitation.InvitationId == invitationId)
{
callback(invitation);
return;
}
}
OurUtils.Logger.e("Invitation with ID " + invitationId + " couldn't be found");
fail(true);
}
});
AndroidTaskUtils.AddOnFailureListener(
task,
exception =>
{
OurUtils.Logger.e("Couldn't load invitations.");
fail(true);
});
}
}
private List <Participant> GetParticipantList()
{
if (mRoom == null)
{
return(new List <Participant>());
}
List <Participant> participants = new List <Participant>();
using (var participantsObject = mRoom.Call <AndroidJavaObject>("getParticipants"))
{
int size = participantsObject.Call <int>("size");
for (int i = 0; i < size; i++)
{
using (var participant = participantsObject.Call <AndroidJavaObject>("get", i))
{
participants.Add(AndroidJavaConverter.ToParticipant(participant));
}
}
}
return(participants);
}
public void AcceptInvitation(string invitationId, Action <bool, TurnBasedMatch> callback)
{
callback = ToOnGameThread(callback);
FindInvitationWithId(invitationId, invitation =>
{
if (invitation == null)
{
OurUtils.Logger.e("Could not find invitation with id " + invitationId);
callback(false, null);
return;
}
using (var task = mClient.Call <AndroidJavaObject>("acceptInvitation", invitationId))
{
AndroidTaskUtils.AddOnSuccessListener <AndroidJavaObject>(
task,
turnBasedMatch =>
callback(true, AndroidJavaConverter.ToTurnBasedMatch(turnBasedMatch)));
AndroidTaskUtils.AddOnFailureListener(task, e => callback(false, null));
}
});
}
internal static Participant ToParticipant(AndroidJavaObject participant)
{
string displayName = participant.Call <string>("getDisplayName");
string participantId = participant.Call <string>("getParticipantId");
Participant.ParticipantStatus status =
AndroidJavaConverter.FromParticipantStatus(participant.Call <int>("getStatus"));
bool connectedToRoom = participant.Call <bool>("isConnectedToRoom");
Player player = null;
try
{
using (var playerObject = participant.Call <AndroidJavaObject>("getPlayer"))
{
player = ToPlayer(playerObject);
}
}
catch (Exception)
{
// Unity throws exception for returned null
}
return(new Participant(displayName, participantId, status, player, connectedToRoom));
}
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);
});
}
}
///<summary></summary>
/// <seealso cref="GooglePlayGames.BasicApi.IPlayGamesClient.LoadMoreScores"/>
public void LoadMoreScores(ScorePageToken token, int rowCount,
Action <LeaderboardScoreData> callback)
{
using (var client = getLeaderboardsClient())
using (var task = client.Call <AndroidJavaObject>("loadMoreScores",
token.InternalObject, rowCount, AndroidJavaConverter.ToPageDirection(token.Direction)))
{
AndroidTaskUtils.AddOnSuccessListener <AndroidJavaObject>(
task,
annotatedData =>
{
using (var leaderboardScores = annotatedData.Call <AndroidJavaObject>("get"))
{
InvokeCallbackOnGameThread(callback, CreateLeaderboardScoreData(
token.LeaderboardId,
token.Collection,
token.TimeSpan,
annotatedData.Call <bool>("isStale")
? ResponseStatus.SuccessWithStale
: ResponseStatus.Success,
leaderboardScores));
leaderboardScores.Call("release");
}
});
AndroidTaskUtils.AddOnFailureListener(
task,
exception =>
{
Debug.Log("LoadMoreScores failed");
InvokeCallbackOnGameThread(callback,
new LeaderboardScoreData(token.LeaderboardId, ResponseStatus.InternalError));
});
}
}
public void onInvitationReceived(AndroidJavaObject invitation)
{
mInvitationDelegate.Invoke(AndroidJavaConverter.ToInvitation(invitation), /* shouldAutoAccept= */
false);
}
///<summary></summary>
/// <seealso cref="GooglePlayGames.BasicApi.IPlayGamesClient.LoadUsers"/>
public void LoadUsers(string[] userIds, Action <IUserProfile[]> callback)
{
if (!IsAuthenticated())
{
InvokeCallbackOnGameThread(callback, new IUserProfile[0]);
return;
}
using (var playersClient = getPlayersClient())
{
object countLock = new object();
int count = userIds.Length;
int resultCount = 0;
IUserProfile[] users = new IUserProfile[count];
for (int i = 0; i < count; ++i)
{
using (var task = playersClient.Call <AndroidJavaObject>("loadPlayer", userIds[i]))
{
AndroidTaskUtils.AddOnSuccessListener <AndroidJavaObject>(
task,
annotatedData =>
{
using (var player = annotatedData.Call <AndroidJavaObject>("get"))
{
string playerId = player.Call <string>("getPlayerId");
for (int j = 0; j < count; ++j)
{
if (playerId == userIds[j])
{
users[j] = AndroidJavaConverter.ToPlayer(player);
break;
}
}
lock (countLock)
{
++resultCount;
if (resultCount == count)
{
InvokeCallbackOnGameThread(callback, users);
}
}
}
});
AndroidTaskUtils.AddOnFailureListener(
task,
exception =>
{
Debug.Log("LoadUsers failed for index " + i);
lock (countLock)
{
++resultCount;
if (resultCount == count)
{
InvokeCallbackOnGameThread(callback, users);
}
}
});
}
}
}
}
///<summary></summary>
/// <seealso cref="GooglePlayGames.BasicApi.IPlayGamesClient.Authenticate"/>
public void Authenticate(Action <bool, string> callback, bool silent)
{
lock (AuthStateLock)
{
// If the user is already authenticated, just fire the callback, we don't need
// any additional work.
if (mAuthState == AuthState.Authenticated)
{
InvokeCallbackOnGameThread(callback, true, null);
return;
}
}
InitializeTokenClient();
Debug.Log("Starting Auth with token client.");
mTokenClient.FetchTokens(silent, (int result) =>
{
bool succeed = result == 0 /* CommonStatusCodes.SUCCEED */;
InitializeGameServices();
if (succeed)
{
using (var signInTasks = new AndroidJavaObject("java.util.ArrayList"))
{
if (mInvitationDelegate != null)
{
mInvitationCallback = new AndroidJavaObject(
"com.google.games.bridge.InvitationCallbackProxy",
new InvitationCallbackProxy(mInvitationDelegate));
using (var invitationsClient = getInvitationsClient())
using (var taskRegisterCallback =
invitationsClient.Call <AndroidJavaObject>("registerInvitationCallback",
mInvitationCallback))
{
signInTasks.Call <bool>("add", taskRegisterCallback);
}
}
AndroidJavaObject taskGetPlayer =
getPlayersClient().Call <AndroidJavaObject>("getCurrentPlayer");
AndroidJavaObject taskGetActivationHint =
getGamesClient().Call <AndroidJavaObject>("getActivationHint");
AndroidJavaObject taskIsCaptureSupported =
getVideosClient().Call <AndroidJavaObject>("isCaptureSupported");
if (!mConfiguration.IsHidingPopups)
{
AndroidJavaObject taskSetViewForPopups;
using (var popupView = AndroidHelperFragment.GetDefaultPopupView())
{
taskSetViewForPopups =
getGamesClient().Call <AndroidJavaObject>("setViewForPopups", popupView);
}
signInTasks.Call <bool>("add", taskSetViewForPopups);
}
signInTasks.Call <bool>("add", taskGetPlayer);
signInTasks.Call <bool>("add", taskGetActivationHint);
signInTasks.Call <bool>("add", taskIsCaptureSupported);
using (var tasks = new AndroidJavaClass(TasksClassName))
using (var allTask = tasks.CallStatic <AndroidJavaObject>("whenAll", signInTasks))
{
AndroidTaskUtils.AddOnCompleteListener <AndroidJavaObject>(
allTask,
completeTask =>
{
if (completeTask.Call <bool>("isSuccessful"))
{
using (var resultObject = taskGetPlayer.Call <AndroidJavaObject>("getResult"))
{
mUser = AndroidJavaConverter.ToPlayer(resultObject);
}
var account = mTokenClient.GetAccount();
lock (GameServicesLock)
{
mSavedGameClient = new AndroidSavedGameClient(account);
mEventsClient = new AndroidEventsClient(account);
bool isCaptureSupported;
using (var resultObject =
taskIsCaptureSupported.Call <AndroidJavaObject>("getResult"))
{
isCaptureSupported = resultObject.Call <bool>("booleanValue");
}
mVideoClient = new AndroidVideoClient(isCaptureSupported, account);
mRealTimeClient = new AndroidRealTimeMultiplayerClient(this, account);
mTurnBasedClient = new AndroidTurnBasedMultiplayerClient(this, account);
mTurnBasedClient.RegisterMatchDelegate(mConfiguration.MatchDelegate);
}
mAuthState = AuthState.Authenticated;
InvokeCallbackOnGameThread(callback, true, "Authentication succeeded");
GooglePlayGames.OurUtils.Logger.d("Authentication succeeded");
try
{
using (var activationHint =
taskGetActivationHint.Call <AndroidJavaObject>("getResult"))
{
if (mInvitationDelegate != null)
{
try
{
using (var invitationObject =
activationHint.Call <AndroidJavaObject>("getParcelable",
"invitation" /* Multiplayer.EXTRA_INVITATION */))
{
Invitation invitation =
AndroidJavaConverter.ToInvitation(invitationObject);
mInvitationDelegate(invitation, /* shouldAutoAccept= */
true);
}
}
catch (Exception)
{
// handle null return
}
}
if (mTurnBasedClient.MatchDelegate != null)
{
try
{
using (var matchObject =
activationHint.Call <AndroidJavaObject>("getParcelable",
"turn_based_match" /* Multiplayer#EXTRA_TURN_BASED_MATCH */)
)
{
TurnBasedMatch turnBasedMatch =
AndroidJavaConverter.ToTurnBasedMatch(matchObject);
mTurnBasedClient.MatchDelegate(
turnBasedMatch, /* shouldAutoLaunch= */ true);
}
}
catch (Exception)
{
}
}
}
}
catch (Exception)
{
// handle null return
}
LoadAchievements(ignore => { });
}
else
{
SignOut();
InvokeCallbackOnGameThread(callback, false, "Authentication failed");
GooglePlayGames.OurUtils.Logger.d("Authentication failed");
}
}
);
}
}
}
else
{
lock (AuthStateLock)
{
if (result == 16 /* CommonStatusCodes.CANCELED */)
{
InvokeCallbackOnGameThread(callback, false, "Authentication canceled");
GooglePlayGames.OurUtils.Logger.d("Authentication canceled");
}
else if (result == 8 /* CommonStatusCodes.DEVELOPER_ERROR */)
{
InvokeCallbackOnGameThread(callback, false, "Authentication failed - developer error");
GooglePlayGames.OurUtils.Logger.d("Authentication failed - developer error");
}
else
{
InvokeCallbackOnGameThread(callback, false, "Authentication failed");
GooglePlayGames.OurUtils.Logger.d("Authentication failed");
}
}
}
});
}
public void CreateWithInvitationScreen(uint minOpponents, uint maxOpponents, uint variant,
RealTimeMultiplayerListener listener)
{
lock (mSessionLock)
{
if (GetRoomStatus() == RoomStatus.Active)
{
OurUtils.Logger.e("Received attempt to create a new room without cleaning up the old one.");
listener.OnRoomConnected(false);
return;
}
AndroidHelperFragment.ShowRtmpSelectOpponentsUI(minOpponents, maxOpponents,
(status, result) =>
{
if (status != UIStatus.Valid)
{
listener.OnRoomConnected(false);
CleanSession();
return;
}
using (var roomConfigClass =
new AndroidJavaClass("com.google.android.gms.games.multiplayer.realtime.RoomConfig"))
using (var roomUpdateCallback = new AndroidJavaObject(
"com.google.games.bridge.RoomUpdateCallbackProxy",
new RoomUpdateCallbackProxy(/* parent= */ this, listener)))
using (var roomConfigBuilder =
roomConfigClass.CallStatic <AndroidJavaObject>("builder", roomUpdateCallback))
{
if (result.MinAutomatchingPlayers > 0)
{
using (var autoMatchCriteria = roomConfigClass.CallStatic <AndroidJavaObject>(
"createAutoMatchCriteria", result.MinAutomatchingPlayers,
result.MaxAutomatchingPlayers, /* exclusiveBitMask= */ (long)0))
using (roomConfigBuilder.Call <AndroidJavaObject>("setAutoMatchCriteria",
autoMatchCriteria))
;
}
if (variant != 0)
{
using (roomConfigBuilder.Call <AndroidJavaObject>("setVariant", (int)variant));
}
using (var messageReceivedListener =
new AndroidJavaObject(
"com.google.games.bridge.RealTimeMessageReceivedListenerProxy",
new MessageReceivedListenerProxy(listener)))
using (roomConfigBuilder.Call <AndroidJavaObject>("setOnMessageReceivedListener",
messageReceivedListener))
;
using (var roomStatusUpdateCallback =
new AndroidJavaObject("com.google.games.bridge.RoomStatusUpdateCallbackProxy",
new RoomStatusUpdateCallbackProxy(this, listener)))
using (roomConfigBuilder.Call <AndroidJavaObject>("setRoomStatusUpdateCallback",
roomStatusUpdateCallback))
;
using (roomConfigBuilder.Call <AndroidJavaObject>("addPlayersToInvite",
AndroidJavaConverter.ToJavaStringList(result.PlayerIdsToInvite)))
{
mRoomConfig = roomConfigBuilder.Call <AndroidJavaObject>("build");
}
mListener = listener;
}
// the min number to start is the number of automatched + the number of named invitations +
// the local player.
mMinPlayersToStart = result.MinAutomatchingPlayers + result.PlayerIdsToInvite.Count + 1;
using (var task = mRtmpClient.Call <AndroidJavaObject>("create", mRoomConfig))
{
AndroidTaskUtils.AddOnFailureListener(
task,
exception =>
{
listener.OnRoomConnected(false);
CleanSession();
});
}
});
}
}
