internal string RematchId()
{
if (!HasRematchId())
{
return(null);
}
return(PInvokeUtilities.OutParamsToString(
(out_string, size) => C.TurnBasedMatch_RematchId(SelfPtr(), out_string, size)));
}
internal IEnumerable <MultiplayerInvitation> Invitations()
{
return(PInvokeUtilities.ToEnumerable(
C.RealTimeMultiplayerManager_FetchInvitationsResponse_GetInvitations_Length(
SelfPtr()),
index => new MultiplayerInvitation(
C.RealTimeMultiplayerManager_FetchInvitationsResponse_GetInvitations_GetElement(
SelfPtr(), index))
));
}
protected HandleRef SelfPtr()
{
if (PInvokeUtilities.IsNull(mSelfPointer))
{
throw new InvalidOperationException(
"Attempted to use object after it was cleaned up");
}
return(mSelfPointer);
}
internal string ConflictId()
{
if (ResponseStatus() != Status.SnapshotOpenStatus.VALID_WITH_CONFLICT)
{
throw new InvalidOperationException("OpenResponse did not have a conflict");
}
return(PInvokeUtilities.OutParamsToString(
(out_string, out_size) => C.SnapshotManager_OpenResponse_GetConflictId(
SelfPtr(), out_string, out_size)));
}
internal byte[] Data()
{
if (!GooglePlayGames.Native.Cwrapper.TurnBasedMatch.TurnBasedMatch_HasData(base.SelfPtr()))
{
Logger.d("Match has no data.");
return(null);
}
return(PInvokeUtilities.OutParamsToArray <byte>(delegate(byte[] bytes, UIntPtr size) {
return GooglePlayGames.Native.Cwrapper.TurnBasedMatch.TurnBasedMatch_Data(base.SelfPtr(), bytes, size);
}));
}
private void Dispose(bool fromFinalizer)
{
if (fromFinalizer || !_refs.ContainsKey(mSelfPointer))
{
if (!PInvokeUtilities.IsNull(mSelfPointer))
{
CallDispose(mSelfPointer);
mSelfPointer = new HandleRef(this, IntPtr.Zero);
}
}
}
internal byte[] Data()
{
if (!RequestSucceeded())
{
throw new InvalidOperationException("Request did not succeed");
}
return(PInvokeUtilities.OutParamsToArray <byte>(
(out_bytes, out_size) => C.SnapshotManager_ReadResponse_GetData(
SelfPtr(), out_bytes, out_size)));
}
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 byte[] Data()
{
if (!C.TurnBasedMatch_HasData(SelfPtr()))
{
Logger.d("Match has no data.");
return(null);
}
return(PInvokeUtilities.OutParamsToArray <byte>(
(bytes, size) => C.TurnBasedMatch_Data(SelfPtr(), bytes, size)));
}
internal string RematchId()
{
// There is a bug in C++ for android that always returns true for
// HasRematchId - so commenting out this optimization until it is
// fixed.
//if (!HasRematchId())
//{
// Logger.d("Returning NUll for rematch id since it does not have one");
// return null;
//}
return(PInvokeUtilities.OutParamsToString(
(out_string, size) => C.TurnBasedMatch_RematchId(SelfPtr(), out_string, size)));
}
private static T IntPtrToCallback<T>(IntPtr handle, bool unpinHandle) where T : class {
if (PInvokeUtilities.IsNull(handle)) {
return null;
}
var gcHandle = GCHandle.FromIntPtr(handle);
try {
return (T)gcHandle.Target;
} catch(System.InvalidCastException e) {
Logger.e("GC Handle pointed to unexpected type: " + gcHandle.Target.ToString() +
". Expected " + typeof(T));
throw e;
} finally {
if (unpinHandle) {
gcHandle.Free();
}
}
}
internal string Id()
{
return(PInvokeUtilities.OutParamsToString(
(out_arg, out_size) => C.AppIdentifier_GetIdentifier(SelfPtr(), out_arg, out_size)));
}
protected bool IsDisposed() => PInvokeUtilities.IsNull(this.mSelfPointer);
public BaseReferenceHolder(IntPtr pointer)
{
this.mSelfPointer = PInvokeUtilities.CheckNonNull(new HandleRef(this, pointer));
}
internal byte[] Payload()
{
return(PInvokeUtilities.OutParamsToArray <byte>((out_arg, out_size) =>
C.ConnectionRequest_GetPayload(SelfPtr(), out_arg, out_size)));
}
internal string RemoteEndpointName()
{
return(PInvokeUtilities.OutParamsToString((out_arg, out_size) =>
C.ConnectionRequest_GetRemoteEndpointName(SelfPtr(), out_arg, out_size)));
}
internal string Id()
{
return(PInvokeUtilities.OutParamsToString(
(out_string, size) => C.TurnBasedMatch_Id(SelfPtr(), out_string, size)));
}
internal string AvatarURL()
{
return(PInvokeUtilities.OutParamsToString(
(out_string, out_size) => C.Player_AvatarUrl(SelfPtr(),
Types.ImageResolution.ICON, out_string, out_size)));
}
internal void SendUnreliableMessageToAll(NativeRealTimeRoom room, byte[] data)
{
C.RealTimeMultiplayerManager_SendUnreliableMessageToOthers(mGameServices.AsHandle(),
room.AsPointer(), data, PInvokeUtilities.ArrayToSizeT(data));
}
internal string GetMetadata()
{
return(PInvokeUtilities.OutParamsToString((out_string, out_size) =>
Score.Score_Metadata(SelfPtr(), out_string, out_size)));
}
internal string LocalDeviceId()
{
return(PInvokeUtilities.OutParamsToString((out_arg, out_size) =>
C.NearbyConnections_GetLocalDeviceId(SelfPtr(), out_arg, out_size)));
}
public IEnumerator <NativePlayer> GetEnumerator()
{
return(PInvokeUtilities.ToEnumerator <NativePlayer>(this.Length(), (Func <UIntPtr, NativePlayer>)(index => this.GetElement(index))));
}
internal List <NativeEvent> Data()
{
IntPtr[] events = PInvokeUtilities.OutParamsToArray <IntPtr>((out_arg, out_size) => C.EventManager_FetchAllResponse_GetData(SelfPtr(), out_arg, out_size));
return(events.Select(ptr => new NativeEvent(ptr)).ToList());
}
protected bool IsDisposed()
{
return(PInvokeUtilities.IsNull(mSelfPointer));
}
private string PlayerIdAtIndex(UIntPtr index)
{
return(PInvokeUtilities.OutParamsToString(
(out_string, size) => C.TurnBasedMatchConfig_PlayerIdsToInvite_GetElement(
SelfPtr(), index, out_string, size)));
}
internal string Title()
{
return(PInvokeUtilities.OutParamsToString(delegate(StringBuilder out_string, UIntPtr out_size) {
return Leaderboard.Leaderboard_Name(base.SelfPtr(), out_string, out_size);
}));
}
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 string Name()
{
return(PInvokeUtilities.OutParamsToString(
(out_string, out_size) => C.Player_Name(SelfPtr(), out_string, out_size)));
}
public IEnumerator <NativeAchievement> GetEnumerator()
{
return(PInvokeUtilities.ToEnumerator(
C.AchievementManager_FetchAllResponse_GetData_Length(SelfPtr()),
(index) => GetElement(index)));
}
internal string GetPlayerId() => PInvokeUtilities.OutParamsToString((out_string, out_size) => ScorePage.ScorePage_Entry_PlayerId(base.SelfPtr(), out_string, out_size));
