com.xd.sdk.common 0.0.1 → 0.0.10-alpha

package/Runtime/Internal/Standalone/Agreement/AgreementModule.cs

@@ -0,0 +1,326 @@
+#if UNITY_EDITOR || UNITY_STANDALONE
+using System;
+using System.IO;
+using System.Threading.Tasks;
+using System.Collections.Generic;
+using System.Threading;
+using Newtonsoft.Json;
+using UnityEngine;
+
+
+namespace XD.SDK.Common.Internal.Standalone
+{
+    public enum SignType
+    {
+        NEW, // 首次签署
+        RENEW, // 续签
+        NO, // 不需要签署
+    }
+
+    public class AgreementModule
+    {
+        private const string FetchAgreementApiPath = "api/init/v2/agreement";
+        private const string SignAgreementApiPath = "api/account/v1/agreement/confirm";
+
+        private const string AgreementFileNameCn = "Agreement_local_cn";
+        private const string AgreementFileNameKr = "Agreement_local_kr";
+        private const string AgreementFileNameDefault = "Agreement_local_df";
+
+        private static readonly Persistence LatestAgreementPersistence = new Persistence(Path.Combine(
+            Application.persistentDataPath,
+            XDGConstants.XD_PERSISTENCE_NAME,
+            "latest_agreement"));
+
+        private static readonly Persistence LocalSignedAgreementPersistence = new Persistence(Path.Combine(
+            Application.persistentDataPath,
+            XDGConstants.XD_PERSISTENCE_NAME,
+            "agreement"));
+
+        /// <summary>
+        /// 线上最新协议
+        /// </summary>
+        private static Agreement _latestAgreement;
+
+        /// <summary>
+        /// 当前签署协议
+        /// </summary>
+        private static Agreement _currentSignedAgreement;
+
+        /// <summary>
+        /// 当前签署协议是否有效
+        /// </summary>
+        public static bool SignedAgreementValid { get; private set; }
+
+        public static bool DisableAgreement { get; set; }
+
+        public static Agreement currentAgreement()
+        {
+            return _latestAgreement;
+        }
+
+        public static async Task ConfirmAgreement()
+        {
+            if (DisableAgreement)
+            {
+                return;
+            }
+
+            SignedAgreementValid = false;
+
+            try
+            {
+                // 获取服务端最新数据
+                var cts = new CancellationTokenSource();
+                cts.CancelAfter(TimeSpan.FromSeconds(3));
+                var response =
+                    await XDHttpClient.Client.GetAsync<AgreementResponse>(FetchAgreementApiPath, cancellationToken: cts.Token);
+                _latestAgreement = response.Agreement;
+                // 服务端数据保存到本地
+                await LatestAgreementPersistence.Save(_latestAgreement);
+            }
+            catch (Exception e)
+            {
+                XDGLogger.Warn($"拉取最新协议失败 {e}");
+            }
+
+            if (_latestAgreement == null
+                || string.IsNullOrEmpty(_latestAgreement.Title)
+                || string.IsNullOrEmpty(_latestAgreement.TitleFirst))
+            {
+                XDGLogger.Warn("fetch agreement failed, try to get cache. ");
+                // 服务端拉取失败，读取本地缓存
+                _latestAgreement = await LatestAgreementPersistence.Load<Agreement>();
+            }
+
+            if (_latestAgreement == null
+                || string.IsNullOrEmpty(_latestAgreement.Title)
+                || string.IsNullOrEmpty(_latestAgreement.TitleFirst))
+            {
+                XDGLogger.Warn("get cache failed, try to get local. ");
+                _latestAgreement = await LoadLocalConfig();
+            }
+
+            var tuple = await GetNeedSignAgreement();
+            var signType = tuple.Item1;
+            var needSignAgreement = tuple.Item2;
+
+            if (signType == SignType.NO)
+            {
+                // 不需要签署
+                SignedAgreementValid = true;
+                return;
+            }
+
+            // 需要签署协议
+            var tcs = new TaskCompletionSource<bool>();
+            var newSign = signType != SignType.RENEW;
+            var data = new Dictionary<string, object>
+            {
+                { "firstCheck", newSign },
+                { "agreement", needSignAgreement }
+            };
+            UIManager.ShowUI<GeneralAgreementAlert>("GeneralAgreementAlert", data,
+                (code, result) =>
+                {
+                    var trackInfo = AliyunTrack.AgreementMapExtra2TrackInfo(result as Dictionary<string, object>);
+                    if (code == 0)
+                    {
+                        SignedAgreementValid = true;
+                        _currentSignedAgreement = needSignAgreement;
+                        _currentSignedAgreement.Extra = result as Dictionary<string, object>;
+                        UIManager.DismissAll();
+                        tcs.TrySetResult(true);
+                        AliyunTrack.AgreementSign(trackInfo);
+                    }
+                    else
+                    {
+                        SignedAgreementValid = false;
+                        Application.Quit();
+                        tcs.TrySetException(new Exception("Disagree"));
+                    }
+                });
+
+            var countryType = AliyunTrack.AgreementCountryType.Default;
+            if (needSignAgreement.Region.Equals("KR", StringComparison.OrdinalIgnoreCase))
+            {
+                countryType = AliyunTrack.AgreementCountryType.Korea;
+            }
+            else if (needSignAgreement.Region.Equals("US", StringComparison.OrdinalIgnoreCase))
+            {
+                countryType = AliyunTrack.AgreementCountryType.US;
+            }
+
+            AliyunTrack.AgreementAsk(countryType, needSignAgreement.Region,
+                needSignAgreement.Version);
+            await tcs.Task;
+        }
+
+        private static async Task<Agreement> LoadLocalConfig()
+        {
+            if (!ConfigModule.IsGlobal)
+            {
+                return GetAgreement(AgreementFileNameCn, XDLocalization.GetLanguageKey(LangType.ZH_CN));
+            }
+
+            var currentRegion = "DF";
+            // 指定了地区就用该地区
+            if (!string.IsNullOrEmpty(ConfigModule.TargetCountryOrRegion))
+            {
+                currentRegion = ConfigModule.TargetCountryOrRegion.ToUpper();
+            }
+            else
+            {
+                // 没有指定则尝试从 ip 中获取地区
+                var ipInfo = await IPInfoModule.GetIpInfo();
+                if (ipInfo != null)
+                {
+                    currentRegion = ipInfo.CountryCode.ToUpper();
+                }
+            }
+
+            // 非 US 和 KR 都还原到 DF
+            if (!currentRegion.Equals("US", StringComparison.OrdinalIgnoreCase) && !currentRegion.Equals("KR", StringComparison.OrdinalIgnoreCase))
+            {
+                currentRegion = "DF";
+            }
+
+            XDGLogger.Warn("get local config : " + currentRegion);
+
+            if (currentRegion.Equals("KR", StringComparison.OrdinalIgnoreCase))
+            {
+                return GetAgreement(AgreementFileNameKr, XDLocalization.GetLanguageKey(LangType.KR));
+            }
+
+            var currentLang = XDLocalization.GetLanguageKey();
+            // todo 海外缺少越南翻译，降级为英文
+            if (currentLang.Equals(XDLocalization.GetLanguageKey(LangType.VI)))
+            {
+                currentLang = XDLocalization.GetLanguageKey(LangType.EN);
+            }
+
+            var tempAgreement = GetAgreement(AgreementFileNameDefault, currentLang);
+            // 从 df 文件中加载后非美国时去除勾选
+            if (tempAgreement != null && !currentRegion.Equals("US", StringComparison.OrdinalIgnoreCase))
+            {
+                tempAgreement.Region = currentRegion;
+                tempAgreement.Options = null;
+            }
+
+            return tempAgreement;
+        }
+
+        private static Agreement GetAgreement(string jsonFileName, string language)
+        {
+            var txtAsset = Resources.Load("Localization/" + jsonFileName) as TextAsset;
+            if (txtAsset == null) return null;
+            var localizableStrings = JsonConvert.DeserializeObject<Dictionary<string, Agreement>>(txtAsset.text);
+            return localizableStrings?[language];
+        }
+
+        private static async Task<Tuple<SignType, Agreement>> GetNeedSignAgreement()
+        {
+            if (_latestAgreement == null)
+            {
+                return new Tuple<SignType, Agreement>(SignType.NO, null);
+            }
+
+            var local = await LocalSignedAgreementPersistence.Load<LocalSignedAgreements>();
+            if (local == null ||
+                !local.AgreementVersions.TryGetValue(_latestAgreement.Region, out string localVersion) ||
+                string.IsNullOrEmpty(localVersion))
+            {
+                // 如果本地没有签署缓存或没有地区对应签署缓存，则需要签署
+                return new Tuple<SignType, Agreement>(SignType.NEW, _latestAgreement);
+            }
+
+            if (string.IsNullOrEmpty(_latestAgreement.Version))
+            {
+                // 当本地签署过，但没有本地缓存，并且拉取也失败
+                return new Tuple<SignType, Agreement>(SignType.RENEW, _latestAgreement);
+            }
+
+            // 比较版本号大小
+            var localVer = new Version(localVersion);
+            var latestVer = new Version(_latestAgreement.Version);
+            if (localVer < latestVer)
+            {
+                return new Tuple<SignType, Agreement>(SignType.RENEW, _latestAgreement);
+            }
+
+            return new Tuple<SignType, Agreement>(SignType.NO, null);
+        }
+
+        /// <summary>
+        /// 签署协议
+        /// </summary>
+        /// <param name="userId">用户 xdid</param>
+        /// <returns></returns>
+        public static async Task SignAgreement(string userId)
+        {
+            if (DisableAgreement)
+            {
+                return;
+            }
+
+            if (_currentSignedAgreement == null)
+            {
+                return;
+            }
+
+            string region = _currentSignedAgreement.Region;
+            string version = _currentSignedAgreement.Version;
+            Dictionary<string, object> data = new Dictionary<string, object>()
+            {
+                { "clientId", ConfigModule.ClientId },
+                { "deviceCode", SystemInfo.deviceUniqueIdentifier },
+                { "agreementRegion", region },
+                { "userId", userId }
+            };
+            if (!string.IsNullOrEmpty(version))
+            {
+                data["agreementVersion"] = version;
+            }
+
+            if (_currentSignedAgreement.Extra != null)
+            {
+                data["extra"] = _currentSignedAgreement.Extra;
+            }
+
+            AgreementConfirmResponse response =
+                await XDHttpClient.Client.PostAsync<AgreementConfirmResponse>(SignAgreementApiPath, data: data);
+            if (!response.Confirm.IsSuccess)
+            {
+                return;
+            }
+
+            var localSignedAgreements =
+                await LocalSignedAgreementPersistence.Load<LocalSignedAgreements>();
+            if (localSignedAgreements == null)
+            {
+                localSignedAgreements = new LocalSignedAgreements();
+            }
+
+            if (localSignedAgreements.AgreementVersions == null)
+            {
+                localSignedAgreements.AgreementVersions = new Dictionary<string, string>();
+            }
+
+            localSignedAgreements.AgreementVersions[region] = response.Confirm.Version;
+            // 持久化
+            await LocalSignedAgreementPersistence.Save(localSignedAgreements);
+
+            _currentSignedAgreement = null;
+        }
+
+        public static void ClearLocalSignedAgreements()
+        {
+            var agreementPath = Path.Combine(Application.persistentDataPath, XDGConstants.XD_PERSISTENCE_NAME,
+                "agreement");
+            if (File.Exists(agreementPath))
+            {
+                File.Delete(agreementPath);
+            }
+        }
+    }
+}
+#endif

