internal void AcceptInvitation(MultiplayerInvitation invitation,
Action <TurnBasedMatchResponse> callback)
{
Logger.d("Accepting invitation: " + invitation.AsPointer().ToInt64());
TurnBasedMultiplayerManager.TurnBasedMultiplayerManager_AcceptInvitation(mGameServices.AsHandle(),
invitation.AsPointer(), InternalTurnBasedMatchCallback, ToCallbackPointer(callback));
}
internal void AcceptInvitation(MultiplayerInvitation invitation,
RealTimeEventListenerHelper listener,
Action <RealTimeRoomResponse> callback)
{
C.RealTimeMultiplayerManager_AcceptInvitation(mGameServices.AsHandle(),
invitation.AsPointer(), listener.AsPointer(), InternalRealTimeRoomCallback,
ToCallbackPointer(callback));
}
internal MultiplayerParticipant Inviter()
{
MultiplayerParticipant participant = new MultiplayerParticipant(MultiplayerInvitation.MultiplayerInvitation_InvitingParticipant(base.SelfPtr()));
if (!participant.Valid())
{
participant.Dispose();
return(null);
}
return(participant);
}
internal Invitation AsInvitation()
{
Invitation.InvType invType = MultiplayerInvitation.ToInvType(this.Type());
string invId = this.Id();
int variant = (int)this.Variant();
Participant inviter;
using (MultiplayerParticipant multiplayerParticipant = this.Inviter())
inviter = multiplayerParticipant != null?multiplayerParticipant.AsParticipant() : (Participant)null;
return(new Invitation(invType, invId, inviter, variant));
}
public void AcceptFromInbox(RealTimeMultiplayerListener listener)
{
lock (mSessionLock)
{
RoomSession newRoom = new RoomSession(mRealtimeManager, listener);
if (mCurrentSession.IsActive())
{
Logger.e("Received attempt to accept invitation without cleaning up active session.");
newRoom.LeaveRoom();
}
else
{
mCurrentSession = newRoom;
mCurrentSession.ShowingUI = true;
mRealtimeManager.ShowRoomInboxUI(delegate(RealtimeManager.RoomInboxUIResponse response)
{
mCurrentSession.ShowingUI = false;
if (response.ResponseStatus() != CommonErrorStatus.UIStatus.VALID)
{
Logger.d("User did not complete invitation screen.");
newRoom.LeaveRoom();
}
else
{
GooglePlayGames.Native.PInvoke.MultiplayerInvitation invitation = response.Invitation();
GooglePlayGames.Native.PInvoke.RealTimeEventListenerHelper helper = HelperForSession(newRoom);
try
{
Logger.d("About to accept invitation " + invitation.Id());
newRoom.StartRoomCreation(mNativeClient.GetUserId(), delegate
{
mRealtimeManager.AcceptInvitation(invitation, helper, delegate(RealtimeManager.RealTimeRoomResponse acceptResponse)
{
using (invitation)
{
newRoom.HandleRoomResponse(acceptResponse);
newRoom.SetInvitation(invitation.AsInvitation());
}
});
});
}
finally
{
if (helper != null)
{
((IDisposable)helper).Dispose();
}
}
}
});
}
}
}
private static void InternalOnMultiplayerInvitationEventCallback(Types.MultiplayerEvent eventType, string matchId, IntPtr match, IntPtr userData)
{
Action <Types.MultiplayerEvent, string, MultiplayerInvitation> action = Callbacks.IntPtrToPermanentCallback <Action <Types.MultiplayerEvent, string, MultiplayerInvitation> >(userData);
using (MultiplayerInvitation arg = MultiplayerInvitation.FromPointer(match))
{
try
{
action?.Invoke(eventType, matchId, arg);
}
catch (Exception arg2)
{
Logger.e("Error encountered executing InternalOnMultiplayerInvitationEventCallback. Smothering to avoid passing exception into Native: " + arg2);
}
}
}
private static void InternalOnMultiplayerInvitationEventCallback(
Types.MultiplayerEvent eventType, string matchId, IntPtr match, IntPtr userData)
{
var callback = Callbacks.IntPtrToPermanentCallback
<Action <Types.MultiplayerEvent, string, MultiplayerInvitation> >(userData);
using (var nativeInvitation = MultiplayerInvitation.FromPointer(match)) {
try {
if (callback != null)
{
callback(eventType, matchId, nativeInvitation);
}
} catch (Exception e) {
Logger.e("Error encountered executing " +
"InternalOnMultiplayerInvitationEventCallback. " +
"Smothering to avoid passing exception into Native: " + e);
}
}
}
private static void InternalOnMultiplayerInvitationEventCallback(Types.MultiplayerEvent eventType, string matchId, IntPtr match, IntPtr userData)
{
Action <Types.MultiplayerEvent, string, MultiplayerInvitation> permanentCallback = Callbacks.IntPtrToPermanentCallback <Action <Types.MultiplayerEvent, string, MultiplayerInvitation> >(userData);
using (MultiplayerInvitation multiplayerInvitation = MultiplayerInvitation.FromPointer(match))
{
try
{
if (permanentCallback == null)
{
return;
}
permanentCallback(eventType, matchId, multiplayerInvitation);
}
catch (Exception ex)
{
Logger.e("Error encountered executing InternalOnMultiplayerInvitationEventCallback. Smothering to avoid passing exception into Native: " + (object)ex);
}
}
}
private static void InternalOnMultiplayerInvitationEventCallback(Types.MultiplayerEvent eventType, string matchId, IntPtr match, IntPtr userData)
{
Action <Types.MultiplayerEvent, string, MultiplayerInvitation> action = Callbacks.IntPtrToPermanentCallback <Action <Types.MultiplayerEvent, string, MultiplayerInvitation> >(userData);
MultiplayerInvitation invitation = MultiplayerInvitation.FromPointer(match);
try
{
if (action != null)
{
action(eventType, matchId, invitation);
}
}
catch (Exception exception)
{
Logger.e("Error encountered executing InternalOnMultiplayerInvitationEventCallback. Smothering to avoid passing exception into Native: " + exception);
}
finally
{
if (invitation != null)
{
invitation.Dispose();
}
}
}
internal uint AutomatchingSlots() => MultiplayerInvitation.MultiplayerInvitation_AutomatchingSlotsAvailable(base.SelfPtr());
internal void DeclineInvitation(MultiplayerInvitation invitation)
{
TurnBasedMultiplayerManager.TurnBasedMultiplayerManager_DeclineInvitation(mGameServices.AsHandle(),
invitation.AsPointer());
}
internal uint Variant() => MultiplayerInvitation.MultiplayerInvitation_Variant(base.SelfPtr());
internal Types.MultiplayerInvitationType Type() => MultiplayerInvitation.MultiplayerInvitation_Type(base.SelfPtr());
internal uint ParticipantCount() => MultiplayerInvitation.MultiplayerInvitation_Participants_Length(base.SelfPtr()).ToUInt32();
internal void AcceptInvitation(MultiplayerInvitation invitation, RealTimeEventListenerHelper listener, Action <RealTimeRoomResponse> callback)
{
if (< > f__mg$cacheA == null)
{
internal void AcceptInvitation(MultiplayerInvitation invitation,
RealTimeEventListenerHelper listener,
Action<RealTimeRoomResponse> callback) {
C.RealTimeMultiplayerManager_AcceptInvitation(mGameServices.AsHandle(),
invitation.AsPointer(), listener.AsPointer(), InternalRealTimeRoomCallback,
ToCallbackPointer(callback));
}
internal void AcceptInvitation(MultiplayerInvitation invitation, Action <TurnBasedMatchResponse> callback)
{
Logger.d("Accepting invitation: " + invitation.AsPointer().ToInt64());
if (< > f__mg$cache6 == null)
{
internal void HandleInvitation(Types.MultiplayerEvent eventType, string invitationId, GooglePlayGames.Native.PInvoke.MultiplayerInvitation invitation)
{
Action <Invitation, bool> currentHandler = mInvitationDelegate;
if (currentHandler == null)
{
Logger.d("Received " + eventType + " for invitation " + invitationId + " but no handler was registered.");
}
else if (eventType == Types.MultiplayerEvent.REMOVED)
{
Logger.d("Ignoring REMOVED for invitation " + invitationId);
}
else
{
bool shouldAutolaunch = eventType == Types.MultiplayerEvent.UPDATED_FROM_APP_LAUNCH;
Invitation invite = invitation.AsInvitation();
PlayGamesHelperObject.RunOnGameThread(delegate
{
currentHandler(invite, shouldAutolaunch);
});
}
}
internal void HandleInvitation(Types.MultiplayerEvent eventType, string invitationId,
MultiplayerInvitation invitation) {
// Stash a reference to the invitation handler in case it is updated while we're handling
// this callback.
var currentHandler = mInvitationDelegate;
if (currentHandler == null) {
Logger.d("Received " + eventType + " for invitation "
+ invitationId + " but no handler was registered.");
return;
}
if (eventType == Types.MultiplayerEvent.REMOVED) {
Logger.d("Ignoring REMOVED for invitation " + invitationId);
return;
}
bool shouldAutolaunch = eventType == Types.MultiplayerEvent.UPDATED_FROM_APP_LAUNCH;
currentHandler(invitation.AsInvitation(), shouldAutolaunch);
}
protected override void CallDispose(HandleRef selfPointer)
{
MultiplayerInvitation.MultiplayerInvitation_Dispose(selfPointer);
}
internal void DeclineInvitation(MultiplayerInvitation invitation) {
C.RealTimeMultiplayerManager_DeclineInvitation(mGameServices.AsHandle(),
invitation.AsPointer());
}
internal string Id() => PInvokeUtilities.OutParamsToString((out_string, size) => MultiplayerInvitation.MultiplayerInvitation_Id(base.SelfPtr(), out_string, size));
internal void DeclineInvitation(MultiplayerInvitation invitation)
{
C.RealTimeMultiplayerManager_DeclineInvitation(mGameServices.AsHandle(),
invitation.AsPointer());
}
internal void HandleInvitation(Types.MultiplayerEvent eventType, string invitationId, GooglePlayGames.Native.PInvoke.MultiplayerInvitation invitation)
{
Action <Invitation, bool> invitationDelegate = this.mInvitationDelegate;
if (invitationDelegate == null)
{
Logger.d("Received " + (object)eventType + " for invitation " + invitationId + " but no handler was registered.");
}
else if (eventType == Types.MultiplayerEvent.REMOVED)
{
Logger.d("Ignoring REMOVED for invitation " + invitationId);
}
else
{
bool flag = eventType == Types.MultiplayerEvent.UPDATED_FROM_APP_LAUNCH;
invitationDelegate(invitation.AsInvitation(), flag);
}
}
