diff --git a/Assets/Plugins/SmartX1App.dll.meta b/Assets/Plugins/SmartX1App.dll.meta
index 3a084c6..d258105 100644
--- a/Assets/Plugins/SmartX1App.dll.meta
+++ b/Assets/Plugins/SmartX1App.dll.meta
@@ -1,27 +1,88 @@
 fileFormatVersion: 2
 guid: 0da92b84a3197f54681e93a2576be223
-timeCreated: 1551513530
-licenseType: Pro
 PluginImporter:
+  externalObjects: {}
   serializedVersion: 2
   iconMap: {}
   executionOrder: {}
+  defineConstraints: []
   isPreloaded: 0
   isOverridable: 0
+  isExplicitlyReferenced: 0
+  validateReferences: 1
   platformData:
-    data:
-      first:
-        Any: 
-      second:
-        enabled: 1
-        settings: {}
-    data:
-      first:
-        Editor: Editor
-      second:
-        enabled: 0
-        settings:
-          DefaultValueInitialized: true
+  - first:
+      '': Any
+    second:
+      enabled: 0
+      settings:
+        Exclude Editor: 1
+        Exclude Linux: 0
+        Exclude Linux64: 0
+        Exclude LinuxUniversal: 0
+        Exclude OSXUniversal: 0
+        Exclude Win: 0
+        Exclude Win64: 0
+  - first:
+      Any: 
+    second:
+      enabled: 1
+      settings: {}
+  - first:
+      Editor: Editor
+    second:
+      enabled: 0
+      settings:
+        CPU: AnyCPU
+        DefaultValueInitialized: true
+        OS: AnyOS
+  - first:
+      Facebook: Win
+    second:
+      enabled: 0
+      settings:
+        CPU: AnyCPU
+  - first:
+      Facebook: Win64
+    second:
+      enabled: 0
+      settings:
+        CPU: AnyCPU
+  - first:
+      Standalone: Linux
+    second:
+      enabled: 1
+      settings:
+        CPU: x86
+  - first:
+      Standalone: Linux64
+    second:
+      enabled: 1
+      settings:
+        CPU: x86_64
+  - first:
+      Standalone: LinuxUniversal
+    second:
+      enabled: 1
+      settings: {}
+  - first:
+      Standalone: OSXUniversal
+    second:
+      enabled: 1
+      settings:
+        CPU: AnyCPU
+  - first:
+      Standalone: Win
+    second:
+      enabled: 1
+      settings:
+        CPU: AnyCPU
+  - first:
+      Standalone: Win64
+    second:
+      enabled: 1
+      settings:
+        CPU: AnyCPU
   userData: 
   assetBundleName: 
   assetBundleVariant: 