package/Runtime/Internal/Standalone/Agreement/AgreementModule.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 28cac1bd1cab4f919b0e9abc9b83231c
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Internal/Standalone/Agreement/LocalSignedAgreements.cs

@@ -0,0 +1,11 @@
+#if UNITY_EDITOR || UNITY_STANDALONE
+using System.Collections.Generic;
+using Newtonsoft.Json;
+
+namespace XD.SDK.Common.Internal.Standalone {
+    public class LocalSignedAgreements {
+        [JsonProperty("agreementVersions")]
+        public Dictionary<string, string> AgreementVersions { get; set; }
+    }
+}
+#endif

package/Runtime/Internal/Standalone/Agreement/LocalSignedAgreements.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 1fafd4d4790f46199b5ca455ab8cacfd
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Internal/Standalone/Agreement.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 7202ed34758e4fc19be9e69aa6327045
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Internal/Standalone/Bind.cs

@@ -0,0 +1,28 @@
+#if UNITY_EDITOR || UNITY_STANDALONE
+using Newtonsoft.Json;
+
+namespace XD.SDK.Common {
+    public class Bind {
+        [JsonProperty("loginType")]
+        public int LoginType { get; set; }
+
+        [JsonProperty("loginName")]
+        public string LoginName { get; set; }
+
+        [JsonProperty("nickName")]
+        public string NickName { get; set; }
+
+        [JsonProperty("avatar")]
+        public string Avatar { get; set; }
+
+        [JsonProperty("bindDate")]
+        public string BindDate { get; set; }
+
+        [JsonProperty("status")]
+        public int Status { get; set; }
+
+        [JsonProperty("openId")]
+        public string OpenId { get; set; }
+    }
+}
+#endif

