GHZMRNavigatorProXR/Assets/Scripts/UI/LoginPanel.cs

using LitJson;
using Newtonsoft.Json;
using Newtonsoft.Json.Linq;
using SC.XR.Unity;
using Blue;
using System;
using System.Collections;
using System.Collections.Generic;
using System.IO;
using System.Text.RegularExpressions;
using UnityEngine;
using UnityEngine.UI;

public class LoginPanel : BaseUI
{
    private SCInputField m_Account;
    private Button m_EmptyAccountBtn;
    private Text m_AccountErrorStr;
    private Transform m_AccountError;
    private string m_AccountStr;

    private SCInputField m_Password;
    private Button m_EmptyPwdBtn;
    //private Button m_LockPwdBtn;
    private bool m_Islock;
    private Text m_PwdErrorStr;
    private Transform m_PwdError;
    private string m_PasswordStr;

    private Button m_Logn;
    private Toggle m_RemenberPwd;
    private bool m_IsRemberPwd;

    private Button m_SNBtn;

    private Text m_SN;
    private Text m_Versaion;

    Toggle Choose21;
    Toggle Choose20;
    protected override void OnAwake()
    {
        base.OnAwake();



        Choose21 = CacheTransform.Find("Choose2.1").GetComponent<Toggle>();
        Choose21.onValueChanged.AddListener((bool b) => {

            UserInfo.Instance.is20 = !b;
        });
        Choose20 = CacheTransform.Find("Choose2.0").GetComponent<Toggle>();
        Choose20.onValueChanged.AddListener((bool b) => {
            UserInfo.Instance.is20 = b;
        });
        UserInfo.Instance.is20 = Choose20.isOn;
        m_Account = CacheTransform.Find("Account/SCInputField").GetComponent<SCInputField>();
        m_EmptyAccountBtn = CacheTransform.Find("Account/EmptyAccount").GetComponent<Button>();
        m_AccountErrorStr = CacheTransform.Find("Error/AccountError/Text").GetComponent<Text>();
        m_AccountError = CacheTransform.Find("Error/AccountError");

        m_Password = CacheTransform.Find("Password/SCInputField").GetComponent<SCInputField>();
        m_EmptyPwdBtn = CacheTransform.Find("Password/EmptyPassword").GetComponent<Button>();
        //m_LockPwdBtn = CacheTransform.Find("Password/Icon").GetComponent<Button>();
        //m_Islock = false;
        m_PwdErrorStr = CacheTransform.Find("Error/PasswordError/Text").GetComponent<Text>();
        m_PwdError = CacheTransform.Find("Error/PasswordError");

        m_Logn = CacheTransform.Find("LoginBtn").GetComponent<Button>();
        m_RemenberPwd = CacheTransform.Find("RememberPwd").GetComponent<Toggle>();


        m_RemenberPwd.isOn = false;
        m_IsRemberPwd = false;

        //m_SNBtn = CacheTransform.Find("SNLoginBtn").GetComponent<Button>();

        m_SN = CacheTransform.Find("SNAndVersion/SN/Text").GetComponent<Text>();
        m_Versaion = CacheTransform.Find("SNAndVersion/Versaion/Text").GetComponent<Text>();
        AddUIListenEvent();
    }

