public void Reveal(string achievementId, Action <SA_Result> callback)
{
//Always revealed
UM_EditorAPIEmulator.WaitForNetwork(() => {
callback.Invoke(new SA_Result());
});
}
//--------------------------------------
// UM_iInAppClient
//--------------------------------------
public void AddPayment(string productId)
{
var transactionsList = GetTransactionsList();
if (transactionsList.productIds.Contains(productId))
{
UM_DialogsUtility.ShowMessage("Restored", "Product with id " + productId + " has been already purchased.");
var transaction = new UM_EditorTransaction(productId, UM_TransactionState.Purchased);
UpdateTransaction(transaction);
return;
}
AddPendingTransaction(productId);
UM_EditorAPIEmulator.WaitForNetwork(() =>
{
UM_iTransaction transaction;
if (productId.Equals(UM_InAppService.TEST_ITEM_UNAVAILABLE))
{
transaction = new UM_EditorTransaction(productId, UM_TransactionState.Failed);
}
else
{
transaction = new UM_EditorTransaction(productId, UM_TransactionState.Purchased);
}
UpdateTransaction(transaction);
});
}
private void StartRequestAccessFlow(Action <AuthorizationStatus> callback)
{
switch (Application.platform)
{
case RuntimePlatform.Android:
IOSRequestAccess(callback);
break;
case RuntimePlatform.IPhonePlayer:
AN_PermissionsUtility.TryToResolvePermission(AndroidPermissions, (granted) =>
{
if (granted)
{
callback.Invoke(AuthorizationStatus.Granted);
}
else
{
callback.Invoke(AuthorizationStatus.Denied);
}
});
break;
default:
UM_EditorAPIEmulator.WaitForNetwork(() => { callback.Invoke(AuthorizationStatus.Granted); });
break;
}
}
//--------------------------------------
// UM_AbstractInAppClient
//--------------------------------------
protected override void ConnectToService(Action <SA_iResult> callback)
{
UM_EditorAPIEmulator.WaitForNetwork(() =>
{
callback.Invoke(new SA_Result());
});
}
public void Unlock(string achievementId, Action <SA_Result> callback)
{
UM_EditorAPIEmulator.WaitForNetwork(() => {
UM_EditorAPIEmulator.SetFloat(achievementId, 100f);
callback.Invoke(new SA_Result());
});
}
public void Load(string id, Action <SA_Result> callback)
{
UM_EditorAPIEmulator.WaitForNetwork(() => {
m_isReady = true;
callback.Invoke(new SA_Result());
});
}
protected override void StartSingInFlow(Action <SA_Result> callback)
{
UM_EditorAPIEmulator.WaitForNetwork(() => {
var playerInfo = new UM_PlayerInfo(UM_PlayerState.SignedIn, UM_Settings.Instance.GSEditorPlayer);
UpdateSignedPlater(playerInfo);
callback.Invoke(new SA_Result());
});
}
public void SubmitScore(string leaderboardId, long score, int context, Action <SA_Result> callback)
{
UM_EditorAPIEmulator.WaitForNetwork(() => {
UM_Score um_score = new UM_Score(score, 10, context, SA_Unix_Time.ToUnixTime(DateTime.Now));
UM_EditorAPIEmulator.SetString(leaderboardId, JsonUtility.ToJson(um_score));
callback.Invoke(new SA_Result());
});
}
public void ShowSendMailDialog(UM_EmailDialogBuilder builder, Action <SA_Result> callback)
{
UM_EditorAPIEmulator.WaitForNetwork(() =>
{
// UM_DialogsUtility.ShowMessage("Send Mail Dialog", "Editor API Sharing Emulation.");
callback.Invoke(new SA_Result());
});
}
public void SingOut(Action <SA_Result> callback)
{
UM_EditorAPIEmulator.WaitForNetwork(() => {
var playerInfo = new UM_PlayerInfo(UM_PlayerState.SignedOut, null);
UpdateSignedPlater(playerInfo);
callback.Invoke(new SA_Result());
});
}
public void LoadLeaderboardsMetadata(Action <UM_LoadLeaderboardsMetaResult> callback)
{
UM_EditorAPIEmulator.WaitForNetwork(() => {
List <UM_iLeaderboard> um_leaderboards = new List <UM_iLeaderboard>();
foreach (var um_leaderboard in UM_Settings.Instance.GSLeaderboards)
{
um_leaderboards.Add(um_leaderboard);
}
var um_result = new UM_LoadLeaderboardsMetaResult(um_leaderboards);
callback.Invoke(um_result);
});
}
public void Show(Action callback)
{
if (!IsReady)
{
string message = "Failed to show banner, banner is not ready!";
Debug.LogError(message);
throw new InvalidOperationException(message);
}
UM_EditorAPIEmulator.WaitForNetwork(() => {
callback.Invoke();
});
}
public void Increment(string achievementId, int numSteps, Action <SA_Result> callback)
{
UM_EditorAPIEmulator.WaitForNetwork(() => {
int currentSteps = 0;
if (UM_EditorAPIEmulator.HasKey(achievementId))
{
currentSteps = (int)UM_EditorAPIEmulator.GetFloat(achievementId);
}
UM_EditorAPIEmulator.SetFloat(achievementId, currentSteps + numSteps);
callback.Invoke(new SA_Result());
});
}
protected override void ObserveTransactions()
{
var transactionsList = GetTransactionsList();
foreach (var productId in transactionsList.productIds)
{
UM_EditorAPIEmulator.WaitForNetwork(() =>
{
var transaction = new UM_EditorTransaction(productId, UM_TransactionState.Purchased);
UpdateTransaction(transaction);
});
}
}
public void LoadCurrentPlayerScore(string leaderboardId, UM_LeaderboardTimeSpan span, UM_LeaderboardCollection collection, Action <UM_ScoreLoadResult> callback)
{
UM_EditorAPIEmulator.WaitForNetwork(() => {
if (UM_EditorAPIEmulator.HasKey(leaderboardId))
{
string json = UM_EditorAPIEmulator.GetString(leaderboardId);
UM_Score um_score = JsonUtility.FromJson <UM_Score>(json);
callback.Invoke(new UM_ScoreLoadResult(um_score));
}
else
{
var error = new SA_Error(100, "Leaderboard with id: " + leaderboardId + " does not have any scores yet.");
callback.Invoke(new UM_ScoreLoadResult(error));
}
});
}
public void Show(Action <UM_RewardedAdsResult> callabck)
{
if (!IsReady)
{
string message = "Failed to show rewarded, contnet is not ready yet!";
Debug.LogError(message);
throw new InvalidOperationException(message);
}
else
{
UM_EditorAPIEmulator.WaitForNetwork(() => {
callabck.Invoke(UM_RewardedAdsResult.Finished);
m_isReady = false;
});
}
}
//--------------------------------------
// UM_iInAppClient
//--------------------------------------
public void AddPayment(string productId)
{
UM_EditorAPIEmulator.WaitForNetwork(() =>
{
UM_iTransaction transaction;
if (productId.Equals(UM_InAppService.TEST_ITEM_UNAVAILABLE))
{
transaction = new UM_EditorTransaction(productId, UM_TransactionState.Failed);
}
else
{
transaction = new UM_EditorTransaction(productId, UM_TransactionState.Purchased);
}
UpdateTransaction(transaction);
});
}
public void Load(Action <UM_AchievementsLoadResult> callback)
{
UM_EditorAPIEmulator.WaitForNetwork(() => {
UM_AchievementsLoadResult loadResult;
var achievements = new List <UM_iAchievement>();
foreach (var achievement in ISN_GKAchievement.GetGameAchievements())
{
if (UM_EditorAPIEmulator.HasKey(achievement.Identifier))
{
achievement.PercentComplete = UM_EditorAPIEmulator.GetFloat(achievement.Identifier);
}
var iosAchievement = new UM_IOSAchievement(achievement);
SetAchievementCahce(iosAchievement);
achievements.Add(iosAchievement);
}
loadResult = new UM_AchievementsLoadResult(achievements);
callback.Invoke(loadResult);
});
}
public void GetAvatar(Action <Texture2D> callback)
{
UM_EditorAPIEmulator.WaitForNetwork(() => {
callback.Invoke(Avatar);
});
}