package/Runtime/Internal/Standalone/Bind.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: d6aeafb632dc4481ad3c8a22b6c5c02b
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Internal/Standalone/BindType.cs

@@ -0,0 +1,9 @@
+#if UNITY_EDITOR || UNITY_STANDALONE
+namespace XD.SDK.Common.Internal.Standalone {
+    public enum BindType {
+        None = -1,
+        Bind = 0,   //绑定
+        UnBind = 1  //未绑定
+    }
+}
+#endif

package/Runtime/Internal/Standalone/BindType.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 367aee88b24d482b98f1427d0129ba47
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Internal/Standalone/Captcha/XDGCaptcha.cs

@@ -0,0 +1,86 @@
+#if UNITY_EDITOR || UNITY_STANDALONE
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEngine;
+
+namespace XD.SDK.Common.Internal.Standalone
+{
+    public class XDGCaptcha
+    {
+        public static void ValidateWithCaptcha(string scene, Dictionary<string, string> additionalQuery,
+            Action<string, XDGError> callback)
+        {
+            if (XDGCommonInternal.IsCn())
+            {
+                callback?.Invoke(null,
+                    new XDGError(ResponseCode.Common.UnavailableService,
+                        "Captcha service is not available in current region. "));
+                return;
+            }
+
+            string host = AuthConstants.GLOBAL_AUTH_HOST;
+            string path = "/captcha";
+            Dictionary<string, string> query = new Dictionary<string, string>()
+            {
+                {"scene", scene},
+                {"clientId", ConfigModule.ClientId},
+                {"platform", XDUtility.GetPlatform()},
+                {"deviceId", SystemInfo.deviceUniqueIdentifier},
+                {"os", SystemInfo.operatingSystem},
+                {"app_version", Application.version},
+                {"language", Application.systemLanguage.ToString()},
+                {"sdkLang", XDLocalization.GetLanguageKey()},
+            };
+            if (additionalQuery != null)
+            {
+                foreach (var pair in additionalQuery)
+                {
+                    query.Add(pair.Key, pair.Value);
+                }
+            }
+
+            string url = host + path + "?" + string.Join("&",
+                query.Select(kvp => $"{Uri.EscapeDataString(kvp.Key)}={Uri.EscapeDataString(kvp.Value)}"));
+
+            UIManager.ShowUI<XDWebViewAlert>("XDWebViewAlert", new Dictionary<string, object>
+            {
+                {"url", url},
+                {"fullScreen", true},
+                {"showBackButton", false},
+                {"showBackground", false}
+            }, (code, data) =>
+            {
+                switch (code)
+                {
+                    case XDWebViewAlert.CLOSE_CODE:
+                        UIManager.Dismiss();
+                        callback?.Invoke(null, XDGErrorExtensions.CancelledError());
+                        break;
+                    case XDWebViewAlert.WEB_CALLBACK:
+                    {
+                        Dictionary<string, object> jsonObj = data as Dictionary<string, object>;
+                        string actionName = jsonObj?["name"] as string;
+                        if (actionName == "action_captchaSuccess")
+                        {
+                            string token = jsonObj?["data"] as string;
+                            if (token?.Length > 0)
+                            {
+                                callback?.Invoke(token, null);
+                                UIManager.Dismiss();
+                                return;
+                            }
+
+                            UIManager.Dismiss();
+                            callback?.Invoke(null,
+                                new XDGError(ResponseCode.Common.Failed,
+                                    "JS callback, get data field as string failed."));
+                        }
+                    }
+                        break;
+                }
+            });
+        }
+    }
+}
+#endif