    /// <summary>
    /// 添加UI的监听事件
    /// </summary>
    private void AddUIListenEvent()
    {
        m_Account.onEndEdit.AddListener(OnAccountEndEdit);
        m_EmptyAccountBtn.onClick.AddListener(OnclickEmptyAccount);

        m_Password.onEndEdit.AddListener(OnPasswordEndEdit);
        m_EmptyPwdBtn.onClick.AddListener(OnClickEmptyPwd);
        //m_LockPwdBtn.onClick.AddListener(OnclickLockPwd);
        //m_Password.contentType = SCInputField.ContentType.Standard;

        Debug.Log("1111111111111111111111111111111111111111111111111111");
        m_Logn.onClick.AddListener(OnClickLogin);
        m_RemenberPwd.onValueChanged.AddListener(OnRemPwdValueChange);
        m_Versaion.text = Application.version;
        //m_SNBtn.onClick.AddListener(OnClickSnBtn);

        // OnClickLogin();


        string path = Application.persistentDataPath + "/Login/";
        LoginAcct la = new LoginAcct();
        la.acc = "";
        la.isre = false;
        la.pw = "";
        if (File.Exists(path + "Login.txt"))
        {
            string msg = File.ReadAllText(path + "Login.txt");
            la = JsonConvert.DeserializeObject<LoginAcct>(msg);

        }
        else
        {
            Directory.CreateDirectory(Application.persistentDataPath + "/Login");
        }

        m_Account.text = la.acc;
        m_Password.text = la.pw;
        m_Logn.interactable = la.isre;
        m_RemenberPwd.isOn = la.isre;
        m_IsRemberPwd = la.isre;
        m_AccountStr = la.acc;
        m_PasswordStr = la.pw;

    }

    #region UI监听事件

