internal static void InternalOnDataReceived(IntPtr room, IntPtr participant, IntPtr data, UIntPtr dataLength, bool isReliable, IntPtr userData) { Logger.d("Entering InternalOnDataReceived: " + userData.ToInt64()); Action <NativeRealTimeRoom, GooglePlayGames.Native.PInvoke.MultiplayerParticipant, byte[], bool> action = Callbacks.IntPtrToPermanentCallback <Action <NativeRealTimeRoom, GooglePlayGames.Native.PInvoke.MultiplayerParticipant, byte[], bool> >(userData); using (NativeRealTimeRoom room2 = NativeRealTimeRoom.FromPointer(room)) { using (GooglePlayGames.Native.PInvoke.MultiplayerParticipant participant2 = GooglePlayGames.Native.PInvoke.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 void LeaveRoom(NativeRealTimeRoom room, Action <Status.ResponseStatus> callback) { C.RealTimeMultiplayerManager_LeaveRoom(mGameServices.AsHandle(), room.AsPointer(), InternalLeaveRoomCallback, Callbacks.ToIntPtr(callback)); }
internal static void PerformRoomAndParticipantCallback(string callbackName, IntPtr room, IntPtr participant, IntPtr data) { Logger.d("Entering " + callbackName); try { // This is a workaround to the fact that we're lacking proper copy constructors - // see comment below. var nativeRoom = NativeRealTimeRoom.FromPointer(room); using (var nativeParticipant = MultiplayerParticipant.FromPointer(participant)) { var callback = Callbacks.IntPtrToPermanentCallback <Action <NativeRealTimeRoom, MultiplayerParticipant> >(data); if (callback != null) { callback(nativeRoom, nativeParticipant); } } } catch (Exception e) { Logger.e("Error encountered executing " + callbackName + ". " + "Smothering to avoid passing exception into Native: " + e); } }
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 arg = NativeRealTimeRoom.FromPointer(room)) { using (MultiplayerParticipant arg2 = MultiplayerParticipant.FromPointer(participant)) { if (action != null) { byte[] array = null; if (dataLength.ToUInt64() != 0L) { array = new byte[dataLength.ToUInt32()]; Marshal.Copy(data, array, 0, (int)dataLength.ToUInt32()); } try { action(arg, arg2, array, isReliable); } catch (Exception arg3) { Logger.e("Error encountered executing InternalOnDataReceived. Smothering to avoid passing exception into Native: " + arg3); } } } } }
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 static void InternalOnDataReceived(IntPtr room, IntPtr participant, IntPtr data, UIntPtr dataLength, bool isReliable, IntPtr userData) { Logger.d("Entering InternalOnDataReceived: " + (object)userData.ToInt64()); Action <NativeRealTimeRoom, MultiplayerParticipant, byte[], bool> permanentCallback = Callbacks.IntPtrToPermanentCallback <Action <NativeRealTimeRoom, MultiplayerParticipant, byte[], bool> >(userData); using (NativeRealTimeRoom nativeRealTimeRoom = NativeRealTimeRoom.FromPointer(room)) { using (MultiplayerParticipant multiplayerParticipant = MultiplayerParticipant.FromPointer(participant)) { if (permanentCallback == null) { return; } byte[] destination = (byte[])null; if ((long)dataLength.ToUInt64() != 0L) { destination = new byte[(IntPtr)dataLength.ToUInt32()]; Marshal.Copy(data, destination, 0, (int)dataLength.ToUInt32()); } try { permanentCallback(nativeRealTimeRoom, multiplayerParticipant, destination, isReliable); } catch (Exception ex) { Logger.e("Error encountered executing InternalOnDataReceived. Smothering to avoid passing exception into Native: " + (object)ex); } } } }
internal static void InternalOnDataReceived( IntPtr room, IntPtr participant, IntPtr data, UIntPtr dataLength, bool isReliable, IntPtr userData) { Logger.d("Entering InternalOnDataReceived: " + userData.ToInt64()); var callback = Callbacks.IntPtrToPermanentCallback <Action <NativeRealTimeRoom, MultiplayerParticipant, byte[], bool> >(userData); using (var nativeRoom = NativeRealTimeRoom.FromPointer(room)) { using (var nativeParticipant = MultiplayerParticipant.FromPointer(participant)) { if (callback == null) { return; } byte[] convertedData = null; if (dataLength.ToUInt64() != 0) { convertedData = new byte[dataLength.ToUInt32()]; Marshal.Copy(data, convertedData, 0, (int)dataLength.ToUInt32()); } try { callback(nativeRoom, nativeParticipant, convertedData, isReliable); } catch (Exception e) { Logger.e("Error encountered executing InternalOnDataReceived. " + "Smothering to avoid passing exception into Native: " + e); } } } }
internal void ShowWaitingRoomUI(NativeRealTimeRoom room, uint minimumParticipantsBeforeStarting, Action<WaitingRoomUIResponse> callback) { Misc.CheckNotNull(room); C.RealTimeMultiplayerManager_ShowWaitingRoomUI(mGameServices.AsHandle(), room.AsPointer(), minimumParticipantsBeforeStarting, InternalWaitingRoomUICallback, Callbacks.ToIntPtr(callback, WaitingRoomUIResponse.FromPointer)); }
internal void ShowWaitingRoomUI(NativeRealTimeRoom room, uint minimumParticipantsBeforeStarting, Action <WaitingRoomUIResponse> callback) { Misc.CheckNotNull(room); C.RealTimeMultiplayerManager_ShowWaitingRoomUI(mGameServices.AsHandle(), room.AsPointer(), minimumParticipantsBeforeStarting, InternalWaitingRoomUICallback, Callbacks.ToIntPtr(callback, WaitingRoomUIResponse.FromPointer)); }
internal void SendUnreliableMessageToSpecificParticipants(NativeRealTimeRoom room, List <MultiplayerParticipant> recipients, byte[] data) { C.RealTimeMultiplayerManager_SendUnreliableMessage( mGameServices.AsHandle(), room.AsPointer(), recipients.Select(r => r.AsPointer()).ToArray(), new UIntPtr((ulong)recipients.LongCount()), data, PInvokeUtilities.ArrayToSizeT(data)); }
internal static void PerformRoomAndParticipantCallback(string callbackName, IntPtr room, IntPtr participant, IntPtr data) { Logger.d("Entering " + callbackName); try { NativeRealTimeRoom arg = NativeRealTimeRoom.FromPointer(room); using (MultiplayerParticipant arg2 = MultiplayerParticipant.FromPointer(participant)) { Callbacks.IntPtrToPermanentCallback <Action <NativeRealTimeRoom, MultiplayerParticipant> >(data)?.Invoke(arg, arg2); } } catch (Exception ex) { Logger.e("Error encountered executing " + callbackName + ". Smothering to avoid passing exception into Native: " + ex); } }
private static IntPtr ToCallbackPointer(Action <NativeRealTimeRoom> callback) { Action <IntPtr> callback2 = delegate(IntPtr result) { NativeRealTimeRoom nativeRealTimeRoom = NativeRealTimeRoom.FromPointer(result); if (callback != null) { callback(nativeRealTimeRoom); } else { nativeRealTimeRoom?.Dispose(); } }; return(Callbacks.ToIntPtr(callback2)); }
// This is a workaround to the fact that we're lacking proper copy constructors on the cwrapper // structs. Clients of the RealTimeEventListener need to hold long-lived references to the // room returned by the callback, but the default implementation of the utility callback method // cleans up all arguments to the callback. This can be gotten rid of when copy constructors // are present in the native sdk. private static IntPtr ToCallbackPointer(Action <NativeRealTimeRoom> callback) { Action <IntPtr> pointerReceiver = result => { NativeRealTimeRoom converted = NativeRealTimeRoom.FromPointer(result); if (callback != null) { callback(converted); } else { if (converted != null) { converted.Dispose(); } } }; return(Callbacks.ToIntPtr(pointerReceiver)); }
private static IntPtr ToCallbackPointer(Action <NativeRealTimeRoom> callback) { return(Callbacks.ToIntPtr((Delegate)(result => { NativeRealTimeRoom nativeRealTimeRoom = NativeRealTimeRoom.FromPointer(result); if (callback != null) { callback(nativeRealTimeRoom); } else { if (nativeRealTimeRoom == null) { return; } nativeRealTimeRoom.Dispose(); } }))); }
internal static void PerformRoomAndParticipantCallback(string callbackName, IntPtr room, IntPtr participant, IntPtr data) { Logger.d("Entering " + callbackName); try { NativeRealTimeRoom room2 = NativeRealTimeRoom.FromPointer(room); using (GooglePlayGames.Native.PInvoke.MultiplayerParticipant participant2 = GooglePlayGames.Native.PInvoke.MultiplayerParticipant.FromPointer(participant)) { Action <NativeRealTimeRoom, GooglePlayGames.Native.PInvoke.MultiplayerParticipant> action = Callbacks.IntPtrToPermanentCallback <Action <NativeRealTimeRoom, GooglePlayGames.Native.PInvoke.MultiplayerParticipant> >(data); if (action != null) { action(room2, participant2); } } } catch (Exception exception) { Logger.e(string.Concat(new object[] { "Error encountered executing ", callbackName, ". Smothering to avoid passing exception into Native: ", exception })); } }
internal static void PerformRoomAndParticipantCallback(string callbackName, IntPtr room, IntPtr participant, IntPtr data) { Logger.d("Entering " + callbackName); try { NativeRealTimeRoom nativeRealTimeRoom = NativeRealTimeRoom.FromPointer(room); using (MultiplayerParticipant multiplayerParticipant = MultiplayerParticipant.FromPointer(participant)) { Action <NativeRealTimeRoom, MultiplayerParticipant> permanentCallback = Callbacks.IntPtrToPermanentCallback <Action <NativeRealTimeRoom, MultiplayerParticipant> >(data); if (permanentCallback == null) { return; } permanentCallback(nativeRealTimeRoom, multiplayerParticipant); } } catch (Exception ex) { Logger.e("Error encountered executing " + callbackName + ". Smothering to avoid passing exception into Native: " + (object)ex); } }
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 SendUnreliableMessageToAll(NativeRealTimeRoom room, byte[] data) { C.RealTimeMultiplayerManager_SendUnreliableMessageToOthers(mGameServices.AsHandle(), room.AsPointer(), data, PInvokeUtilities.ArrayToSizeT(data)); }
internal void SendUnreliableMessageToSpecificParticipants(NativeRealTimeRoom room, List<MultiplayerParticipant> recipients, byte[] data) { C.RealTimeMultiplayerManager_SendUnreliableMessage( mGameServices.AsHandle(), room.AsPointer(), recipients.Select(r => r.AsPointer()).ToArray(), new UIntPtr((ulong) recipients.LongCount()), data, PInvokeUtilities.ArrayToSizeT(data)); }
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 LeaveRoom(NativeRealTimeRoom room, Action<Status.ResponseStatus> callback) { C.RealTimeMultiplayerManager_LeaveRoom(mGameServices.AsHandle(), room.AsPointer(), InternalLeaveRoomCallback, Callbacks.ToIntPtr(callback)); }
internal void LeaveRoom(NativeRealTimeRoom room, Action <GooglePlayGames.Native.Cwrapper.CommonErrorStatus.ResponseStatus> callback) { RealTimeMultiplayerManager.RealTimeMultiplayerManager_LeaveRoom(this.mGameServices.AsHandle(), room.AsPointer(), new RealTimeMultiplayerManager.LeaveRoomCallback(RealtimeManager.InternalLeaveRoomCallback), Callbacks.ToIntPtr(callback)); }
internal void SendReliableMessage(NativeRealTimeRoom room, GooglePlayGames.Native.PInvoke.MultiplayerParticipant participant, byte[] data, Action <GooglePlayGames.Native.Cwrapper.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(callback)); }
internal void SendUnreliableMessageToSpecificParticipants(NativeRealTimeRoom room, List <GooglePlayGames.Native.PInvoke.MultiplayerParticipant> recipients, byte[] data) { if (< > f__am$cache1 == null) {