package/Runtime/Internal/Standalone/Captcha/XDGCaptcha.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 1ec34dcb033c410c9a3e6f296fcfe6a5
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Internal/Standalone/Captcha.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: c7934a90158f4fceb74f9523675061b2
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Internal/Standalone/Common/LocalServiceUtils.cs

@@ -0,0 +1,37 @@
+#if UNITY_EDITOR || UNITY_STANDALONE
+using System;
+using System.Net;
+using System.Net.Sockets;
+using System.Security.Cryptography;
+
+namespace XD.SDK.Common.Internal.Standalone {
+    public class LocalServerUtils {
+        public static int GetRandomUnusedPort() {
+            var listener = new TcpListener(IPAddress.Loopback, 0);
+            listener.Start();
+            var port = ((IPEndPoint)listener.LocalEndpoint).Port;
+            listener.Stop();
+            return port;
+        }
+
+        public static string GenerateRandomDataBase64url(uint length) {
+            RNGCryptoServiceProvider rng = new RNGCryptoServiceProvider();
+            byte[] bytes = new byte[length];
+            rng.GetBytes(bytes);
+            return Base64UrlEncodeNoPadding(bytes);
+        }
+
+        private static string Base64UrlEncodeNoPadding(byte[] buffer) {
+            string base64 = Convert.ToBase64String(buffer);
+
+            // Converts base64 to base64url.
+            base64 = base64.Replace("+", "-");
+            base64 = base64.Replace("/", "_");
+            // Strips padding.
+            base64 = base64.Replace("=", "");
+
+            return base64;
+        }
+    }
+}
+#endif