    /// <summary>
    /// 账号输入完成
    /// </summary>
    /// <param name="str"></param>
    private void OnAccountEndEdit(string str)
    {
        m_AccountStr = "";
        if (string.IsNullOrWhiteSpace(str))
        {
            m_AccountError.gameObject.SetActive(true);
            m_AccountErrorStr.text = "请输入邮箱账号";
        }
        else
        {
            //邮箱名以数字或字母开头；邮箱名可由字母、数字、点号、减号、下划线组成；邮箱名（@前的字符）长度为3～18个字符；邮箱名不能以点号、减号或下划线结尾；不能出现连续两个或两个以上的点号、减号。  
            //string pattern = @"^[a-zA-Z0-9]((?<!(\.\.|--))[a-zA-Z0-9\._-]){1,16}[a-zA-Z0-9]@([0-9a-zA-Z][0-9a-zA-Z-]{0,62}\.)+([0-9a-zA-Z][0-9a-zA-Z-]{0,62})\.?|((25[0-5]|2[0-4]\d|[01]?\d\d?)\.){3}(25[0-5]|2[0-4]\d|[01]?\d\d?)$";  
            string pattern = @"^([\w-\.]+)@([\w-\.]+)(\.[a-zA-Z0-9]+)$";

            if (Regex.IsMatch(str, pattern))
            {
                m_AccountStr = str;
                m_AccountErrorStr.text = "";
                m_AccountError.gameObject.SetActive(false);

            }
            else
            {
                m_AccountError.gameObject.SetActive(true);
                m_AccountErrorStr.text = "账号不合法";
            }
        }

        if (!string.IsNullOrWhiteSpace(m_AccountStr) && !string.IsNullOrWhiteSpace(m_PasswordStr))
        {
            m_Logn.interactable = true;
        }
    }
    /// <summary>
    /// 清理账号输入
    /// </summary>
    private void OnclickEmptyAccount()
    {
        m_AccountErrorStr.text = "账号不能为空";
        m_AccountError.gameObject.SetActive(true);
        m_AccountStr = "";
        m_Account.text = "";
        m_Logn.interactable = false;
    }
    /// <summary>
    /// 密码输入完成
    /// </summary>
    /// <param name="str"></param>
    private void OnPasswordEndEdit(string str)
    {
        m_PasswordStr = "";
        if (string.IsNullOrWhiteSpace(str))
        {
            m_PwdError.gameObject.SetActive(true);
            m_PwdErrorStr.text = "请输入密码";
        }
        else
        {
            Regex RegCHZN = new Regex("[\u4e00-\u9fa5]");
            if (RegCHZN.IsMatch(str))
            {
                m_PwdError.gameObject.SetActive(true);
                m_PwdErrorStr.text = "密码不合法";
                return;
            }

            //int n = 0;
            ////必须包含小写字母
            //string pattern1 = @"(?=.*[a-z])";
            ////必须包含大写字母
            //string pattern2 = @"(?=.*[A-Z])";
            ////必须包含数字
            //string pattern3 = @"(?=.*\d)";
            ////string pattern3 = @"(?=.*[0 - 9])";
            ////必须包含特殊符号
            //string pattern4 = @"(?=.*[ !""#$%&'()*+,-./:;<=>?@\[\]\^_`{|}~])";
            //string pattern4 = @"(?=([\x21-\x7e]+)[^a-zA-Z0-9])";
            //至少8个字符，最多32个字符
            string pattern5 = @"^.{8,32}$";

            if (!Regex.IsMatch(str, pattern5))
            {
                m_PwdError.gameObject.SetActive(true);
                m_PwdErrorStr.text = "密码小于8位数或大于32位";
                return;
            }
            m_PasswordStr = str;
            m_PwdErrorStr.text = "";
            m_PwdError.gameObject.SetActive(false);

            //if (Regex.IsMatch(str, pattern1))
            //{
            //    n++;
            //}
            //if (Regex.IsMatch(str, pattern2))
            //{
            //    n++;
            //}
            //if (Regex.IsMatch(str, pattern3))
            //{
            //    n++;
            //}
            //if (Regex.IsMatch(str, pattern4))
            //{
            //    n++;
            //}

            //if (n >= 3)
            //{
            //    m_PasswordStr = str;
            //    m_PwdErrorStr.text = "";
            //    m_PwdError.gameObject.SetActive(false);
            //}
            //else
            //{
            //    m_PwdError.gameObject.SetActive(true);
            //    m_PasswordStr = "";
            //    m_PwdErrorStr.text = "密码不正确，请重新输入";
            //}
        }

        if (!string.IsNullOrWhiteSpace(m_AccountStr) && !string.IsNullOrWhiteSpace(m_PasswordStr))
        {
            m_Logn.interactable = true;
        }
    }
    /// <summary>
    /// 清理密码输入
    /// </summary>
    private void OnClickEmptyPwd()
    {
        m_PwdErrorStr.text = "密码不能为空";
        m_PwdError.gameObject.SetActive(true);
        m_PasswordStr = "";
        m_Password.text = "";
        m_Logn.interactable = false;
    }
    /// <summary>
    /// 是否可以显示密码
    /// </summary>
    private void OnclickLockPwd()
    {
        if (m_Islock)
        {
            m_Password.contentType = SCInputField.ContentType.Password;
        }
        else
        {
            m_Password.contentType = SCInputField.ContentType.Standard;

        }
        m_Islock = !m_Islock;
    }
    public class LoginAcct
    {
        public string acc;
        public string pw;
        public bool isre;
    }
    /// <summary>
    /// 登录
    /// </summary>
    private void OnClickLogin()
    {
        Debug.Log("22222222222222222222222222222222222");
        if (string.IsNullOrWhiteSpace(m_AccountStr))
        {
            //m_AccountError.gameObject.SetActive(true);
            
            m_AccountErrorStr.text = "账号不能为空";
            return;
        }

        if (string.IsNullOrWhiteSpace(m_PasswordStr))
        {
            //m_PwdError.gameObject.SetActive(true);
            m_PwdErrorStr.text = "密码不能为空";
            return;
        }
    
        if (m_RemenberPwd.isOn)
        {
            LoginAcct la = new LoginAcct();
            la.acc = m_AccountStr;
            la.pw = m_PasswordStr;
            la.isre = true;
            string msg = JsonConvert.SerializeObject(la);
            string path = Application.persistentDataPath + "/Login/";
            using (System.IO.StreamWriter writer = System.IO.File.CreateText(path + "Login.txt"))
            {
                writer.Write(msg);
                //writer.
            }
        }
        else
        {
            LoginAcct la = new LoginAcct();
            la.acc = "";
            la.pw = "";
            la.isre = false;
            string msg = JsonConvert.SerializeObject(la);
            string path = Application.persistentDataPath + "/Login/";
            using (System.IO.StreamWriter writer = System.IO.File.CreateText(path + "Login.txt"))
            {
                writer.Write(msg);
                //writer.
            }
        }
        //向服务器发送账号和密码进行验证

       // Debug.Log("向服务器发送账号和密码进行登录");
        SendLogin sendLogin = new SendLogin();
        sendLogin.email = m_AccountStr;
        sendLogin.password = m_PasswordStr;
        sendLogin.remember = m_IsRemberPwd;
        if(DeviceType.type =="Phone")
            sendLogin.device = "android";
        else
            sendLogin.device = "glasses";

        UserInfo.Instance.Account = m_AccountStr;
        UserInfo.Instance.Password = m_PasswordStr;
        string jsonLogin = JsonMapper.ToJson(sendLogin);
      //  Debug.Log(jsonLogin);
        UIManager.Instance.ShowUI(UINameConfig.LoadingPanel, typeof(LoadingPanel), (int)ELoadState.login);

        HttpTool.Instance.PostLogin("/user/login", jsonLogin, LoginCallBack);

        //if (UserInfo.Instance.is20)
        //{
        //    HttpTool.Instance.PostLogin("/user/login", jsonLogin, LoginCallBack2);
        //}
        //else
        //{
        //    HttpTool.Instance.PostLogin("/user/login", jsonLogin, LoginCallBack);
        //}
    }
    /// <summary>
    /// 登录返回数据
    /// </summary>
    /// <param name="message"></param>
    public void LoginCallBack(string mes)
    {
        //Debug.Log(mes);
        JObject obj = JObject.Parse(mes);
        if (obj["code"].ToString() != "200")
        {
            m_Logn.interactable = true;
            m_AccountError.gameObject.SetActive(true);
            m_AccountErrorStr.text = obj["message"].ToString();
            UIManager.Instance.HideUI(UINameConfig.LoadingPanel);
            return;

        }
        else
        {


            UIManager.Instance.ShowUI(UINameConfig.LoadingPanel, typeof(LoadingPanel), (int)ELoadState.getUserInfo);
            UserInfo.Instance.Token = obj["data"]["token"].ToString();
            COSDownLoad.Instance.Credential();

            HttpTool.Instance.Get("/user/getUserInfo", GetUserInfoCallBack);

          //  StartCoroutine(LoginCallBackYS(3f));
        }
    }

