public void Initialization()
{
if (_achievementsClient == null)
{
_achievementsClient = AN_Games.GetAchievementsClient();
}
}
public void Initialization()
{
if (_leaderBoardsClient == null)
{
_leaderBoardsClient = AN_Games.GetLeaderboardsClient();
}
}
public override void Test()
{
var client = AN_Games.GetAchievementsClient();
client.Load(false, (result) => {
if (result.IsSucceeded)
{
foreach (var achievement in result.Achievements)
{
if (achievement.Type == AN_Achievement.AchievementType.INCREMENTAL)
{
if (achievement.TotalSteps > achievement.CurrentSteps)
{
m_achievement = achievement;
}
}
}
if (m_achievement != null)
{
TestIncrement();
}
else
{
SetResult(SA_TestResult.WithError("Wasn't able to find suitable Achievement to Incremental"));
}
}
else
{
SetAPIResult(result);
}
});
}
public override void Test()
{
var client = AN_Games.GetAchievementsClient();
client.Load(false, (result) => {
if (result.IsSucceeded)
{
foreach (var achievement in result.Achievements)
{
if (achievement.Type == AN_Achievement.AchievementType.STANDARD && achievement.State == AN_Achievement.AchievementState.HIDDEN)
{
m_achievement = achievement;
break;
}
}
if (m_achievement != null)
{
TestOperation();
}
else
{
SetResult(SA_TestResult.WithError("Wasn't able to find suitable Achievement to Reveal"));
}
}
else
{
SetAPIResult(result);
}
});
}
private void RetrivePlayer(Action <SA_Result> callback)
{
AN_Logger.Log("UM_AndroidSignInClient, cleint sigined-in, getting the player info");
//When Sign in is finished with successes
var gamesClient = AN_Games.GetGamesClient();
gamesClient.SetViewForPopups(AN_MainActivity.Instance);
//optionally
gamesClient.SetGravityForPopups(AN_Gravity.TOP | AN_Gravity.CENTER_HORIZONTAL);
AN_PlayersClient client = AN_Games.GetPlayersClient();
SA_Result apiResult;
client.GetCurrentPlayer((result) => {
if (result.IsSucceeded)
{
apiResult = new SA_Result();
AN_Logger.Log("UM_AndroidSignInClient, player info retrived, OnPlayerChnaged event will be sent");
UpdatePlayerInfo(result.Data);
}
else
{
apiResult = new SA_Result(result.Error);
}
AN_Logger.Log("UM_AndroidSignInClient, sending sing in result");
callback.Invoke(apiResult);
});
}
public void Load(Action <UM_AchievementsLoadResult> callback)
{
var client = AN_Games.GetAchievementsClient();
client.Load(false, (result) => {
UM_AchievementsLoadResult loadResult;
if (result.IsSucceeded)
{
var achievements = new List <UM_iAchievement>();
foreach (var achievement in result.Achievements)
{
var androidAchievement = new UM_AndroidAchievement(achievement);
achievements.Add(androidAchievement);
SetAchievementCahce(androidAchievement);
}
loadResult = new UM_AchievementsLoadResult(achievements);
}
else
{
loadResult = new UM_AchievementsLoadResult(result.Error);
}
callback.Invoke(loadResult);
});
}
private void PrintSignedPlayerInfo()
{
AN_PlayersClient client = AN_Games.GetPlayersClient();
client.GetCurrentPlayer((result) => {
if (result.IsSucceeded)
{
AN_Player player = result.Data;
//Printing player info:
AN_Logger.Log("player.Id: " + player.PlayerId);
AN_Logger.Log("player.DisplayName: " + player.DisplayName);
AN_Logger.Log("player.HiResImageUri: " + player.HiResImageUri);
AN_Logger.Log("player.IconImageUri: " + player.IconImageUri);
AN_Logger.Log("player.HasIconImage: " + player.HasIconImage);
AN_Logger.Log("player.HasHiResImage: " + player.HasHiResImage);
if (!player.HasHiResImage)
{
var url = player.HiResImageUri;
AN_ImageManager manager = new AN_ImageManager();
manager.LoadImage(url, (imaheLoadResult) => {
});
}
}
else
{
AN_Logger.Log("Failed to load Current Player " + result.Error.FullMessage);
}
});
}
public void FetchSavedGames(Action <UM_SavedGamesMetadataResult> callback)
{
var client = AN_Games.GetSnapshotsClient();
client.Load((result) => {
UM_SavedGamesMetadataResult loadResult;
if (result.IsSucceeded)
{
loadResult = new UM_SavedGamesMetadataResult();
foreach (var meta in result.Snapshots)
{
var an_meta = new UM_AndroidSavedGameMetadata(meta);
loadResult.AddMetadata(an_meta);
}
}
else
{
loadResult = new UM_SavedGamesMetadataResult(result.Error);
}
callback.Invoke(loadResult);
});
}
public override void Test()
{
var client = AN_Games.GetAchievementsClient();
client.Load(false, (result) => {
if (result.IsSucceeded)
{
AN_Logger.Log("Load Achievements Succeeded, count: " + result.Achievements.Count);
foreach (var achievement in result.Achievements)
{
AN_Logger.Log("------------------------------------------------");
AN_Logger.Log("achievement.AchievementId: " + achievement.AchievementId);
AN_Logger.Log("achievement.Description: " + achievement.Description);
AN_Logger.Log("achievement.Name: " + achievement.Name);
AN_Logger.Log("achievement.UnlockedImageUri: " + achievement.UnlockedImageUri);
AN_Logger.Log("achievement.CurrentSteps: " + achievement.CurrentSteps);
AN_Logger.Log("achievement.TotalSteps: " + achievement.TotalSteps);
AN_Logger.Log("achievement.Type: " + achievement.Type);
AN_Logger.Log("achievement.Sate: " + achievement.State);
}
AN_Logger.Log("------------------------------------------------");
SetResult(SA_TestResult.OK);
}
else
{
SetAPIResult(result);
}
});
}
public void LoadGameWithMeta(UM_iSavedGameMetadata game, Action <UM_SavedGameDataLoadResult> callback)
{
var client = AN_Games.GetSnapshotsClient();
var conflictPolicy = AN_SnapshotsClient.ResolutionPolicy.LAST_KNOWN_GOOD;
client.Open(game.Name, true, conflictPolicy, result =>
{
UM_SavedGameDataLoadResult loadResult;
if (result.IsSucceeded)
{
var snapshot = result.Data.GetSnapshot();
var data = snapshot.ReadFully();
client.CommitAndClose(snapshot, AN_SnapshotMetadataChange.EMPTY_CHANGE, commitResult =>
{
if (commitResult.IsSucceeded)
{
loadResult = new UM_SavedGameDataLoadResult(data, new AndroidSaveInfo(commitResult.Metadata));
}
else
{
loadResult = new UM_SavedGameDataLoadResult(commitResult.Error);
}
callback.Invoke(loadResult);
});
}
else
{
loadResult = new UM_SavedGameDataLoadResult(result.Error);
callback.Invoke(loadResult);
}
});
}
public override void Test()
{
var client = AN_Games.GetSnapshotsClient();
client.Load((result) => {
if (result.IsSucceeded)
{
if (result.Snapshots.Count == 0)
{
SetResult(SA_TestResult.WithError("There are no spanpshot's. Can't test delete action"));
return;
}
AN_SnapshotMetadata meta = result.Snapshots[0];
client.Delete(meta, (deleteResult) => {
if (deleteResult.IsSucceeded)
{
AN_Logger.Log("deleteResult.SnapshotId: " + deleteResult.SnapshotId);
}
SetAPIResult(deleteResult);
});
}
else
{
SetAPIResult(result);
}
});
}
private void VerifySnapshotsSave(string name)
{
var client = AN_Games.GetSnapshotsClient();
client.Open(name, m_createIfNotFound, m_conflictPolicy, (result) => {
if (result.IsSucceeded)
{
AN_Snapshot snapshot = result.Data.GetSnapshot();
byte[] data = snapshot.ReadFully();
var meta = snapshot.GetMetadata();
if (meta.ProgressValue != m_progress)
{
SetResult(SA_TestResult.WithError("ProgressValue verification failed"));
return;
}
if (meta.PlayedTime != m_playedTime)
{
SetResult(SA_TestResult.WithError("PlayedTime verification failed"));
return;
}
string snapshotData = string.Empty;
snapshotData = snapshotData.FromBytes(data);
if (!snapshotData.Equals(m_snpashotData))
{
SetResult(SA_TestResult.WithError("Snapshot Data verification failed"));
return;
}
}
SetAPIResult(result);
});
}
public override void Test()
{
SignInClient.RevokeAccess(() => {
//Now we need to make sure we can't Sing in siletly
SilentSignIn((result) => {
if (result.IsSucceeded)
{
SetResult(SA_TestResult.WithError("User was able to do Silent SignIn after RevokeAccess"));
}
else
{
//InteractiveSignIn should work
InteractiveSignIn((InteractiveSignInResult) => {
SetAPIResult(InteractiveSignInResult);
if (InteractiveSignInResult.IsSucceeded)
{
var gamesClient = AN_Games.GetGamesClient();
gamesClient.SetViewForPopups(AN_MainActivity.Instance);
//optionally
gamesClient.SetGravityForPopups(AN_Gravity.TOP | AN_Gravity.CENTER_HORIZONTAL);
}
});
}
});
});
}
public void LoadLeaderboardsMetadata(Action <UM_LoadLeaderboardsMetaResult> callback)
{
var leaderboards = AN_Games.GetLeaderboardsClient();
leaderboards.LoadLeaderboardMetadata(false, (result) => {
UM_LoadLeaderboardsMetaResult um_result;
if (result.IsSucceeded)
{
List <UM_iLeaderboard> um_leaderboards = new List <UM_iLeaderboard>();
foreach (var leaderboard in result.Leaderboards)
{
var um_leaderboardMetda = new UM_LeaderboardMeta(leaderboard.LeaderboardId, leaderboard.DisplayName);
um_leaderboards.Add(um_leaderboardMetda);
}
um_result = new UM_LoadLeaderboardsMetaResult(um_leaderboards);
}
else
{
um_result = new UM_LoadLeaderboardsMetaResult(result.Error);
}
callback.Invoke(um_result);
});
}
private void TestOperation()
{
Debug.Log("RevealImmediate: " + m_achievement.Name);
var client = AN_Games.GetAchievementsClient();
client.RevealImmediate(m_achievement.AchievementId, (result) => {
SetAPIResult(result);
});
}
private void TestIncrement()
{
var client = AN_Games.GetAchievementsClient();
Debug.Log("Incrementing: " + m_achievement.Name);
client.IncrementImmediate(m_achievement.AchievementId, 1, (result) => {
SetAPIResult(result);
});
}
public void ActivateGPlayPopup()
{
var gamesClient = AN_Games.GetGamesClient();
gamesClient.SetViewForPopups(AN_MainActivity.Instance);
//optionally
gamesClient.SetGravityForPopups(AN_Gravity.TOP | AN_Gravity.CENTER_HORIZONTAL);
}
private void ReadAndWrite(string name)
{
var client = AN_Games.GetSnapshotsClient();
client.Open(name, m_createIfNotFound, m_conflictPolicy, (result) => {
if (result.IsSucceeded)
{
AN_Logger.Log("We have snapshot, reading data...");
AN_Snapshot snapshot = result.Data.GetSnapshot();
byte[] data = snapshot.ReadFully();
var meta = snapshot.GetMetadata();
m_progress = meta.ProgressValue + 10;
m_playedTime = meta.PlayedTime + 100;
string base64Text = Convert.ToBase64String(data);
AN_Logger.Log("Snapshot data: " + base64Text);
PrintSnapshotMetadata(snapshot.GetMetadata());
AN_Logger.Log("Writing data...");
m_snpashotData = "My game data " + name;
data = m_snpashotData.ToBytes();
snapshot.WriteBytes(data);
SA_ScreenUtil.TakeScreenshot(512, (screenshot) => {
var changeBuilder = new AN_SnapshotMetadataChange.Builder();
changeBuilder.SetDescription("Hello Description");
changeBuilder.SetPlayedTimeMillis(m_playedTime);
changeBuilder.SetProgressValue(m_progress);
changeBuilder.SetCoverImage(screenshot);
AN_SnapshotMetadataChange changes = changeBuilder.Build();
client.CommitAndClose(snapshot, changes, (commitResult) => {
if (commitResult.IsSucceeded)
{
PrintSnapshotMetadata(commitResult.Metadata);
VerifySnapshotsSave(name);
}
else
{
SetAPIResult(result);
}
});
});
}
else
{
SetAPIResult(result);
}
});
}
public void SubmitScore(string leaderboardId, long score, int context, Action <SA_Result> callback)
{
var client = AN_Games.GetLeaderboardsClient();
client.SubmitScoreImmediate(leaderboardId, score, context.ToString(), (result) => {
ReportScoreSubmited(leaderboardId, score, result);
callback.Invoke(result);
});
}
public void Delete(UM_iSavedGameMetadata game, Action <SA_Result> callback)
{
UM_AndroidSavedGameMetadata an_meta = (UM_AndroidSavedGameMetadata)game;
var client = AN_Games.GetSnapshotsClient();
client.Delete(an_meta.NativeMeta, (result) => {
callback.Invoke(result);
});
}
private void OpenSnapshot(string name)
{
var client = AN_Games.GetSnapshotsClient();
bool createIfNotFound = true;
var conflictPolicy = AN_SnapshotsClient.ResolutionPolicy.LAST_KNOWN_GOOD;
client.Open(name, createIfNotFound, conflictPolicy, (result) => {
if (result.IsSucceeded)
{
Debug.Log("We have snapshot, reading data...");
AN_Snapshot snapshot = result.Data;
byte[] data = snapshot.ReadFully();
long progress = snapshot.GetMetadata().ProgressValue;
string base64Text = Convert.ToBase64String(data);
Debug.Log("Snapshot data: " + base64Text);
Debug.Log("Snapshot progress: " + snapshot.GetMetadata().ProgressValue);
Debug.Log("Snapshot played time: " + snapshot.GetMetadata().PlayedTime);
Debug.Log("Writing data...");
string mydata = "My game data";
data = mydata.ToBytes();
snapshot.WriteBytes(data);
SA_ScreenUtil.TakeScreenshot(512, (screenshot) => {
var changeBuilder = new AN_SnapshotMetadataChange.Builder();
changeBuilder.SetDescription("Hello Description");
changeBuilder.SetPlayedTimeMillis(10000);
changeBuilder.SetProgressValue(progress + 1);
changeBuilder.SetCoverImage(screenshot);
AN_SnapshotMetadataChange changes = changeBuilder.Build();
client.CommitAndClose(snapshot, changes, (commitResult) => {
if (commitResult.IsSucceeded)
{
PrintMeta(commitResult.Metadata);
}
else
{
Debug.Log("CommitAndClose Snapshots Failed: " + result.Error.FullMessage);
}
});
});
}
else
{
Debug.Log("Open Snapshots Failed: " + result.Error.FullMessage);
}
});
}
public void submitPlayerScore(string leaderboardId, int score)
{
if (leaderboardId == null)
{
leaderboardId = iLeaderboardId;
}
var leaderboards = AN_Games.GetLeaderboardsClient();
leaderboards.SubmitScore(leaderboardId, score);
}
public void Unlock(string achievementId, Action <SA_Result> callback)
{
var client = AN_Games.GetAchievementsClient();
client.UnlockImmediate(achievementId, (result) => {
if (result.IsSucceeded)
{
UnlockLocally(achievementId);
}
callback.Invoke(result);
});
}
private void Start()
{
m_createNew.onClick.AddListener(() => {
Debug.Log("User choosed to create the Snapshot");
CreateSnapshot();
});
m_nativeUI.onClick.AddListener(() => {
var client = AN_Games.GetSnapshotsClient();
client.ShowSelectSnapshotIntent("Hello World!", (result) => {
if (result.IsSucceeded)
{
switch (result.State)
{
case AN_SnapshotUIResult.UserInteractionState.EXTRA_SNAPSHOT_METADATA:
Debug.Log("User choosed to load the Snapshot");
LoadSnapshot(result.Metadata);
break;
case AN_SnapshotUIResult.UserInteractionState.EXTRA_SNAPSHOT_NEW:
Debug.Log("User choosed to create the Snapshot");
CreateSnapshot();
break;
}
}
else
{
Debug.Log("Snapshots UI Failed: " + result.Error.FullMessage);
}
});
});
m_load.onClick.AddListener(() => {
var client = AN_Games.GetSnapshotsClient();
client.Load((result) => {
if (result.IsSucceeded)
{
AN_Logger.Log("Load Snapshots Succeeded, count: " + result.Snapshots.Count);
foreach (var meta in result.Snapshots)
{
PrintMeta(meta);
}
}
else
{
Debug.Log("Load Snapshots Failed: " + result.Error.FullMessage);
}
});
});
}
public void GetSignedInPlayerData(Action <AN_Player> resultCallback = null)
{
if (!IsGoogleApiAvailable || AN_GoogleSignIn.GetLastSignedInAccount() == null)
{
return;
}
if (_currentPlayerData != null) //early exit with existing player data
{
//Printing player info:
Debug.Log("player.Id: " + _currentPlayerData.PlayerId);
Debug.Log("player.Title: " + _currentPlayerData.Title);
Debug.Log("player.DisplayName: " + _currentPlayerData.DisplayName);
Debug.Log("player.HiResImageUri: " + _currentPlayerData.HiResImageUri);
Debug.Log("player.IconImageUri: " + _currentPlayerData.IconImageUri);
Debug.Log("player.HasIconImage: " + _currentPlayerData.HasIconImage);
Debug.Log("player.HasHiResImage: " + _currentPlayerData.HasHiResImage);
resultCallback.SafeInvoke(_currentPlayerData);
return;
}
AN_PlayersClient client = AN_Games.GetPlayersClient();
client.GetCurrentPlayer(result =>
{
if (result.IsSucceeded)
{
_currentPlayerData = result.Data;
//Printing player info:
Debug.Log("player.Id: " + _currentPlayerData.PlayerId);
Debug.Log("player.Title: " + _currentPlayerData.Title);
Debug.Log("player.DisplayName: " + _currentPlayerData.DisplayName);
Debug.Log("player.HiResImageUri: " + _currentPlayerData.HiResImageUri);
Debug.Log("player.IconImageUri: " + _currentPlayerData.IconImageUri);
Debug.Log("player.HasIconImage: " + _currentPlayerData.HasIconImage);
Debug.Log("player.HasHiResImage: " + _currentPlayerData.HasHiResImage);
resultCallback.SafeInvoke(_currentPlayerData);
}
else
{
Debug.Log("Failed to load Current Player " + result.Error.FullMessage);
resultCallback.SafeInvoke(null);
}
});
}
public override void Test()
{
var client = AN_Games.GetSnapshotsClient();
client.Load((result) => {
if (result.IsSucceeded)
{
foreach (var meta in result.Snapshots)
{
PrintSnapshotMetadata(meta);
}
}
SetAPIResult(result);
});
}
public void Increment(string achievementId, int numSteps, Action <SA_Result> callback)
{
var client = AN_Games.GetAchievementsClient();
client.IncrementImmediate(achievementId, numSteps, (result) => {
if (result.IsSucceeded)
{
IncrementLocally(achievementId, numSteps);
callback.Invoke(new SA_Result());
}
else
{
callback.Invoke(new SA_Result(result.Error));
}
});
}
public void ShowUI()
{
var client = AN_Games.GetAchievementsClient();
client.GetAchievementsIntent((result) => {
if (result.IsSucceeded)
{
var intent = result.Intent;
AN_ProxyActivity proxy = new AN_ProxyActivity();
proxy.StartActivityForResult(intent, (intentResult) => {
proxy.Finish();
});
}
else
{
Debug.LogError("Failed to Get Achievements Intent " + result.Error.FullMessage);
}
});
}
private void Start()
{
m_CreateRoomButton.onClick.AddListener(() =>
{
var exclusiveBitMask = 1;
var minAutoMatchPlayers = 2;
var maxAutoMatchPlayers = 4;
var autoMatchCriteria = AN_RoomConfig.CreateAutoMatchCriteria(minAutoMatchPlayers, maxAutoMatchPlayers, exclusiveBitMask);
var builder = AN_RoomConfig.NewBuilder(this);
builder.SetOnMessageReceivedListener(this);
builder.SetRoomStatusUpdateCallback(this);
builder.SetAutoMatchCriteria(autoMatchCriteria);
var roomConfig = builder.Build();
var client = AN_Games.GetRealTimeMultiplayerClient();
client.Create(roomConfig);
});
}
public void ShowUI(Action <SA_Result> callback)
{
var client = AN_Games.GetLeaderboardsClient();
client.GetAllLeaderboardsIntent((result) => {
if (result.IsSucceeded)
{
var intent = result.Intent;
AN_ProxyActivity proxy = new AN_ProxyActivity();
proxy.StartActivityForResult(intent, (intentResult) => {
proxy.Finish();
callback.Invoke(intentResult);
});
}
else
{
callback.Invoke(result);
}
});
}
