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));
}
});
}
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 static void ShowInboxUI(Action <UIStatus, TurnBasedMatch> cb)
{
using (var helperFragment = new AndroidJavaClass(HelperFragmentClass))
using (var task = helperFragment.CallStatic <AndroidJavaObject>("showInboxUi",
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 turnBasedMatch = result.Get <AndroidJavaObject>("turnBasedMatch"))
{
cb.Invoke((UIStatus)status, AndroidJavaConverter.ToTurnBasedMatch(turnBasedMatch));
}
});
AndroidTaskUtils.AddOnFailureListener(
task,
exception =>
{
Debug.Log("showInboxUi failed with exception");
cb.Invoke(UIStatus.InternalError, 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));
}
}
});
}
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);
}
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));
}
});
}
///<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 onTurnBasedMatchReceived(AndroidJavaObject turnBasedMatch)
{
mMatchDelegate.Invoke(AndroidJavaConverter.ToTurnBasedMatch(turnBasedMatch), /* shouldAutoLaunch= */
false);
}
