internal void FetchAll(Types.DataSource source,
Action<FetchAllResponse> callback) {
C.SnapshotManager_FetchAll(
mServices.AsHandle(),
source,
InternalFetchAllCallback,
Callbacks.ToIntPtr<FetchAllResponse>(callback, FetchAllResponse.FromPointer));
}
internal void Fetch(Types.DataSource source, string questId, Action<FetchResponse> callback)
{
C.QuestManager_Fetch(
mServices.AsHandle(),
source,
questId,
InternalFetchCallback,
Callbacks.ToIntPtr<FetchResponse>(callback, FetchResponse.FromPointer));
}
internal void FetchList(Types.DataSource source, int fetchFlags,
Action<FetchListResponse> callback)
{
C.QuestManager_FetchList(
mServices.AsHandle(),
source,
fetchFlags,
InternalFetchListCallback,
Callbacks.ToIntPtr<FetchListResponse>(callback, FetchListResponse.FromPointer));
}
internal void Open(string fileName, Types.DataSource source,
Types.SnapshotConflictPolicy conflictPolicy, Action<OpenResponse> callback) {
Misc.CheckNotNull(fileName);
Misc.CheckNotNull(callback);
C.SnapshotManager_Open(mServices.AsHandle(),
source,
fileName,
conflictPolicy,
InternalOpenCallback,
Callbacks.ToIntPtr<OpenResponse>(callback, OpenResponse.FromPointer));
}
private static Invitation.InvType ToInvType(Types.MultiplayerInvitationType invitationType)
{
switch (invitationType)
{
case Types.MultiplayerInvitationType.REAL_TIME:
return Invitation.InvType.RealTime;
case Types.MultiplayerInvitationType.TURN_BASED:
return Invitation.InvType.TurnBased;
default:
Logger.d("Found unknown invitation type: " + invitationType);
return Invitation.InvType.Unknown;
}
}
private void HandleAuthTransition(Types.AuthOperation operation, Status.AuthStatus status) {
Logger.d("Starting Auth Transition. Op: " + operation + " status: " + status);
lock (AuthStateLock) {
switch (operation) {
case Types.AuthOperation.SIGN_IN:
if (status == Status.AuthStatus.VALID) {
// If sign-in succeeded, treat any silent auth callbacks the same way
// we would treat loud ones.
if (mSilentAuthCallbacks != null) {
mPendingAuthCallbacks += mSilentAuthCallbacks;
mSilentAuthCallbacks = null;
}
uint currentAuthGeneration = mAuthGeneration;
mServices.AchievementManager().FetchAll(
results => PopulateAchievements(currentAuthGeneration, results));
mServices.PlayerManager().FetchSelf(
results => PopulateUser(currentAuthGeneration, results));
} else {
// Auth failed
if (mAuthState == AuthState.SilentPending) {
// The initial silent auth failed - take note of that and
// notify any pending silent-auth callbacks. If there are
// additional non-silent auth callbacks pending, attempt to auth
// by popping the Auth UI.
mSilentAuthFailed = true;
mAuthState = AuthState.Unauthenticated;
var silentCallbacks = mSilentAuthCallbacks;
mSilentAuthCallbacks = null;
InvokeCallbackOnGameThread(silentCallbacks, false);
if (mPendingAuthCallbacks != null) {
GameServices().StartAuthorizationUI();
}
} else {
// Noisy sign-in failed - report failure.
Action<bool> localCallbacks = mPendingAuthCallbacks;
mPendingAuthCallbacks = null;
InvokeCallbackOnGameThread(localCallbacks, false);
}
}
break;
case Types.AuthOperation.SIGN_OUT:
mAuthState = AuthState.Unauthenticated;
break;
default:
Logger.e("Unknown AuthOperation " + operation);
break;
}
}
}
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);
}
internal void HandleMatchEvent(Types.MultiplayerEvent eventType, string matchId,
NativeTurnBasedMatch match)
{
// Capture the current value of the delegate to protect against racing updates.
var currentDelegate = mMatchDelegate;
if (currentDelegate == null)
{
return;
}
// Ignore REMOVED events - this plugin has no use for them.
if (eventType == Types.MultiplayerEvent.REMOVED)
{
Logger.d("Ignoring REMOVE event for match " + matchId);
return;
}
bool shouldAutolaunch = eventType == Types.MultiplayerEvent.UPDATED_FROM_APP_LAUNCH;
match.ReferToMe();
Callbacks.AsCoroutine(WaitForLogin(()=>
{currentDelegate(match.AsTurnBasedMatch(mNativeClient.GetUserId()), shouldAutolaunch);
match.ForgetMe();}));
}
internal ParticipantResults WithResult(string participantId, uint placing,
Types.MatchResult result)
{
return new ParticipantResults(C.ParticipantResults_WithResult(
SelfPtr(), participantId, placing, result));
}
private static TBM.MatchStatus ToMatchStatus(
string pendingParticipantId, Types.MatchStatus status)
{
switch (status)
{
case Types.MatchStatus.CANCELED:
return TBM.MatchStatus.Cancelled;
case Types.MatchStatus.COMPLETED:
return TBM.MatchStatus.Complete;
case Types.MatchStatus.EXPIRED:
return TBM.MatchStatus.Expired;
case Types.MatchStatus.INVITED:
return TBM.MatchStatus.Active;
case Types.MatchStatus.MY_TURN:
return TBM.MatchStatus.Active;
case Types.MatchStatus.PENDING_COMPLETION:
return TBM.MatchStatus.Complete;
case Types.MatchStatus.THEIR_TURN:
// If it's their turn, but we don't have a valid pending participant, it's because
// we're still automatching against that participant.
return pendingParticipantId == null
? TBM.MatchStatus.AutoMatching
: TBM.MatchStatus.Active;
default:
return TBM.MatchStatus.Unknown;
}
}
private static TBM.MatchTurnStatus ToTurnStatus(Types.MatchStatus status)
{
switch (status)
{
case Types.MatchStatus.CANCELED:
return TBM.MatchTurnStatus.Complete;
case Types.MatchStatus.COMPLETED:
return TBM.MatchTurnStatus.Complete;
case Types.MatchStatus.EXPIRED:
return TBM.MatchTurnStatus.Complete;
case Types.MatchStatus.INVITED:
return TBM.MatchTurnStatus.Invited;
case Types.MatchStatus.MY_TURN:
return TBM.MatchTurnStatus.MyTurn;
case Types.MatchStatus.PENDING_COMPLETION:
return TBM.MatchTurnStatus.Complete;
case Types.MatchStatus.THEIR_TURN:
return TBM.MatchTurnStatus.TheirTurn;
default:
return TBM.MatchTurnStatus.Unknown;
}
}
internal NearbyConnectionsManagerBuilder SetDefaultLogLevel(Types.LogLevel minLevel)
{
C.NearbyConnections_Builder_SetDefaultOnLog(SelfPtr(), minLevel);
return this;
}
