982 lines
36 KiB
C#
982 lines
36 KiB
C#
using Core.KV;
|
|
using game.KV;
|
|
using System;
|
|
using System.Collections.Generic;
|
|
using System.Globalization;
|
|
using System.Linq;
|
|
using System.Threading;
|
|
using System.Threading.Tasks;
|
|
using asap.core;
|
|
using GameCore;
|
|
using tysdk;
|
|
using UnityEngine;
|
|
using Newtonsoft.Json;
|
|
using YiDun.Protector;
|
|
#if UNITY_ANDROID
|
|
using TapjoyUnity.Internal;
|
|
#endif
|
|
|
|
namespace game
|
|
{
|
|
// Failed login attempts may retry; explicit logout ends this service lifetime.
|
|
public class KvUserService : IUserService
|
|
{
|
|
[Inject]
|
|
public IConfig config
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
[Inject]
|
|
public ICustomServerMgr customServerMgr
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
[Inject]
|
|
public IPlayerSaveStore SaveStore
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
|
|
//
|
|
private readonly KvRuntimeSelection selection;
|
|
|
|
private readonly CancellationTokenSource lifetime = new();
|
|
private readonly Dictionary<string, PlayInfo> profiles = new();
|
|
private readonly Dictionary<string, int> levels = new();
|
|
|
|
private KvGameLoadCoordinator coordinator;
|
|
private KvSessionOwner handle;
|
|
private bool loading, closing, published;
|
|
private KvSessionOwner failedHandle;
|
|
private int mmTestValue;
|
|
private Task closeTask;
|
|
private long epoch;
|
|
private string playerId;
|
|
private uint internalId;
|
|
public string CustomId
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
public string UserId => KVHandoffReady ? playerId : null;
|
|
public string ApiPlayerId => UserId;
|
|
public uint InternalId => KVHandoffReady ? internalId : 0;
|
|
public bool IsLogin => KVHandoffReady && playerId != null;
|
|
public bool IsAuthorized => published && InternalId != 0 && KVHandoffReady;
|
|
public CancellationToken LoginLifetime => lifetime.Token;
|
|
public DateTime LastLoginTime
|
|
{
|
|
get;
|
|
private set;
|
|
}
|
|
public DateTime LoginTime
|
|
{
|
|
get;
|
|
private set;
|
|
}
|
|
public DateTime CreateTime
|
|
{
|
|
get;
|
|
private set;
|
|
}
|
|
public string DisplayName
|
|
{
|
|
get;
|
|
private set;
|
|
}
|
|
public string AvatarUrl
|
|
{
|
|
get;
|
|
private set;
|
|
}
|
|
public string Language
|
|
{
|
|
get;
|
|
private set;
|
|
}
|
|
public string ContinentCode
|
|
{
|
|
get;
|
|
private set;
|
|
}
|
|
public Dictionary<string, string> EAccoutUrl
|
|
{
|
|
get;
|
|
protected set;
|
|
} = new Dictionary<string, string>();
|
|
internal bool KVHandoffReady => !closing && handle != null && coordinator != null &&
|
|
coordinator.TryGetCurrentGameHandle(epoch, out var current) && ReferenceEquals(current, handle);
|
|
|
|
public KvUserService()
|
|
{
|
|
selection = SubBoostrap.RuntimeSelection;
|
|
Application.quitting += OnApplicationQuitting;
|
|
}
|
|
|
|
protected virtual string NewPlayerName => $"Angler#{CustomId}";
|
|
protected virtual string NewPlayerAvatar => string.Empty;
|
|
|
|
protected virtual void InitData(IDictionary<string, string> data)
|
|
{
|
|
}
|
|
|
|
public virtual async Task<ELoginStep> Login(Action<int> progress, bool tyrLoginByToken = true)
|
|
{
|
|
if (loading || closing)
|
|
{
|
|
return ELoginStep.Api;
|
|
}
|
|
if (IsLogin)
|
|
{
|
|
progress?.Invoke(2);
|
|
return ELoginStep.Done;
|
|
}
|
|
if (selection == null || !selection.IsKV || !selection.TryAdmitPlayer(CustomId, out var canonicalId))
|
|
{
|
|
return ELoginStep.Api;
|
|
}
|
|
|
|
loading = true;
|
|
var requestedId = CustomId;
|
|
bool successEventStarted = false;
|
|
IChatService chat = null;
|
|
try
|
|
{
|
|
CustomServerMgr server;
|
|
KvSaveStore store;
|
|
KvGameLoadResult result;
|
|
KvSessionOwner original;
|
|
try
|
|
{
|
|
if (!await ReleaseFailedLoginAsync() || closing)
|
|
{
|
|
return ELoginStep.Api;
|
|
}
|
|
server = customServerMgr as CustomServerMgr;
|
|
if (server == null || server.ApiBaseUri.AbsoluteUri != selection.Api.AbsoluteUri)
|
|
{
|
|
throw new InvalidOperationException("Formal KV transport required.");
|
|
}
|
|
coordinator = new KvGameLoadCoordinator(
|
|
() => loading && !closing && !published && handle == null,
|
|
server.BindKVForGame, server.ClearKVForGame);
|
|
server.KVUnauthorized += OnUnauthorized;
|
|
var api = selection.Api;
|
|
var cacheRoot = Application.persistentDataPath;
|
|
if (api == null || !api.IsAbsoluteUri || (api.Scheme != "http" && api.Scheme != "https") ||
|
|
!string.IsNullOrEmpty(api.UserInfo) || !string.IsNullOrEmpty(api.Query) || !string.IsNullOrEmpty(api.Fragment))
|
|
{
|
|
throw new ArgumentException("Formal KV endpoint mismatch.", nameof(api));
|
|
}
|
|
if (string.IsNullOrEmpty(cacheRoot))
|
|
{
|
|
throw new ArgumentException("Controlled load configuration invalid.");
|
|
}
|
|
api = new Uri(api.AbsoluteUri.TrimEnd('/') + "/");
|
|
result = await coordinator.LoadForGameAsync(canonicalId, api, cacheRoot, LoginLifetime,
|
|
() => !closing && CustomId == requestedId);
|
|
if (result.Error != KVGameLoadError.None ||
|
|
closing || CustomId != requestedId || result.Account == null ||
|
|
result.Account.PlayerId != canonicalId || result.Account.Epoch != result.Epoch ||
|
|
!coordinator.TryGetCurrentGameHandle(result.Epoch, out original))
|
|
{
|
|
await FailLoginAsync();
|
|
return ELoginStep.Api;
|
|
}
|
|
epoch = result.Epoch;
|
|
handle = original;
|
|
store = SaveStore as KvSaveStore;
|
|
if (store == null)
|
|
{
|
|
throw new InvalidOperationException("KV save store required.");
|
|
}
|
|
store.Bind(original, LoginLifetime);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Debug.LogError("KV preparation failed: " + ex.GetType().Name);
|
|
await FailLoginAsync();
|
|
return ELoginStep.Api;
|
|
}
|
|
await PrepareProfileAsync(result.Account);
|
|
if (!KVHandoffReady || CustomId != requestedId)
|
|
{
|
|
await FailLoginAsync();
|
|
return ELoginStep.Api;
|
|
}
|
|
playerId = result.Account.PlayerId;
|
|
internalId = result.Account.InternalId;
|
|
ZZTimeHelper.AdjustTime(LoginTime);
|
|
ZZTimeHelper.WathForcusChange();
|
|
if (!original.CompareDatas(ZZTimeHelper.UtcNow().Ticks).Success)
|
|
{
|
|
await FailLoginAsync();
|
|
return ELoginStep.Api;
|
|
}
|
|
var merged = original.ReadLocalSnapshot();
|
|
if (!merged.Success)
|
|
{
|
|
await FailLoginAsync();
|
|
return ELoginStep.Api;
|
|
}
|
|
KvMgr.Bind(store);
|
|
InitializePlayerData(merged.Data.ToDictionary(pair => pair.Key, pair => pair.Value, StringComparer.Ordinal));
|
|
if (!KVHandoffReady || CustomId != requestedId)
|
|
{
|
|
await FailLoginAsync();
|
|
return ELoginStep.Api;
|
|
}
|
|
SetMMTestValue();
|
|
try
|
|
{
|
|
BindPromptServices(original);
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Debug.LogError("KV prompt binding failed: " + ex.GetType().Name);
|
|
await FailLoginAsync();
|
|
return ELoginStep.Api;
|
|
}
|
|
chat = GContext.container.Resolve<IChatService>();
|
|
chat.WaitingForLogin();
|
|
OnYinDunLogin();
|
|
if (!KVHandoffReady || CustomId != requestedId)
|
|
{
|
|
await FailLoginAsync();
|
|
return ELoginStep.Api;
|
|
}
|
|
server.EnableKVBusiness(epoch);
|
|
published = true;
|
|
successEventStarted = true;
|
|
try
|
|
{
|
|
GContext.Publish(new EvtAPISvrLoginSuccess { playerId = playerId, internalId = internalId });
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
// Original LoginApiServer catches subscriber errors and removes API authorization.
|
|
Debug.LogError(ex);
|
|
internalId = 0;
|
|
published = false;
|
|
server.DisableKVBusiness();
|
|
}
|
|
if (closing)
|
|
{
|
|
return ELoginStep.Api;
|
|
}
|
|
InitTapJoy();
|
|
progress?.Invoke(2);
|
|
return ELoginStep.Done;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
if (successEventStarted)
|
|
{
|
|
throw;
|
|
}
|
|
Debug.LogError("KV login failed: " + ex.GetType().Name);
|
|
try
|
|
{
|
|
(chat as IDisposable)?.Dispose();
|
|
}
|
|
catch (Exception cleanupError)
|
|
{
|
|
Debug.LogError("KV chat cleanup failed: " + cleanupError);
|
|
}
|
|
try
|
|
{
|
|
await FailLoginAsync();
|
|
}
|
|
catch (Exception cleanupError)
|
|
{
|
|
Debug.LogError("KV login cleanup failed: " + cleanupError);
|
|
}
|
|
throw;
|
|
}
|
|
finally
|
|
{
|
|
loading = false;
|
|
}
|
|
}
|
|
|
|
private void InitializePlayerData(Dictionary<string, string> data)
|
|
{
|
|
mmTestValue = 0;
|
|
if (!data.ContainsKey("MMTest"))
|
|
{
|
|
if (config.Get<bool>("NewlyCreated", false))
|
|
{
|
|
mmTestValue = -1;
|
|
}
|
|
else
|
|
{
|
|
SaveStore.Write("MMTest", "MMFailParam#0").RequireAccepted();
|
|
}
|
|
}
|
|
else
|
|
{
|
|
var parts = data["MMTest"].Split('#');
|
|
if (parts.Length > 1 && parts[0] == "MMFailParam")
|
|
{
|
|
int.TryParse(parts[1], out var value);
|
|
mmTestValue = value;
|
|
}
|
|
else
|
|
{
|
|
mmTestValue = 0;
|
|
SaveStore.Write("MMTest", "MMFailParam#0").RequireAccepted();
|
|
}
|
|
}
|
|
GContext.container.Resolve<PlayerData>().LoadPlayerData(data);
|
|
InitData(data);
|
|
}
|
|
|
|
private async Task PrepareProfileAsync(KvAccountDescriptor account)
|
|
{
|
|
if (account.InternalId == 0 || account.CreateTimeUtc == DateTime.MinValue || account.ServerTimeUtc == DateTime.MinValue)
|
|
{
|
|
throw new InvalidOperationException("Authenticated account metadata required.");
|
|
}
|
|
CreateTime = account.CreateTimeUtc;
|
|
LoginTime = account.ServerTimeUtc;
|
|
config.Set("NewlyCreated", account.NewlyCreated);
|
|
var previous = Read("LastLoginTimeUtc");
|
|
LastLoginTime = ParseLastLoginTime(previous.Value, previous.Found.Value);
|
|
DisplayName = Read("DisplayName").Value;
|
|
AvatarUrl = Read("AvatarUrl").Value ?? string.Empty;
|
|
Language = Read("Language").Value;
|
|
var continent = Read("ContinentCode").Value;
|
|
ContinentCode = new[] { "AF", "AN", "AS", "EU", "NA", "OC", "SA" }.Contains(continent) ? continent : null;
|
|
if (string.IsNullOrEmpty(DisplayName))
|
|
{
|
|
var name = await ChangeDisplayName(NewPlayerName);
|
|
LoginLifetime.ThrowIfCancellationRequested();
|
|
if (!KVHandoffReady)
|
|
{
|
|
throw new InvalidOperationException("Stale KV profile.");
|
|
}
|
|
DisplayName = name;
|
|
}
|
|
if (string.IsNullOrEmpty(AvatarUrl))
|
|
{
|
|
await UpdateAvatarUrl(NewPlayerAvatar);
|
|
}
|
|
await UpdateLanguage(GContext.container.Resolve<ISettingService>().Lang);
|
|
LoginLifetime.ThrowIfCancellationRequested();
|
|
}
|
|
|
|
private async Task FailLoginAsync()
|
|
{
|
|
if (closing)
|
|
{
|
|
return;
|
|
}
|
|
if (closeTask != null)
|
|
{
|
|
await ReleaseFailedLoginAsync();
|
|
return;
|
|
}
|
|
failedHandle = handle;
|
|
handle = null;
|
|
playerId = null;
|
|
internalId = 0;
|
|
published = false;
|
|
DisplayName = AvatarUrl = Language = ContinentCode = null;
|
|
ClearPlayInfos();
|
|
if (customServerMgr is CustomServerMgr server)
|
|
{
|
|
server.KVUnauthorized -= OnUnauthorized;
|
|
server.DisableKVBusiness();
|
|
}
|
|
closeTask = coordinator?.Revoke() ?? Task.CompletedTask;
|
|
await ReleaseFailedLoginAsync();
|
|
}
|
|
|
|
private async Task<bool> ReleaseFailedLoginAsync()
|
|
{
|
|
if (closeTask == null)
|
|
{
|
|
return true;
|
|
}
|
|
var status = await (coordinator?.ObserveQuitAsync() ?? Task.FromResult(KVShutdownStatus.Ready));
|
|
if (closing || status != KVShutdownStatus.Ready || closeTask.Status != TaskStatus.RanToCompletion)
|
|
{
|
|
return false;
|
|
}
|
|
if (failedHandle != null)
|
|
{
|
|
KvMgr.Unbind(SaveStore as KvSaveStore);
|
|
(SaveStore as KvSaveStore)?.ReleaseFailedBinding(failedHandle);
|
|
(GContext.container.Resolve<ISettingService>() as DefaultSettingService)?.ReleaseFailedPromptOwner(failedHandle);
|
|
GContext.container.Resolve<ClubService>().ReleaseFailedPromptOwner(failedHandle);
|
|
}
|
|
failedHandle = null;
|
|
closeTask = null;
|
|
coordinator = null;
|
|
epoch = 0;
|
|
return true;
|
|
}
|
|
|
|
internal static DateTime ParseLastLoginTime(string value, bool found)
|
|
{
|
|
if (!found)
|
|
{
|
|
return DateTime.MinValue;
|
|
}
|
|
if (!DateTime.TryParseExact(value, "O", CultureInfo.InvariantCulture, DateTimeStyles.RoundtripKind, out var time) ||
|
|
time == DateTime.MinValue || time.Kind == DateTimeKind.Unspecified)
|
|
{
|
|
throw new FormatException("Invalid LastLoginTimeUtc.");
|
|
}
|
|
return time.ToUniversalTime();
|
|
}
|
|
|
|
private PlayerSaveReadResult Read(string key)
|
|
{
|
|
var result = SaveStore.Read(key);
|
|
if (!result.Success)
|
|
{
|
|
throw new InvalidOperationException("KV profile read failed: " + result.Error);
|
|
}
|
|
return result;
|
|
}
|
|
|
|
private void BindPromptServices(KvSessionOwner original)
|
|
{
|
|
if (!KVHandoffReady)
|
|
{
|
|
throw new InvalidOperationException("Prompt binding is stale.");
|
|
}
|
|
var settings = GContext.container.Resolve<ISettingService>() as DefaultSettingService;
|
|
var notifications = GContext.container.Resolve<ILocalNotificationService>() as LocalNotificationService;
|
|
var club = GContext.container.Resolve<ClubService>();
|
|
if (settings == null || notifications == null || club == null)
|
|
{
|
|
throw new InvalidOperationException("Formal prompt services required.");
|
|
}
|
|
settings.PreflightFormalPromptOwner(original);
|
|
club.PreflightFormalPromptOwner(original);
|
|
notifications.PreflightFormalPromptSettings(settings);
|
|
settings.BindFormalPromptOwner(original);
|
|
club.BindFormalPromptOwner(original);
|
|
notifications.BindFormalPromptSettings(settings);
|
|
if (!KVHandoffReady)
|
|
{
|
|
throw new InvalidOperationException("Formal prompt binding changed.");
|
|
}
|
|
}
|
|
|
|
private void OnUnauthorized(int version)
|
|
{
|
|
if (version == customServerMgr.SessionVersion)
|
|
{
|
|
Logout();
|
|
}
|
|
}
|
|
|
|
private void OnApplicationQuitting()
|
|
{
|
|
var original = SaveStore as KvSaveStore;
|
|
try
|
|
{
|
|
KvMgr.Stop(original);
|
|
if (original != null && original.IsCurrent)
|
|
{
|
|
_ = original.SyncDataAsync();
|
|
}
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Debug.LogError("KV quit save failed: " + ex.GetType().Name);
|
|
}
|
|
finally
|
|
{
|
|
Logout();
|
|
}
|
|
}
|
|
|
|
public virtual void Logout()
|
|
{
|
|
ObserveClose(CloseKVForValidationAsync());
|
|
}
|
|
private async void ObserveClose(Task task)
|
|
{
|
|
try
|
|
{
|
|
await task;
|
|
}
|
|
catch (Exception ex)
|
|
{
|
|
Debug.LogError("KV close failed: " + ex.GetType().Name);
|
|
}
|
|
}
|
|
internal Task CloseKVForValidationAsync()
|
|
{
|
|
if (closing)
|
|
{
|
|
return closeTask ?? Task.CompletedTask;
|
|
}
|
|
closing = true;
|
|
published = false;
|
|
KvMgr.Unbind(SaveStore as KvSaveStore);
|
|
(SaveStore as KvSaveStore)?.Dispose();
|
|
playerId = null;
|
|
internalId = 0;
|
|
handle = null;
|
|
epoch = 0;
|
|
DisplayName = AvatarUrl = Language = ContinentCode = null;
|
|
ClearPlayInfos();
|
|
Application.quitting -= OnApplicationQuitting;
|
|
if (customServerMgr is CustomServerMgr server)
|
|
{
|
|
server.KVUnauthorized -= OnUnauthorized;
|
|
server.DisableKVBusiness();
|
|
}
|
|
// Revoke first; a synchronous cancellation callback must already see invalid identity.
|
|
closeTask = coordinator?.Revoke() ?? Task.CompletedTask;
|
|
lifetime.Cancel();
|
|
return closeTask;
|
|
}
|
|
internal Task<KVShutdownStatus> ObserveKVQuitAsync() =>
|
|
coordinator?.ObserveQuitAsync() ?? Task.FromResult(KVShutdownStatus.Ready);
|
|
|
|
private async Task<bool> SaveProfile(string key, string value)
|
|
{
|
|
var original = handle;
|
|
var store = SaveStore;
|
|
if ((!IsLogin && !loading) || !KVHandoffReady || store == null)
|
|
{
|
|
return false;
|
|
}
|
|
try
|
|
{
|
|
var result = await store.SyncDataImmidiate(key, value);
|
|
return ReferenceEquals(original, handle) && KVHandoffReady &&
|
|
ReferenceEquals(store, SaveStore) && store.IsCurrent && result;
|
|
}
|
|
catch (OperationCanceledException)
|
|
{
|
|
return false;
|
|
}
|
|
}
|
|
|
|
public async Task<string> ChangeDisplayName(string newName)
|
|
{
|
|
var originName = string.IsNullOrEmpty(DisplayName) ? NewPlayerName : DisplayName;
|
|
if (!await SaveProfile("DisplayName", newName))
|
|
{
|
|
return originName;
|
|
}
|
|
DisplayName = newName;
|
|
GContext.Publish(new ChangeAvatarEvent());
|
|
UpdateProfileName();
|
|
return newName;
|
|
}
|
|
public async Task<string> UpdateAvatarUrl(string url)
|
|
{
|
|
var originUrl = AvatarUrl;
|
|
|
|
Debug.Log("UpdateAvatarUrlAsync originUrl:" + originUrl + " url " + url);
|
|
|
|
if (string.IsNullOrEmpty(url))
|
|
{
|
|
return originUrl;
|
|
}
|
|
if (url == originUrl)
|
|
{
|
|
return originUrl;
|
|
}
|
|
|
|
if (!await SaveProfile("AvatarUrl", url))
|
|
{
|
|
return originUrl;
|
|
}
|
|
AvatarUrl = url;
|
|
GContext.Publish(new ChangeAvatarEvent());
|
|
UpdateProfileAvatar();
|
|
return url;
|
|
}
|
|
public async Task<string> UpdateLanguage(string code)
|
|
{
|
|
if (Language == code)
|
|
{
|
|
return Language;
|
|
}
|
|
|
|
if (await SaveProfile("Language", code.Replace('_', '-')))
|
|
{
|
|
Language = code;
|
|
}
|
|
return Language;
|
|
}
|
|
public void GMMMT(int value)
|
|
{
|
|
mmTestValue = value;
|
|
SaveStore.Write("MMTest", $"MMFailParam#{mmTestValue}").RequireAccepted();
|
|
SetMMTestValue();
|
|
}
|
|
|
|
private void SetMMTestValue()
|
|
{
|
|
string ab = GContext.container.Resolve<MMTService>().Init(mmTestValue);
|
|
GEvent.SetUserProp("MMTestValue", ab, true);
|
|
Debug.Log($"UserId:{UserId} MMTestValue :0b{Convert.ToString(mmTestValue, 2)} MMTestValueString:{ab}");
|
|
}
|
|
|
|
protected void AvatarToKV(TYSdkFacade.AccountInfo accountInfo)
|
|
{
|
|
if (accountInfo != null &&
|
|
(accountInfo.channel == EAccoutType.hwFacebook || accountInfo.channel == EAccoutType.hwGoogle) &&
|
|
!string.IsNullOrEmpty(accountInfo.avatar))
|
|
{
|
|
if (EAccoutUrl == null)
|
|
{
|
|
EAccoutUrl = new Dictionary<string, string>();
|
|
}
|
|
EAccoutUrl[accountInfo.channel.ToString()] = accountInfo.avatar;
|
|
SaveStore.Write("EAccoutUrl", JsonConvert.SerializeObject(EAccoutUrl)).RequireAccepted();
|
|
}
|
|
}
|
|
|
|
private void InitTapJoy()
|
|
{
|
|
#if UNITY_ANDROID
|
|
var lastBalanceStr = Read("TapJoy_Diamond").Value ?? "";
|
|
Debug.Log($"InitTapJoy -> {lastBalanceStr}");
|
|
var lastBalance = int.TryParse(lastBalanceStr, out var temp) ? temp : 0;
|
|
|
|
var tapjoyObject = GameObject.FindObjectOfType<TapjoyComponent>();
|
|
if (tapjoyObject && tapjoyObject.gameObject && !tapjoyObject.GetComponent<TapjoyHelper>())
|
|
{
|
|
var tapjoyHelper = tapjoyObject.gameObject.AddComponent<TapjoyHelper>();
|
|
GameObject.DontDestroyOnLoad(tapjoyHelper);
|
|
tapjoyHelper.Init(lastBalance, OnEarnCurrencyName, OnBalance);
|
|
}
|
|
return;
|
|
void OnEarnCurrencyName(string currencyName, int amount)
|
|
{
|
|
Debug.Log($"OnEarnCurrencyName -> {currencyName} {amount}");
|
|
// var amount = (balance - lastBalance);
|
|
var diamonds = new ItemData { id = 1005, count = amount };
|
|
diamonds.curCount = (ulong)GContext.container.Resolve<PlayerItemData>().GetItemCount(diamonds.id);
|
|
GContext.container.Resolve<PlayerItemData>().AddItem(diamonds, null);
|
|
GContext.Publish(new ShowData(new List<ItemData> { diamonds }, RewardType.NormalOne));
|
|
GContext.Publish(new ShowData());
|
|
#if AGG
|
|
using (var e = GEvent.GameEvent("tapjoy"))
|
|
{
|
|
e.AddContent("item_id", diamonds.id)
|
|
.AddContent("item_count", diamonds.count);
|
|
}
|
|
#endif
|
|
|
|
|
|
}
|
|
void OnBalance(string currencyName, int balance)
|
|
{
|
|
Debug.Log($"OnBalance -> {currencyName} {balance}");
|
|
// const string tapjoyKey = "TapJoy_Diamond";
|
|
// var lastBalanceStr = PlayFabMgr.Instance.GetLocalData(tapjoyKey) ?? "";
|
|
// var lastBalance = int.TryParse(lastBalanceStr, out var temp) ? temp : 0;
|
|
{
|
|
// PlayFabMgr.Instance.UpdateUserDataValue(tapjoyKey, balance.ToString());
|
|
// if (balance > lastBalance)
|
|
// {
|
|
// var amount = (balance - lastBalance);
|
|
// var diamonds = new ItemData { id = 1005, count = amount };
|
|
// diamonds.curCount = (ulong)GContext.container.Resolve<PlayerItemData>().GetItemCount(diamonds.id);
|
|
// GContext.container.Resolve<PlayerItemData>().AddItem(diamonds);
|
|
// GContext.Publish(new ShowData(new List<ItemData> { diamonds }, RewardType.NormalOne));
|
|
// // GContext.Publish(new ShowData(diamonds));
|
|
// GContext.Publish(new ShowData());
|
|
// }
|
|
}
|
|
}
|
|
#endif
|
|
}
|
|
private async void OnYinDunLogin()
|
|
{
|
|
// 开发模式下，先不启用了
|
|
if (config != null && (config.Get("DEBUG", "0") == "1" || config.Get("GM", "0") == "1"))
|
|
{
|
|
return;
|
|
}
|
|
var userService = GContext.container.Resolve<IUserService>();
|
|
var yiDunManager = GContext.container.Resolve<YiDunManager>();
|
|
var roleName = userService.DisplayName;
|
|
var roleId = userService.UserId;
|
|
var roleAccount = userService.CustomId;
|
|
var versionData = new
|
|
{
|
|
GameVersion = Application.version,
|
|
AssetVersion = config.Get(GConstant.K_AssetVersion, string.Empty),
|
|
#if UNITY_ANDROID
|
|
Channel = GConstant.Yidun_GooglePlayChannel
|
|
#elif UNITY_IOS
|
|
Channel = GConstant.Yidun_IOSChannel
|
|
#endif
|
|
};
|
|
Debug.Log($"JsonUtility.ToJson(versionData) => {JsonConvert.SerializeObject(versionData)}");
|
|
|
|
#if (UNITY_ANDROID || UNITY_IOS || UNITY_IPHONE) && !UNITY_EDITOR
|
|
var businessId = GConstant.Yidun_AndroidBusinessId;
|
|
#if UNITY_IOS
|
|
businessId = GConstant.Yidun_IOSBusinessId;
|
|
#endif
|
|
|
|
yiDunManager.SetRoleInfo(businessId, roleId, roleName, roleAccount, null, -1, JsonConvert.SerializeObject(versionData));
|
|
yiDunManager.PostRiskCheck();
|
|
#endif
|
|
}
|
|
|
|
public double CreateTotalSeconds() => (ZZTimeHelper.UtcNow() - CreateTime).TotalSeconds;
|
|
|
|
private sealed class BindConflictPreviewResponse
|
|
{
|
|
public int Code
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
public bool Exists
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
public bool HasArchive
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
public string DisplayName
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
public string AvatarUrl
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
public int Level
|
|
{
|
|
get;
|
|
set;
|
|
}
|
|
}
|
|
|
|
public async Task<PlayFabTools.PFPlayerInfo> GetBindConflictPreview(int sdkId)
|
|
{
|
|
try
|
|
{
|
|
string json = null;
|
|
for (var attempt = 0; attempt < 4; attempt++)
|
|
{
|
|
json = await customServerMgr.AccountRequest("GetBindConflictPreview",
|
|
new { targetUserId = sdkId.ToString() });
|
|
if (json != null)
|
|
{
|
|
break;
|
|
}
|
|
if (attempt < 3)
|
|
{
|
|
await Task.Delay(TimeSpan.FromSeconds(1 << attempt));
|
|
}
|
|
}
|
|
if (string.IsNullOrEmpty(json))
|
|
{
|
|
return PlayFabTools.PFPlayerInfo.Empty(sdkId);
|
|
}
|
|
|
|
var response = JsonConvert.DeserializeObject<BindConflictPreviewResponse>(json);
|
|
if (response == null || response.Code <= 0 || !response.Exists)
|
|
{
|
|
return PlayFabTools.PFPlayerInfo.Empty(sdkId);
|
|
}
|
|
if (!response.HasArchive)
|
|
{
|
|
return new PlayFabTools.PFPlayerInfo
|
|
{
|
|
SdkId = sdkId,
|
|
PlayFabId = sdkId.ToString()
|
|
};
|
|
}
|
|
return new PlayFabTools.PFPlayerInfo
|
|
{
|
|
SdkId = sdkId,
|
|
PlayFabId = sdkId.ToString(),
|
|
DisplayName = response.DisplayName,
|
|
Avatar = response.AvatarUrl,
|
|
Level = response.Level
|
|
};
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
Debug.LogWarning(e.Message);
|
|
return PlayFabTools.PFPlayerInfo.Empty(sdkId);
|
|
}
|
|
}
|
|
|
|
// The non-AGG channel has no account-link operation; never manufacture a successful binding.
|
|
public virtual async Task<(int code, int userid)> LinkAccount(EAccoutType type)
|
|
{
|
|
await Awaiters.NextFrame;
|
|
return (1, 0);
|
|
}
|
|
public virtual async Task<bool> GetLinkState(EAccoutType type)
|
|
{
|
|
await Awaiters.NextFrame;
|
|
return false;
|
|
}
|
|
public string GetDefaultName(string id) => "Angler#" + (string.IsNullOrEmpty(id) ? string.Empty : id.Substring(0, Math.Min(5, id.Length)));
|
|
public void SetPlayerLv(string id, int level) => levels[id] = id == UserId ? GContext.container.Resolve<PlayerData>().lv : level;
|
|
public int GetPlayerLv(string id) => levels.TryGetValue(id, out var level) ? level : 1;
|
|
public async Task<(string, int)> GetPlayLv(string id)
|
|
{
|
|
var level = id == UserId && IsAuthorized ? (int)GContext.container.Resolve<PlayerData>().lv :
|
|
id != null && levels.TryGetValue(id, out var cachedLevel) ? cachedLevel : -1;
|
|
if (level >= 0)
|
|
{
|
|
return (id, level);
|
|
}
|
|
if (id != UserId && !string.IsNullOrEmpty(id) && !levels.ContainsKey(id))
|
|
{
|
|
var json = await customServerMgr.FriendRequest("SearchFriend", new SearchFriendReq { PlayFabId = id });
|
|
if (!string.IsNullOrEmpty(json))
|
|
{
|
|
SearchFriendResp response = null;
|
|
try
|
|
{
|
|
response = Newtonsoft.Json.JsonConvert.DeserializeObject<SearchFriendResp>(json);
|
|
}
|
|
catch (Newtonsoft.Json.JsonException ex)
|
|
{
|
|
Debug.LogError("KV player level response failed: " + ex.GetType().Name);
|
|
}
|
|
if (response != null && response.Code > 0 && response.KvProfile != null)
|
|
{
|
|
level = response.KvProfile.Level ?? 1;
|
|
if (level >= 0)
|
|
{
|
|
levels[id] = level;
|
|
return (id, level);
|
|
}
|
|
}
|
|
}
|
|
}
|
|
throw new InvalidOperationException("Public player level has not been loaded.");
|
|
}
|
|
public PlayInfo GetPlayInfo(string id)
|
|
{
|
|
if (string.IsNullOrEmpty(id))
|
|
{
|
|
return null;
|
|
}
|
|
if (!profiles.TryGetValue(id, out var profile))
|
|
{
|
|
profile = new PlayInfo { name = GetDefaultName(id) };
|
|
profiles.Add(id, profile);
|
|
SetPlayInfo(id, profile);
|
|
}
|
|
return profile;
|
|
}
|
|
private async void SetPlayInfo(string id, PlayInfo profile)
|
|
{
|
|
if (id == UserId)
|
|
{
|
|
profile.name = DisplayName;
|
|
profile.avatarUrl = AvatarUrl;
|
|
GContext.Publish(new GetClubPlayInfoEvent { id = id, name = profile.name, avatarUrl = profile.avatarUrl });
|
|
return;
|
|
}
|
|
var json = await customServerMgr.FriendRequest("SearchFriend", new SearchFriendReq { PlayFabId = id });
|
|
if (string.IsNullOrEmpty(json))
|
|
{
|
|
return;
|
|
}
|
|
SearchFriendResp result;
|
|
try
|
|
{
|
|
result = Newtonsoft.Json.JsonConvert.DeserializeObject<SearchFriendResp>(json);
|
|
}
|
|
catch (Newtonsoft.Json.JsonException ex)
|
|
{
|
|
Debug.LogError("KV player profile response failed: " + ex.GetType().Name);
|
|
return;
|
|
}
|
|
if (result != null && result.Code > 0 && result.KvProfile != null)
|
|
{
|
|
if (!string.IsNullOrEmpty(result.KvProfile.DisplayName))
|
|
{
|
|
profile.name = result.KvProfile.DisplayName;
|
|
}
|
|
profile.avatarUrl = result.KvProfile.AvatarUrl;
|
|
GContext.Publish(new GetClubPlayInfoEvent { id = id, name = profile.name, avatarUrl = profile.avatarUrl });
|
|
}
|
|
}
|
|
public void SetPlayInfo(string id, string name, string avatarUrl)
|
|
{
|
|
profiles[id] = new PlayInfo
|
|
{
|
|
name = string.IsNullOrEmpty(name) ? GetDefaultName(id) : name,
|
|
avatarUrl = avatarUrl
|
|
};
|
|
}
|
|
public void ClearPlayInfos()
|
|
{
|
|
profiles.Clear();
|
|
levels.Clear();
|
|
}
|
|
private void UpdateProfileName()
|
|
{
|
|
if (!IsAuthorized)
|
|
{
|
|
return;
|
|
}
|
|
|
|
PlayerProfile playerProfile = new PlayerProfile();
|
|
playerProfile.DisplayName = DisplayName;
|
|
LoginRequest loginRequest = new LoginRequest() { playerId = ApiPlayerId, playerProfile = playerProfile };
|
|
customServerMgr.AccountRequest("UpdateProfile", loginRequest);
|
|
}
|
|
private void UpdateProfileAvatar()
|
|
{
|
|
if (!IsAuthorized)
|
|
{
|
|
return;
|
|
}
|
|
|
|
PlayerProfile playerProfile = new PlayerProfile();
|
|
playerProfile.Avatar = AvatarUrl;
|
|
LoginRequest loginRequest = new LoginRequest() { playerId = ApiPlayerId, playerProfile = playerProfile };
|
|
customServerMgr.AccountRequest("UpdateProfile", loginRequest);
|
|
}
|
|
public void UpdateProfile()
|
|
{
|
|
if (IsAuthorized)
|
|
{
|
|
customServerMgr.AccountRequest("UpdateProfile", new LoginRequest
|
|
{
|
|
playerId = ApiPlayerId,
|
|
playerProfile = new PlayerProfile { Level = GContext.container.Resolve<PlayerData>().lv, Avatar = AvatarUrl, DisplayName = DisplayName }
|
|
});
|
|
}
|
|
}
|
|
public void UpdateProfileLv()
|
|
{
|
|
if (IsAuthorized)
|
|
{
|
|
customServerMgr.AccountRequest("UpdateProfile", new LoginRequest
|
|
{
|
|
playerId = ApiPlayerId,
|
|
playerProfile = new PlayerProfile { Level = GContext.container.Resolve<PlayerData>().lv }
|
|
});
|
|
}
|
|
}
|
|
}
|
|
}
|