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 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); } }