// called from game thread
public void CreateWithInvitationScreen(int minOpponents, int maxOpponents, int variant,
RealTimeMultiplayerListener listener)
{
Logger.d(string.Format("AndroidRtmpClient.CreateWithInvitationScreen, " +
"opponents={0}-{1}, variant={2}", minOpponents, maxOpponents, variant));
if (!PrepareToCreateRoom("CreateWithInvitationScreen", listener))
{
return;
}
mRtmpListener = listener;
mVariant = variant;
mClient.CallClientApi("rtmp create with invitation screen", () => {
AndroidJavaClass klass = JavaUtil.GetClass(
JavaConsts.SupportSelectOpponentsHelperActivity);
mLaunchedExternalActivity = true;
klass.CallStatic("launch", true, mClient.GetActivity(),
new SelectOpponentsProxy(this), Logger.DebugLogEnabled,
minOpponents, maxOpponents);
}, (bool success) => {
if (!success)
{
FailRoomSetup("Failed to create game because GoogleApiClient was disconnected");
}
});
}
public void AcceptFromInbox(Action <bool, TurnBasedMatch> callback)
{
Logger.d(string.Format("AndroidTbmpClient.AcceptFromInbox", new object[0]));
this.mClient.CallClientApi("tbmp launch inbox", delegate
{
AndroidJavaClass @class = JavaUtil.GetClass("com.google.example.games.pluginsupport.InvitationInboxHelperActivity");
@class.CallStatic("launch", new object[]
{
false,
this.mClient.GetActivity(),
new AndroidTbmpClient.InvitationInboxProxy(this, callback),
Logger.DebugLogEnabled
});
}, delegate(bool success)
{
if (!success)
{
Logger.w("Failed to accept tbmp w/ inbox: client disconnected.");
if (callback != null)
{
callback(false, null);
}
}
});
}
public void CreateQuickGame(int minOpponents, int maxOpponents, int variant, RealTimeMultiplayerListener listener)
{
Logger.d(string.Format("AndroidRtmpClient.CreateQuickGame, opponents={0}-{1}, variant={2}", minOpponents, maxOpponents, variant));
if (!this.PrepareToCreateRoom("CreateQuickGame", listener))
{
return;
}
this.mRtmpListener = listener;
this.mVariant = variant;
this.mClient.CallClientApi("rtmp create quick game", delegate
{
AndroidJavaClass @class = JavaUtil.GetClass("com.google.example.games.pluginsupport.RtmpUtils");
@class.CallStatic("createQuickGame", new object[]
{
this.mClient.GHManager.GetApiClient(),
minOpponents,
maxOpponents,
variant,
new AndroidRtmpClient.RoomUpdateProxy(this),
new AndroidRtmpClient.RoomStatusUpdateProxy(this),
new AndroidRtmpClient.RealTimeMessageReceivedProxy(this)
});
}, delegate(bool success)
{
if (!success)
{
this.FailRoomSetup("Failed to create game because GoogleApiClient was disconnected");
}
});
}
public void CreateQuickMatch(int minOpponents, int maxOpponents, int variant, Action <bool, TurnBasedMatch> callback)
{
Logger.d(string.Format("AndroidTbmpClient.CreateQuickMatch, opponents {0}-{1}, var {2}", minOpponents, maxOpponents, variant));
this.mClient.CallClientApi("tbmp create quick game", delegate
{
AndroidTbmpClient.ResultProxy resultProxy = new AndroidTbmpClient.ResultProxy(this, "createMatch");
resultProxy.SetMatchCallback(callback);
AndroidJavaClass @class = JavaUtil.GetClass("com.google.example.games.pluginsupport.TbmpUtils");
using (AndroidJavaObject androidJavaObject = @class.CallStatic <AndroidJavaObject>("createQuickMatch", new object[]
{
this.mClient.GHManager.GetApiClient(),
minOpponents,
maxOpponents,
variant
}))
{
androidJavaObject.Call("setResultCallback", new object[]
{
resultProxy
});
}
}, delegate(bool success)
{
if (!success)
{
Logger.w("Failed to create tbmp quick match: client disconnected.");
if (callback != null)
{
callback(false, null);
}
}
});
}
public void CreateWithInvitationScreen(int minOpponents, int maxOpponents, int variant, Action <bool, TurnBasedMatch> callback)
{
Logger.d(string.Format("AndroidTbmpClient.CreateWithInvitationScreen, opponents {0}-{1}, variant {2}", minOpponents, maxOpponents, variant));
this.mClient.CallClientApi("tbmp launch invitation screen", delegate
{
AndroidJavaClass @class = JavaUtil.GetClass("com.google.example.games.pluginsupport.SelectOpponentsHelperActivity");
@class.CallStatic("launch", new object[]
{
false,
this.mClient.GetActivity(),
new AndroidTbmpClient.SelectOpponentsProxy(this, callback, variant),
Logger.DebugLogEnabled,
minOpponents,
maxOpponents
});
}, delegate(bool success)
{
if (!success)
{
Logger.w("Failed to create tbmp w/ invite screen: client disconnected.");
if (callback != null)
{
callback(false, null);
}
}
});
}
// called on game thread
public void CreateQuickMatch(int minOpponents, int maxOpponents, int variant,
Action <bool, TurnBasedMatch> callback)
{
Logger.d(string.Format("AndroidTbmpClient.CreateQuickMatch, opponents {0}-{1}, var {2}",
minOpponents, maxOpponents, variant));
mClient.CallClientApi("tbmp create quick game", () => {
ResultProxy proxy = new ResultProxy(this, "createMatch");
proxy.SetMatchCallback(callback);
AndroidJavaClass tbmpUtil = JavaUtil.GetClass(JavaConsts.SupportTbmpUtilsClass);
using (AndroidJavaObject pendingResult = tbmpUtil.CallStatic <AndroidJavaObject>(
"createQuickMatch", mClient.GHManager.GetApiClient(),
minOpponents, maxOpponents, variant)) {
pendingResult.Call("setResultCallback", proxy);
}
}, (bool success) => {
if (!success)
{
Logger.w("Failed to create tbmp quick match: client disconnected.");
if (callback != null)
{
callback.Invoke(false, null);
}
}
});
}
public void AcceptInvitation(string invitationId, RealTimeMultiplayerListener listener)
{
Logger.d("AndroidRtmpClient.AcceptInvitation " + invitationId);
if (!this.PrepareToCreateRoom("AcceptInvitation", listener))
{
return;
}
this.mRtmpListener = listener;
this.mClient.ClearInvitationIfFromNotification(invitationId);
this.mClient.CallClientApi("rtmp accept invitation", delegate
{
Logger.d("Accepting invite via support lib.");
AndroidJavaClass @class = JavaUtil.GetClass("com.google.example.games.pluginsupport.RtmpUtils");
@class.CallStatic("accept", new object[]
{
this.mClient.GHManager.GetApiClient(),
invitationId,
new AndroidRtmpClient.RoomUpdateProxy(this),
new AndroidRtmpClient.RoomStatusUpdateProxy(this),
new AndroidRtmpClient.RealTimeMessageReceivedProxy(this)
});
}, delegate(bool success)
{
if (!success)
{
this.FailRoomSetup("Failed to accept invitation because GoogleApiClient was disconnected");
}
});
}
public void AcceptFromInbox(RealTimeMultiplayerListener listener)
{
Logger.d("AndroidRtmpClient.AcceptFromInbox.");
if (!this.PrepareToCreateRoom("AcceptFromInbox", listener))
{
return;
}
this.mRtmpListener = listener;
this.mClient.CallClientApi("rtmp accept with inbox screen", delegate
{
AndroidJavaClass @class = JavaUtil.GetClass("com.google.example.games.pluginsupport.InvitationInboxHelperActivity");
this.mLaunchedExternalActivity = true;
@class.CallStatic("launch", new object[]
{
true,
this.mClient.GetActivity(),
new AndroidRtmpClient.InvitationInboxProxy(this),
Logger.DebugLogEnabled
});
}, delegate(bool success)
{
if (!success)
{
this.FailRoomSetup("Failed to accept from inbox because GoogleApiClient was disconnected");
}
});
}
public void CreateWithInvitationScreen(int minOpponents, int maxOpponents, int variant, RealTimeMultiplayerListener listener)
{
Logger.d(string.Format("AndroidRtmpClient.CreateWithInvitationScreen, opponents={0}-{1}, variant={2}", minOpponents, maxOpponents, variant));
if (!this.PrepareToCreateRoom("CreateWithInvitationScreen", listener))
{
return;
}
this.mRtmpListener = listener;
this.mVariant = variant;
this.mClient.CallClientApi("rtmp create with invitation screen", delegate
{
AndroidJavaClass @class = JavaUtil.GetClass("com.google.example.games.pluginsupport.SelectOpponentsHelperActivity");
this.mLaunchedExternalActivity = true;
@class.CallStatic("launch", new object[]
{
true,
this.mClient.GetActivity(),
new AndroidRtmpClient.SelectOpponentsProxy(this),
Logger.DebugLogEnabled,
minOpponents,
maxOpponents
});
}, delegate(bool success)
{
if (!success)
{
this.FailRoomSetup("Failed to create game because GoogleApiClient was disconnected");
}
});
}
// called from game thread
public void CreateQuickGame(int minOpponents, int maxOpponents, int variant,
RealTimeMultiplayerListener listener)
{
Logger.d(string.Format("AndroidRtmpClient.CreateQuickGame, opponents={0}-{1}, " +
"variant={2}", minOpponents, maxOpponents, variant));
if (!PrepareToCreateRoom("CreateQuickGame", listener))
{
return;
}
mRtmpListener = listener;
mVariant = variant;
mClient.CallClientApi("rtmp create quick game", () => {
AndroidJavaClass rtmpUtil = JavaUtil.GetClass(JavaConsts.SupportRtmpUtilsClass);
rtmpUtil.CallStatic("createQuickGame", mClient.GHManager.GetApiClient(),
minOpponents, maxOpponents, variant,
new RoomUpdateProxy(this), new RoomStatusUpdateProxy(this),
new RealTimeMessageReceivedProxy(this));
}, (bool success) => {
if (!success)
{
FailRoomSetup("Failed to create game because GoogleApiClient was disconnected");
}
});
}
// called on game thread
public void CreateWithInvitationScreen(int minOpponents, int maxOpponents,
int variant, Action <bool, TurnBasedMatch> callback)
{
Logger.d(string.Format("AndroidTbmpClient.CreateWithInvitationScreen, " +
"opponents {0}-{1}, variant {2}", minOpponents, maxOpponents,
variant));
mClient.CallClientApi("tbmp launch invitation screen", () => {
AndroidJavaClass klass = JavaUtil.GetClass(
JavaConsts.SupportSelectOpponentsHelperActivity);
klass.CallStatic("launch", false, mClient.GetActivity(),
new SelectOpponentsProxy(this, callback, variant),
Logger.DebugLogEnabled,
minOpponents, maxOpponents);
}, (bool success) => {
if (!success)
{
Logger.w("Failed to create tbmp w/ invite screen: client disconnected.");
if (callback != null)
{
callback.Invoke(false, null);
}
}
});
}
public void StartSelectSnapshotActivity(string title, bool allowAdd, bool allowDelete,
int maxSnapshots, OnSnapshotResultListener listener)
{
Logger.d("AndroidClient.StartSelectSnapshotActivity");
CallClientApi("select snapshot ui", () => {
AndroidJavaClass klass = JavaUtil.GetClass(
JavaConsts.SupportSelectSnapshotHelperActivity);
klass.CallStatic("launch", GetActivity(), new SelectSnapshotProxy(this, listener),
title, allowAdd, allowDelete, maxSnapshots);
}, null);
}
private void OnSelectOpponentsResult(bool success, AndroidJavaObject opponents, bool hasAutoMatch, AndroidJavaObject autoMatchCriteria, Action <bool, TurnBasedMatch> callback, int variant)
{
Logger.d(string.Concat(new object[]
{
"AndroidTbmpClient.OnSelectOpponentsResult, success=",
success,
", hasAutoMatch=",
hasAutoMatch
}));
if (!success)
{
Logger.w("Tbmp select opponents dialog terminated with failure.");
if (callback != null)
{
Logger.d("Reporting select-opponents dialog failure to callback.");
PlayGamesHelperObject.RunOnGameThread(delegate
{
callback(false, null);
});
}
return;
}
Logger.d("Creating TBMP match from opponents received from dialog.");
this.mClient.CallClientApi("create match w/ opponents from dialog", delegate
{
AndroidTbmpClient.ResultProxy resultProxy = new AndroidTbmpClient.ResultProxy(this, "createMatch");
resultProxy.SetMatchCallback(callback);
AndroidJavaClass @class = JavaUtil.GetClass("com.google.example.games.pluginsupport.TbmpUtils");
using (AndroidJavaObject androidJavaObject = @class.CallStatic <AndroidJavaObject>("create", new object[]
{
this.mClient.GHManager.GetApiClient(),
opponents,
variant,
(!hasAutoMatch) ? null : autoMatchCriteria
}))
{
androidJavaObject.Call("setResultCallback", new object[]
{
resultProxy
});
}
}, delegate(bool ok)
{
if (!ok)
{
Logger.w("Failed to create match w/ opponents from dialog: client disconnected.");
if (callback != null)
{
callback(false, null);
}
}
});
}
private void OnSelectOpponentsResult(bool success, AndroidJavaObject opponents,
bool hasAutoMatch, AndroidJavaObject autoMatchCriteria,
Action <bool, TurnBasedMatch> callback, int variant)
{
Logger.d("AndroidTbmpClient.OnSelectOpponentsResult, success=" + success +
", hasAutoMatch=" + hasAutoMatch);
if (!success)
{
Logger.w("Tbmp select opponents dialog terminated with failure.");
if (callback != null)
{
Logger.d("Reporting select-opponents dialog failure to callback.");
PlayGamesHelperObject.RunOnGameThread(() => {
callback.Invoke(false, null);
});
}
return;
}
Logger.d("Creating TBMP match from opponents received from dialog.");
mClient.CallClientApi("create match w/ opponents from dialog", () => {
ResultProxy proxy = new ResultProxy(this, "createMatch");
proxy.SetMatchCallback(callback);
AndroidJavaClass tbmpUtil = JavaUtil.GetClass(JavaConsts.SupportTbmpUtilsClass);
using (AndroidJavaObject pendingResult = tbmpUtil.CallStatic <AndroidJavaObject>(
"create", mClient.GHManager.GetApiClient(),
opponents, variant, hasAutoMatch ? autoMatchCriteria : null)) {
pendingResult.Call("setResultCallback", proxy);
}
}, (bool ok) => {
if (!ok)
{
Logger.w("Failed to create match w/ opponents from dialog: client disconnected.");
if (callback != null)
{
callback.Invoke(false, null);
}
}
});
}
public void CreateQuickGame(int minOpponents, int maxOpponents, IList <string> playersToInvite, int variant,
RealTimeMultiplayerListener listener)
{
Logger.d(string.Format("AndroidRtmpClient.CreateQuickGame, opponents={0}-{1}, player={2}" +
"variant={3}", minOpponents, maxOpponents, playersToInvite, variant));
if (!PrepareToCreateRoom("CreateQuickGame", listener))
{
return;
}
mRtmpListener = listener;
mVariant = variant;
mClient.CallClientApi("rtmp create quick game", () =>
{
AndroidJavaClass rtmpUtil = JavaUtil.GetClass(JavaConsts.SupportRtmpUtilsClass);
// Bundle autoMatchCriteria = RoomConfig.createAutoMatchCriteria(minOpponents, maxOpponents, 0);
AndroidJavaClass RoomConfig = new AndroidJavaClass("com.google.android.gms.games.multiplayer.realtime.RoomConfig");
AndroidJavaObject autoMatchCriteria = RoomConfig.CallStatic <AndroidJavaObject>("createAutoMatchCriteria", minOpponents, maxOpponents, 0);
// IList<string> to java.util.ArrayList<String>
AndroidJavaObject javaUtilArrayList = new AndroidJavaClass("java.utils.ArrayList");
foreach (var player in playersToInvite)
{
javaUtilArrayList.Call("add", player);
}
// public static void create(GoogleApiClient apiClient, ArrayList<String> playersToInvite, int variant, Bundle autoMatchCriteria,
// RoomUpdateListener roomUpdateListener, RoomStatusUpdateListener roomStatusUpdateListener, RealTimeMessageReceivedListener messageReceivedListener)
rtmpUtil.CallStatic("create", mClient.GHManager.GetApiClient(), javaUtilArrayList, variant, autoMatchCriteria,
new RoomUpdateProxy(this), new RoomStatusUpdateProxy(this),
new RealTimeMessageReceivedProxy(this));
}, (bool success) =>
{
if (!success)
{
FailRoomSetup("Failed to create game because GoogleApiClient was disconnected");
}
});
}
private void OnInvitationInboxResult(bool success, string invitationId)
{
Logger.d(string.Concat(new object[]
{
"AndroidRtmpClient.OnInvitationInboxResult, success=",
success,
", invitationId=",
invitationId
}));
if (!this.CheckRtmpActive("OnInvitationInboxResult"))
{
return;
}
this.mLaunchedExternalActivity = false;
if (!success || invitationId == null || invitationId.Length == 0)
{
Logger.w("Failed to setup room because invitation inbox UI failed.");
this.FailRoomSetup("Invitation inbox UI failed.");
return;
}
this.mClient.ClearInvitationIfFromNotification(invitationId);
this.mClient.CallClientApi("accept invite from inbox", delegate
{
Logger.d("Accepting invite from inbox via support lib.");
AndroidJavaClass @class = JavaUtil.GetClass("com.google.example.games.pluginsupport.RtmpUtils");
@class.CallStatic("accept", new object[]
{
this.mClient.GHManager.GetApiClient(),
invitationId,
new AndroidRtmpClient.RoomUpdateProxy(this),
new AndroidRtmpClient.RoomStatusUpdateProxy(this),
new AndroidRtmpClient.RealTimeMessageReceivedProxy(this)
});
}, delegate(bool ok)
{
if (!ok)
{
this.FailRoomSetup("GoogleApiClient lost connection.");
}
});
}
// called on game thread
public void AcceptFromInbox(Action <bool, TurnBasedMatch> callback)
{
Logger.d(string.Format("AndroidTbmpClient.AcceptFromInbox"));
mClient.CallClientApi("tbmp launch inbox", () => {
AndroidJavaClass klass = JavaUtil.GetClass(
JavaConsts.SupportInvitationInboxHelperActivity);
klass.CallStatic("launch", false, mClient.GetActivity(),
new InvitationInboxProxy(this, callback),
Logger.DebugLogEnabled);
}, (bool success) => {
if (!success)
{
Logger.w("Failed to accept tbmp w/ inbox: client disconnected.");
if (callback != null)
{
callback.Invoke(false, null);
}
}
});
}
// called from game thread
public void AcceptFromInbox(RealTimeMultiplayerListener listener)
{
Logger.d("AndroidRtmpClient.AcceptFromInbox.");
if (!PrepareToCreateRoom("AcceptFromInbox", listener))
{
return;
}
mRtmpListener = listener;
mClient.CallClientApi("rtmp accept with inbox screen", () => {
AndroidJavaClass klass = JavaUtil.GetClass(
JavaConsts.SupportInvitationInboxHelperActivity);
mLaunchedExternalActivity = true;
klass.CallStatic("launch", true, mClient.GetActivity(),
new InvitationInboxProxy(this), Logger.DebugLogEnabled);
}, (bool success) => {
if (!success)
{
FailRoomSetup("Failed to accept from inbox because GoogleApiClient was disconnected");
}
});
}
private void OnInvitationInboxResult(bool success, string invitationId)
{
Logger.d("AndroidRtmpClient.OnInvitationInboxResult, " +
"success=" + success + ", invitationId=" + invitationId);
if (!CheckRtmpActive("OnInvitationInboxResult"))
{
return;
}
// we now do not have an external Activity that we launched
mLaunchedExternalActivity = false;
if (!success || invitationId == null || invitationId.Length == 0)
{
Logger.w("Failed to setup room because invitation inbox UI failed.");
FailRoomSetup("Invitation inbox UI failed.");
return;
}
mClient.ClearInvitationIfFromNotification(invitationId);
// we use CallClientApi instead of calling the API directly because we need
// to make sure that we call it when the GoogleApiClient is connected, which is
// not necessarily true at this point (we just came back from an external
// activity)
mClient.CallClientApi("accept invite from inbox", () => {
Logger.d("Accepting invite from inbox via support lib.");
AndroidJavaClass rtmpUtil = JavaUtil.GetClass(JavaConsts.SupportRtmpUtilsClass);
rtmpUtil.CallStatic("accept", mClient.GHManager.GetApiClient(), invitationId,
new RoomUpdateProxy(this), new RoomStatusUpdateProxy(this),
new RealTimeMessageReceivedProxy(this));
}, (bool ok) => {
if (!ok)
{
FailRoomSetup("GoogleApiClient lost connection.");
}
});
}
private void OnSelectOpponentsResult(bool success, AndroidJavaObject opponents,
bool hasAutoMatch, AndroidJavaObject autoMatchCriteria)
{
Logger.d("AndroidRtmpClient.OnSelectOpponentsResult, success=" + success);
if (!CheckRtmpActive("OnSelectOpponentsResult"))
{
return;
}
// we now do not have an external Activity that we launched
mLaunchedExternalActivity = false;
if (!success)
{
Logger.w("Room setup failed because select-opponents UI failed.");
FailRoomSetup("Select opponents UI failed.");
return;
}
// at this point, we have to create the room -- but we have to make sure that
// our GoogleApiClient is connected before we do that. It might NOT be connected
// right now because we just came back from calling an external Activity.
// So we use CallClientApi to make sure we are only doing this at the right time:
mClient.CallClientApi("creating room w/ select-opponents result", () => {
Logger.d("Creating room via support lib's RtmpUtil.");
AndroidJavaClass rtmpUtil = JavaUtil.GetClass(JavaConsts.SupportRtmpUtilsClass);
rtmpUtil.CallStatic("create", mClient.GHManager.GetApiClient(),
opponents, mVariant, hasAutoMatch ? autoMatchCriteria : null,
new RoomUpdateProxy(this), new RoomStatusUpdateProxy(this),
new RealTimeMessageReceivedProxy(this));
}, (bool ok) => {
if (!ok)
{
FailRoomSetup("GoogleApiClient lost connection");
}
});
}
// called from the game thread
public void AcceptInvitation(string invitationId, RealTimeMultiplayerListener listener)
{
Logger.d("AndroidRtmpClient.AcceptInvitation " + invitationId);
if (!PrepareToCreateRoom("AcceptInvitation", listener))
{
return;
}
mRtmpListener = listener;
mClient.ClearInvitationIfFromNotification(invitationId);
mClient.CallClientApi("rtmp accept invitation", () => {
Logger.d("Accepting invite via support lib.");
AndroidJavaClass rtmpUtil = JavaUtil.GetClass(JavaConsts.SupportRtmpUtilsClass);
rtmpUtil.CallStatic("accept", mClient.GHManager.GetApiClient(), invitationId,
new RoomUpdateProxy(this), new RoomStatusUpdateProxy(this),
new RealTimeMessageReceivedProxy(this));
}, (bool success) => {
if (!success)
{
FailRoomSetup("Failed to accept invitation because GoogleApiClient was disconnected");
}
});
}
private void OnSelectOpponentsResult(bool success, AndroidJavaObject opponents, bool hasAutoMatch, AndroidJavaObject autoMatchCriteria)
{
Logger.d("AndroidRtmpClient.OnSelectOpponentsResult, success=" + success);
if (!this.CheckRtmpActive("OnSelectOpponentsResult"))
{
return;
}
this.mLaunchedExternalActivity = false;
if (!success)
{
Logger.w("Room setup failed because select-opponents UI failed.");
this.FailRoomSetup("Select opponents UI failed.");
return;
}
this.mClient.CallClientApi("creating room w/ select-opponents result", delegate
{
Logger.d("Creating room via support lib's RtmpUtil.");
AndroidJavaClass @class = JavaUtil.GetClass("com.google.example.games.pluginsupport.RtmpUtils");
@class.CallStatic("create", new object[]
{
this.mClient.GHManager.GetApiClient(),
opponents,
this.mVariant,
(!hasAutoMatch) ? null : autoMatchCriteria,
new AndroidRtmpClient.RoomUpdateProxy(this),
new AndroidRtmpClient.RoomStatusUpdateProxy(this),
new AndroidRtmpClient.RealTimeMessageReceivedProxy(this)
});
}, delegate(bool ok)
{
if (!ok)
{
this.FailRoomSetup("GoogleApiClient lost connection");
}
});
}
public static AndroidJavaClass GetGmsClass(string className)
{
return(JavaUtil.GetClass("com.google.android.gms." + className));
}
private void CheckForConnectionExtras()
{
// check to see if we have a pending invitation in our gamehelper
Logger.d("AndroidClient: CheckInvitationFromNotification.");
Logger.d("AndroidClient: looking for invitation in our GameHelper.");
Invitation invFromNotif = null;
AndroidJavaObject invObj = mGHManager.GetInvitation();
AndroidJavaObject matchObj = mGHManager.GetTurnBasedMatch();
mGHManager.ClearInvitationAndTurnBasedMatch();
if (invObj != null)
{
Logger.d("Found invitation in GameHelper. Converting.");
invFromNotif = ConvertInvitation(invObj);
Logger.d("Found invitation in our GameHelper: " + invFromNotif);
}
else
{
Logger.d("No invitation in our GameHelper. Trying SignInHelperManager.");
AndroidJavaClass cls = JavaUtil.GetClass(JavaConsts.SignInHelperManagerClass);
using (AndroidJavaObject inst = cls.CallStatic <AndroidJavaObject>("getInstance")) {
if (inst.Call <bool>("hasInvitation"))
{
invFromNotif = ConvertInvitation(inst.Call <AndroidJavaObject>("getInvitation"));
Logger.d("Found invitation in SignInHelperManager: " + invFromNotif);
inst.Call("forgetInvitation");
}
else
{
Logger.d("No invitation in SignInHelperManager either.");
}
}
}
TurnBasedMatch match = null;
if (matchObj != null)
{
Logger.d("Found match in GameHelper. Converting.");
match = JavaUtil.ConvertMatch(mUserId, matchObj);
Logger.d("Match from GameHelper: " + match);
}
else
{
Logger.d("No match in our GameHelper. Trying SignInHelperManager.");
AndroidJavaClass cls = JavaUtil.GetClass(JavaConsts.SignInHelperManagerClass);
using (AndroidJavaObject inst = cls.CallStatic <AndroidJavaObject>("getInstance")) {
if (inst.Call <bool>("hasTurnBasedMatch"))
{
match = JavaUtil.ConvertMatch(mUserId,
inst.Call <AndroidJavaObject>("getTurnBasedMatch"));
Logger.d("Found match in SignInHelperManager: " + match);
inst.Call("forgetTurnBasedMatch");
}
else
{
Logger.d("No match in SignInHelperManager either.");
}
}
}
// if we got an invitation from the notification, invoke the delegate
if (invFromNotif != null)
{
if (mInvitationDelegate != null)
{
Logger.d("Invoking invitation received delegate to deal with invitation " +
" from notification.");
PlayGamesHelperObject.RunOnGameThread(() => {
if (mInvitationDelegate != null)
{
mInvitationDelegate.Invoke(invFromNotif, true);
}
});
}
else
{
Logger.d("No delegate to handle invitation from notification; queueing.");
mInvitationFromNotification = invFromNotif;
}
}
// if we got a turn-based match, hand it over to the TBMP client who will know
// better what to do with it
if (match != null)
{
mTbmpClient.HandleMatchFromNotification(match);
}
}
private void CheckForConnectionExtras()
{
Logger.d("AndroidClient: CheckInvitationFromNotification.");
Logger.d("AndroidClient: looking for invitation in our GameHelper.");
Invitation invFromNotif = null;
AndroidJavaObject invitation = this.mGHManager.GetInvitation();
AndroidJavaObject turnBasedMatch = this.mGHManager.GetTurnBasedMatch();
this.mGHManager.ClearInvitationAndTurnBasedMatch();
if (invitation != null)
{
Logger.d("Found invitation in GameHelper. Converting.");
invFromNotif = this.ConvertInvitation(invitation);
Logger.d("Found invitation in our GameHelper: " + invFromNotif);
}
else
{
Logger.d("No invitation in our GameHelper. Trying SignInHelperManager.");
AndroidJavaClass @class = JavaUtil.GetClass("com.google.example.games.pluginsupport.SignInHelperManager");
using (AndroidJavaObject androidJavaObject = @class.CallStatic <AndroidJavaObject>("getInstance", new object[0]))
{
if (androidJavaObject.Call <bool>("hasInvitation", new object[0]))
{
invFromNotif = this.ConvertInvitation(androidJavaObject.Call <AndroidJavaObject>("getInvitation", new object[0]));
Logger.d("Found invitation in SignInHelperManager: " + invFromNotif);
androidJavaObject.Call("forgetInvitation", new object[0]);
}
else
{
Logger.d("No invitation in SignInHelperManager either.");
}
}
}
TurnBasedMatch turnBasedMatch2 = null;
if (turnBasedMatch != null)
{
Logger.d("Found match in GameHelper. Converting.");
turnBasedMatch2 = JavaUtil.ConvertMatch(this.mUserId, turnBasedMatch);
Logger.d("Match from GameHelper: " + turnBasedMatch2);
}
else
{
Logger.d("No match in our GameHelper. Trying SignInHelperManager.");
AndroidJavaClass class2 = JavaUtil.GetClass("com.google.example.games.pluginsupport.SignInHelperManager");
using (AndroidJavaObject androidJavaObject2 = class2.CallStatic <AndroidJavaObject>("getInstance", new object[0]))
{
if (androidJavaObject2.Call <bool>("hasTurnBasedMatch", new object[0]))
{
turnBasedMatch2 = JavaUtil.ConvertMatch(this.mUserId, androidJavaObject2.Call <AndroidJavaObject>("getTurnBasedMatch", new object[0]));
Logger.d("Found match in SignInHelperManager: " + turnBasedMatch2);
androidJavaObject2.Call("forgetTurnBasedMatch", new object[0]);
}
else
{
Logger.d("No match in SignInHelperManager either.");
}
}
}
if (invFromNotif != null)
{
if (this.mInvitationDelegate != null)
{
Logger.d("Invoking invitation received delegate to deal with invitation from notification.");
PlayGamesHelperObject.RunOnGameThread(delegate
{
if (this.mInvitationDelegate != null)
{
this.mInvitationDelegate(invFromNotif, true);
}
});
}
else
{
Logger.d("No delegate to handle invitation from notification; queueing.");
this.mInvitationFromNotification = invFromNotif;
}
}
if (turnBasedMatch2 != null)
{
this.mTbmpClient.HandleMatchFromNotification(turnBasedMatch2);
}
}