    public void GetUserInfoCallBack(string msg)
    {
        JObject jobect = JObject.Parse(msg);
        Debug.Log("DGJ ===>  "+jobect["code"].ToString());
        if(int.Parse( jobect["code"].ToString()) == 200)
        {
            Debug.Log("DGJ ===>  " + jobect["data"]["type"].ToString());
            if (int.Parse(jobect["data"]["type"].ToString()) == 0)
            {
                Debug.Log(jobect["data"]["type"].ToString());
                UserInfo.Instance.is20 = true;
                StartCoroutine( LoginCallBack2YS(2));
            }
            else if (int.Parse(jobect["data"]["type"].ToString()) == 1)
            {
              

                Debug.Log(jobect["data"]["type"].ToString());
                UserInfo.Instance.is20 = false;
                StartCoroutine( LoginCallBackYS(2));
            }
            else
                return;
        }
        else
        {
            UIManager.Instance.ShowUI(UINameConfig.LoadingPanel, typeof(LoadingPanel), "/user/getUserInfo 通讯出错 请尝试重启应用");
        }
    }

    private IEnumerator LoginCallBack2YS( float times)
    {
       // yield return new WaitForSeconds(times);
        yield return new WaitForFixedUpdate();
        UserManager.Instance.loginBack(true);
        GameManager.Instance.arcamre.SetActive(true);
        GameManager.Instance.immser.SetActive(false);
    }

