public void ChooseGKSavedGame(iOSGKSavedGame chosenGame, byte[] data)
{
if (chosenGame != _base && chosenGame != _remote)
{
_completeCallback(null, "Attempted to choose a saved game that was not part of the conflict.");
return;
}
var conflictingGames = new iOSGKSavedGame[] { _base, _remote };
if (data != null)
{
RequestResolveConflict(conflictingGames, data);
}
else
{
// Load data of the chosen game
InternalLoadSavedGameData(chosenGame, (byte[] chosenData, string loadDataError) =>
{
if (!string.IsNullOrEmpty(loadDataError))
{
// Loading data failed -> cannot resolve conflict
_completeCallback(null, loadDataError);
}
else
{
// Loading data succeeded -> now resolve conflict using the chosen game data
RequestResolveConflict(conflictingGames, chosenData);
}
});
}
}
internal static void InternalSaveGameData(iOSGKSavedGame savedGame, byte[] data, Action <iOSGKSavedGame, string> callback)
{
Util.NullArgumentTest(savedGame);
Util.NullArgumentTest(data);
Util.NullArgumentTest(callback);
iOSSavedGameNative._SaveGameData(
savedGame.ToPointer(),
data,
data.Length,
InternalSaveGameDataCallback,
PInvokeCallbackUtil.ToIntPtr <SaveGameDataResponse>(
response =>
{
string error = response.GetError();
if (string.IsNullOrEmpty(error))
{
callback(response.GetSavedGame(), error);
}
else
{
callback(null, error);
}
},
SaveGameDataResponse.FromPointer
)
);
}
internal NativeConflictResolver(iOSGKSavedGame baseGame, iOSGKSavedGame remoteGame,
Action <iOSGKSavedGame, string> completeCallback, Action <iOSGKSavedGame[]> repeatAction)
{
this._base = Util.NullArgumentTest(baseGame);
this._remote = Util.NullArgumentTest(remoteGame);
this._completeCallback = Util.NullArgumentTest(completeCallback);
this._repeatResolveConflicts = Util.NullArgumentTest(repeatAction);
}
public void OpenWithManualConflictResolution(string name, bool prefetchDataOnConflict,
SavedGameConflictResolver resolverFunction,
Action <SavedGame, string> completedCallback)
{
Util.NullArgumentTest(name);
Util.NullArgumentTest(resolverFunction);
Util.NullArgumentTest(completedCallback);
InternalOpenWithManualConflictResolution(
name,
prefetchDataOnConflict,
// Internal conflict callback
(IIOSConflictResolver resolver,
iOSGKSavedGame baseGame, byte[] baseData,
iOSGKSavedGame remoteGame, byte[] remoteData) =>
{
// Invoke the user's conflict resolving function, get their choice
var choice = resolverFunction(new SavedGame(baseGame), baseData, new SavedGame(remoteGame), remoteData);
// Let the internal client know the selected saved game,
// if the passed data is null if will loaded automatically from the chosen iOSGKSavedGame
iOSGKSavedGame selectedGame = null;
byte[] selectedData = null;
switch (choice)
{
case SavedGameConflictResolutionStrategy.UseBase:
selectedGame = baseGame;
selectedData = baseData;
break;
case SavedGameConflictResolutionStrategy.UseRemote:
selectedGame = remoteGame;
selectedData = remoteData;
break;
default:
Debug.LogError("Unhandled conflict resolution strategy: " + choice.ToString());
break;
}
resolver.ChooseGKSavedGame(selectedGame, selectedData);
},
// Completed callback
(iOSGKSavedGame gkSavedGame, string error) =>
{
completedCallback(gkSavedGame != null ? new SavedGame(gkSavedGame) : null, error);
}
);
}
internal static void InternalDeleteSavedGame(iOSGKSavedGame savedGame, Action <string> callback)
{
Util.NullArgumentTest(savedGame);
Util.NullArgumentTest(callback);
iOSSavedGameNative._DeleteSavedGame(
savedGame.Name,
InternalDeleteSavedGameCallback,
PInvokeCallbackUtil.ToIntPtr <DeleteSavedGameResponse>(
response =>
{
callback(response.GetError());
},
DeleteSavedGameResponse.FromPointer
)
);
}
internal static void InternalLoadSavedGameData(iOSGKSavedGame savedGame, Action <byte[], string> callback)
{
Util.NullArgumentTest(savedGame);
Util.NullArgumentTest(callback);
iOSSavedGameNative._LoadSavedGameData(
savedGame.ToPointer(),
InternalLoadSavedGameDataCallback,
PInvokeCallbackUtil.ToIntPtr <LoadSavedGameDataResponse>(
response =>
{
callback(response.GetData(), response.GetError());
},
LoadSavedGameDataResponse.FromPointer
)
);
}
internal SavedGame(iOSGKSavedGame gkSavedGame)
{
Helper.NullArgumentTest(gkSavedGame);
GKSavedGame = gkSavedGame;
}
internal SavedGame(iOSGKSavedGame gkSavedGame)
{
Util.NullArgumentTest(gkSavedGame);
GKSavedGame = gkSavedGame;
}