diff --git a/Assets/Plugins/SmartX1AppX64.dll b/Assets/Plugins/SmartX1AppX64.dll
new file mode 100644
index 0000000..a276833
Binary files /dev/null and b/Assets/Plugins/SmartX1AppX64.dll differ
diff --git a/Assets/Plugins/SmartX1AppX64.dll.meta b/Assets/Plugins/SmartX1AppX64.dll.meta
new file mode 100644
index 0000000..1bdc6e2
--- /dev/null
+++ b/Assets/Plugins/SmartX1AppX64.dll.meta
@@ -0,0 +1,27 @@
+fileFormatVersion: 2
+guid: 0a982d274fd319c429332954ac197479
+PluginImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  iconMap: {}
+  executionOrder: {}
+  defineConstraints: []
+  isPreloaded: 0
+  isOverridable: 0
+  isExplicitlyReferenced: 0
+  validateReferences: 1
+  platformData:
+  - first:
+      Any: 
+    second:
+      enabled: 1
+      settings: {}
+  - first:
+      Editor: Editor
+    second:
+      enabled: 0
+      settings:
+        DefaultValueInitialized: true
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Scene/Dummy.unity b/Assets/Scene/Dummy.unity
index 9eb8942..b40a407 100644
Binary files a/Assets/Scene/Dummy.unity and b/Assets/Scene/Dummy.unity differ
diff --git a/Assets/Scripts/HelpScripts/QuitApplicationManager.cs b/Assets/Scripts/HelpScripts/QuitApplicationManager.cs
index 88be72e..ad4fba8 100644
--- a/Assets/Scripts/HelpScripts/QuitApplicationManager.cs
+++ b/Assets/Scripts/HelpScripts/QuitApplicationManager.cs
@@ -37,7 +37,7 @@ public class QuitApplicationManager : MonoSingleton<QuitApplicationManager> {
         process.GetMode("assets", ref smart, ref unique, ref validity);
         if(smart)
         {
-            SmartController.Instance.Init();
+           // SmartController.Instance.Init();
         }
         else if(validity)
         {
diff --git a/Assets/Scripts/HelpScripts/QuitApplicationManager.cs.meta b/Assets/Scripts/HelpScripts/QuitApplicationManager.cs.meta
index a034322..fe590d0 100644
--- a/Assets/Scripts/HelpScripts/QuitApplicationManager.cs.meta
+++ b/Assets/Scripts/HelpScripts/QuitApplicationManager.cs.meta
@@ -1,8 +1,7 @@
 fileFormatVersion: 2
 guid: db723300d2c5b00469e43ea91e7cd35f
-timeCreated: 1551517212
-licenseType: Pro
 MonoImporter:
+  externalObjects: {}
   serializedVersion: 2
   defaultReferences: []
   executionOrder: 0
diff --git a/Assets/Scripts/SmartX1/ApplicationClose.cs b/Assets/Scripts/SmartX1/ApplicationClose.cs
new file mode 100644
index 0000000..e1fa344
--- /dev/null
+++ b/Assets/Scripts/SmartX1/ApplicationClose.cs
@@ -0,0 +1,73 @@
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using UnityEngine;
+using UnityEngine.Events;
+
+/// <summary>
+/// 程序关闭提示处理
+/// </summary>
+public class ApplicationClose : MonoBehaviour
+{
+    private bool isSure = false;//是否点击确定（退出）按钮
+    public string SignOutApi = "/api/Account/SignOut";
+
+    public bool isSmartX1Exit = false;//是否是检测到没有加密狗而自动退出程序
+
+    private void Awake()
+    {
+        DontDestroyOnLoad(this);
+    }
+
+    //private void OnApplicationQuit()
+    //{
+    //    if (!isSmartX1Exit)
+    //    {
+    //        if (!isSure)
+    //        {
+    //            Application.CancelQuit();
+
+    //            MessageBox.Show("确定退出程序？",
+    //                Sure,
+    //                null
+    //                );
+    //        }
+    //    }
+    //}
+
+    //private void Sure()
+    //{
+    //    if (!string.IsNullOrEmpty(WebRequestManager.Instance.userName))
+    //    {
+    //        WebRequestManager.Instance.PostJson(WebRequestManager.Instance.httpUrl + SignOutApi, SignOuted, SignOutError);
+    //    }
+    //    else
+    //    {
+    //        isSure = true;
+    //        Application.Quit();
+    //    }
+    //}
+
+    private void SignOuted()
+    {
+        isSure = true;
+        Application.Quit();
+    }
+
+    private void SignOutError(int errorCode, string errorMsg)
+    {
+        //MessageBox.Show($"退出程序错误：{errorCode},{errorMsg}", 20);
+    }
+
+    // Start is called before the first frame update
+    void Start()
+    {
+        
+    }
+
+    // Update is called once per frame
+    void Update()
+    {
+        
+    }
+}
diff --git a/Assets/Scripts/SmartX1/ApplicationClose.cs.meta b/Assets/Scripts/SmartX1/ApplicationClose.cs.meta
new file mode 100644
index 0000000..d6c0ec7
--- /dev/null
+++ b/Assets/Scripts/SmartX1/ApplicationClose.cs.meta
@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 037aa7f639e77b14e8c0fe047fcb62e5
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Scripts/SmartX1/SmartApp.cs.meta b/Assets/Scripts/SmartX1/SmartApp.cs.meta
index e77dd21..d40454b 100644
--- a/Assets/Scripts/SmartX1/SmartApp.cs.meta
+++ b/Assets/Scripts/SmartX1/SmartApp.cs.meta
@@ -1,8 +1,7 @@
 fileFormatVersion: 2
-guid: ea8506719ccdade4e9996886ab543d10
-timeCreated: 1515718375
-licenseType: Pro
+guid: 1f37c58fbc18d614fb830dd6caea7b71
 MonoImporter:
+  externalObjects: {}
   serializedVersion: 2
   defaultReferences: []
   executionOrder: 0
diff --git a/Assets/Scripts/SmartX1/SmartController.cs b/Assets/Scripts/SmartX1/SmartController.cs
index f2e77a4..3c09fe9 100644
--- a/Assets/Scripts/SmartX1/SmartController.cs
+++ b/Assets/Scripts/SmartX1/SmartController.cs
@@ -1,57 +1,68 @@
-using AX.DevelopEngine;
-using SmartX1Demo;
+using UnityEngine;
 using System;
-using System.Collections;
+using System.Xml;
 using System.IO;
+using System.Text;
 using System.Security.Cryptography;
 using System.Security.Cryptography.Xml;
-using System.Text;
-using System.Xml;
-using UnityEngine;
-using AX.MessageSystem;
-using AX.Timer;
+using System.Collections;
+using SmartX1Demo;
 
-public class SmartController : MonoSingleton<SmartController> {
+public class SmartController : MonoBehaviour 
+{
     int[] keyHandles = new int[8];
     int[] keyNumber = new int[8];
     private int Rtn = 0;
     SmartApp smart = new SmartApp();
-    private Timer timer1_quit, timer2_checkExist;
-    string appid = "";
+    private bool IsQuit = false;
+    private DateTime t1, t2, t11;
+    string appid = "AXKC";
 
-    private uint uP1 = 0x987F6BCD, uP2 = 0xE193C5B2, uP3 = 0xD507CC28, uP4 = 0x4B125AF6;
+    // Use this for initialization
+    void Start () {
+        t2 = DateTime.Now;
+        t1 = DateTime.Now;
+        DontDestroyOnLoad(GameObject.Find("SmartX1"));
+        tipStyle = new GUIStyle();
+        tipStyle.fontSize = 40;
+        tipStyle.normal.textColor = Color.red;
 
-    public void Init()
-    {
-        StartInit();
-    }
-	// Use this for initialization
-	void StartInit () {
-        timer1_quit = new Timer(5.0f);
-        timer1_quit.AddTimeOutEvent(() => 
-        {
-            //Debug.Log("程序退出！");
-            QuitApplicationManager.Instance.SureQuit();
-        });
+        original_filepath = Application.streamingAssetsPath + @"/xml/SmartXProject.xml";
+        encode_filepath = Application.streamingAssetsPath + @"/xml/enSmartXProject.xml";
+        decode_filepath = Application.streamingAssetsPath + @"/xml/deSmartXProject.xml";
 
-        string original_filepath = Application.dataPath + @"/xml/SmartXProject.xml";
-        //string encode_filepath = Application.dataPath + @"/xml/enSmartXProject.xml";
-        //string decode_filepath = Application.dataPath + @"/xml/deSmartXProject.xml";
+        ControlXML();
 
-        XmlProcess xmlProcess = new XmlProcess(original_filepath);
-        xmlProcess.SmartControlXML(ref appid);
-        if (string.IsNullOrEmpty(appid))
-        {
-            QuitApplication();
-            return;
-        }
         //检测加密狗是否存在
         FindSmartX1();
+	}
+    
+    public string GetAppID(string filepath)
+    {
+        if (File.Exists(filepath))
+        {
+            XmlDocument xmlDoc = new XmlDocument();
+            xmlDoc.Load(filepath);
+            XmlNode root = xmlDoc.SelectSingleNode("SmartX1");
+            XmlNodeList nodeList = root.ChildNodes;
+            foreach (XmlElement elem in nodeList)
+            {
+                if (elem.Name == "BaseInfo")
+                {
+                    foreach (XmlElement zq in elem.ChildNodes)
+                    {
+                        if (zq.Name == "AppID")
+                        {
+                            return zq.InnerText;
+                        }
+                    }
+                }
 
-        timer2_checkExist = new Timer(10.0f);
-        timer2_checkExist.AddTimeOutEvent(CheckExist);
-        timer2_checkExist.StartTimerRepeat();
+            }
+        }
+        return "";
     }
+
     bool FindSmartX1()
     {
         try
@@ -59,8 +70,10 @@ public class SmartController : MonoSingleton<SmartController> {
             Rtn = smart.SmartX1Find(appid, keyHandles, keyNumber);
             if (Rtn != 0)
             {
-                Debug.Log("SmartX1Find Error,ErrorCode =" + Rtn.ToString());
-                QuitApplication();
+                IsQuit = true;
+                t1 = DateTime.Now;
+                t2 = DateTime.Now;
+                t11 = DateTime.Now;
                 return false;
             }
             Debug.Log("SmartX1Find Successfully");
@@ -70,62 +83,203 @@ public class SmartController : MonoSingleton<SmartController> {
         {
             Debug.Log(keyHandles[0]);
             Debug.Log("异常" + ex.Message);
-            QuitApplication();
+            GameObject.Find("Application").GetComponent<ApplicationClose>().isSmartX1Exit = true;
+            Application.Quit();
             return false;
         }
     }
 
-    private void QuitApplication()
+    bool CheckExist()
+    {
+        try
+        {
+            Rtn = smart.SmartX1CheckExist(keyHandles[0]);
+            if (Rtn != 0)
+            {
+                //Debug.Log("SmartX1 not exist!" + Rtn.ToString());
+                IsQuit = true;
+                t1 = DateTime.Now;
+                t2 = DateTime.Now;
+                t11 = DateTime.Now;
+                return false;
+            }
+            //Debug.Log("SmartX1Exist!");
+            return true;
+        }
+        catch (Exception ex)
+        {
+            //Debug.Log(keyHandles[0]);
+            //Debug.Log("异常" + ex.Message);
+            GameObject.Find("Application").GetComponent<ApplicationClose>().isSmartX1Exit = true;
+            Application.Quit();
+            return false;
+        }
+    }
+
+    private GUIStyle tipStyle;
+    private int timer = 5;
+    void OnGUI()
+    {
+        if (IsQuit)
+        {
+            t2 = DateTime.Now;
+            if(t2-t11>new TimeSpan(0,0,1))
+            {
+                if(timer>0)
+                    timer--;
+                t11 = t2;
+            }
+            GUI.Label(new Rect(Screen.width / 2 - 150, Screen.height / 2 - 75, 300, 150), "密钥验证失败，程序将在"+timer+"秒后退出！", tipStyle);            
+            
+            if (t2 - t1 > new TimeSpan(0, 0, 5))
+            {
+                //Debug.Log("程序退出！");
+                GameObject.Find("Application").GetComponent<ApplicationClose>().isSmartX1Exit = true;
+                Application.Quit();
+            }
+        }
+    }
+
+	// Update is called once per frame
+	void Update () {
+        if (IsQuit)
+            return;
+        t2 = DateTime.Now;
+        if (t2 - t1 > new TimeSpan(0, 0, 0, 10, 0))
+        {
+            t1 = t2;
+            CheckExist();
+        }
+	}
+
+    //xml文件加密解密
+    void ControlXML()
     {
-        timer1_quit.StartTimer();
+        if (File.Exists(original_filepath))//证明这次是第一次运行该程序，获取当前配置文件
+        {
+            appid = GetAppID(original_filepath);
+            //StartCoroutine(GenerateEncodeXML());
+            GenerateEncodeXML1();
+        }
+        else
+        {
+            if (File.Exists(encode_filepath))
+            {
+                fileDcryption(encode_filepath);
+                if (File.Exists(decode_filepath))
+                {
+                    appid = GetAppID(decode_filepath);
+                    File.Delete(decode_filepath);
+                }
+            }
+        }
     }
 
-    private void ReadStorage()
+    IEnumerator GenerateEncodeXML()
     {
-        int read_rtn = 0;
-        byte[] pbuffer = new byte[4096];
+        yield return new WaitForSeconds(1.0f);
+        fileEncryption(original_filepath);
+        if (File.Exists(encode_filepath))
+        {
+            File.Delete(original_filepath);
+        }
+    }
 
-        int open_rtn = smart.SmartX1Open(keyHandles[0], (int)uP1, (int)uP2, (int)uP3, (int)uP4);
-        if (open_rtn == 0)//打开成功
+    void GenerateEncodeXML1()
+    {
+        fileEncryption(original_filepath);
+        if (File.Exists(encode_filepath))
         {
-            read_rtn = smart.SmartX1ReadStorage(keyHandles[0], 0, 4096, pbuffer);
-            string data= Encoding.GetEncoding("gb2312").GetString(pbuffer);
-            Debug.Log(data);
+            File.Delete(original_filepath);
         }
     }
 
-    void CheckExist()
+    //加密xml文件
+    private void Encrypt(XmlDocument doc, string ElementName, SymmetricAlgorithm key)
     {
-        try
+        XmlElement elementEncrypt = doc.GetElementsByTagName(ElementName)[0] as XmlElement;
+        EncryptedXml eXml = new EncryptedXml();
+        byte[] encryptElement = eXml.EncryptData(elementEncrypt, key, false);//
+        EncryptedData edElement = new EncryptedData();
+        edElement.Type = EncryptedXml.XmlEncElementUrl;
+        string encryptionMethod = null;
+
+        if (key is TripleDES)
         {
-            Rtn = smart.SmartX1CheckExist(keyHandles[0]);
-            if (Rtn != 0)
+            encryptionMethod = EncryptedXml.XmlEncTripleDESUrl;
+        }
+        else if (key is DES)
+        {
+            encryptionMethod = EncryptedXml.XmlEncDESUrl;
+        }
+
+        if (key is Rijndael)
+        {
+            switch (key.KeySize)
             {
-                Debug.Log("SmartX1 not exist!" + Rtn.ToString());
-                QuitApplication();
-                return;
+                case 128:
+                    encryptionMethod = EncryptedXml.XmlEncAES128Url;
+                    break;
+                case 192:
+                    encryptionMethod = EncryptedXml.XmlEncAES192Url;
+                    break;
+                case 256:
+                    encryptionMethod = EncryptedXml.XmlEncAES256Url;
+                    break;
             }
-            Debug.Log("SmartX1Exist!");
-            return;
         }
-        catch (Exception ex)
+        edElement.EncryptionMethod = new EncryptionMethod(encryptionMethod);
+        edElement.CipherData.CipherValue = encryptElement;
+        EncryptedXml.ReplaceElement(elementEncrypt, edElement, false);
+    }
+
+    //XML文件解密
+    private void Decrypt(XmlDocument doc, SymmetricAlgorithm Alg)
+    {
+        XmlElement encryptedElement = doc.GetElementsByTagName("EncryptedData")[0] as XmlElement;
+        EncryptedData edElement = new EncryptedData();
+        edElement.LoadXml(encryptedElement);
+        EncryptedXml exml = new EncryptedXml();
+        byte[] rgbOutput = exml.DecryptData(edElement, Alg);
+        exml.ReplaceData(encryptedElement, rgbOutput);
+    }
+
+    string original_filepath = "";
+    string encode_filepath = "";
+    string decode_filepath = "";
+
+    //举例，对某个XML文件加密
+    private void fileEncryption(string filename)
+    {
+        RijndaelManaged key = new RijndaelManaged();
+        //设置密钥：key为32位=数字或字母16个=汉子8个
+        byte[] byteKey = Encoding.Unicode.GetBytes("1111111111111111");
+        key.Key = byteKey;
+        XmlDocument xmldoc = new XmlDocument();
+        xmldoc.PreserveWhitespace = true;
+        xmldoc.Load(original_filepath);//想要加密的xml文件
+        Encrypt(xmldoc, "SmartX1", key);//需要加密的节点
+        if (key != null)
         {
-            Debug.Log(keyHandles[0]);
-            Debug.Log("异常" + ex.Message);
-            QuitApplication();
-            return;
+            key.Clear();
         }
+        xmldoc.Save(encode_filepath);//生成加密后的xml文件
     }
-    void OnGUI()
+
+    //举例，对某个xml文件解密
+    private void fileDcryption(string filename)
     {
-        if (timer1_quit.IsTimering)
+        RijndaelManaged key = new RijndaelManaged();
+        byte[] byteKey = Encoding.Unicode.GetBytes("1111111111111111");
+        key.Key = byteKey;
+        XmlDocument xmldoc = new XmlDocument();
+        xmldoc.PreserveWhitespace = true;
+        xmldoc.Load(encode_filepath);//加载要解密的xml文件
+        Decrypt(xmldoc, key);
+        if (key != null)
         {
-            QuitApplicationManager.Instance.SetGuiTip("加密狗验证失败，程序将在 " + timer1_quit.GetRemainingTime() + " 秒后退出！");        
+            key.Clear();
         }
+        xmldoc.Save(decode_filepath);//生成解密后的文件
     }
-	// Update is called once per frame
-	void Update () {
-        timer1_quit.UpdateTimer();
-        timer2_checkExist.UpdateTimer();
-	}
 }
diff --git a/Assets/Scripts/SmartX1/SmartController.cs.meta b/Assets/Scripts/SmartX1/SmartController.cs.meta
index e3a5595..ecd5a00 100644
--- a/Assets/Scripts/SmartX1/SmartController.cs.meta
+++ b/Assets/Scripts/SmartX1/SmartController.cs.meta
@@ -1,8 +1,7 @@
 fileFormatVersion: 2
-guid: b7b3bd4e725af2649a00a7c9d90fa7ea
-timeCreated: 1495250299
-licenseType: Pro
+guid: f77080dba14a37a4abf47c331b296fb0
 MonoImporter:
+  externalObjects: {}
   serializedVersion: 2
   defaultReferences: []
   executionOrder: 0
diff --git a/Assets/Scripts/SmartX1/SmartX1.prefab b/Assets/Scripts/SmartX1/SmartX1.prefab
new file mode 100644
index 0000000..13f614e
--- /dev/null
+++ b/Assets/Scripts/SmartX1/SmartX1.prefab
@@ -0,0 +1,45 @@
+%YAML 1.1
+%TAG !u! tag:unity3d.com,2011:
+--- !u!1 &8989827126564560699
+GameObject:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  serializedVersion: 6
+  m_Component:
+  - component: {fileID: 2279724216670829176}
+  - component: {fileID: 6226444345072152341}
+  m_Layer: 0
+  m_Name: SmartX1
+  m_TagString: Untagged
+  m_Icon: {fileID: 0}
+  m_NavMeshLayer: 0
+  m_StaticEditorFlags: 0
+  m_IsActive: 1
+--- !u!4 &2279724216670829176
+Transform:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 8989827126564560699}
+  m_LocalRotation: {x: 0, y: 0, z: 0, w: 1}
+  m_LocalPosition: {x: 0, y: 0, z: 0}
+  m_LocalScale: {x: 1, y: 1, z: 1}
+  m_Children: []
+  m_Father: {fileID: 0}
+  m_RootOrder: 0
+  m_LocalEulerAnglesHint: {x: 0, y: 0, z: 0}
+--- !u!114 &6226444345072152341
+MonoBehaviour:
+  m_ObjectHideFlags: 0
+  m_CorrespondingSourceObject: {fileID: 0}
+  m_PrefabInstance: {fileID: 0}
+  m_PrefabAsset: {fileID: 0}
+  m_GameObject: {fileID: 8989827126564560699}
+  m_Enabled: 1
+  m_EditorHideFlags: 0
+  m_Script: {fileID: 11500000, guid: f77080dba14a37a4abf47c331b296fb0, type: 3}
+  m_Name: 
+  m_EditorClassIdentifier: 
diff --git a/Assets/Scripts/SmartX1/SmartX1.prefab.meta b/Assets/Scripts/SmartX1/SmartX1.prefab.meta
new file mode 100644
index 0000000..78f51cc
--- /dev/null
+++ b/Assets/Scripts/SmartX1/SmartX1.prefab.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 5b9fb6e0da36afd4aa32e5d0d18f29f9
+PrefabImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/Scripts/SmartX1/SmartX1Api.cs b/Assets/Scripts/SmartX1/SmartX1Api.cs
index b15ab98..030beb9 100644
--- a/Assets/Scripts/SmartX1/SmartX1Api.cs
+++ b/Assets/Scripts/SmartX1/SmartX1Api.cs
@@ -114,78 +114,78 @@ namespace SmartX1Demo
     class SmartX1_X64
     {
         // Find
-        [DllImport("SmartX1App.dll", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)]
+        [DllImport("SmartX1AppX64", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)]
         public static extern int SmartX1Find(string appID, int[] keyHandles, int[] keyNumber);
 
         //open
-        [DllImport("SmartX1App.dll", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)]
+        [DllImport("SmartX1AppX64", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)]
         public static extern int SmartX1Open(int keyHandle, int uPin1, int uPin2, int uPin3, int uPin4);
         //close
 
-        [DllImport("SmartX1App.dll", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)]
+        [DllImport("SmartX1AppX64", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)]
         public static extern int SmartX1Close(int keyHandle);
 
         //checkExist
 
-        [DllImport("SmartX1App.dll", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)]
+        [DllImport("SmartX1AppX64", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)]
         public static extern int SmartX1CheckExist(int keyHandle);
 
         //getUid
-        [DllImport("SmartX1App.dll", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)]
+        [DllImport("SmartX1AppX64", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)]
         public static extern int SmartX1GetUid(int keyHandle, StringBuilder uid);
 
         //ReadStorage
-        [DllImport("SmartX1App.dll", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)]
+        [DllImport("SmartX1AppX64", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)]
         public static extern int SmartX1ReadStorage(int keyHandle, int startAddr, int length, byte[] pBuffer);
 
         //WriteStorage
-        [DllImport("SmartX1App.dll", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)]
+        [DllImport("SmartX1AppX64", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)]
         public static extern int SmartX1WriteStorage(int keyHandle, int startAddr, int length, byte[] pBuffer);
 
         //PageLogin
-        [DllImport("SmartX1App.dll", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)]
+        [DllImport("SmartX1AppX64", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)]
         public static extern int SmartX1PageLogin(int keyHandle, int pageNo, byte[] password, int length);
 
         //PageLogout
-        [DllImport("SmartX1App.dll", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)]
+        [DllImport("SmartX1AppX64", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)]
         public static extern int SmartX1PageLogout(int keyHandle, int pageNo);
 
         //ReadPage
-        [DllImport("SmartX1App.dll", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)]
+        [DllImport("SmartX1AppX64", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)]
         public static extern int SmartX1ReadPage(int keyHandle, int pageNo, int startAddr, ref int length, byte[] pBuffer);
 
         //WritePage
-        [DllImport("SmartX1App.dll", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)]
+        [DllImport("SmartX1AppX64", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)]
         public static extern int SmartX1WritePage(int keyHandle, int pageNo, int startAddr, int length, byte[] pBuffer);
 
         //ReadMem
-        [DllImport("SmartX1App.dll", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)]
+        [DllImport("SmartX1AppX64", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)]
         public static extern int SmartX1ReadMem(int keyHandle, int start, int length, byte[] pBuffer);
 
         //WriteMem
-        [DllImport("SmartX1App.dll", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)]
+        [DllImport("SmartX1AppX64", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)]
         public static extern int SmartX1WriteMem(int keyHandle, int start, int length, byte[] pBuffer);
 
         //encrypt
-        [DllImport("SmartX1App.dll", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)]
+        [DllImport("SmartX1AppX64", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)]
         public static extern int SmartX1TriDesEncrypt(int keyHandle, int buffSize, byte[] pBuffer);
 
         //desDecrypt
-        [DllImport("SmartX1App.dll", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)]
+        [DllImport("SmartX1AppX64", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)]
         public static extern int SmartX1TriDesDecrypt(int keyHandle, int buffSize, byte[] pBuffer);
 
         //led
-        [DllImport("SmartX1App.dll", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)]
+        [DllImport("SmartX1AppX64", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)]
         public static extern int SmartX1Led(int keyHandle, int state);
 
 
-        [DllImport("SmartX1App.dll", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)]
+        [DllImport("SmartX1AppX64", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)]
         public static extern int SmartX1PageGetProperty(int keyHandle, int pageNo, int propId, int[] propValue);
 
-        [DllImport("SmartX1App.dll", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)]
+        [DllImport("SmartX1AppX64", CharSet = CharSet.Ansi, CallingConvention = CallingConvention.StdCall)]
         public static extern int SmartX1GetSoftVersion(int keyHandle, int[] version);
 
-        public static string TridesEncrypt(string data, string key, Encoding encoding)
+        public static  string TridesEncrypt(string data, string key, Encoding encoding)
         {
             TripleDESCryptoServiceProvider des = new TripleDESCryptoServiceProvider();
             des.Key = Encoding.Default.GetBytes(key);
@@ -200,7 +200,7 @@ namespace SmartX1Demo
 
         }
 
-        public static string TridesDecEncrypt(byte[] data, string key, Encoding encoding)
+        public static  string TridesDecEncrypt(byte[] data, string key, Encoding encoding)
         {
             TripleDESCryptoServiceProvider des = new TripleDESCryptoServiceProvider();
             des.Key = Encoding.Default.GetBytes(key);
diff --git a/Assets/Scripts/SmartX1/SmartX1Api.cs.meta b/Assets/Scripts/SmartX1/SmartX1Api.cs.meta
index 64cdfef..ecafac8 100644
--- a/Assets/Scripts/SmartX1/SmartX1Api.cs.meta
+++ b/Assets/Scripts/SmartX1/SmartX1Api.cs.meta
@@ -1,8 +1,7 @@
 fileFormatVersion: 2
-guid: aa527fc755baf7d47ab4c14d9de2a6e8
-timeCreated: 1515718375
-licenseType: Pro
+guid: 30969e5b5d02c2a418f4e239698f27a8
 MonoImporter:
+  externalObjects: {}
   serializedVersion: 2
   defaultReferences: []
   executionOrder: 0
diff --git a/Assets/StreamingAssets/xml/enSmartXProject.xml b/Assets/StreamingAssets/xml/enSmartXProject.xml
new file mode 100644
index 0000000..d259afb
--- /dev/null
+++ b/Assets/StreamingAssets/xml/enSmartXProject.xml
@@ -0,0 +1,2 @@
+<?xml version="1.0" encoding="utf-8"?>
+<EncryptedData Type="http://www.w3.org/2001/04/xmlenc#Element" xmlns="http://www.w3.org/2001/04/xmlenc#"><EncryptionMethod Algorithm="http://www.w3.org/2001/04/xmlenc#aes256-cbc" /><CipherData><CipherValue>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</CipherValue></CipherData></EncryptedData>
diff --git a/Assets/StreamingAssets/xml/enSmartXProject.xml.meta b/Assets/StreamingAssets/xml/enSmartXProject.xml.meta
new file mode 100644
index 0000000..290351a
--- /dev/null
+++ b/Assets/StreamingAssets/xml/enSmartXProject.xml.meta
@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 944e36cc0105df7429f07908bc196bbc
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
diff --git a/Assets/StreamingAssets/xml/enValidity.xml b/Assets/StreamingAssets/xml/enValidity.xml
index 12ad594..795e4a4 100644
--- a/Assets/StreamingAssets/xml/enValidity.xml
+++ b/Assets/StreamingAssets/xml/enValidity.xml
@@ -1,2 +1,2 @@
 <?xml version="1.0" encoding="utf-8"?>
-<EncryptedData Type="http://www.w3.org/2001/04/xmlenc#Element" xmlns="http://www.w3.org/2001/04/xmlenc#"><EncryptionMethod Algorithm="http://www.w3.org/2001/04/xmlenc#aes256-cbc" /><CipherData><CipherValue>EW7y3TXHjRCpD5Z0u4b9lXDEGhbI03JD06Eet/pyzAf/D0ySpBf0JIMuUIQiC6nidTwqaXuiASoVdaYKR/rfzxLNvd0SLlBH229V4oWlwhWhWuC0Q5YFuy2IPElAg+03r+53VhFCqEwKOKSPELu8xp30g1gxybezXInZ5XDqb6p8PySIUq62k81HHJ65wSebj0HPKNfU/I9ECdkbT0zZ39gx7yL43VbQqgm0jhEs/H8lS66sH/NVon/cXq6l8R/SkMhImMWv8AbOCmShC2SBfQ==</CipherValue></CipherData></EncryptedData>
\ No newline at end of file
+<EncryptedData Type="http://www.w3.org/2001/04/xmlenc#Element" xmlns="http://www.w3.org/2001/04/xmlenc#"><EncryptionMethod Algorithm="http://www.w3.org/2001/04/xmlenc#aes256-cbc" /><CipherData><CipherValue>xuqm34QlXASINUzIaK/VNRYC/nOG0yiBMYXTxo+xgUq7QchCjh9cAG+KmNJwStwaItmKOo94TESMX+Hi5M5zFc2c8HpGkKREJPhwi46aDkhqNHDOiVO6kaAeKinY3Nd7vBeJkoNF9XPahEmwWIrRN5Ihx64wtq3SI1MwGqamwaeQTtgmtkhmwKx+q+gWqBRZjTtkURh0Rx7TIw5SP6HnILhZnmEHyhVHDo5TF0RWfHhBaDeFolon7EZ73EsmX8yM9M5W5BgQiqXYSsc8KLuYMg==</CipherValue></CipherData></EncryptedData>
\ No newline at end of file