    private IEnumerator LoginCallBackYS(float times)
    {
       // yield return new WaitForSeconds(times);
        yield return new WaitForFixedUpdate();
        UIManager.Instance.ShowUI(UINameConfig.LoadingPanel, typeof(LoadingPanel), (int)ELoadState.getMaterialValue);
        StartCoroutine(GetAllMaterials(UserInfo.Instance.Token));
        GameManager.Instance.arcamre.SetActive(false);
        GameManager.Instance.immser.SetActive(true);
    }


    /// <summary>
    /// 获取账号下的场景返回数据
    /// </summary>
    /// <param name="message"></param>
    private IEnumerator GetAllSceneDataCallBack(string message)
    {

        Debug.Log("账号下的场景返回数据:  " + message);
        if (!string.IsNullOrWhiteSpace(message))
        {
            JObject jobject = JObject.Parse(message);
            if (jobject["code"].ToString() == "200")
            {
                message = jobject["data"]["list"].ToString();
                if (!string.IsNullOrWhiteSpace(message))
                {
                    List<SceneValue> listScenesPage = JsonConvert.DeserializeObject<List<SceneValue>>(message);
                    UIManager.Instance.ShowUI(UINameConfig.LoadingPanel, typeof(LoadingPanel), (int)ELoadState.sninfo);
                    yield return StartCoroutine(WaitSnInfo(listScenesPage));

                }
            }
            else
            {
                UIManager.Instance.HideUI(UINameConfig.LoadingPanel);
                m_Logn.interactable = true;
                m_AccountError.gameObject.SetActive(true);
                m_AccountErrorStr.text = "账号下的场景数据获取失败";
            }
        }
        Debug.LogError("获取场景列表失败");
    }

    /// <summary>
    /// 获取账号下的场景返回数据
    /// </summary>
    /// <param name="message"></param>
    private void GetAllSceneDataCallBack2(string message)
    {

        Debug.Log("账号下的场景返回数据:  " + message);
        if (!string.IsNullOrWhiteSpace(message))
        {
            JObject jobject = JObject.Parse(message);
            if (jobject["code"].ToString() == "200")
            {
                message = jobject["data"]["list"].ToString();
                if (!string.IsNullOrWhiteSpace(message))
                {
                    List<SceneValue> listScenesPage = JsonConvert.DeserializeObject<List<SceneValue>>(message);
                    UIManager.Instance.ShowUI(UINameConfig.LoadingPanel, typeof(LoadingPanel), (int)ELoadState.sninfo);
                   StartCoroutine(WaitSnInfo(listScenesPage));

                }
            }
            else
            {
                UIManager.Instance.HideUI(UINameConfig.LoadingPanel);
                m_Logn.interactable = true;
                m_AccountError.gameObject.SetActive(true);
                m_AccountErrorStr.text = "账号下的场景数据获取失败";
            }
        }
        Debug.LogError("获取场景列表失败");
    }



    /// <summary>
    /// 绑定设备
    /// </summary>
    /// <param name="scenes"></param>
    /// <returns></returns>
    IEnumerator WaitSnInfo(List<SceneValue> scenes)
    {
        List<SceneValue> sucessvalues = new List<SceneValue>();
        List<SceneValue> failevalues = new List<SceneValue>();
        bool finish = false;
        for (int i = 0; i < scenes.Count; i++)
        {
            SendSnInfo sendNet = new SendSnInfo();
            sendNet.sn = SendSN.GetSN();
            //sendNet.sn = "Nreal-SN";
            //API_GSXR_Slam.SlamManager.plugin.SN;
            sendNet.projectId = scenes[i].id;
            string jsonData = JsonMapper.ToJson(sendNet);
            yield return StartCoroutine(HttpTool.Instance.SendHttp("/client/snInfo", jsonData, (message) =>
            {
                JObject jobject = JObject.Parse(message);
                if (jobject["code"].ToString() == "200")
                {
                    sucessvalues.Add(scenes[i]);
                }
                else
                {
                    failevalues.Add(scenes[i]);
                }
                finish = true;
            }));
        }

        UIManager.Instance.ShowUI(UINameConfig.LoadingPanel, typeof(LoadingPanel), (int)ELoadState.initscene);
        string str = string.Format("{0}个场景绑定成功,{1}个场景绑定失败", sucessvalues.Count, failevalues.Count);
     //   Debug.Log(str);
        ((LoadingPanel)UIManager.Instance.GetUI(UINameConfig.LoadingPanel)).TextStr = str;

        yield return new WaitForSeconds(1f);
        yield return finish;
        UIManager.Instance.ShowUI(UINameConfig.SceneChoose, typeof(SceneChoose), sucessvalues);
        UIManager.Instance.HideUI(UINameConfig.LoadingPanel);
        Hide();
    }