package/Runtime/Internal/Standalone/Common/LocalServiceUtils.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 6cb594ac835f45248cf0c1f3972ceff9
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Runtime/Internal/Standalone/Common/User32.cs

@@ -0,0 +1,92 @@
+#if UNITY_STANDALONE_WIN
+
+using System;
+using System.Runtime.InteropServices;
+using UnityEngine;
+
+namespace XD.SDK.Common.Internal.Standalone {
+    public class User32 {
+        private const int SW_SHOWNORMAL = 1;
+
+        private delegate bool EnumThreadDelegate(IntPtr hwnd, IntPtr lParam);
+
+        [DllImport("user32.dll")]
+        private static extern bool EnumThreadWindows(int dwThreadId, EnumThreadDelegate lpfn, IntPtr lParam);
+
+        private static IntPtr GetWindowHandle()
+        {
+            IntPtr returnHwnd = IntPtr.Zero;
+            var threadId = GetCurrentThreadId();
+            Debug.Log("Current thread id: " + threadId);
+            EnumThreadWindows(threadId,
+                (hWnd, lParam) =>
+                {
+                    if (returnHwnd == IntPtr.Zero)
+                        returnHwnd = hWnd;
+                    return true;
+                }, IntPtr.Zero);
+            return returnHwnd;
+        }
+
+        [DllImport("User32.dll")]
+        private static extern bool ShowWindowAsync(IntPtr hWnd, int cmdShow);
+        [DllImport("User32.dll")]
+        private static extern bool SetForegroundWindow(IntPtr hWnd);
+
+        [DllImport("user32.dll")]
+        private static extern bool SetWindowPos(IntPtr hWnd, int hWndlnsertAfter, int X, int Y, int cx, int cy, uint Flags);
+        [DllImport("user32.dll", EntryPoint = "SystemParametersInfo")]
+        public static extern int SystemParametersInfo(int uAction, int uParam, IntPtr lpvParam, int fuWinIni);
+        [DllImport("User32.dll", SetLastError = true)]
+        public static extern int GetForegroundWindow();
+        [DllImport("User32.dll", CharSet = CharSet.Auto)]
+        public static extern int GetWindowThreadProcessId(IntPtr hwnd, out int ID);
+        [DllImport("User32.dll", SetLastError = true)]
+        static extern void SwitchToThisWindow(IntPtr hWnd, bool fAltTab);
+        [DllImport("user32.dll")]
+        private static extern bool ShowWindow(IntPtr hWnd, int nCmdShow);
+        [DllImport("user32.dll")]
+        private static extern int AttachThreadInput(int CurrentForegroundThread, int MakeThisThreadForegrouond, bool boolAttach);
+
+        [DllImport("kernel32.dll", ExactSpelling = true, CharSet = CharSet.Auto)]
+        public static extern int GetCurrentThreadId();
+        [DllImport("user32", CharSet = CharSet.Auto)]
+        static extern bool SystemParametersInfo(int uiAction, int uiParam, ref int pvParam, int fWinIni);
+        [DllImport("user32", CharSet = CharSet.Auto)]
+        static extern bool LockSetForegroundWindow(int a);
+
+        [DllImport("user32", CharSet = CharSet.Auto)]
+        static extern bool AllowSetForegroundWindow(int a);
+
+        internal static void ForceWindowIntoForeground()
+        {
+            IntPtr window = GetWindowHandle();
+            int currentThread = GetCurrentThreadId();
+            int activeWindow = GetForegroundWindow();
+            int activeThread = GetWindowThreadProcessId((IntPtr)activeWindow, out int activeProcess);
+            int windowThread = GetWindowThreadProcessId(window, out int windowProcess);
+            if (currentThread != activeThread)
+                AttachThreadInput(currentThread, activeThread, true);
+            if (windowThread != currentThread)
+                AttachThreadInput(windowThread, currentThread, true);
+
+            int oldTimeout = 0, newTimeout = 0;
+            SystemParametersInfo(0x2000, 0, ref oldTimeout, 0);
+            SystemParametersInfo(0x2000, 0, ref newTimeout, 0);
+            LockSetForegroundWindow(2);
+            AllowSetForegroundWindow(-1);
+
+            SetForegroundWindow(window);
+            ShowWindow(window, SW_SHOWNORMAL);
+
+            SystemParametersInfo(0x2000, 0, ref oldTimeout, 0);
+
+            if (currentThread != activeThread)
+                AttachThreadInput(currentThread, activeThread, false);
+            if (windowThread != currentThread)
+                AttachThreadInput(windowThread, currentThread, false);
+        }
+    }
+}
+
+#endif