diff options
Diffstat (limited to 'Client/Assets/Scripts/XUtliPoolLib/XUpdater/XUpdater.cs')
| -rw-r--r-- | Client/Assets/Scripts/XUtliPoolLib/XUpdater/XUpdater.cs | 1644 |
1 files changed, 1644 insertions, 0 deletions
diff --git a/Client/Assets/Scripts/XUtliPoolLib/XUpdater/XUpdater.cs b/Client/Assets/Scripts/XUtliPoolLib/XUpdater/XUpdater.cs new file mode 100644 index 00000000..dba75741 --- /dev/null +++ b/Client/Assets/Scripts/XUtliPoolLib/XUpdater/XUpdater.cs @@ -0,0 +1,1644 @@ +using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.IO;
+using System.Reflection;
+using System.Text;
+using System.Threading;
+using System.Xml.Serialization;
+using UnityEngine;
+using XUtliPoolLib;
+
+namespace XUpdater
+{
+ public sealed class XUpdater : XSingleton<XUpdater>
+ {
+ public static XLaunchMode LaunchMode
+ {
+ get
+ {
+ return XUpdater._launch_mode;
+ }
+ }
+
+ public bool EditorMode
+ {
+ get
+ {
+ return this._bEditorMode;
+ }
+ }
+
+ public string Version
+ {
+ get
+ {
+ return this._version;
+ }
+ }
+
+ public string TargetVersion
+ {
+ get
+ {
+ return this._target_version;
+ }
+ }
+
+ public bool NeedCheckFile
+ {
+ get
+ {
+ return this._need_check_file;
+ }
+ }
+
+ public BuildTarget RunTimePlatform
+ {
+ get
+ {
+ return this._runtime_platform;
+ }
+ }
+
+ public string Platform
+ {
+ get
+ {
+ return this._platform_name;
+ }
+ }
+
+ public IPlatform XPlatform
+ {
+ get
+ {
+ return this._platform;
+ }
+ }
+
+ public ILuaEngine XLuaEngine
+ {
+ get
+ {
+ return this._lua_engine;
+ }
+ }
+
+ public IApolloManager XApolloManager
+ {
+ get
+ {
+ return this._apolloManager;
+ }
+ }
+
+ public IBroardcast XBroadCast
+ {
+ get
+ {
+ return this._broadcast;
+ }
+ }
+
+ public ITssSdk XTssSdk
+ {
+ get
+ {
+ return this._tssSdk;
+ }
+ }
+
+ public IXPandoraMgr XPandoraManager
+ {
+ get
+ {
+ return this._pandoraManager;
+ }
+ }
+
+ public IXGameSirControl GameSirControl
+ {
+ get
+ {
+ return this._SirControl;
+ }
+ }
+
+ public IResourceHelp XResourceHelp
+ {
+ get
+ {
+ return this._resourcehelp;
+ }
+ }
+
+ public bool IsDone
+ {
+ get
+ {
+ return this._update_done;
+ }
+ }
+
+ internal eUPdatePhase Phase
+ {
+ set
+ {
+ this._phase = value;
+ }
+ }
+
+ public int ManagedThreadId
+ {
+ get
+ {
+ return this._main_threadId;
+ }
+ }
+
+ public bool Reboot { get; set; }
+
+ public static readonly uint Major_Version = 1u;
+
+ private static XLaunchMode _launch_mode = XLaunchMode.Live;
+
+ public static GameObject XGameRoot = null;
+
+ public static Assembly Ass = Assembly.GetAssembly(typeof(GameObject));
+
+ public static int Md5Length = 16;
+
+ private int _main_threadId = 0;
+
+ private bool _bEditorMode = false;
+
+ private bool _bFetchVersion = false;
+
+ private bool _bFetchServer = false;
+
+ private StringBuilder _log = new StringBuilder();
+
+ private IEnumerator _downloader = null;
+
+ private IEnumerator _download_prepare = null;
+
+ private IEnumerator _comparer = null;
+
+ private IEnumerator _launcher = null;
+
+ private IEnumerator _finish = null;
+
+ private byte[] _script = null;
+
+ private bool _on_file_download_retry = false;
+
+ private bool _on_file_download_need_retry = false;
+
+ private bool _update_done = false;
+
+ private bool _bundle_fetching = false;
+
+ private bool _asset_loading = false;
+
+ private XVersion _version_getter = null;
+
+ private XBundle _bundle_getter = null;
+
+ private XFileLog _filelog_getter = null;
+
+ private IFMOD_Listener _fmod_listenter = null;
+
+ private ITssSdk _tssSdk = null;
+
+ private IApolloManager _apolloManager = null;
+
+ private IBroardcast _broadcast = null;
+
+ private ILuaEngine _lua_engine = null;
+
+ private IXPandoraMgr _pandoraManager = null;
+
+ private IXGameSirControl _SirControl = null;
+
+ private IXVideo _video = null;
+
+ private IPlatform _platform = null;
+
+ private BuildTarget _runtime_platform = BuildTarget.Unknown;
+
+ private string _platform_name = "";
+
+ private string _version = "0.0.0";
+
+ private string _target_version = "0.0.0";
+
+ private bool _need_check_file = false;
+
+ private bool _need_play_cg = true;
+
+ private XFetchVersionNetwork _fetch_version_network = null;
+
+ private float _fetch_version_time = 0f;
+
+ private ulong _update_pakcage_size = 0UL;
+
+ private XVersionData _server = null;
+
+ private XVersionData _client = null;
+
+ private XVersionData _buildin = null;
+
+ private IResourceHelp _resourcehelp = null;
+
+ private XBundleData _bundle_data = null;
+
+ private eUPdatePhase _phase = eUPdatePhase.xUP_None;
+
+ private List<XBundleData> _download_bundle = new List<XBundleData>();
+
+ private List<XBundleData> _cacheload_bundle = new List<XBundleData>();
+
+ private List<XMetaResPackage> _meta_bundle = new List<XMetaResPackage>();
+
+ private Dictionary<uint, UnityEngine.Object> _persist_assets = new Dictionary<uint, UnityEngine.Object>();
+
+ private Dictionary<uint, byte[]> _persist_image = new Dictionary<uint, byte[]>();
+
+ private Dictionary<uint, XBundleData> _assets = new Dictionary<uint, XBundleData>();
+
+ private Dictionary<uint, XResPackage> _res_list = new Dictionary<uint, XResPackage>();
+
+ private Dictionary<uint, AssetBundle> _bundles = new Dictionary<uint, AssetBundle>();
+
+ public AssetBundleManager ABManager;
+
+ private bool _is_download_update_pic = false;
+
+ public override bool Init()
+ {
+ this._main_threadId = Thread.CurrentThread.ManagedThreadId;
+ this._bEditorMode = ((int)Application.platform == 7 || (int)Application.platform == 0 || (int)Application.platform == 2);
+ this.Reboot = false;
+ XUpdater.XGameRoot = GameObject.Find("XGamePoint");
+ this.GetLaunchMode();
+ RuntimePlatform platform = Application.platform;
+ if ((int)platform != 8)
+ {
+ if ((int)platform != 11)
+ {
+ this._runtime_platform = BuildTarget.Standalone;
+ this._platform_name = (this.PatchPrefix() ?? "");
+ }
+ else
+ {
+ this._runtime_platform = BuildTarget.Android;
+ this._platform_name = this.PatchPrefix() + "Android/";
+ }
+ }
+ else
+ {
+ this._runtime_platform = BuildTarget.IOS;
+ this._platform_name = this.PatchPrefix() + "IOS/";
+ }
+ this._version_getter = XUpdater.XGameRoot.AddComponent<XVersion>();
+ this._bundle_getter = XUpdater.XGameRoot.AddComponent<XBundle>();
+ this._filelog_getter = XUpdater.XGameRoot.AddComponent<XFileLog>();
+ this._fmod_listenter = (GameObject.Find("Main Camera").GetComponent("FMOD_Listener") as IFMOD_Listener);
+ this._tssSdk = (XUpdater.XGameRoot.GetComponent("TssSDKManager") as ITssSdk);
+ this._apolloManager = (XUpdater.XGameRoot.GetComponent("ApolloManager") as IApolloManager);
+ this._broadcast = (XUpdater.XGameRoot.GetComponent("BroadcastManager") as IBroardcast);
+ this._platform = (XUpdater.XGameRoot.GetComponent("XPlatform") as IPlatform);
+ this._video = (XUpdater.XGameRoot.GetComponent("XVideoMgr") as IXVideo);
+ this._lua_engine = (XUpdater.XGameRoot.GetComponent("LuaEngine") as ILuaEngine);
+ this._pandoraManager = (XUpdater.XGameRoot.GetComponent("XPandoraMgr") as IXPandoraMgr);
+ this._SirControl = (XUpdater.XGameRoot.GetComponent("XGameSirControl") as IXGameSirControl);
+ bool flag = this._SirControl != null;
+ if (flag)
+ {
+ this._SirControl.Init();
+ }
+ this.ABManager = XUpdater.XGameRoot.AddComponent<AssetBundleManager>();
+ this.ABManager.Init();
+ XSingleton<XDebug>.singleton.Init(this._platform, this._filelog_getter);
+ XSingleton<XCaching>.singleton.Init();
+ XSingleton<XLoadingUI>.singleton.Init();
+ XBinaryReader.Init();
+ UnityEngine.Object.DontDestroyOnLoad(XUpdater.XGameRoot);
+ return true;
+ }
+
+ public override void Uninit()
+ {
+ foreach (AssetBundle assetBundle in this._bundles.Values)
+ {
+ assetBundle.Unload(false);
+ }
+ this._assets.Clear();
+ this._persist_assets.Clear();
+ this._bundles.Clear();
+ this._res_list.Clear();
+ bool flag = this._video != null && this._video.isPlaying;
+ if (flag)
+ {
+ this._video.Stop();
+ }
+ this._phase = eUPdatePhase.xUP_Prepare;
+ this._update_done = false;
+ bool flag2 = this._fetch_version_network != null;
+ if (flag2)
+ {
+ this._fetch_version_network.Close();
+ }
+ UnityEngine.Object.Destroy(XUpdater.XGameRoot);
+ }
+
+ public void Clear()
+ {
+ foreach (KeyValuePair<uint, AssetBundle> keyValuePair in this._bundles)
+ {
+ AssetBundle value = keyValuePair.Value;
+ value.Unload(false);
+ }
+ this._bundles.Clear();
+ }
+
+ public void Update()
+ {
+ switch (this._phase)
+ {
+ case eUPdatePhase.xUP_Prepare:
+ {
+ bool flag = this.Preparing();
+ if (flag)
+ {
+ this._phase = eUPdatePhase.xUP_FetchVersion;
+ }
+ else
+ {
+ XSingleton<XLoadingUI>.singleton.SetStatus(XSingleton<XStringTable>.singleton.GetString("XUPDATE_ERROR_FETCHLOCALVERSIONERROR"), byte.MaxValue, byte.MaxValue, byte.MaxValue);
+ this.OnError();
+ }
+ break;
+ }
+ case eUPdatePhase.xUP_FetchVersion:
+ {
+ bool flag2 = !this._bFetchVersion;
+ if (flag2)
+ {
+ bool flag3 = this._fetch_version_network == null;
+ if (flag3)
+ {
+ this._fetch_version_network = new XFetchVersionNetwork();
+ }
+ XSingleton<XLoadingUI>.singleton.SetStatus(XSingleton<XStringTable>.singleton.GetString("XUPDATE_INFO_FETCHVERSION"), byte.MaxValue, byte.MaxValue, byte.MaxValue);
+ this._fetch_version_network.Init();
+ string host = XSingleton<XCaching>.singleton.VersionServer.Substring(0, XSingleton<XCaching>.singleton.VersionServer.LastIndexOf(':'));
+ string s = XSingleton<XCaching>.singleton.VersionServer.Substring(XSingleton<XCaching>.singleton.VersionServer.LastIndexOf(':') + 1);
+ bool flag4 = this._fetch_version_network.Connect(host, int.Parse(s));
+ if (flag4)
+ {
+ this._bFetchVersion = true;
+ this._fetch_version_time = Time.time;
+ }
+ else
+ {
+ XSingleton<XLoadingUI>.singleton.SetStatus(XSingleton<XStringTable>.singleton.GetString("XUPDATE_ERROR_FETCHVERSIONERROR"), byte.MaxValue, byte.MaxValue, byte.MaxValue);
+ XSingleton<XUpdater>.singleton.OnError();
+ this._fetch_version_network.Close();
+ }
+ }
+ else
+ {
+ bool flag5 = Time.time - this._fetch_version_time > 5f;
+ if (flag5)
+ {
+ XSingleton<XLoadingUI>.singleton.SetStatus(XSingleton<XStringTable>.singleton.GetString("XUPDATE_ERROR_FETCHVERSIONERROR"), byte.MaxValue, byte.MaxValue, byte.MaxValue);
+ XSingleton<XUpdater>.singleton.OnError();
+ this._fetch_version_network.Close();
+ }
+ }
+ break;
+ }
+ case eUPdatePhase.xUP_LoadVersion:
+ {
+ bool flag6 = !this._bFetchServer;
+ if (flag6)
+ {
+ this._cacheload_bundle.Clear();
+ this._download_bundle.Clear();
+ this._meta_bundle.Clear();
+ this._version_getter.ServerDownload(new HandleVersionDownload(this.OnVersionDownloaded), new HandleVersionLoaded(this.OnVersionLoaded));
+ }
+ this._bFetchServer = true;
+ break;
+ }
+ case eUPdatePhase.xUP_CompareVersion:
+ {
+ bool flag7 = this._comparer == null;
+ if (flag7)
+ {
+ this._comparer = this.VersionComparer();
+ }
+ else
+ {
+ bool flag8 = !this._comparer.MoveNext();
+ if (flag8)
+ {
+ this._comparer = null;
+ }
+ }
+ break;
+ }
+ case eUPdatePhase.xUP_DownLoadBundle:
+ {
+ bool flag9 = this._downloader == null;
+ if (flag9)
+ {
+ this._downloader = this.DownLoadBundles();
+ }
+ else
+ {
+ bool flag10 = !this._downloader.MoveNext();
+ if (flag10)
+ {
+ this._downloader = null;
+ this._phase = eUPdatePhase.xUP_ShowVersion;
+ }
+ }
+ break;
+ }
+ case eUPdatePhase.xUP_ShowVersion:
+ this.ShowVersionInfo(this._server, true);
+ break;
+ case eUPdatePhase.xUP_LaunchGame:
+ {
+ bool flag11 = this._launcher == null;
+ if (flag11)
+ {
+ this._launcher = this.LaunchGame();
+ }
+ else
+ {
+ bool flag12 = !this._launcher.MoveNext();
+ if (flag12)
+ {
+ this._launcher = null;
+ this.OnEnding();
+ }
+ }
+ break;
+ }
+ case eUPdatePhase.xUP_Finish:
+ {
+ bool flag13 = this._finish == null;
+ if (flag13)
+ {
+ this._finish = this.Finish();
+ }
+ else
+ {
+ bool flag14 = !this._finish.MoveNext();
+ if (flag14)
+ {
+ this._finish = null;
+ this._update_done = true;
+ XSingleton<XShell>.singleton.StartGame();
+ }
+ }
+ break;
+ }
+ }
+ XSingleton<XLoadingUI>.singleton.OnUpdate();
+ }
+
+ public void Begin()
+ {
+ this._update_done = false;
+ this._bFetchVersion = false;
+ this._bFetchServer = false;
+ bool flag = !XSingleton<XStringTable>.singleton.SyncInit();
+ if (flag)
+ {
+ this._log.Remove(0, this._log.Length);
+ this._log.Append("Error occurred when loading string table.");
+ XSingleton<XLoadingUI>.singleton.SetStatus(this._log.ToString(), byte.MaxValue, byte.MaxValue, byte.MaxValue);
+ XSingleton<XUpdater>.singleton.OnError();
+ }
+ else
+ {
+ bool flag2 = !this.CheckMemory();
+ if (flag2)
+ {
+ this._log.Remove(0, this._log.Length);
+ this._log.Append(XSingleton<XStringTable>.singleton.GetString("XUPDATE_INFO_EXCLUDE1GPHONE"));
+ XSingleton<XLoadingUI>.singleton.SetStatus(this._log.ToString(), byte.MaxValue, byte.MaxValue, byte.MaxValue);
+ XSingleton<XUpdater>.singleton.OnError();
+ }
+ else
+ {
+ bool flag3 = XSingleton<XCaching>.singleton.EnableCache();
+ if (flag3)
+ {
+ this._phase = eUPdatePhase.xUP_Prepare;
+ }
+ else
+ {
+ this._log.Remove(0, this._log.Length);
+ this._log.Append(XSingleton<XStringTable>.singleton.GetString("XUPDATE_ERROR_ACCESSDENIED"));
+ XSingleton<XLoadingUI>.singleton.SetStatus(this._log.ToString(), byte.MaxValue, byte.MaxValue, byte.MaxValue);
+ XSingleton<XUpdater>.singleton.OnError();
+ }
+ }
+ }
+ }
+
+ private IEnumerator Finish()
+ {
+ bool flag = this._server != null;
+ if (flag)
+ {
+ this._server.Bundles.Clear();
+ this._version = this._server.ToString();
+ }
+ this._server = null;
+ this._client = null;
+ this._buildin = null;
+ bool flag2 = this._need_play_cg && this._video != null;
+ if (flag2)
+ {
+ this._video.Play(false);
+ yield return null;
+ while (this._video.isPlaying)
+ {
+ yield return null;
+ }
+ }
+ UnityEngine.Object.DestroyObject(this._version_getter);
+ UnityEngine.Object.DestroyObject(this._bundle_getter);
+ yield break;
+ }
+
+ public void OnError()
+ {
+ this._phase = eUPdatePhase.xUP_Error;
+ }
+
+ public void DevStart()
+ {
+ this._phase = eUPdatePhase.xUP_ShowVersion;
+ }
+
+ public void OnRetry()
+ {
+ eUPdatePhase phase = this._phase;
+ if (phase != eUPdatePhase.xUP_DownLoadBundle)
+ {
+ if (phase != eUPdatePhase.xUP_Finish)
+ {
+ if (phase == eUPdatePhase.xUP_Error)
+ {
+ bool flag = this._server == null;
+ if (flag)
+ {
+ this.Begin();
+ }
+ }
+ }
+ else
+ {
+ bool isPlaying = this._video.isPlaying;
+ if (isPlaying)
+ {
+ this._video.Stop();
+ }
+ }
+ }
+ else
+ {
+ bool on_file_download_need_retry = this._on_file_download_need_retry;
+ if (on_file_download_need_retry)
+ {
+ this._on_file_download_retry = true;
+ }
+ }
+ }
+
+ private void OnEnding()
+ {
+ XSingleton<XLoadingUI>.singleton.LoadingOK = true;
+ this._download_bundle.Clear();
+ this._cacheload_bundle.Clear();
+ this._meta_bundle.Clear();
+ this._phase = eUPdatePhase.xUP_Ending;
+ }
+
+ public bool ContainRes(uint hash)
+ {
+ return this._res_list.ContainsKey(hash);
+ }
+
+ public UnityEngine.Object ResourceLoad(uint hash)
+ {
+ UnityEngine.Object result = null;
+ XResPackage xresPackage = null;
+ bool flag = this._res_list != null && this._res_list.TryGetValue(hash, out xresPackage);
+ if (flag)
+ {
+ bool flag2 = !this._persist_assets.TryGetValue(hash, out result);
+ if (flag2)
+ {
+ AssetBundle assetBundle = null;
+ uint key = XSingleton<XCommon>.singleton.XHash(xresPackage.bundle);
+ bool flag3 = !this._bundles.TryGetValue(key, out assetBundle);
+ if (flag3)
+ {
+ byte[] array = null;
+ bool flag4 = !this._persist_image.TryGetValue(key, out array);
+ if (flag4)
+ {
+ XBundleData data = null;
+ bool flag5 = this._assets.TryGetValue(key, out data);
+ if (!flag5)
+ {
+ return null;
+ }
+ array = XSingleton<XCaching>.singleton.LoadFile(XSingleton<XCaching>.singleton.GetLocalPath(data));
+ }
+ assetBundle = AssetBundle.LoadFromMemory(array);
+ this._bundles.Add(key, assetBundle);
+ }
+ string text = xresPackage.location.Substring(xresPackage.location.LastIndexOf('/') + 1);
+ result = assetBundle.LoadAsset(text, XUpdater.Ass.GetType(xresPackage.type));
+ }
+ }
+ return result;
+ }
+
+ private AsyncVersionProcessRequest OnVersionDownloaded(TextAsset text)
+ {
+ AsyncVersionProcessRequest avpr = new AsyncVersionProcessRequest();
+ XSingleton<XLoadingUI>.singleton.SetStatus(XSingleton<XStringTable>.singleton.GetString("XUPDATE_INFO_FETCHMANIFEST"), byte.MaxValue, byte.MaxValue, byte.MaxValue);
+ bool flag = text != null;
+ if (flag)
+ {
+ byte[] contents = text.bytes;
+ //!
+ new Thread((ThreadStart)delegate
+ {
+ avpr.IsCorrect = this.LoadVersion(contents);
+ avpr.IsDone = true;
+ }).Start();
+ }
+ else
+ {
+ avpr.IsDone = true;
+ avpr.IsCorrect = false;
+ }
+ return avpr;
+ }
+
+ private void OnVersionLoaded(bool correct)
+ {
+ if (correct)
+ {
+ this._phase = eUPdatePhase.xUP_CompareVersion;
+ }
+ else
+ {
+ this._log.Remove(0, this._log.Length);
+ this._log.Append(XSingleton<XStringTable>.singleton.GetString("XUPDATE_ERROR_MANIFESTERROR"));
+ XSingleton<XLoadingUI>.singleton.SetStatus(this._log.ToString(), byte.MaxValue, byte.MaxValue, byte.MaxValue);
+ XSingleton<XUpdater>.singleton.OnError();
+ }
+ }
+
+ private void OnBundleFetched(WWW www, byte[] bytes, XBundleData data, bool newdownload)
+ {
+ if (newdownload)
+ {
+ XSingleton<XDebug>.singleton.AddLog("Finished Download ", data.Name, null, null, null, null, XDebugColor.XDebug_None);
+ this._log.Remove(0, this._log.Length);
+ this._log.AppendFormat(XSingleton<XStringTable>.singleton.GetString("XUPDATE_INFO_DOWNLOAD_FILE_COMPLETE"), data.Name);
+ XSingleton<XLoadingUI>.singleton.SetStatus(this._log.ToString(), byte.MaxValue, byte.MaxValue, byte.MaxValue);
+ }
+ else
+ {
+ XSingleton<XDebug>.singleton.AddLog("Finished Extract ", data.Name, null, null, null, null, XDebugColor.XDebug_None);
+ this._log.Remove(0, this._log.Length);
+ this._log.AppendFormat(XSingleton<XStringTable>.singleton.GetString("XUPDATE_INFO_EXTRACTING_COMPLETE"), data.Name);
+ XSingleton<XLoadingUI>.singleton.SetStatus(this._log.ToString(), byte.MaxValue, byte.MaxValue, byte.MaxValue);
+ }
+ uint key = XSingleton<XCommon>.singleton.XHash(data.Name);
+ bool load = false;
+ this._bundle_data = data;
+ switch (this._bundle_data.Level)
+ {
+ case AssetLevel.Memory:
+ load = true;
+ break;
+ case AssetLevel.Image:
+ {
+ byte[] array = new byte[bytes.Length];
+ bytes.CopyTo(array, 0);
+ this._persist_image.Add(key, array);
+ break;
+ }
+ }
+ this._assets.Add(key, this._bundle_data);
+ this._bundle_getter.GetBundle(www, bytes, new HandleLoadBundle(this.OnBundleLoaded), load);
+ }
+
+ private void OnBundleLoaded(AssetBundle bundle)
+ {
+ bool flag = bundle != null;
+ if (flag)
+ {
+ this._bundles.Add(XSingleton<XCommon>.singleton.XHash(this._bundle_data.Name), bundle);
+ }
+ this._bundle_fetching = false;
+ }
+
+ private void OnAssetLoaded(XResPackage package, UnityEngine.Object asset)
+ {
+ uint key = XSingleton<XCommon>.singleton.XHash(package.location);
+ bool flag = asset != null;
+ if (flag)
+ {
+ bool flag2 = !this._persist_assets.ContainsKey(key);
+ if (flag2)
+ {
+ this._persist_assets.Add(key, asset);
+ }
+ else
+ {
+ this._persist_assets[key] = asset;
+ }
+ }
+ this._asset_loading = false;
+ }
+
+ private void UpdateLocalVersion(Stream s)
+ {
+ this._buildin = this.FetchBuildIn(s);
+ this._client = this.FetchBuildOut();
+ bool flag = this._buildin != null;
+ if (flag)
+ {
+ XSingleton<XDebug>.singleton.AddLog("BuildIn version: ", this._buildin.ToString(), null, null, null, null, XDebugColor.XDebug_None);
+ }
+ bool flag2 = this._client != null;
+ if (flag2)
+ {
+ XSingleton<XDebug>.singleton.AddLog("BuildOut version: ", this._client.ToString(), null, null, null, null, XDebugColor.XDebug_None);
+ }
+ this._need_play_cg = (this._client == null);
+ bool flag3 = this._client == null;
+ if (flag3)
+ {
+ this._client = new XVersionData(this._buildin);
+ bool flag4 = !XSingleton<XCaching>.singleton.CleanCache();
+ if (flag4)
+ {
+ this._log.Remove(0, this._log.Length);
+ this._log.Append(XSingleton<XStringTable>.singleton.GetString("XUPDATE_ERROR_DELETEDENIED"));
+ XSingleton<XLoadingUI>.singleton.SetStatus(this._log.ToString(), byte.MaxValue, byte.MaxValue, byte.MaxValue);
+ XSingleton<XUpdater>.singleton.OnError();
+ }
+ }
+ else
+ {
+ int num = this._client.CompareTo(this._buildin);
+ bool flag5 = num < 0 || this._buildin.Build_Version != this._client.Build_Version;
+ if (flag5)
+ {
+ this._need_play_cg = true;
+ this._client.VersionCopy(this._buildin);
+ bool flag6 = !XSingleton<XCaching>.singleton.CleanCache();
+ if (flag6)
+ {
+ this._log.Remove(0, this._log.Length);
+ this._log.Append(XSingleton<XStringTable>.singleton.GetString("XUPDATE_ERROR_DELETEDENIED"));
+ XSingleton<XLoadingUI>.singleton.SetStatus(this._log.ToString(), byte.MaxValue, byte.MaxValue, byte.MaxValue);
+ XSingleton<XUpdater>.singleton.OnError();
+ }
+ }
+ }
+ XSingleton<XDebug>.singleton.AddLog("Client version: ", this._client.ToString(), null, null, null, null, XDebugColor.XDebug_None);
+ }
+
+ private XVersionData FetchBuildIn(Stream s)
+ {
+ bool flag = s == null;
+ XVersionData result;
+ if (flag)
+ {
+ result = null;
+ }
+ else
+ {
+ StreamReader streamReader = new StreamReader(s);
+ string version = streamReader.ReadToEnd();
+ result = XVersionData.Convert2Version(version);
+ }
+ return result;
+ }
+
+ private XVersionData FetchBuildOut()
+ {
+ string localVersion = XVersion.GetLocalVersion();
+ XSingleton<XDebug>.singleton.AddLog("Local Version Path " + localVersion, null, null, null, null, null, XDebugColor.XDebug_None);
+ XVersionData result = null;
+ bool flag = File.Exists(localVersion);
+ if (flag)
+ {
+ byte[] buffer = this.XCryptography(File.ReadAllBytes(localVersion));
+ using (MemoryStream memoryStream = new MemoryStream(buffer))
+ {
+ XmlSerializer xmlSerializer = new XmlSerializer(typeof(XVersionData));
+ try
+ {
+ result = (xmlSerializer.Deserialize(memoryStream) as XVersionData);
+ }
+ catch (Exception ex)
+ {
+ result = null;
+ XSingleton<XDebug>.singleton.AddLog("Build Out Version Fetching FAILED! " + ex.Message, null, null, null, null, null, XDebugColor.XDebug_None);
+ }
+ finally
+ {
+ memoryStream.Close();
+ }
+ }
+ }
+ else
+ {
+ XSingleton<XDebug>.singleton.AddLog("Local Version Path " + localVersion + " not exists.", null, null, null, null, null, XDebugColor.XDebug_None);
+ }
+ return result;
+ }
+
+ private bool LoadVersion(byte[] text)
+ {
+ string a = BitConverter.ToString(text, 0, XUpdater.Md5Length);
+ string b = XSingleton<XCaching>.singleton.CalculateMD5(text, XUpdater.Md5Length, text.Length - XUpdater.Md5Length);
+ bool flag = a == b;
+ if (flag)
+ {
+ using (MemoryStream memoryStream = new MemoryStream(text, XUpdater.Md5Length, text.Length - XUpdater.Md5Length))
+ {
+ XmlSerializer xmlSerializer = new XmlSerializer(typeof(XVersionData));
+ this._server = (xmlSerializer.Deserialize(memoryStream) as XVersionData);
+ bool flag2 = this._server != null && this._server.Target_Platform == this._runtime_platform;
+ if (flag2)
+ {
+ XSingleton<XDebug>.singleton.AddLog("Server version: ", this._server.ToString(), null, null, null, null, XDebugColor.XDebug_None);
+ return true;
+ }
+ }
+ }
+ XSingleton<XDebug>.singleton.AddLog("Analysis Server version error!", null, null, null, null, null, XDebugColor.XDebug_None);
+ this._server = null;
+ return false;
+ }
+
+ private bool CheckMemory()
+ {
+ return true;
+ }
+
+ private bool Preparing()
+ {
+ Stream stream = null;
+ XSingleton<XDebug>.singleton.AddLog("Fetch local version...", null, null, null, null, null, XDebugColor.XDebug_None);
+ bool flag = (int)Application.platform == 8;
+ if (flag)
+ {
+ stream = XSingleton<XResourceLoaderMgr>.singleton.ReadText("ios-version", ".bytes", false);
+ }
+ else
+ {
+ bool flag2 = (int)Application.platform == 11;
+ if (flag2)
+ {
+ stream = XSingleton<XResourceLoaderMgr>.singleton.ReadText("android-version", ".bytes", false);
+ }
+ }
+ bool flag3 = stream != null;
+ bool result;
+ if (flag3)
+ {
+ this.UpdateLocalVersion(stream);
+ XSingleton<XResourceLoaderMgr>.singleton.ClearStream(stream);
+ result = true;
+ }
+ else
+ {
+ result = (XUpdater.LaunchMode == XLaunchMode.Dev);
+ }
+ return result;
+ }
+
+ private IEnumerator VersionComparer()
+ {
+ int compare = this._client.CompareTo(this._server);
+ this._update_pakcage_size = 0UL;
+ bool flag = compare > 0;
+ if (flag)
+ {
+ this._server = this._client;
+ this._download_prepare = null;
+ this.DownLoadConfirmed(false);
+ }
+ else
+ {
+ bool flag2 = compare == 0 || (compare < 0 && this._client.CanUpdated(this._server));
+ if (flag2)
+ {
+ bool flag3 = this._download_prepare == null;
+ if (flag3)
+ {
+ this._download_prepare = this.DownLoadPrepare();
+ }
+ while (this._download_prepare.MoveNext())
+ {
+ yield return null;
+ }
+ this._download_prepare = null;
+ this.DownLoadConfirmed(compare != 0);
+ }
+ else
+ {
+ XSingleton<XLoadingUI>.singleton.SetStatus(XSingleton<XStringTable>.singleton.GetString("XUPDATE_ERROR_VERSIONNOTMATCH"), byte.MaxValue, byte.MaxValue, byte.MaxValue);
+ this.ShowVersionInfo(this._client, false);
+ Texture tex = null;
+ bool flag4 = !this._is_download_update_pic;
+ if (flag4)
+ {
+ WWW www = new WWW("https://image.lzgjx.qq.com/sharingicon/updateimg.jpg");
+ while (!www.isDone)
+ {
+ yield return null;
+ }
+ bool flag5 = string.IsNullOrEmpty(www.error);
+ if (flag5)
+ {
+ tex = www.texture;
+ }
+ www.Dispose();
+ this._is_download_update_pic = true;
+ www = null;
+ }
+ this._phase = eUPdatePhase.xUP_Error;
+ XSingleton<XLoadingUI>.singleton.SetDownLoad(new XLoadingUI.OnSureCallBack(this.ToAppStore), tex);
+ tex = null;
+ }
+ }
+ yield break;
+ }
+
+ private void ToAppStore()
+ {
+ RuntimePlatform platform = Application.platform;
+ if ((int)platform != 8)
+ {
+ if ((int)platform == 11)
+ {
+ for (int i = 0; i < this._client.Res.Count; i++)
+ {
+ bool flag = this._client.Res[i].location == "Table/StringTable";
+ if (flag)
+ {
+ XBundleData specificBundle = this._client.GetSpecificBundle(this._client.Res[i].bundle);
+ string localPath = XSingleton<XCaching>.singleton.GetLocalPath(specificBundle);
+ try
+ {
+ byte[] array = File.ReadAllBytes(localPath);
+ bool flag2 = array != null;
+ if (flag2)
+ {
+ AssetBundle assetBundle = AssetBundle.LoadFromMemory(array);
+ bool flag3 = assetBundle != null;
+ if (flag3)
+ {
+ TextAsset textAsset = assetBundle.LoadAsset("StringTable", typeof(TextAsset)) as TextAsset;
+ bool flag4 = textAsset != null;
+ if (flag4)
+ {
+ bool flag5 = !XSingleton<XStringTable>.singleton.ReInit(textAsset);
+ if (flag5)
+ {
+ XSingleton<XStringTable>.singleton.SyncInit();
+ }
+ }
+ }
+ }
+ }
+ catch (Exception ex)
+ {
+ XSingleton<XDebug>.singleton.AddErrorLog("ToAndroidAppStore: ", ex.Message, null, null, null, null);
+ }
+ break;
+ }
+ }
+ string @string = XSingleton<XStringTable>.singleton.GetString("XUPDATE_ERROR_VERSIONNOTMATCH_ANDROID_URL");
+ XSingleton<XDebug>.singleton.AddLog("AndroidAppStore Url: ", @string, null, null, null, null, XDebugColor.XDebug_None);
+ Application.OpenURL(@string);
+ }
+ }
+ else
+ {
+ for (int j = 0; j < this._client.Res.Count; j++)
+ {
+ bool flag6 = this._client.Res[j].location == "Table/StringTable";
+ if (flag6)
+ {
+ XBundleData specificBundle2 = this._client.GetSpecificBundle(this._client.Res[j].bundle);
+ string localPath2 = XSingleton<XCaching>.singleton.GetLocalPath(specificBundle2);
+ try
+ {
+ byte[] array2 = File.ReadAllBytes(localPath2);
+ bool flag7 = array2 != null;
+ if (flag7)
+ {
+ AssetBundle assetBundle2 = AssetBundle.LoadFromMemory(array2);
+ bool flag8 = assetBundle2 != null;
+ if (flag8)
+ {
+ TextAsset textAsset2 = assetBundle2.LoadAsset("StringTable", typeof(TextAsset)) as TextAsset;
+ bool flag9 = textAsset2 != null;
+ if (flag9)
+ {
+ bool flag10 = !XSingleton<XStringTable>.singleton.ReInit(textAsset2);
+ if (flag10)
+ {
+ XSingleton<XStringTable>.singleton.SyncInit();
+ }
+ }
+ }
+ }
+ }
+ catch (Exception ex2)
+ {
+ XSingleton<XDebug>.singleton.AddErrorLog("ToAppStore: ", ex2.Message, null, null, null, null);
+ }
+ break;
+ }
+ }
+ string string2 = XSingleton<XStringTable>.singleton.GetString("XUPDATE_ERROR_VERSIONNOTMATCH_URL");
+ XSingleton<XDebug>.singleton.AddLog("AppStore Url: ", string2, null, null, null, null, XDebugColor.XDebug_None);
+ Application.OpenURL(string2);
+ }
+ }
+
+ private void DownLoadConfirmedCallBack()
+ {
+ this._phase = eUPdatePhase.xUP_DownLoadBundle;
+ }
+
+ private void DownLoadCancelledCallBack()
+ {
+ this._phase = eUPdatePhase.xUP_Error;
+ XSingleton<XLoadingUI>.singleton.SetStatus("", byte.MaxValue, byte.MaxValue, byte.MaxValue);
+ this.ShowVersionInfo(this._client, false);
+ }
+
+ private void DownLoadConfirmed(bool updated)
+ {
+ if (updated)
+ {
+ bool flag = this._update_pakcage_size < 1048576UL;
+ if (flag)
+ {
+ this.DownLoadConfirmedCallBack();
+ }
+ else
+ {
+ XSingleton<XLoadingUI>.singleton.SetDialog(this._update_pakcage_size, new XLoadingUI.OnSureCallBack(this.DownLoadConfirmedCallBack), new XLoadingUI.OnSureCallBack(this.DownLoadCancelledCallBack));
+ this._phase = eUPdatePhase.xUP_DownLoadConfirm;
+ }
+ }
+ else
+ {
+ this._phase = eUPdatePhase.xUP_DownLoadBundle;
+ }
+ }
+
+ private IEnumerator DownLoadPrepare()
+ {
+ int num;
+ for (int i = 0; i < this._server.Res.Count; i = num + 1)
+ {
+ bool flag = !this._buildin.NeedDownload(this._server.Res[i].bundle);
+ if (!flag)
+ {
+ XBundleData bundle = this._server.GetSpecificBundle(this._server.Res[i].bundle);
+ bool flag2 = bundle == null;
+ if (flag2)
+ {
+ XSingleton<XDebug>.singleton.AddLog("Bundle ", this._server.Res[i].bundle, " is missing in sever bundle set.", null, null, null, XDebugColor.XDebug_None);
+ }
+ else
+ {
+ bool flag3 = this._cacheload_bundle.Contains(bundle);
+ if (!flag3)
+ {
+ bool flag4 = this._download_bundle.Contains(bundle);
+ if (!flag4)
+ {
+ AsyncCachedRequest acr = XSingleton<XCaching>.singleton.IsBundleCached(bundle, this._server.MD5_Size);
+ while (!acr.IsDone)
+ {
+ yield return null;
+ }
+ bool flag5 = !acr.Cached && acr.MaybeCached;
+ if (flag5)
+ {
+ XBundleData clientData = null;
+ foreach (XBundleData data in this._client.Bundles)
+ {
+ bool flag6 = data.Name == bundle.Name;
+ if (flag6)
+ {
+ clientData = data;
+ break;
+ }
+ //data = null;
+ }
+ List<XBundleData>.Enumerator enumerator = default(List<XBundleData>.Enumerator);
+ acr.Cached = (clientData != null && clientData.MD5 == bundle.MD5);
+ clientData = null;
+ }
+ XSingleton<XDebug>.singleton.AddLog("Bundle ", bundle.Name, " cached is ", acr.Cached.ToString(), null, null, XDebugColor.XDebug_None);
+ bool cached = acr.Cached;
+ if (cached)
+ {
+ this._cacheload_bundle.Add(bundle);
+ }
+ else
+ {
+ this._download_bundle.Add(bundle);
+ this._update_pakcage_size += (ulong)bundle.Size;
+ }
+ bundle = null;
+ acr = null;
+ }
+ }
+ }
+ }
+ num = i;
+ }
+ this.MetaPrepare(this._server.AB);
+ this.MetaPrepare(this._server.Scene);
+ this.MetaPrepare(this._server.FMOD);
+ yield break;
+ }
+
+ private void MetaPrepare(List<XMetaResPackage> meta)
+ {
+ bool flag = this._platform != null && !this._platform.IsPublish();
+ for (int i = 0; i < meta.Count; i++)
+ {
+ bool flag2 = !this._buildin.NeedDownload(meta[i].bundle) || !this._client.NeedDownload(meta[i].bundle);
+ if (!flag2)
+ {
+ bool flag3 = !this._meta_bundle.Contains(meta[i]);
+ if (flag3)
+ {
+ this._meta_bundle.Add(meta[i]);
+ }
+ bool flag4 = flag;
+ if (flag4)
+ {
+ XSingleton<XDebug>.singleton.AddLog("Meta ", meta[i].download, " is prepared to downloading...", null, null, null, XDebugColor.XDebug_None);
+ }
+ this._update_pakcage_size += (ulong)meta[i].Size;
+ }
+ }
+ }
+
+ private IEnumerator DownLoadBundles()
+ {
+ bool log = this._platform != null && !this._platform.IsPublish();
+ int total = this._download_bundle.Count + this._cacheload_bundle.Count + this._meta_bundle.Count;
+ int processed = 0;
+ int num;
+ for (int i = 0; i < this._download_bundle.Count; i = num + 1)
+ {
+ while (this._bundle_fetching)
+ {
+ yield return null;
+ }
+ bool flag = log;
+ if (flag)
+ {
+ XSingleton<XDebug>.singleton.AddLog("Updating ", this._download_bundle[i].Name, " ... ", processed.ToString(), "/", total.ToString(), XDebugColor.XDebug_None);
+ }
+ this._bundle_fetching = true;
+ num = processed + 1;
+ processed = num;
+ XSingleton<XCaching>.singleton.Download(this._download_bundle[i], new HandleFetchBundle(this.OnBundleFetched), (float)processed / (float)total);
+ num = i;
+ }
+ for (int j = 0; j < this._cacheload_bundle.Count; j = num + 1)
+ {
+ while (this._bundle_fetching)
+ {
+ yield return null;
+ }
+ bool flag2 = log;
+ if (flag2)
+ {
+ XSingleton<XDebug>.singleton.AddLog("Extracting ", this._cacheload_bundle[j].Name, " ... ", processed.ToString(), "/", total.ToString(), XDebugColor.XDebug_None);
+ }
+ this._bundle_fetching = true;
+ num = processed + 1;
+ processed = num;
+ bool flag3 = (int)Application.platform == 8;
+ if (flag3)
+ {
+ while (!XSingleton<XCaching>.singleton.Extract(this._cacheload_bundle[j], new HandleFetchBundle(this.OnBundleFetched), (float)processed / (float)total))
+ {
+ yield return null;
+ }
+ }
+ else
+ {
+ XSingleton<XCaching>.singleton.Extract(this._cacheload_bundle[j], new HandleFetchBundle(this.OnBundleFetched), (float)processed / (float)total);
+ }
+ num = j;
+ }
+ while (this._bundle_fetching)
+ {
+ yield return null;
+ }
+ for (int k = 0; k < this._meta_bundle.Count; k = num + 1)
+ {
+ num = processed + 1;
+ processed = num;
+ AsyncWriteRequest awr = XSingleton<XCaching>.singleton.Download(this._meta_bundle[k].download, this._meta_bundle[k].Size, (float)processed / (float)total);
+ bool flag4 = log;
+ if (flag4)
+ {
+ XSingleton<XDebug>.singleton.AddLog("Download meta ", this._meta_bundle[k].download, " ... ", processed.ToString(), "/", total.ToString(), XDebugColor.XDebug_None);
+ }
+ while (!awr.IsDone)
+ {
+ bool hasError = awr.HasError;
+ if (hasError)
+ {
+ bool on_file_download_retry = this._on_file_download_retry;
+ if (on_file_download_retry)
+ {
+ this._on_file_download_retry = false;
+ this._on_file_download_need_retry = false;
+ num = k;
+ k = num - 1;
+ num = processed;
+ processed = num - 1;
+ this._log.Length = 0;
+ this._log.Append(XSingleton<XStringTable>.singleton.GetString("XUPDATE_INFO_RETRY"));
+ XSingleton<XLoadingUI>.singleton.SetStatus(this._log.ToString(), byte.MaxValue, byte.MaxValue, byte.MaxValue);
+ yield return null;
+ break;
+ }
+ this._on_file_download_need_retry = true;
+ this._log.Length = 0;
+ this._log.AppendFormat(XSingleton<XStringTable>.singleton.GetString("XUPDATE_ERROR_DOWNLOADRESFAILED_AND_RETRY"), awr.Name);
+ XSingleton<XLoadingUI>.singleton.SetStatus(this._log.ToString(), byte.MaxValue, byte.MaxValue, byte.MaxValue);
+ yield return null;
+ }
+ else
+ {
+ yield return null;
+ }
+ }
+ awr = null;
+ num = k;
+ }
+ for (int l = 0; l < this._server.Res.Count; l = num + 1)
+ {
+ bool flag5 = this.ProcessAssets(this._server.Res[l]);
+ if (flag5)
+ {
+ bool flag6 = this._server.Res[l].rtype != ResourceType.Script;
+ if (flag6)
+ {
+ uint hash = XSingleton<XCommon>.singleton.XHash(this._server.Res[l].location);
+ this._res_list.Add(hash, this._server.Res[l]);
+ }
+ this._log.Remove(0, this._log.Length);
+ this._log.AppendFormat(XSingleton<XStringTable>.singleton.GetString("XUPDATE_INFO_PRELOADING"), ((float)l / (float)this._server.Res.Count * 100f).ToString("F0"));
+ XSingleton<XLoadingUI>.singleton.SetStatus(this._log.ToString(), byte.MaxValue, byte.MaxValue, byte.MaxValue);
+ bool flag7 = l << 30 == 0;
+ if (flag7)
+ {
+ yield return null;
+ }
+ }
+ num = l;
+ }
+ AsyncLogRequest alr = this.LogNewVersion();
+ while (!alr.IsDone)
+ {
+ Thread.Sleep(1);
+ }
+ this.XPlatform.SetNoBackupFlag(XVersion.GetLocalVersion());
+ yield break;
+ }
+
+ private AsyncLogRequest LogNewVersion()
+ {
+ AsyncLogRequest alr = new AsyncLogRequest();
+ bool flag = this._server != this._client;
+ if (flag)
+ {
+ new Thread((ThreadStart)delegate
+ {
+ using (MemoryStream memoryStream = new MemoryStream())
+ {
+ XmlSerializer xmlSerializer = new XmlSerializer(typeof(XVersionData));
+ XmlSerializerNamespaces xmlSerializerNamespaces = new XmlSerializerNamespaces();
+ xmlSerializerNamespaces.Add(string.Empty, string.Empty);
+ xmlSerializer.Serialize(memoryStream, this._server, xmlSerializerNamespaces);
+ File.WriteAllBytes(XVersion.GetLocalVersion(), this.XCryptography(memoryStream.ToArray()));
+ }
+ alr.IsDone = true;
+ }).Start();
+ }
+ else
+ {
+ alr.IsDone = true;
+ }
+ return alr;
+ }
+
+ private void ShowVersionInfo(XVersionData data, bool launch = true)
+ {
+ bool flag = data != null;
+ if (flag)
+ {
+ this._log.Remove(0, this._log.Length);
+ this._log.Append("v").Append(data.ToString());
+ XSingleton<XLoadingUI>.singleton.SetVersion(this._log.ToString());
+ }
+ else
+ {
+ XSingleton<XLoadingUI>.singleton.SetVersion("Dev 0.0.0");
+ }
+ if (launch)
+ {
+ this._phase = eUPdatePhase.xUP_LaunchGame;
+ }
+ }
+
+ private bool ProcessAssets(XResPackage res)
+ {
+ AssetBundle assetBundle = null;
+ bool flag = this._bundles.TryGetValue(XSingleton<XCommon>.singleton.XHash(res.bundle), out assetBundle);
+ bool result;
+ if (flag)
+ {
+ string text = res.location.Substring(res.location.LastIndexOf('/') + 1);
+ ResourceType rtype = res.rtype;
+ if (rtype != ResourceType.Assets)
+ {
+ if (rtype == ResourceType.Script)
+ {
+ TextAsset textAsset = assetBundle.LoadAsset(text, XUpdater.Ass.GetType(res.type)) as TextAsset;
+ this._script = textAsset.bytes;
+ assetBundle.Unload(false);
+ this._bundles.Remove(XSingleton<XCommon>.singleton.XHash(res.bundle));
+ }
+ }
+ else
+ {
+ this.OnAssetLoaded(res, assetBundle.LoadAsset(text, XUpdater.Ass.GetType(res.type)));
+ }
+ result = true;
+ }
+ else
+ {
+ result = false;
+ }
+ return result;
+ }
+
+ private IEnumerator AsyncProcessAssets(XResPackage package, AssetBundle bundle)
+ {
+ string name = package.location.Substring(package.location.LastIndexOf('/') + 1);
+ this._asset_loading = true;
+ this._bundle_getter.GetAsset(bundle, package, new HandleLoadAsset(this.OnAssetLoaded));
+ while (this._asset_loading)
+ {
+ yield return null;
+ }
+ yield break;
+ }
+
+ private IEnumerator LaunchGame()
+ {
+ XSingleton<XLoadingUI>.singleton.SetStatus(XSingleton<XStringTable>.singleton.GetString("XUPDATE_INFO_LOADING"), byte.MaxValue, byte.MaxValue, byte.MaxValue);
+ yield return null;
+ this.ABManager.Init();
+ this.XPlatform.ReloadFMOD();
+ AsyncAssemblyRequest aar = new AsyncAssemblyRequest();
+ ResourceRequest rrq = null;
+ bool flag = (int) Application.platform == 11;
+ if (flag)
+ {
+ string path = Application.persistentDataPath + "/XMainClient.bytes";
+ bool flag2 = File.Exists(path);
+ if (flag2)
+ {
+ this._script = File.ReadAllBytes(path);
+ }
+ bool flag3 = this._script == null && (int)Application.platform == 11;
+ if (flag3)
+ {
+ rrq = Resources.LoadAsync("XMainClient", typeof(TextAsset));
+ yield return rrq;
+ this._script = (rrq.asset as TextAsset).bytes;
+ }
+ path = null;
+ }
+ RuntimePlatform platform = Application.platform;
+ if ((int)platform != 8)
+ {
+ if ((int)platform != 11)
+ {
+ }
+ //!
+ // aar.Main = ((this._script == null) ? Assembly.Load("XMainClient") : Assembly.Load(this._script));
+ }
+ else
+ {
+// aar.Main = Assembly.Load("XMainClient");
+ }
+ // XSingleton<XShell>.singleton.MakeEntrance(aar.Main);
+ XSingleton<XShell>.singleton._MakeEntrance();
+
+ bool flag4 = rrq != null && rrq.asset != null;
+ if (flag4)
+ {
+ Resources.UnloadAsset(rrq.asset);
+ }
+ this._script = null;
+ this._log.Remove(0, this._log.Length);
+ this._log.Append(XSingleton<XStringTable>.singleton.GetString("XUPDATE_INFO_LAUNCHING"));
+ XSingleton<XLoadingUI>.singleton.SetStatus(this._log.ToString(), byte.MaxValue, byte.MaxValue, byte.MaxValue);
+ yield return null;
+ XSingleton<XShell>.singleton.PreLaunch();
+ while (!XSingleton<XShell>.singleton.Launched())
+ {
+ yield return null;
+ XSingleton<XShell>.singleton.Launch();
+ }
+ this.XLuaEngine.InitLua();
+ yield break;
+ }
+
+ private byte[] XCryptography(byte[] bs)
+ {
+ for (int i = 0; i < bs.Length; i++)
+ {
+ bs[i] ^= 154;
+ }
+ return bs;
+ }
+
+ private string PatchPrefix()
+ {
+ XLaunchMode launchMode = XUpdater.LaunchMode;
+ string result;
+ if (launchMode != XLaunchMode.Live)
+ {
+ if (launchMode != XLaunchMode.PreProduct)
+ {
+ if (launchMode != XLaunchMode.Dev)
+ {
+ result = "Patch/Live/";
+ }
+ else
+ {
+ result = "Patch/Dev/";
+ }
+ }
+ else
+ {
+ result = "Patch/PreProduct/";
+ }
+ }
+ else
+ {
+ result = "Patch/Live/";
+ }
+ return result;
+ }
+
+ private void GetLaunchMode()
+ {
+ XUpdater._launch_mode = XLaunchMode.Dev;
+ }
+
+ public void PlayCG(object o = null)
+ {
+ this._video.Play(false);
+ }
+
+ public void SetServerVersion(string data)
+ {
+ string b = "";
+ bool flag = this._buildin != null;
+ if (flag)
+ {
+ b = this._buildin.Build_Version.ToString();
+ }
+ string[] array = data.Split(new char[]
+ {
+ '|'
+ });
+ RuntimePlatform platform = Application.platform;
+ if ((int)platform != 8)
+ {
+ if ((int)platform == 11)
+ {
+ this._target_version = array[1];
+ try
+ {
+ bool flag2 = array.Length > 4;
+ if (flag2)
+ {
+ string[] array2 = array[4].Split(new char[]
+ {
+ ':'
+ });
+ for (int i = 0; i < array2.Length; i++)
+ {
+ string[] array3 = array2[i].Split(new char[]
+ {
+ '.'
+ });
+ bool flag3 = array3.Length > 1 && array3[1] == b;
+ if (flag3)
+ {
+ this._target_version = array2[i];
+ }
+ }
+ }
+ }
+ catch (Exception ex)
+ {
+ XSingleton<XDebug>.singleton.AddErrorLog("GetServer ExData Error!!! " + ex.Message, null, null, null, null, null);
+ }
+ }
+ }
+ else
+ {
+ this._target_version = array[0];
+ try
+ {
+ bool flag4 = array.Length > 3;
+ if (flag4)
+ {
+ string[] array4 = array[3].Split(new char[]
+ {
+ ':'
+ });
+ for (int j = 0; j < array4.Length; j++)
+ {
+ string[] array5 = array4[j].Split(new char[]
+ {
+ '.'
+ });
+ bool flag5 = array5.Length > 1 && array5[1] == b;
+ if (flag5)
+ {
+ this._target_version = array4[j];
+ }
+ }
+ }
+ }
+ catch (Exception ex2)
+ {
+ XSingleton<XDebug>.singleton.AddErrorLog("GetServer ExData Error!!! " + ex2.Message, null, null, null, null, null);
+ }
+ }
+ try
+ {
+ bool flag6 = array.Length > 2;
+ if (flag6)
+ {
+ this._need_check_file = (array[2] == "1");
+ }
+ }
+ catch (Exception ex3)
+ {
+ XSingleton<XDebug>.singleton.AddErrorLog("GetServer CheckFile Flag Error!!! " + ex3.Message, null, null, null, null, null);
+ }
+ XSingleton<XDebug>.singleton.AddGreenLog(data, null, null, null, null, null);
+ this._fetch_version_network.Close();
+ this._phase = eUPdatePhase.xUP_LoadVersion;
+ }
+ }
+}
|