    List<DownLoadMaterial> listMaterail = new List<DownLoadMaterial>();

    /// <summary>
    /// 获取素材库列表
    /// </summary>
    /// <param name="mes"></param>
    /// <returns></returns>
    IEnumerator GetAllMaterials(string mes)
    {
        string message = "";
        yield return StartCoroutine(HttpTool.Instance.SendHttp("/material/init", mes, (m) =>
        {
            message = m;
        },false));
        yield return null;



        if (!string.IsNullOrWhiteSpace(message))
        {
            JObject jObject = JObject.Parse(message);
            if (jObject["code"].ToString() == "200")
            {
                //处理素材库信息
                string data = jObject["data"].ToString();
                JObject dataObject = JObject.Parse(data);

                string single = dataObject["single"].ToString();
                string library = dataObject["library"].ToString();
                string combination = dataObject["combination"].ToString();

                List<MaterialObl> singleMaterials = new List<MaterialObl>();
                List<MaterialObl> libraryMaterials = new List<MaterialObl>();
                List<MaterialObl> combinationMaterials = new List<MaterialObl>();
                if (!string.IsNullOrWhiteSpace(single))
                {
                    singleMaterials = JsonConvert.DeserializeObject<List<MaterialObl>>(single);
                    DataManager.Instance.AllMaterials.Add("single", singleMaterials);
                    yield return null;
                }
                if (!string.IsNullOrWhiteSpace(library))
                {
                    libraryMaterials = JsonConvert.DeserializeObject<List<MaterialObl>>(library);
                    DataManager.Instance.AllMaterials.Add("library", libraryMaterials);
                    yield return null;
                }
                if (!string.IsNullOrWhiteSpace(combination))
                {
                    combinationMaterials = JsonConvert.DeserializeObject<List<MaterialObl>>(combination);
                    DataManager.Instance.AllMaterials.Add("combination", combinationMaterials);
                    yield return null;
                }
                //CalMat(singleMaterials);
                //CalMat(libraryMaterials);
                //CalMat(combinationMaterials);
                CalMatCOS(singleMaterials);
                CalMatCOS(libraryMaterials);
                CalMatCOS(combinationMaterials);

                DownloadResManager.Instance.DownLoad(listMaterail);
            }

            UIManager.Instance.ShowUI(UINameConfig.LoadingPanel, typeof(LoadingPanel), (int)ELoadState.getAllScene);
          //  HttpTool.Instance.Get("/project/index", GetAllSceneDataCallBack2);
         //   StartCoroutine(HttpTool.Instance.SendHttp("/project/index", "", GetAllSceneDataCallBack2, false));
            string indexmsg = "";
            //获取账号下的场景数据
            yield return StartCoroutine( HttpTool.Instance.SendHttp("/project/index","", (string msg)=> {
                indexmsg = msg;
            },false));

            if(indexmsg =="")
            {
                UIManager.Instance.ShowUI(UINameConfig.LoadingPanel, typeof(LoadingPanel), "/project/index 通讯出错  请尝试重启应用");
            }
            else
            {
                yield return null;

                yield return StartCoroutine(GetAllSceneDataCallBack(indexmsg));

            }
        }
        else
        {

            UIManager.Instance.ShowUI(UINameConfig.LoadingPanel, typeof(LoadingPanel), "/material/init 通讯出错  请尝试重启应用");
        }
    }

