internal static void InternalMultiplayerStatusCallback(GooglePlayGames.Native.Cwrapper.CommonErrorStatus.MultiplayerStatus status, IntPtr data)
{
Logger.d("InternalMultiplayerStatusCallback: " + status);
Action <GooglePlayGames.Native.Cwrapper.CommonErrorStatus.MultiplayerStatus> action = Callbacks.IntPtrToTempCallback <Action <GooglePlayGames.Native.Cwrapper.CommonErrorStatus.MultiplayerStatus> >(data);
try
{
action(status);
}
catch (Exception exception)
{
Logger.e("Error encountered executing InternalMultiplayerStatusCallback. Smothering to avoid passing exception into Native: " + exception);
}
}
internal void ShowRoomInboxUI(Action <RoomInboxUIResponse> callback)
{
C.RealTimeMultiplayerManager_ShowRoomInboxUI(mGameServices.AsHandle(),
InternalRoomInboxUICallback,
Callbacks.ToIntPtr(callback, RoomInboxUIResponse.FromPointer));
}
internal static void InternalIsCaptureAvailableCallback(IntPtr response, IntPtr data)
{
Callbacks.PerformInternalCallback(
"VideoManager#IsCaptureAvailableCallback", Callbacks.Type.Temporary, response, data);
}
internal void FetchInvitations(Action <FetchInvitationsResponse> callback)
{
C.RealTimeMultiplayerManager_FetchInvitations(mGameServices.AsHandle(),
InternalFetchInvitationsCallback,
Callbacks.ToIntPtr(callback, FetchInvitationsResponse.FromPointer));
}
internal static void InternalPlayerSelectUIcallback(IntPtr response, IntPtr data)
{
Callbacks.PerformInternalCallback(
"RealtimeManager#PlayerSelectUICallback", Callbacks.Type.Temporary, response, data);
}
internal void ShowPlayerSelectUI(uint minimumPlayers, uint maxiumPlayers,
bool allowAutomatching, Action <PlayerSelectUIResponse> callback)
{
TurnBasedMultiplayerManager.TurnBasedMultiplayerManager_ShowPlayerSelectUI(mGameServices.AsHandle(), minimumPlayers,
maxiumPlayers, allowAutomatching, InternalPlayerSelectUIcallback,
Callbacks.ToIntPtr(callback, PlayerSelectUIResponse.FromPointer));
}
private static void InternalOnMultiplayerInvitationEventCallback(Types.MultiplayerEvent eventType, string matchId, IntPtr match, IntPtr userData)
{
Action <Types.MultiplayerEvent, string, GooglePlayGames.Native.PInvoke.MultiplayerInvitation> action = Callbacks.IntPtrToPermanentCallback <Action <Types.MultiplayerEvent, string, GooglePlayGames.Native.PInvoke.MultiplayerInvitation> >(userData);
GooglePlayGames.Native.PInvoke.MultiplayerInvitation invitation = GooglePlayGames.Native.PInvoke.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 void ShowPlayerSelectUI(uint minimumPlayers, uint maxiumPlayers, bool allowAutomatching, Action <PlayerSelectUIResponse> callback)
{
RealTimeMultiplayerManager.RealTimeMultiplayerManager_ShowPlayerSelectUI(this.mGameServices.AsHandle(), minimumPlayers, maxiumPlayers, allowAutomatching, new RealTimeMultiplayerManager.PlayerSelectUICallback(RealtimeManager.InternalPlayerSelectUIcallback), Callbacks.ToIntPtr <PlayerSelectUIResponse>(callback, new Func <IntPtr, PlayerSelectUIResponse>(PlayerSelectUIResponse.FromPointer)));
}
internal void ShowRoomInboxUI(Action <RealtimeManager.RoomInboxUIResponse> callback)
{
RealTimeMultiplayerManager.RealTimeMultiplayerManager_ShowRoomInboxUI(this.mGameServices.AsHandle(), new RealTimeMultiplayerManager.RoomInboxUICallback(RealtimeManager.InternalRoomInboxUICallback), Callbacks.ToIntPtr <RealtimeManager.RoomInboxUIResponse>(callback, new Func <IntPtr, RealtimeManager.RoomInboxUIResponse>(RealtimeManager.RoomInboxUIResponse.FromPointer)));
}
internal void SendReliableMessage(NativeRealTimeRoom room, MultiplayerParticipant participant, byte[] data, Action <CommonErrorStatus.MultiplayerStatus> callback)
{
RealTimeMultiplayerManager.RealTimeMultiplayerManager_SendReliableMessage(this.mGameServices.AsHandle(), room.AsPointer(), participant.AsPointer(), data, PInvokeUtilities.ArrayToSizeT <byte>(data), new RealTimeMultiplayerManager.SendReliableMessageCallback(RealtimeManager.InternalSendReliableMessageCallback), Callbacks.ToIntPtr((Delegate)callback));
}
private static IntPtr ToCallbackPointer(Action <RealtimeManager.RealTimeRoomResponse> callback)
{
return(Callbacks.ToIntPtr <RealtimeManager.RealTimeRoomResponse>(callback, new Func <IntPtr, RealtimeManager.RealTimeRoomResponse>(RealtimeManager.RealTimeRoomResponse.FromPointer)));
}
internal void LeaveRoom(NativeRealTimeRoom room, Action <CommonErrorStatus.ResponseStatus> callback)
{
RealTimeMultiplayerManager.RealTimeMultiplayerManager_LeaveRoom(this.mGameServices.AsHandle(), room.AsPointer(), new RealTimeMultiplayerManager.LeaveRoomCallback(RealtimeManager.InternalLeaveRoomCallback), Callbacks.ToIntPtr((Delegate)callback));
}
internal static void InternalFetchCallback(IntPtr response, IntPtr data)
{
Callbacks.PerformInternalCallback("EventManager#FetchCallback", Callbacks.Type.Temporary, response, data);
}
internal void Fetch(Types.DataSource source, string eventId, Action <EventManager.FetchResponse> callback)
{
GooglePlayGames.Native.Cwrapper.EventManager.EventManager_Fetch(this.mServices.AsHandle(), source, eventId, new GooglePlayGames.Native.Cwrapper.EventManager.FetchCallback(EventManager.InternalFetchCallback), Callbacks.ToIntPtr <EventManager.FetchResponse>(callback, new Func <IntPtr, EventManager.FetchResponse>(EventManager.FetchResponse.FromPointer)));
}
internal static void InternalOnRoomConnectedSetChangedCallback(IntPtr response, IntPtr data)
{
Callbacks.PerformInternalCallback(
"RealTimeEventListenerHelper#InternalOnRoomConnectedSetChangedCallback",
Callbacks.Type.Permanent, response, data);
}
internal void ShowWaitingRoomUI(NativeRealTimeRoom room, uint minimumParticipantsBeforeStarting, Action <RealtimeManager.WaitingRoomUIResponse> callback)
{
Misc.CheckNotNull <NativeRealTimeRoom>(room);
RealTimeMultiplayerManager.RealTimeMultiplayerManager_ShowWaitingRoomUI(this.mGameServices.AsHandle(), room.AsPointer(), minimumParticipantsBeforeStarting, new RealTimeMultiplayerManager.WaitingRoomUICallback(RealtimeManager.InternalWaitingRoomUICallback), Callbacks.ToIntPtr <RealtimeManager.WaitingRoomUIResponse>(callback, new Func <IntPtr, RealtimeManager.WaitingRoomUIResponse>(RealtimeManager.WaitingRoomUIResponse.FromPointer)));
}
internal void ShowInboxUI(Action <MatchInboxUIResponse> callback)
{
TurnBasedMultiplayerManager.TurnBasedMultiplayerManager_ShowMatchInboxUI(mGameServices.AsHandle(),
InternalMatchInboxUICallback,
Callbacks.ToIntPtr <MatchInboxUIResponse>(callback, MatchInboxUIResponse.FromPointer));
}
internal void FetchInvitations(Action <RealtimeManager.FetchInvitationsResponse> callback)
{
RealTimeMultiplayerManager.RealTimeMultiplayerManager_FetchInvitations(this.mGameServices.AsHandle(), new RealTimeMultiplayerManager.FetchInvitationsCallback(RealtimeManager.InternalFetchInvitationsCallback), Callbacks.ToIntPtr <RealtimeManager.FetchInvitationsResponse>(callback, new Func <IntPtr, RealtimeManager.FetchInvitationsResponse>(RealtimeManager.FetchInvitationsResponse.FromPointer)));
}
internal static void InternalTurnBasedMatchesCallback(IntPtr response, IntPtr data)
{
Callbacks.PerformInternalCallback(
"TurnBasedManager#TurnBasedMatchesCallback", Callbacks.Type.Temporary, response, data);
}
internal static void InternalOnDataReceived(IntPtr room, IntPtr participant, IntPtr data, UIntPtr dataLength, bool isReliable, IntPtr userData)
{
Logger.d("Entering InternalOnDataReceived: " + userData.ToInt64());
Action <NativeRealTimeRoom, MultiplayerParticipant, byte[], bool> action = Callbacks.IntPtrToPermanentCallback <Action <NativeRealTimeRoom, MultiplayerParticipant, byte[], bool> >(userData);
using (NativeRealTimeRoom room2 = NativeRealTimeRoom.FromPointer(room))
{
using (MultiplayerParticipant participant2 = MultiplayerParticipant.FromPointer(participant))
{
if (action != null)
{
byte[] destination = null;
if (dataLength.ToUInt64() != 0L)
{
destination = new byte[dataLength.ToUInt32()];
Marshal.Copy(data, destination, 0, (int)dataLength.ToUInt32());
}
try
{
action(room2, participant2, destination, isReliable);
}
catch (Exception exception)
{
Logger.e("Error encountered executing InternalOnDataReceived. Smothering to avoid passing exception into Native: " + exception);
}
}
}
}
}
internal static void InternalFetchInvitationsCallback(IntPtr response, IntPtr data)
{
Callbacks.PerformInternalCallback(
"RealtimeManager#InternalFetchInvitationsCallback",
Callbacks.Type.Temporary, response, data);
}
internal void SetOnAuthStartedCallback(AuthStartedCallback callback)
{
C.GameServices_Builder_SetOnAuthActionStarted(SelfPtr(), InternalAuthStartedCallback,
Callbacks.ToIntPtr(callback));
}
internal void SendReliableMessage(NativeRealTimeRoom room, MultiplayerParticipant participant,
byte[] data, Action <Status.MultiplayerStatus> callback)
{
C.RealTimeMultiplayerManager_SendReliableMessage(mGameServices.AsHandle(),
room.AsPointer(), participant.AsPointer(), data, PInvokeUtilities.ArrayToSizeT(data),
InternalSendReliableMessageCallback, Callbacks.ToIntPtr(callback));
}
internal void SetOnMessageReceivedCallback(OnMessageReceived callback)
{
MessageListenerHelper.MessageListenerHelper_SetOnMessageReceivedCallback(SelfPtr(), InternalOnMessageReceivedCallback, Callbacks.ToIntPtr(callback));
}
internal static void InternalRoomInboxUICallback(IntPtr response, IntPtr data)
{
Callbacks.PerformInternalCallback(
"RealtimeManager#InternalRoomInboxUICallback",
Callbacks.Type.Temporary, response, data);
}
internal void SetOnDisconnectedCallback(Action <long, string> callback)
{
MessageListenerHelper.MessageListenerHelper_SetOnDisconnectedCallback(SelfPtr(), InternalOnDisconnectedCallback, Callbacks.ToIntPtr(callback));
}
internal static void InternalCaptureCapabilitiesCallback(IntPtr response, IntPtr data)
{
Callbacks.PerformInternalCallback(
"VideoManager#CaptureCapabilitiesCallback", Callbacks.Type.Temporary, response, data);
}
private static void InternalIntentHandler(IntPtr intent, IntPtr userData)
{
Callbacks.PerformInternalCallback("AndroidPlatformConfiguration#InternalIntentHandler",
Callbacks.Type.Permanent, intent, userData);
}
internal void SetOptionalIntentHandlerForUI(Action <IntPtr> intentHandler)
{
Misc.CheckNotNull(intentHandler);
C.AndroidPlatformConfiguration_SetOptionalIntentHandlerForUI(SelfPtr(),
InternalIntentHandler, Callbacks.ToIntPtr(intentHandler));
}
internal void GetAllTurnbasedMatches(Action <TurnBasedMatchesResponse> callback)
{
TurnBasedMultiplayerManager.TurnBasedMultiplayerManager_FetchMatches(this.mGameServices.AsHandle(), new TurnBasedMultiplayerManager.TurnBasedMatchesCallback(TurnBasedManager.InternalTurnBasedMatchesCallback), Callbacks.ToIntPtr <TurnBasedMatchesResponse>(callback, new Func <IntPtr, TurnBasedMatchesResponse>(TurnBasedMatchesResponse.FromPointer)));
}