    private void CalMat(List<MaterialObl> mats)
    {
        //for (int i = 0; i < mats.Count; i++)
        //{
        //    var mat = mats[i];
        //    if (!string.IsNullOrWhiteSpace(mat.icon))
        //    {
        //        DownloadData data1 = new DownloadData();
        //        string filename = Path.GetFileName(mat.icon);
        //        data1.name = filename;
        //        data1.type = 1;
        //        data1.downloadPath = mat.icon;
        //        data1.updateTime = mat.updateTime;

        //        data1.localSavePath = DownloadManager.Instance.LocaDataPath + "/Icon/" + filename;
        //        DownloadManager.Instance.AddDownloadData(data1);
        //    }
        //    if (mat.materialList != null)
        //    {
        //        for (int m = 0; m < mat.materialList.Count; m++)
        //        {  
        //            var matObj = mat.materialList[m];
        //            if (int.Parse(matObj.type) != 4)
        //            {
        //                DownloadData data = new DownloadData(matObj);
        //                DownloadManager.Instance.AddDownloadData(data);
        //            }
        //        }
        //    }
        //}
    }
   
    private void CalMatCOS(List<MaterialObl> mats)
    {
     
        for (int i = 0; i < mats.Count; i++)
        {
            var mat = mats[i];
            if (!string.IsNullOrWhiteSpace(mat.icon))
            {
                DownLoadMaterial data1 = new DownLoadMaterial();
                string filename = Path.GetFileName(mat.icon);
                data1.downLoadPath = mat.icon;
                data1.updataTime = mat.updateTime;

                data1.localLoadPath = Application.persistentDataPath + "/Material/" + filename;
                listMaterail.Add(data1);
            }
            if (mat.materialList != null)
            {
                for (int m = 0; m < mat.materialList.Count; m++)
                {
                    var matObj = mat.materialList[m];
                    if (matObj.type != 4 && matObj.type != 0)
                    {
                        DownLoadMaterial data1 = new DownLoadMaterial();
                        string filename = Path.GetFileName(matObj.DownloadPath);
                        data1.downLoadPath = matObj.DownloadPath;
                        data1.updataTime = mat.updateTime;
                        data1.localLoadPath = Application.persistentDataPath + "/Material/" + filename;
                        listMaterail.Add(data1);
                    }
                }
            }
        }

       
    }

    /// <summary>
    /// 是否记住密码
    /// </summary>
    /// <param name="b"></param>
    private void OnRemPwdValueChange(bool b)
    {
        m_IsRemberPwd = b;
    }

    /// <summary>
    /// 使用SN进行登录
    /// </summary>
    private void OnClickSnBtn()
    {
        string sn = SendSN.GetSN();
        //string sn = API_GSXR_Slam.SlamManager.plugin.SN;
    }

    #endregion


    protected override void OnInit()
    {
        base.OnInit();
    }

    protected override void OnShow(object param)
    {
        base.OnShow(param);

        gameObject.transform.localScale = new Vector3(1, 1, 1);



    }

    private void Update()
    {
        if (API_GSXR_Slam.GSXR_Is_SlamInitialized())
        {
            m_SN.text = SendSN.GetSN();
            //m_SN.text = API_GSXR_Slam.SlamManager.plugin.SN;
        }

    }

    protected override void OnHide()
    {
        base.OnHide();
    }

    protected override void OnDestroy()
    {
        base.OnDestroy();
    }
}

public class SendInit
{
    public string sn { get; set; }
    public int projectId { get; set; }
}

public class SendLogin
{
    public string email { get; set; }
    public string password { get; set; }

    public bool remember { get; set; }

    public string device { get; set; }
}

public class SendMaterials
{
    public string url { get; set; }
}

public class SendSceneDetail
{
    public int id { get; set; }
}