2019-10-18-2

WJC

2019-10-18 fdf2472a13873ab3570e3c82de50896b8f5ac1cb

2019-10-18-2

最新

 .DS_Store

Binary files differ

 ZigbeeApp/.vs/GateWay/xs/UserPrefs.xml

@@ -2,32 +2,42 @@
  <MonoDevelop.Ide.ItemProperties.GateWay.Droid PreferredExecutionTarget="Android.SelectDevice" />
  <MonoDevelop.Ide.ItemProperties.GateWay.Ios automaticSigning="False" PreferredExecutionTarget="MonoDevelop.IPhone.IPhoneDeviceTarget.913cb77b0eef11c9119c61a02bc00fec01bf67d6" />
  <MonoDevelop.Ide.ItemProperties.ShardLib PreferredExecutionTarget="Android.M7BBB18B19152766" />
  <MonoDevelop.Ide.Workbench ActiveDocument="Shared/Phone/Device/Logic/Send.cs">
  <MonoDevelop.Ide.Workbench ActiveDocument="Shared/Phone/ZigBee/Device/CommonDevice.cs">
    <Files>
      <File FileName="Shared/Phone/Device/Logic/DeviceStateCondition.cs" Line="243" Column="42" />
      <File FileName="Shared/Phone/Device/Logic/MemberList.cs" />
      <File FileName="Shared/Phone/ZigBee/Device/DeviceType.cs" />
      <File FileName="Shared/Phone/ZigBee/Device/TemperatureSensor.cs" />
      <File FileName="Shared/Phone/Device/Logic/LogicDevicePage.cs" Line="230" Column="57" />
      <File FileName="Shared/Phone/Device/Category/Category.cs" />
      <File FileName="Shared/Phone/Device/Logic/TemplateDeviceCondition.cs" Line="225" Column="57" />
      <File FileName="Shared/Phone/Device/Logic/TemplateDeviceAction.cs" Line="230" Column="57" />
      <File FileName="Shared/Phone/Device/Logic/Send.cs" Line="689" Column="1" />
      <File FileName="Shared/Phone/Device/Logic/LogicCommunalPage.cs" Line="250" Column="59" />
      <File FileName="Shared/Phone/Device/Logic/DeviceStateCondition.cs" Line="1509" Column="45" />
      <File FileName="Shared/Phone/ZigBee/Device/TemperatureSensor.cs" Line="11" Column="29" />
      <File FileName="Shared/Phone/Device/Category/Category.cs" Line="2601" Column="26" />
      <File FileName="../../../Downloads/ZigbeeApp-6/Shared/Phone/Device/Category/Category.cs" Line="9" Column="39" />
      <File FileName="Shared/Phone/Device/Logic/Send.cs" Line="1" Column="1" />
      <File FileName="Shared/Common/Room.cs" Line="1" Column="1" />
      <File FileName="GateWay.Ios/Main.cs" Line="14" Column="1" />
      <File FileName="GateWay.Ios/Main.cs" Line="14" Column="1" />
      <File FileName="Shared/Phone/Device/Logic/LogicIfon.cs" Line="22" Column="37" />
      <File FileName="Shared/Phone/ZigBee/Device/CommonDevice.cs" Line="294" Column="27" />
    </Files>
    <Pads>
      <Pad Id="ProjectPad">
        <State name="__root__">
          <Node name="GateWay" expanded="True">
            <Node name="GateWay.Ios" expanded="True" />
            <Node name="GateWay.Ios" expanded="True">
              <Node name="Resources" expanded="True">
                <Node name="Phone" expanded="True">
                  <Node name="ZigeeLogic" expanded="True" />
                </Node>
              </Node>
            </Node>
            <Node name="Shared" expanded="True">
              <Node name="Common" expanded="True" />
              <Node name="Phone" expanded="True">
                <Node name="Device" expanded="True">
                  <Node name="Logic" expanded="True">
                    <Node name="Send.cs" selected="True" />
                  </Node>
                  <Node name="Category" expanded="True" />
                  <Node name="Logic" expanded="True" />
                </Node>
                <Node name="ZigBee" expanded="True">
                  <Node name="Device" expanded="True" />
                  <Node name="Device" expanded="True">
                    <Node name="CommonDevice.cs" selected="True" />
                  </Node>
                </Node>
              </Node>
            </Node>
@@ -39,9 +49,7 @@
  <MonoDevelop.Ide.DebuggingService.PinnedWatches />
  <MonoDevelop.Ide.Workspace ActiveConfiguration="Debug|iPhone" />
  <MonoDevelop.Ide.DebuggingService.Breakpoints>
    <BreakpointStore>
      <Breakpoint file="/Users/hdl/Desktop/HomeApp/ZigbeeApp/Shared/Phone/Device/Logic/Send.cs" relfile="Shared/Phone/Device/Logic/Send.cs" line="689" column="1" />
    </BreakpointStore>
    <BreakpointStore />
  </MonoDevelop.Ide.DebuggingService.Breakpoints>
  <MultiItemStartupConfigurations />
</Properties>

 ZigbeeApp/.vs/GateWay/xs/sqlite3/storage.ide

Binary files differ

 ZigbeeApp/.vs/GateWay/xs/sqlite3/storage.ide-shm

Binary files differ

 ZigbeeApp/.vs/GateWay/xs/sqlite3/storage.ide-wal

Binary files differ

 ZigbeeApp/GateWay.Ios/Resources/Phone/.DS_Store

Binary files differ

 ZigbeeApp/Shared/Common/Room.cs

@@ -7,1336 +7,1335 @@

namespace Shared.Common
{
    /// <summary>
    /// 房间对象
    /// </summary>
    [System.Serializable]
    public class Room
    {
        #region ◆ 变量____________________________
    /// <summary>
    /// 房间对象
    /// </summary>
    [System.Serializable]
    public class Room
    {
        #region ◆ 变量____________________________

        /// <summary>
        /// 房间文件
        /// </summary>
        /// <value>The name of the file.</value>
        [Newtonsoft.Json.JsonIgnore]
        public string FileName
        {
            get
            {
                return $"Room_{Id}.json";
            }
        }
        /// <summary>
        /// 房间id--使用guid
        /// Guid.NewGuid().ToString()
        /// </summary>
        public string Id = Guid.NewGuid().ToString();
        /// <summary>
        /// 楼层Id
        /// 新增时使用Guid
        /// </summary>
        public string FloorId = "Floor1";
        /// <summary>
        /// 楼层名称
        /// </summary>
        public string FloorName
        {
            get
            {
               return GetFloorNameById(FloorId);
            }
        }
        /// <summary>
        /// 房间名
        /// </summary>
        public string Name = string.Empty;
        /// <summary>
        /// 房间文件
        /// </summary>
        /// <value>The name of the file.</value>
        [Newtonsoft.Json.JsonIgnore]
        public string FileName
        {
            get
            {
                return $"Room_{Id}.json";
            }
        }
        /// <summary>
        /// 房间id--使用guid
        /// Guid.NewGuid().ToString()
        /// </summary>
        public string Id = Guid.NewGuid().ToString();
        /// <summary>
        /// 楼层Id
        /// 新增时使用Guid
        /// </summary>
        public string FloorId = "Floor1";
        /// <summary>
        /// 楼层名称
        /// </summary>
        public string FloorName
        {
            get
            {
                return GetFloorNameById(FloorId);
            }
        }
        /// <summary>
        /// 房间名
        /// </summary>
        public string Name = string.Empty;

        /// <summary>
        /// 房间背景图
        /// </summary>
        public string BackgroundImage = string.Empty;
        /// <summary>
        /// 房间背景图
        /// </summary>
        public string BackgroundImage = string.Empty;

        /// <summary>
        /// 图片来源 0--本地图库 1--拍照 2--系统图库
        /// </summary>
        public int BackgroundImageType = 0;
        /// <summary>
        /// 图片来源 0--本地图库 1--拍照 2--系统图库
        /// </summary>
        public int BackgroundImageType = 0;

        /// <summary>
        /// 楼层--备用
        /// </summary>
        public Dictionary<string, string> FloorList = new Dictionary<string, string> { };
        /// <summary>
        /// 楼层--备用
        /// </summary>
        public Dictionary<string, string> FloorList = new Dictionary<string, string> { };

        /// <summary>

        /// 温度传感器(设备主键)

        /// </summary>
        public string TemperatrueDevice = string.Empty;
        /// <summary>

        /// 湿度传感器(设备主键)

        /// </summary>
        public string HumidityDevice = string.Empty;
        /// <summary>
        /// 温度传感器(设备主键)
        /// </summary>
        public string TemperatrueDevice = string.Empty;
        /// <summary>
        /// 湿度传感器(设备主键)
        /// </summary>
        public string HumidityDevice = string.Empty;

        /// <summary>
        /// 当前选择的房间
        /// </summary>
        public static Room CurrentRoom;
        /// <summary>
        /// 当前选择的房间
        /// </summary>
        public static Room CurrentRoom;

        /// <summary>
        /// 房间里所有的设备列表
        /// </summary>
        [Newtonsoft.Json.JsonIgnore]
        public List<DeviceUI> DeviceUIList = new List<DeviceUI> { };
        /// <summary>
        ///设备文件路径列表
        /// </summary>
        public readonly List<string> DeviceUIFilePathList = new List<string>();
        /// <summary>
        /// 房间里所有的设备列表
        /// </summary>
        [Newtonsoft.Json.JsonIgnore]
        public List<DeviceUI> DeviceUIList = new List<DeviceUI> { };
        /// <summary>
        ///设备文件路径列表
        /// </summary>
        public readonly List<string> DeviceUIFilePathList = new List<string>();

        /// <summary>
        /// 喜爱房间id
        /// </summary>
        public const string LoveRoomId= "Favorite";
        /// <summary>
        /// 喜爱房间id
        /// </summary>
        public const string LoveRoomId = "Favorite";

        /// <summary>
        /// 是否是默认喜爱房间
        /// </summary>
        /// <value><c>true</c> if is love; otherwise, <c>false</c>.</value>
        [Newtonsoft.Json.JsonIgnore]
        public bool IsLove
        {
            get
            {
                return Id == LoveRoomId;
            }
        }
        /// <summary>
        /// 是否是默认喜爱房间
        /// </summary>
        /// <value><c>true</c> if is love; otherwise, <c>false</c>.</value>
        [Newtonsoft.Json.JsonIgnore]
        public bool IsLove
        {
            get
            {
                return Id == LoveRoomId;
            }
        }

        /// <summary>
        /// 是否是分享过来的房间
        /// 注：分享过来的房间不能删除，不能编辑该房间，不能对设备（功能）、场景进行增删改
        /// </summary>
        public bool IsSharedRoom = false;
        /// <summary>
        /// 是否是分享过来的房间
        /// 注：分享过来的房间不能删除，不能编辑该房间，不能对设备（功能）、场景进行增删改
        /// </summary>
        public bool IsSharedRoom = false;

        /// <summary>
        /// 是否可以刷新房间数据了
        /// 需要等初始化本地设备数据后在可以初始化房间数据
        /// </summary>
        public static bool CanInitAllRoom;
        /// <summary>
        /// 是否可以刷新房间数据了
        /// 需要等初始化本地设备数据后在可以初始化房间数据
        /// </summary>
        public static bool CanInitAllRoom;

        /// <summary>
        /// 获取喜爱房间的所有设备路径
        /// </summary>
        /// <value>The love room device list.</value>
        [Newtonsoft.Json.JsonIgnore]
        public static List<string> LoveRoomDeviceUIFilePathList
        {
            get
            {
                if (Lists.Count == 0)
                {
                    return new List<string> { };
                }
                return GetLoveRoom().DeviceUIFilePathList;
            }
        }
        /// <summary>
        /// 获取喜爱房间的所有设备路径
        /// </summary>
        /// <value>The love room device list.</value>
        [Newtonsoft.Json.JsonIgnore]
        public static List<string> LoveRoomDeviceUIFilePathList
        {
            get
            {
                if (Lists.Count == 0)
                {
                    return new List<string> { };
                }
                return GetLoveRoom().DeviceUIFilePathList;
            }
        }

        /// <summary>
        /// 所有房间的所有设备类型
        /// 先调用 GetAllRoomDeviceTypeList()
        /// </summary>
        /// <value>All room device type list.</value>
        [Newtonsoft.Json.JsonIgnore]
        public static List<DeviceType> AllRoomDeviceTypeList = new List<DeviceType> { };
        /// <summary>
        /// 所有房间的所有设备类型
        /// 先调用 GetAllRoomDeviceTypeList()
        /// </summary>
        /// <value>All room device type list.</value>
        [Newtonsoft.Json.JsonIgnore]
        public static List<DeviceType> AllRoomDeviceTypeList = new List<DeviceType> { };

        /// <summary>
        /// 获取所有房间的所有场景
        /// </summary>
        /// <value>All room scene UIL ist.</value>
        [Newtonsoft.Json.JsonIgnore]
        public static List<SceneUI> AllRoomSceneUIList
        {
            get
            {
                var sceneList = new List<SceneUI> { };
                foreach (var r in Shared.Common.Room.Lists)
                {
                    if (r.SceneUIList.Count == 0)
                    {
                        continue;
                    }
                    foreach (var sceneUI in r.SceneUIList)
                    {
                        if (sceneUI == null)
                        {
                            continue;
                        }
                        sceneList.Add(sceneUI);
                    }
                }
                return sceneList;
            }
        }
        /// <summary>
        /// 场景列表---不再序列化
        /// </summary>
        [Newtonsoft.Json.JsonIgnore]
        public List<SceneUI> SceneUIList = new List<SceneUI> { };
        /// <summary>
        ///场景文件列表
        /// </summary>
        public readonly List<string> SceneUIFilePathList = new List<string>();
        /// <summary>
        /// 获取所有房间的所有场景
        /// </summary>
        /// <value>All room scene UIL ist.</value>
        [Newtonsoft.Json.JsonIgnore]
        public static List<SceneUI> AllRoomSceneUIList
        {
            get
            {
                var sceneList = new List<SceneUI> { };
                foreach (var r in Shared.Common.Room.Lists)
                {
                    if (r.SceneUIList.Count == 0)
                    {
                        continue;
                    }
                    foreach (var sceneUI in r.SceneUIList)
                    {
                        if (sceneUI == null)
                        {
                            continue;
                        }
                        sceneList.Add(sceneUI);
                    }
                }
                return sceneList;
            }
        }
        /// <summary>
        /// 场景列表---不再序列化
        /// </summary>
        [Newtonsoft.Json.JsonIgnore]
        public List<SceneUI> SceneUIList = new List<SceneUI> { };
        /// <summary>
        ///场景文件列表
        /// </summary>
        public readonly List<string> SceneUIFilePathList = new List<string>();

        /// <summary>
        /// 所有的房间信息
        /// </summary>
        public static List<Room> Lists = new List<Room>();
        /// <summary>
        /// 所有的房间信息
        /// </summary>
        public static List<Room> Lists = new List<Room>();

        /// <summary>
        /// 获取所有房间的所有设备
        /// 请先调用 GetAllRoomDeviceUIList()方法
        /// </summary>
        /// <value>All room device UIL ist.</value>
        [Newtonsoft.Json.JsonIgnore]
        public static List<DeviceUI> AllRoomDeviceUIList = new List<DeviceUI> { };
        /// <summary>
        /// 获取所有房间的所有设备
        /// 请先调用 GetAllRoomDeviceUIList()方法
        /// </summary>
        /// <value>All room device UIL ist.</value>
        [Newtonsoft.Json.JsonIgnore]
        public static List<DeviceUI> AllRoomDeviceUIList = new List<DeviceUI> { };

        #endregion
        #endregion

        #region ◆ 构造方法________________________
        #region ◆ 构造方法________________________

        /// <summary>
        /// 构造方法
        /// </summary>
        static Room()
        {
            InitAllRoom();
        }
        /// <summary>
        /// 构造方法
        /// </summary>
        static Room()
        {
            InitAllRoom();
        }

        #endregion
        #endregion

        #region ◆ 初始化__________________________
        #region ◆ 初始化__________________________

        /// <summary>
        /// 初始化房间信息
        /// 从文件中全部读取所有的房间数据到内存
        /// </summary>
        public static void InitAllRoom()
        {
            if (CanInitAllRoom == false)
            {
                return;
            }
            Lists.Clear();
            if (Config.Instance.Home.RoomFilePathList.Contains("Room_Favorite.json") == false)
            {
                //默认添加喜爱的房间--禁止修改房间名
                var love = new Room { Name = Language.StringByID(R.MyInternationalizationString.Favorite), BackgroundImage = "Room/r0.png", Id = LoveRoomId };
                love.Save(true);
                //添加到house 房间路径列表
                var currentHome = Config.Instance.Home;
                currentHome.RoomFilePathList.Insert(0, love.FileName);
                currentHome.Save();
            }
            foreach (var roomFilePath in Config.Instance.Home.RoomFilePathList)
            {
                var room = GetRoomByFilePath(roomFilePath);
        /// <summary>
        /// 初始化房间信息
        /// 从文件中全部读取所有的房间数据到内存
        /// </summary>
        public static void InitAllRoom()
        {
            if (CanInitAllRoom == false)
            {
                return;
            }
            Lists.Clear();
            if (Config.Instance.Home.RoomFilePathList.Contains("Room_Favorite.json") == false)
            {
                //默认添加喜爱的房间--禁止修改房间名
                var love = new Room { Name = Language.StringByID(R.MyInternationalizationString.Favorite), BackgroundImage = "Room/r0.png", Id = LoveRoomId };
                love.Save(true);
                //添加到house 房间路径列表
                var currentHome = Config.Instance.Home;
                currentHome.RoomFilePathList.Insert(0, love.FileName);
                currentHome.Save();
            }
            foreach (var roomFilePath in Config.Instance.Home.RoomFilePathList)
            {
                var room = GetRoomByFilePath(roomFilePath);

                if (null != room)
                {
                    if (room.IsSharedRoom)
                    {
                        room.Name = $"({Language.StringByID(R.MyInternationalizationString.Shared)}){room.Name}";
                    }
                    Lists.Add(room);
                }
            }
        }
                if (null != room)
                {
                    if (room.IsSharedRoom)
                    {
                        room.Name = $"({Language.StringByID(R.MyInternationalizationString.Shared)}){room.Name}";
                    }
                    Lists.Add(room);
                }
            }
        }

        /// <summary>

        /// 从本地重新加载全部的房间

        /// </summary>
        public static void RefreshAllRoomByLocation()

        {

            Lists.Clear();

            var homeTemp = Config.Instance.Home;

            homeTemp.RoomFilePathList.Clear();



            var listFile = Global.FileListByHomeId();



            //我的喜爱的房间必须要在第0位才行

            string fRoom = "Room_Favorite.json";

            if (listFile.Contains(fRoom) == true)

            {

                listFile.Remove(fRoom);

                homeTemp.AddRoomListFilePath(fRoom);

            }



            foreach (string fileName in listFile)

            {

                if (fileName.StartsWith("Room_"))

                {

                    homeTemp.AddRoomListFilePath(fileName);

                }

            }

            homeTemp.Save(false);

            CanInitAllRoom = true;

            InitAllRoom();

        }
        /// <summary>
        /// 从本地重新加载全部的房间
        /// </summary>
        public static void RefreshAllRoomByLocation()
        {
            Lists.Clear();
            var homeTemp = Config.Instance.Home;
            homeTemp.RoomFilePathList.Clear();

        #endregion
            var listFile = Global.FileListByHomeId();

        #region ◆ 添加房间_________________________
            //我的喜爱的房间必须要在第0位才行
            string fRoom = "Room_Favorite.json";
            if (listFile.Contains(fRoom) == true)
            {
                listFile.Remove(fRoom);
                homeTemp.AddRoomListFilePath(fRoom);
            }

        /// <summary>
        /// 增加房间
        /// </summary>
        /// <returns><c>true</c>, if room was added, <c>false</c> otherwise.</returns>
        /// <param name="room">Room.</param>
        public bool AddRoom(Room room)
        {
            if (string.IsNullOrEmpty(room.FileName) || Global.IsExistsByHomeId(room.FileName))
            {
                return false;
            }
            if (Config.Instance.Home.RoomFilePathList.Contains(room.FileName))
            {
                return false;
            }
            Lists.Add(room);
            var r = Config.Instance.Home.AddRoomListFilePath(room.FileName);
            if (r == false)
            {
                return false;
            }
            Save();
            HdlAutoBackupLogic.AddOrEditorFile(room.FileName);
            return true;
        }
            foreach (string fileName in listFile)
            {
                if (fileName.StartsWith("Room_"))
                {
                    homeTemp.AddRoomListFilePath(fileName);
                }
            }
            homeTemp.Save(false);
            CanInitAllRoom = true;
            InitAllRoom();
        }

        #endregion
        #endregion

        #region ◆ 删除房间_________________________
        #region ◆ 添加房间_________________________

        /// <summary>
        /// 删除房间
        /// </summary>
        public bool Remove(string roomFilePath)
        {
            var room = GetRoomByFilePath(roomFilePath);
            if (null == room)
            {
                return false;
            }
            //删除来自拍照或者系统图库的房间背景图片
            if (room.BackgroundImageType == 1 || room.BackgroundImageType == 2)
            {
                DeleteBackGroundIamageFilebyHomeId(room.BackgroundImage);
            }
            if (Global.IsExistsByHomeId(roomFilePath) == false)
            {
                return false;
            }
            Config.Instance.Home.RemoveRoomListFilePath(roomFilePath);
            //删除文件
            Global.DeleteFilebyHomeId(roomFilePath);
            Lists.Remove(room);
            HdlAutoBackupLogic.DeleteFile(roomFilePath);
            return true;
        }
        /// <summary>
        /// 增加房间
        /// </summary>
        /// <returns><c>true</c>, if room was added, <c>false</c> otherwise.</returns>
        /// <param name="room">Room.</param>
        public bool AddRoom(Room room)
        {
            if (string.IsNullOrEmpty(room.FileName) || Global.IsExistsByHomeId(room.FileName))
            {
                return false;
            }
            if (Config.Instance.Home.RoomFilePathList.Contains(room.FileName))
            {
                return false;
            }
            Lists.Add(room);
            var r = Config.Instance.Home.AddRoomListFilePath(room.FileName);
            if (r == false)
            {
                return false;
            }
            Save();
            HdlAutoBackupLogic.AddOrEditorFile(room.FileName);
            return true;
        }

        #endregion
        #endregion

        #region ◆ 获取房间________________________
        #region ◆ 删除房间_________________________

        /// <summary>
        /// 获取喜爱房间
        /// </summary>
        /// <returns></returns>
        public static Room GetLoveRoom()
        {
            return CurrentRoom.GetRoomById(LoveRoomId);
        }
        /// <summary>
        /// 删除房间
        /// </summary>
        public bool Remove(string roomFilePath)
        {
            var room = GetRoomByFilePath(roomFilePath);
            if (null == room)
            {
                return false;
            }
            //删除来自拍照或者系统图库的房间背景图片
            if (room.BackgroundImageType == 1 || room.BackgroundImageType == 2)
            {
                DeleteBackGroundIamageFilebyHomeId(room.BackgroundImage);
            }
            if (Global.IsExistsByHomeId(roomFilePath) == false)
            {
                return false;
            }
            Config.Instance.Home.RemoveRoomListFilePath(roomFilePath);
            //删除文件
            Global.DeleteFilebyHomeId(roomFilePath);
            Lists.Remove(room);
            HdlAutoBackupLogic.DeleteFile(roomFilePath);
            return true;
        }

        /// <summary>
        /// 通过路径获取房间
        /// </summary>
        /// <returns>The room by file path.</returns>
        /// <param name="roomFilePath">Room file path.</param>
        public static Room GetRoomByFilePath(string roomFilePath)
        {
            try
            {
                var roomFile = Global.ReadFileByHomeId(roomFilePath);
                var nowRoom = Newtonsoft.Json.JsonConvert.DeserializeObject<Room>(System.Text.Encoding.UTF8.GetString(roomFile));
        #endregion

                if (null == nowRoom)
                {
                    System.Console.WriteLine("房间文件路径不对，文件路径为：" + roomFilePath);
                    return null;
                }
        #region ◆ 获取房间________________________

                var beforeRoom = Lists.Find((obj) => obj.Id == nowRoom.Id);
                if (beforeRoom != null)
                {
                    var tempDeviceUIList = new List<DeviceUI>();
                    tempDeviceUIList.AddRange(beforeRoom.DeviceUIList);
                    var tempSceneUIList = new List<SceneUI>();
                    tempSceneUIList.AddRange(beforeRoom.SceneUIList);
                    //设备（deviceUI）
                    beforeRoom.DeviceUIList.Clear();
                    foreach (var deviceFilePath in beforeRoom.DeviceUIFilePathList)
                    {
                        beforeRoom.DeviceUIList.Add(Common.LocalDevice.Current.GetDeviceUI(deviceFilePath));
                    }
                    //场景(SceneUI)
                    beforeRoom.SceneUIList.Clear();
                    foreach (var sceneFilePath in beforeRoom.SceneUIFilePathList)
                    {
                        var jsonInfo = Encoding.UTF8.GetString(Global.ReadFileByHomeId(sceneFilePath));
                        var tempSceneUI = Newtonsoft.Json.JsonConvert.DeserializeObject<SceneUI>(jsonInfo);
                        if (tempSceneUI != null)
                        {
                            var scene = tempSceneUIList.Find((obj) => obj.FileName == tempSceneUI.FileName);
                            if (scene != null)
                            {
                                beforeRoom.SceneUIList.Add(scene);
                            }
                            else
                            {
                                beforeRoom.AddScene(scene);
                            }
                        }
                    }
        /// <summary>
        /// 获取喜爱房间
        /// </summary>
        /// <returns></returns>
        public static Room GetLoveRoom()
        {
            return CurrentRoom.GetRoomById(LoveRoomId);
        }

                    return beforeRoom;
                }
        /// <summary>
        /// 通过路径获取房间
        /// </summary>
        /// <returns>The room by file path.</returns>
        /// <param name="roomFilePath">Room file path.</param>
        public static Room GetRoomByFilePath(string roomFilePath)
        {
            try
            {
                var roomFile = Global.ReadFileByHomeId(roomFilePath);
                var nowRoom = Newtonsoft.Json.JsonConvert.DeserializeObject<Room>(System.Text.Encoding.UTF8.GetString(roomFile));

                //设备（deviceUI）
                nowRoom.DeviceUIList.Clear();
                foreach (var deviceFilePath in nowRoom.DeviceUIFilePathList)
                {
                    var tempCommon = LocalDevice.Current.GetDeviceUI(deviceFilePath);
                    if (tempCommon == null || tempCommon.CommonDevice == null)
                    {
                        continue;
                    }
                    nowRoom.DeviceUIList.Add(tempCommon);
                }
                //场景(SceneUI)
                nowRoom.SceneUIList.Clear();
                foreach (var sceneUIFilePath in nowRoom.SceneUIFilePathList)
                {
                    var jsonInfo = Encoding.UTF8.GetString(Global.ReadFileByHomeId(sceneUIFilePath));
                    var tempScene = Newtonsoft.Json.JsonConvert.DeserializeObject<SceneUI>(jsonInfo);
                    if (tempScene == null)
                    {
                        continue;
                    }
                    nowRoom.SceneUIList.Add(tempScene);
                }
                return nowRoom;
            }
            catch(Exception ex)
            {
                return null;
            }
        }
                if (null == nowRoom)
                {
                    System.Console.WriteLine("房间文件路径不对，文件路径为：" + roomFilePath);
                    return null;
                }

        /// <summary>
        /// 根据房间Id，获取房间对象
        /// </summary>
        /// <returns>The room by name.</returns>
        /// <param name="roomId">房间ID</param>
        public Room GetRoomById(string roomId)
        {
            return Lists.Find((obj) => obj.Id == roomId);
        }
                var beforeRoom = Lists.Find((obj) => obj.Id == nowRoom.Id);
                if (beforeRoom != null)
                {
                    var tempDeviceUIList = new List<DeviceUI>();
                    tempDeviceUIList.AddRange(beforeRoom.DeviceUIList);
                    var tempSceneUIList = new List<SceneUI>();
                    tempSceneUIList.AddRange(beforeRoom.SceneUIList);
                    //设备（deviceUI）
                    beforeRoom.DeviceUIList.Clear();
                    foreach (var deviceFilePath in beforeRoom.DeviceUIFilePathList)
                    {
                        beforeRoom.DeviceUIList.Add(Common.LocalDevice.Current.GetDeviceUI(deviceFilePath));
                    }
                    //场景(SceneUI)
                    beforeRoom.SceneUIList.Clear();
                    foreach (var sceneFilePath in beforeRoom.SceneUIFilePathList)
                    {
                        var jsonInfo = Encoding.UTF8.GetString(Global.ReadFileByHomeId(sceneFilePath));
                        var tempSceneUI = Newtonsoft.Json.JsonConvert.DeserializeObject<SceneUI>(jsonInfo);
                        if (tempSceneUI != null)
                        {
                            var scene = tempSceneUIList.Find((obj) => obj.FileName == tempSceneUI.FileName);
                            if (scene != null)
                            {
                                beforeRoom.SceneUIList.Add(scene);
                            }
                            else
                            {
                                beforeRoom.AddScene(scene);
                            }
                        }
                    }

        /// <summary>
        /// 根据设备获取房间名字(楼层+房间名)
        /// </summary>
        /// <returns>房间名</returns>
        /// <param name="device">设备对象</param>
        public string GetRoomNameByDevice(CommonDevice device)
        {
            var room = this.GetRoomByDevice(device);
            if (room == null)

            {

                //未分配区域

                return Language.StringByID(R.MyInternationalizationString.uDeviceNotAssignedRoom);

            }
            if (Config.Instance.Home.FloorDics.ContainsKey(room.FloorId) == true)

            {

                //(楼层+房间名)

                return Config.Instance.Home.FloorDics[room.FloorId] + " " + room.Name;

            }
            return room.Name;
        }
                    return beforeRoom;
                }

        /// <summary>
        /// 获取设备所在的房间
        /// </summary>
        /// <returns>The room by device.</returns>
        /// <param name="device">设备对象</param>
        public Room GetRoomByDevice(CommonDevice device)
        {
            var deviceUI = new DeviceUI { };

            deviceUI.DeviceAddr = device.DeviceAddr;

            deviceUI.DeviceEpoint = device.DeviceEpoint;
                //设备（deviceUI）
                nowRoom.DeviceUIList.Clear();
                foreach (var deviceFilePath in nowRoom.DeviceUIFilePathList)
                {
                    var tempCommon = LocalDevice.Current.GetDeviceUI(deviceFilePath);
                    if (tempCommon == null || tempCommon.CommonDevice == null)
                    {
                        continue;
                    }
                    nowRoom.DeviceUIList.Add(tempCommon);
                }
                //场景(SceneUI)
                nowRoom.SceneUIList.Clear();
                foreach (var sceneUIFilePath in nowRoom.SceneUIFilePathList)
                {
                    var jsonInfo = Encoding.UTF8.GetString(Global.ReadFileByHomeId(sceneUIFilePath));
                    var tempScene = Newtonsoft.Json.JsonConvert.DeserializeObject<SceneUI>(jsonInfo);
                    if (tempScene == null)
                    {
                        continue;
                    }
                    nowRoom.SceneUIList.Add(tempScene);
                }
                return nowRoom;
            }
            catch (Exception ex)
            {
                return null;
            }
        }

            return Lists.Find((obj) => obj.DeviceUIFilePathList.Contains(deviceUI.FileName));
        }
        /// <summary>
        /// 根据房间Id，获取房间对象
        /// </summary>
        /// <returns>The room by name.</returns>
        /// <param name="roomId">房间ID</param>
        public Room GetRoomById(string roomId)
        {
            return Lists.Find((obj) => obj.Id == roomId);
        }

        /// <summary>
        /// 通过场景id获取房间名
        /// </summary>
        /// <returns>The room name by scene identifier.</returns>
        /// <param name="sceneId">Scene identifier.</param>
        public string GetRoomNameBySceneId(int sceneId)
        {
            var room = GetRoomBySceneId(sceneId);
            if (room == null)
            {
                return null;
            }
            return room.Name;
        }
        /// <summary>
        /// 根据设备获取房间名字(楼层+房间名)
        /// </summary>
        /// <returns>房间名</returns>
        /// <param name="device">设备对象</param>
        public string GetRoomNameByDevice(CommonDevice device)
        {
            var room = this.GetRoomByDevice(device);
            if (room == null)
            {
                //未分配区域
                return Language.StringByID(R.MyInternationalizationString.uDeviceNotAssignedRoom);
            }
            if (Config.Instance.Home.FloorDics.ContainsKey(room.FloorId) == true)
            {
                //(楼层+房间名)
                return Config.Instance.Home.FloorDics[room.FloorId] + " " + room.Name;
            }
            return room.Name;
        }

        /// <summary>
        /// 通过场景id获取房间对象
        /// </summary>
        /// <returns>The room  by scene identifier.</returns>
        /// <param name="sceneId">Scene identifier.</param>
        public Room GetRoomBySceneId(int sceneId)
        {
            foreach (var r in Lists)
            {
                foreach (var scene in r.SceneUIList)
                {
                    if (scene.Id == sceneId)
                    {
                        return r;
                    }
                }
            }
            return null;
        }
        /// <summary>
        /// 获取设备所在的房间
        /// </summary>
        /// <returns>The room by device.</returns>
        /// <param name="device">设备对象</param>
        public Room GetRoomByDevice(CommonDevice device)
        {
            var deviceUI = new DeviceUI { };
            deviceUI.DeviceAddr = device.DeviceAddr;
            deviceUI.DeviceEpoint = device.DeviceEpoint;

            return Lists.Find((obj) => obj.DeviceUIFilePathList.Contains(deviceUI.FileName));
        }

        #endregion
        /// <summary>
        /// 通过场景id获取房间名
        /// </summary>
        /// <returns>The room name by scene identifier.</returns>
        /// <param name="sceneId">Scene identifier.</param>
        public string GetRoomNameBySceneId(int sceneId)
        {
            var room = GetRoomBySceneId(sceneId);
            if (room == null)
            {
                return null;
            }
            return room.Name;
        }

        #region ◆ 房间方法________________________
        /// <summary>
        /// 通过场景id获取房间对象
        /// </summary>
        /// <returns>The room  by scene identifier.</returns>
        /// <param name="sceneId">Scene identifier.</param>
        public Room GetRoomBySceneId(int sceneId)
        {
            foreach (var r in Lists)
            {
                foreach (var scene in r.SceneUIList)
                {
                    if (scene.Id == sceneId)
                    {
                        return r;
                    }
                }
            }
            return null;
        }

        /// <summary>
        /// 设备的房间变更
        /// </summary>
        /// <param name="device">设备对象</param>
        /// <param name="roomId">新房间Id</param>
        public void ChangedRoom(CommonDevice device, string roomId)
        {
            //房间是否修改
            if (this.IsRoomChanged(device, roomId) == false)
            {
                return;
            }
            //从原来的房间移除设备
            this.DeleteDevice(device);

            //添加到新的房间
            var room = this.GetRoomById(roomId);
            if (room != null)

            {

                room.AddDevice(device);

            }
        }



        /// <summary>
        /// 房间名字是否有修改
        /// </summary>
        /// <param name="device">设备对象</param>
        /// <param name="roomId">新房间Id</param>
        /// <returns></returns>
        public bool IsRoomChanged(CommonDevice device, string roomId)
        {
            var room = this.GetRoomByDevice(device);
            if (room == null || room.Id != roomId)

            {

                return true;

            }
            return false;
        }
        #endregion

        #endregion
        #region ◆ 房间方法________________________

        #region ◆ 更新房间_________________________
        /// <summary>
        /// 设备的房间变更
        /// </summary>
        /// <param name="device">设备对象</param>
        /// <param name="roomId">新房间Id</param>
        public void ChangedRoom(CommonDevice device, string roomId)
        {
            //房间是否修改
            if (this.IsRoomChanged(device, roomId) == false)
            {
                return;
            }
            //从原来的房间移除设备
            this.DeleteDevice(device);

        /// <summary>
        /// Updates the memorry.
        /// </summary>
        /// <param name="roomFilePath">Room file path.</param>
        public static void UpdateMemorry(string roomFilePath)
        {
            GetRoomByFilePath(roomFilePath);
        }
            //添加到新的房间
            var room = this.GetRoomById(roomId);
            if (room != null)
            {
                room.AddDevice(device);
            }
        }

        /// <summary>
        /// 房间名字是否有修改
        /// </summary>
        /// <param name="device">设备对象</param>
        /// <param name="roomId">新房间Id</param>
        /// <returns></returns>
        public bool IsRoomChanged(CommonDevice device, string roomId)
        {
            var room = this.GetRoomByDevice(device);
            if (room == null || room.Id != roomId)
            {
                return true;
            }
            return false;
        }

        #endregion

        #region ◆ 更新房间_________________________

        /// <summary>
        /// Updates the memorry.
        /// </summary>
        /// <param name="roomFilePath">Room file path.</param>
        public static void UpdateMemorry(string roomFilePath)
        {
            GetRoomByFilePath(roomFilePath);
        }

        #endregion

        #region ◆ 房间背景图的相关___________________
        /// <summary>
        /// 删除背景图片
        /// </summary>
        /// <param name="fileName">fileName实际上包含了住宅路劲 如 住宅/文件名.</param>
        public static void DeleteBackGroundIamageFilebyHomeId(string fileName)
        {
            if (fileName == null)
            {
                return;
            }
            var pathLists = fileName.Split('/');
            if (pathLists == null || pathLists.Count() < 9 || pathLists[8] == null)
            {
                return;
            }
            var path = System.IO.Path.Combine(Config.Instance.FullPath, fileName);
            if (!Global.IsExistsByHomeId(pathLists[8]))
            {
                return;
            }
            //删除本地图片
            System.IO.File.Delete(path);
            //删除备份
            Phone.UserCenter.HdlAutoBackupLogic.DeleteFile(pathLists[8]);
        }

        /// <summary>
        /// 移动背景图片到住宅目录下
        /// </summary>
        /// <param name="oldFile">需要移动的文件(直接文件名)</param>
        /// <param name="newFile">要移动到的位置-(包含住宅路径：住宅/文件名)</param>
        public void MoveBackGroundIamageFileToDirectory(string oldFile, string newFile)
        {
            try
            {
                var newPath = System.IO.Path.Combine(Config.Instance.FullPath, newFile);
                var path = System.IO.Path.Combine(Shared.IO.FileUtils.RootPath, oldFile);
                Global.MoveFileToDirectory(path, newPath);
                //备份
                Phone.UserCenter.HdlAutoBackupLogic.AddOrEditorFile(oldFile);
                //Save();
            }
            catch (Exception ex)
            {
                System.Console.WriteLine("移动图片异常 " + ex.Message);
            }
        }

        #endregion

        #region ◆ 添加设备________________________

        /// <summary>
        /// 添加设备
        /// </summary>
        /// <param name="deviceUIFilePath">Device UIF ile path.</param>
        public void AddDevice(string deviceUIFilePath)
        {
            if (string.IsNullOrEmpty(deviceUIFilePath))
            {
                return;
            }
            var jsonInfo = Encoding.UTF8.GetString(Global.ReadFileByHomeId(deviceUIFilePath));
            var deviceUI = Newtonsoft.Json.JsonConvert.DeserializeObject<DeviceUI>(jsonInfo);
            if (null == deviceUI || null == deviceUI.CommonDevice)
            {
                //当前对象数据无效
                return;
            }
            if (!DeviceUIFilePathList.Contains(deviceUIFilePath) && !DeviceUIList.Contains(deviceUI))
            {
                DeviceUIFilePathList.Add(deviceUIFilePath);
                DeviceUIList.Add(deviceUI);
            }
            //保存到本地
            Save();
        }

        /// <summary>
        /// 添加设备
        /// </summary>
        /// <param name="device">要添加的设备对象</param>
        public void AddDevice(CommonDevice device)
        {
            if (device == null)
            {
                return;
            }
            //设备信息保存到本地
            device.Save();

            //添加自动备份
            HdlAutoBackupLogic.AddOrEditorFile(device.FilePath);

            DeviceUI deviceUI = Common.LocalDevice.Current.GetDeviceUI(device);
            if (DeviceUIFilePathList.Contains(deviceUI.FileName) == false)
            {
                DeviceUIFilePathList.Add(deviceUI.FileName);
                DeviceUIList.Add(deviceUI);
                //保存到本地
                Save();

                //添加自动备份
                HdlAutoBackupLogic.AddOrEditorFile(FileName);
            }
        }

        #endregion

        #region ◆ 删除设备_________________________

        /// <summary>
        /// 删除功能-设备
        /// </summary>
        /// <param name="deviceUIFilePath">Device UIF ile path.</param>
        public void DeleteDevice(string deviceUIFilePath)
        {
            if (deviceUIFilePath == null) return;
            if (DeviceUIFilePathList.Contains(deviceUIFilePath) && Global.IsExistsByHomeId(deviceUIFilePath))
            {
                DeviceUIFilePathList.Remove(deviceUIFilePath);
                DeviceUIList.RemoveAll((obj) => obj.FileName == deviceUIFilePath);
                HdlAutoBackupLogic.DeleteFile(deviceUIFilePath);
                Save();
            }
        }

        /// <summary>
        /// 删除设备
        /// </summary>
        /// <param name="device">要删除的设备对象</param>
        public void DeleteDevice(CommonDevice device)
        {
            if (device == null)
            {
                return;
            }
            DeviceUI deviceUI = new DeviceUI();
            deviceUI.DeviceAddr = device.DeviceAddr;
            deviceUI.DeviceEpoint = device.DeviceEpoint;

            //根据设备，获取所在的房间
            var room = this.GetRoomByDevice(device);
            if (room == null)
            {
                return;
            }
            //移除缓存
            if (room.DeviceUIFilePathList.Contains(deviceUI.FileName) == false)
            {
                return;
            }
            room.DeviceUIFilePathList.Remove(deviceUI.FileName);

            room.DeviceUIList.RemoveAll((obj) => obj.FileName == deviceUI.FileName);
            room.Save();
            //更改自动备份
            HdlAutoBackupLogic.AddOrEditorFile(room.FileName);
        }

        #endregion

        #region ◆ 获取设备_________________________

        /// <summary>
        /// 获取所有房间的所有设备
        /// </summary>
        public static void GetAllRoomDeviceUIList()
        {
            List<string> devicePathList = new List<string>();
            //所有房间的所有设备
            AllRoomDeviceUIList.Clear();
            foreach (var room in Shared.Common.Room.Lists)
            {
                if (room.IsSharedRoom)
                {
                    continue;
                }
                if (room.DeviceUIList.Count == 0)
                {
                    continue;
                }
                foreach (var device in room.DeviceUIList)
                {
                    if (device == null || device.CommonDevice == null)
                    {
                        continue;
                    }
                    if (!devicePathList.Contains(device.FileName))
                    {
                        AllRoomDeviceUIList.Add(device);
                        devicePathList.Add(device.FileName);
                    }
                }
            }
        }

        #endregion
        /// <summary>
        /// 根据设备获取它的UI对象，如果不存在则新建
        /// </summary>
        /// <returns>The device user interface.</returns>
        /// <param name="device">设备对象</param>
        public DeviceUI GetDeviceUI(CommonDevice device)
        {
            return Common.LocalDevice.Current.GetDeviceUI(device);
        }

        #region ◆ 房间背景图的相关___________________
        /// <summary>
        /// 删除背景图片
        /// </summary>
        /// <param name="fileName">fileName实际上包含了住宅路劲 如 住宅/文件名.</param>
        public static void DeleteBackGroundIamageFilebyHomeId(string fileName)
        {
            if (fileName == null)
            {
                return;
            }
            var pathLists = fileName.Split('/');
            if (pathLists == null || pathLists.Count() < 9 || pathLists[8] == null)
            {
                return;
            }
            var path = System.IO.Path.Combine(Config.Instance.FullPath, fileName);
            if (!Global.IsExistsByHomeId(pathLists[8]))
            {
                return;
            }
            //删除本地图片
            System.IO.File.Delete(path);
            //删除备份
            Phone.UserCenter.HdlAutoBackupLogic.DeleteFile(pathLists[8]);
        }
        /// <summary>
        /// 重新获取-所有房间的所有设备类型
        /// </summary>
        public static void GetAllRoomDeviceTypeList()
        {
            AllRoomDeviceTypeList.Clear();
            foreach (var deviceUI in AllRoomDeviceUIList)
            {
                if (deviceUI == null || deviceUI.CommonDevice == null)
                {
                    continue;
                }
                if (!AllRoomDeviceTypeList.Contains(deviceUI.CommonDevice.Type))
                {
                    AllRoomDeviceTypeList.Add(deviceUI.CommonDevice.Type);
                }
            }
        }

        /// <summary>
        /// 移动背景图片到住宅目录下
        /// </summary>
        /// <param name="oldFile">需要移动的文件(直接文件名)</param>
        /// <param name="newFile">要移动到的位置-(包含住宅路径：住宅/文件名)</param>
        public void MoveBackGroundIamageFileToDirectory(string oldFile, string newFile)
        {
            try
            {
                var newPath = System.IO.Path.Combine(Config.Instance.FullPath, newFile);
                var path = System.IO.Path.Combine(Shared.IO.FileUtils.RootPath,oldFile);
                Global.MoveFileToDirectory(path, newPath);
                //备份
                Phone.UserCenter.HdlAutoBackupLogic.AddOrEditorFile(oldFile);
                //Save();
            }
            catch (Exception ex)
            {
                System.Console.WriteLine("移动图片异常 " + ex.Message);
            }
        }
        /// <summary>
        /// 获取当前房间下的全部设备
        /// </summary>
        /// <returns></returns>
        public List<CommonDevice> GetRoomListDevice()
        {
            var listDevice = new List<CommonDevice>();
            foreach (var device in this.DeviceUIList)
            {
                if (device == null || device.CommonDevice == null)
                {
                    continue;
                }
                listDevice.Add(device.CommonDevice);
            }
            if (listDevice.Count == 0)
            {
                return listDevice;
            }
            return Common.LocalDevice.Current.SortDevice(listDevice);
        }

        #endregion
        #endregion

        #region ◆ 添加设备________________________
        #region ◆ 添加场景_________________________

        /// <summary>
        /// 添加设备
        /// </summary>
        /// <param name="deviceUIFilePath">Device UIF ile path.</param>
        public void AddDevice(string deviceUIFilePath)
        {
            if (string.IsNullOrEmpty(deviceUIFilePath))
            {
                return;
            }
            var jsonInfo = Encoding.UTF8.GetString(Global.ReadFileByHomeId(deviceUIFilePath));
            var deviceUI = Newtonsoft.Json.JsonConvert.DeserializeObject<DeviceUI>(jsonInfo);
            if (null == deviceUI || null == deviceUI.CommonDevice)
            {
                //当前对象数据无效
                return;
            }
            if (!DeviceUIFilePathList.Contains(deviceUIFilePath) && !DeviceUIList.Contains(deviceUI))
            {
                DeviceUIFilePathList.Add(deviceUIFilePath);
                DeviceUIList.Add(deviceUI);
            }
            //保存到本地
            Save();
        }
        /// <summary>
        /// 添加场景  0失败 1成功  -1已经存在
        /// </summary>
        /// <returns>The scene.</returns>
        /// <param name="sceneName">Scene name.</param>
        /// <param name="sceneIconPath">背景图片，不包含住宅路径 如果iconPathType=1或者2 需要拼接住宅 变成 住宅/sceneIconPath</param>
        /// <param name="commons">Commons.</param>
        /// <param name="iconPathType">I场景背景图片来源类型 图片来源 0--本地图库 1--拍照 2--系统图库 默认0</param>
        public async System.Threading.Tasks.Task<int> AddScene(string sceneName, string sceneIconPath, List<ZigBee.Device.Scene.AddSceneMemberData> commons, int iconPathType = 0)
        {
            if (AllRoomSceneUIList.Find(s => s.Name == sceneName) != null)
            {
                return -1;
            }
            var getSceneIdAllData = await ZigBee.Device.Scene.GetSceneNewIdAsync(sceneName);
            if (getSceneIdAllData == null || getSceneIdAllData.getSceneIdData == null)
            {
                return 0;
            }
            var getSceneIdData = getSceneIdAllData.getSceneIdData;
            //循环相同报错
            foreach (var tempSceneUI in AllRoomSceneUIList)
            {
                if (tempSceneUI.Id == getSceneIdAllData.getSceneIdData.NewScenesId)
                {
                    //场景已存在
                    return -1;
                }
            }

        /// <summary>
        /// 添加设备
        /// </summary>
        /// <param name="device">要添加的设备对象</param>
        public void AddDevice(CommonDevice device)
        {
            if (device == null)
            {
                return;
            }
            //设备信息保存到本地
            device.Save();
            bool result = true;
            foreach (var common in commons)
            {
                //添加新成员
                var addSceneMemberData = new ZigBee.Device.Scene.AddSceneMemberData
                {
                    DeviceAddr = common.DeviceAddr,
                    Type = common.Type,
                    Epoint = common.Epoint,
                    ScenesId = getSceneIdData.NewScenesId,
                    TaskList = common.TaskList,
                    DelayTime = common.DelayTime,
                    ElseScenesId = common.ElseScenesId
                };
                //common.ScenesId = getSceneIdData.NewScenesId;
                //添加新成员 返回结果
                var addSceneMemberResponseAllData = await ZigBee.Device.Scene.AddSceneMemberAsync(addSceneMemberData);
                if (addSceneMemberResponseAllData == null || addSceneMemberResponseAllData.addSceneMemberResponseData == null)
                {
                    continue;
                }
                var addSceneMemberResponseData = addSceneMemberResponseAllData.addSceneMemberResponseData;
                if (addSceneMemberResponseData == null && addSceneMemberResponseData.Result != 1)
                {
                    result = false;
                }
            }
            //加入成功
            if (result)
            {
                //iconPathType=0 直接传值， iconPathType=1和iconPathType=2需要拼接住宅路径
                var fullPath = sceneIconPath;
                if (iconPathType == 1 || iconPathType == 2)
                {
                    Common.Room.CurrentRoom.MoveBackGroundIamageFileToDirectory(sceneIconPath, $"{Config.Instance.FullPath}/{sceneIconPath}");
                    fullPath = $"{Config.Instance.FullPath}/{sceneIconPath}";
                }
                var sceneUI = new SceneUI
                {
                    Name = sceneName,
                    Id = getSceneIdData.NewScenesId,
                    IconPath = fullPath,
                    IconPathType = iconPathType,
                    AddSceneMemberDataList = commons
                };
                SceneUIList.Add(sceneUI);
                SceneUIFilePathList.Add(sceneUI.FileName);
                sceneUI.Save();
                Save();
                HdlAutoBackupLogic.AddOrEditorFile(sceneUI.FileName);
                return 1;
            }
            return 0;
        }

            //添加自动备份
            HdlAutoBackupLogic.AddOrEditorFile(device.FilePath);
        /// <summary>
        /// 添加场景
        /// </summary>
        /// <param name="scene">Scene.</param>
        public void AddScene(SceneUI scene)
        {
            var sceneUI = new SceneUI
            {
                Name = scene.Name,
                Id = scene.Id,
                IconPath = scene.IconPath,
                IconPathType = scene.IconPathType,
                AddSceneMemberDataList = scene.AddSceneMemberDataList
            };
            SceneUIList.Add(sceneUI);
            SceneUIFilePathList.Add(sceneUI.FileName);
            sceneUI.Save();
            Save();
        }

            DeviceUI deviceUI = Common.LocalDevice.Current.GetDeviceUI(device);
            if (DeviceUIFilePathList.Contains(deviceUI.FileName) == false)
            {
                DeviceUIFilePathList.Add(deviceUI.FileName);
                DeviceUIList.Add(deviceUI);
                //保存到本地
                Save();
        #endregion

                //添加自动备份
                HdlAutoBackupLogic.AddOrEditorFile(FileName);
            }
        }
        #region ◆ 设备是否收藏______________________

        #endregion
        /// <summary>
        /// 是否是收藏设备
        /// </summary>
        /// <param name="room"></param>
        /// <param name="filePath"></param>
        /// <returns></returns>
        public bool IsCollectInRoom(Room room, string filePath)
        {
            if (room.IsLove)
            {
                return true;
            }
            if (GetLoveRoom().DeviceUIFilePathList.Find((obj) => obj == filePath) == null)
            {
                return false;
            }
            return true;
        }
        #endregion

        #region ◆ 删除设备_________________________
        #region ◆ 修改场景________________________

        /// <summary>
        /// 删除功能-设备
        /// </summary>
        /// <param name="deviceUIFilePath">Device UIF ile path.</param>
        public void DeleteDevice(string deviceUIFilePath)
        {
            if (deviceUIFilePath == null) return;
            if (DeviceUIFilePathList.Contains(deviceUIFilePath) && Global.IsExistsByHomeId(deviceUIFilePath))
            {
                DeviceUIFilePathList.Remove(deviceUIFilePath);
                DeviceUIList.RemoveAll((obj) => obj.FileName == deviceUIFilePath);
                HdlAutoBackupLogic.DeleteFile(deviceUIFilePath);
                Save();
            }
        }
        /// <summary>
        /// 修改场景设备 0失败 1成功
        /// </summary>
        /// <returns>The scene.</returns>
        /// <param name="sceneUI">Scene user interface.</param>
        /// <param name="sceneRemoveMemberData">Scene remove member data.</param>
        /// <param name="addCommons">Add commons.</param>
        public async System.Threading.Tasks.Task<int> ModifyScene(SceneUI sceneUI, Scene.SceneRemoveMemberData sceneRemoveMemberData, List<Scene.AddSceneMemberData> addCommons)
        {
            if (AllRoomSceneUIList.Find(s => s.Name == sceneUI.Name) == null)
            {
                return 0;
            }

        /// <summary>
        /// 删除设备
        /// </summary>
        /// <param name="device">要删除的设备对象</param>
        public void DeleteDevice(CommonDevice device)
        {
            if (device == null)
            {
                return;
            }
            DeviceUI deviceUI = new DeviceUI();
            deviceUI.DeviceAddr = device.DeviceAddr;

            deviceUI.DeviceEpoint = device.DeviceEpoint;
            bool result = true;
            //移除成员 返回结果
            var removeSceneMemberResponseAllData = await ZigBee.Device.Scene.RemoveSceneMemberAsync(sceneRemoveMemberData);
            if (removeSceneMemberResponseAllData == null || removeSceneMemberResponseAllData.removeSceneMemberResponseData == null)
            {
                return 0;
            }
            var removeSceneMemberResponseData = removeSceneMemberResponseAllData.removeSceneMemberResponseData;
            if (removeSceneMemberResponseData == null)
            {
                return 0;
            }
            if (removeSceneMemberResponseData.Result != 0)
            {
                result = false;
            }
            //添加
            foreach (var addCommon in addCommons)
            {
                //添加新成员
                var addSceneMemberData = new ZigBee.Device.Scene.AddSceneMemberData
                {
                    DeviceAddr = addCommon.DeviceAddr,
                    Type = addCommon.Type,
                    Epoint = addCommon.Epoint,
                    ScenesId = sceneUI.Id,
                    TaskList = addCommon.TaskList,
                    DelayTime = addCommon.DelayTime,
                    ElseScenesId = addCommon.ElseScenesId
                };
                //添加新成员 返回结果
                var addSceneMemberResponseAllData = await ZigBee.Device.Scene.AddSceneMemberAsync(addSceneMemberData);
                if (addSceneMemberResponseAllData == null || addSceneMemberResponseAllData.addSceneMemberResponseData == null)
                {
                    result = false;
                    System.Console.WriteLine("添加场景失败");
                    continue;
                }
                var addSceneMemberResponseData = addSceneMemberResponseAllData.addSceneMemberResponseData;
                if (addSceneMemberResponseData == null && addSceneMemberResponseData.Result != 1)
                {
                    result = false;
                }
            }
            //加入成功
            if (result)
            {
                sceneUI.AddSceneMemberDataList = addCommons;
                sceneUI.Save();
                return 1;
            }
            return 0;
        }

            //根据设备，获取所在的房间
            var room = this.GetRoomByDevice(device);
            if (room == null)

            {

                return;

            }

            //移除缓存

            if (room.DeviceUIFilePathList.Contains(deviceUI.FileName) == false)

            {

                return;

            }

            room.DeviceUIFilePathList.Remove(deviceUI.FileName);



            room.DeviceUIList.RemoveAll((obj) => obj.FileName == deviceUI.FileName);

            room.Save();

            //更改自动备份

            HdlAutoBackupLogic.AddOrEditorFile(room.FileName);
        }
        #endregion

        #endregion
        #region ◆ 删除场景________________________

        #region ◆ 获取设备_________________________
        /// <summary>
        /// 移除场景--该仅进行了对本地场景数据的删除
        /// </summary>
        /// <param name="sceneUI">Scene user interface.</param>
        public void RemoveScene(SceneUI sceneUI)
        {
            if (Global.IsExistsByHomeId(sceneUI.FileName) == false)
            {
                return;
            }
            SceneUIList.Remove(sceneUI);
            SceneUIFilePathList.Remove(sceneUI.FileName);
            Save();
            Global.DeleteFilebyHomeId(sceneUI.FileName);
            HdlAutoBackupLogic.DeleteFile(sceneUI.FileName);
            HdlAutoBackupLogic.AddOrEditorFile(FileName);
        }

        /// <summary>
        /// 获取所有房间的所有设备
        /// </summary>
        public static void GetAllRoomDeviceUIList()
        {
            List<string> devicePathList = new List<string>();
            //所有房间的所有设备
            AllRoomDeviceUIList.Clear();
            foreach (var room in Shared.Common.Room.Lists)
            {
                if(room.IsSharedRoom)
                {
                    continue;
                }
                if (room.DeviceUIList.Count == 0)
                {
                    continue;
                }
                foreach (var device in room.DeviceUIList)
                {
                    if (device == null || device.CommonDevice == null)
                    {
                        continue;
                    }
                    if (!devicePathList.Contains(device.FileName))
                    {
                        AllRoomDeviceUIList.Add(device);
                        devicePathList.Add(device.FileName);
                    }
                }
            }
        }
        #endregion

        /// <summary>
        /// 根据设备获取它的UI对象，如果不存在则新建
        /// </summary>
        /// <returns>The device user interface.</returns>
        /// <param name="device">设备对象</param>
        public DeviceUI GetDeviceUI(CommonDevice device)
        {
            return Common.LocalDevice.Current.GetDeviceUI(device);
        }
        #region ◆ 获取场景________________________

        /// <summary>
        /// 重新获取-所有房间的所有设备类型
        /// </summary>
        public static void GetAllRoomDeviceTypeList()
        {
            AllRoomDeviceTypeList.Clear();
            foreach (var deviceUI in AllRoomDeviceUIList)
            {
                if (deviceUI == null || deviceUI.CommonDevice == null)
                {
                    continue;
                }
                if (!AllRoomDeviceTypeList.Contains(deviceUI.CommonDevice.Type))
                {
                    AllRoomDeviceTypeList.Add(deviceUI.CommonDevice.Type);
                }
            }
        }
        /// <summary>
        /// 通过场景id获取场景
        /// </summary>
        /// <returns>The scene UIB y scene identifier.</returns>
        /// <param name="sceneId">Scene identifier.</param>
        public SceneUI GetSceneUIBySceneId(int sceneId)
        {
            foreach (var r in Lists)
            {
                foreach (var sceneUI in r.SceneUIList)
                {
                    if (sceneUI.Id == sceneId)
                    {
                        return sceneUI;
                    }
                }
            }
            return null;
        }

        /// <summary>

        /// 获取当前房间下的全部设备

        /// </summary>

        /// <returns></returns>
        public List<CommonDevice> GetRoomListDevice()

        {

            var listDevice = new List<CommonDevice>();

            foreach (var device in this.DeviceUIList)

            {

                if (device == null || device.CommonDevice == null)

                {

                    continue;

                }

                listDevice.Add(device.CommonDevice);

            }

            if (listDevice.Count == 0)

            {

                return listDevice;

            }

            return Common.LocalDevice.Current.SortDevice(listDevice);

        }
        #endregion

        #endregion
        #region ◆ 刷新场景_________________________

        #region ◆ 添加场景_________________________
        /// <summary>
        /// 刷新房间的场景列表
        /// </summary>
        public async System.Threading.Tasks.Task<bool> RefreshSceneUIList()
        {
            return false;
            //System.Console.WriteLine($"开始请求网关场景****{DateTime.Now.ToString("yyMMdd hhmmss fff")}*****");
            //bool result = true;
            //var sceneList = await ZigBee.Device.Scene.GetSceneListAsync();
            //System.Console.WriteLine($"结束请求网关场景****{DateTime.Now.ToString("yyMMdd hhmmss fff")}*****");
            //if (sceneList == null)
            //{
            //    return false;
            //}
            //List<int> sceneIDList = new List<int> { };
            //System.Console.WriteLine($"开始本地场景****{DateTime.Now.ToString("yyMMdd hhmmss fff")}*****");
            //foreach (var scene in sceneList)
            //{
            //    if (scene == null)
            //    {
            //        continue;
            //    }
            //    sceneIDList.Add(scene.ScenesId);
            //}
            //foreach(var r in Lists)
            //{
            //    if(r.SceneUIList==null || r.SceneUIList.Count==0)
            //    {
            //        continue;
            //    }
            //    foreach(var rScene in r.SceneUIList)
            //    {
            //        if(rScene==null)
            //        {
            //            continue;
            //        }
            //        //var scene = sceneList.Find((obj) => rScene.ScenesId == obj.ScenesId);
            //        if(sceneIDList.Contains(rScene.ScenesId)==false)
            //        {
            //            var removeResult = r.SceneUIList.Remove(rScene);
            //            r.Save();
            //            if (removeResult == false)
            //            {
            //                result = false;
            //            }
            //        }
            //    }
            //}
            //System.Console.WriteLine($"结束本地场景****{DateTime.Now.ToString("yyMMdd hhmmss fff")}*****");
            //return result;
        }

        /// <summary>
        /// 添加场景  0失败 1成功  -1已经存在
        /// </summary>
        /// <returns>The scene.</returns>
        /// <param name="sceneName">Scene name.</param>
        /// <param name="sceneIconPath">背景图片，不包含住宅路径 如果iconPathType=1或者2 需要拼接住宅 变成 住宅/sceneIconPath</param>
        /// <param name="commons">Commons.</param>
        /// <param name="iconPathType">I场景背景图片来源类型 图片来源 0--本地图库 1--拍照 2--系统图库 默认0</param>
        public async System.Threading.Tasks.Task<int> AddScene(string sceneName, string sceneIconPath, List<ZigBee.Device.Scene.AddSceneMemberData> commons, int iconPathType = 0)
        {
            if (AllRoomSceneUIList.Find(s => s.Name == sceneName) != null)
            {
                return -1;
            }
            var getSceneIdAllData = await ZigBee.Device.Scene.GetSceneNewIdAsync(sceneName);
            if (getSceneIdAllData == null || getSceneIdAllData.getSceneIdData == null)
            {
                return 0;
            }
            var getSceneIdData = getSceneIdAllData.getSceneIdData;
            //循环相同报错
            foreach (var tempSceneUI in AllRoomSceneUIList)
            {
                if (tempSceneUI.Id == getSceneIdAllData.getSceneIdData.NewScenesId)
                {
                    //场景已存在
                    return -1;
                }
            }
        #endregion

            bool result = true;
            foreach (var common in commons)
            {
                //添加新成员
                var addSceneMemberData = new ZigBee.Device.Scene.AddSceneMemberData
                {
                    DeviceAddr = common.DeviceAddr,
                    Type = common.Type,
                    Epoint = common.Epoint,
                    ScenesId = getSceneIdData.NewScenesId,
                    TaskList = common.TaskList,
                    DelayTime = common.DelayTime,
                    ElseScenesId = common.ElseScenesId
                };
                //common.ScenesId = getSceneIdData.NewScenesId;
                //添加新成员 返回结果
                var addSceneMemberResponseAllData = await ZigBee.Device.Scene.AddSceneMemberAsync(addSceneMemberData);
                if (addSceneMemberResponseAllData == null || addSceneMemberResponseAllData.addSceneMemberResponseData == null)
                {
                    continue;
                }
                var addSceneMemberResponseData = addSceneMemberResponseAllData.addSceneMemberResponseData;
                if (addSceneMemberResponseData == null && addSceneMemberResponseData.Result != 1)
                {
                    result = false;
                }
            }
            //加入成功
            if (result)
            {
                //iconPathType=0 直接传值， iconPathType=1和iconPathType=2需要拼接住宅路径
                var fullPath = sceneIconPath;
                if (iconPathType == 1 || iconPathType == 2)
                {
                    Common.Room.CurrentRoom.MoveBackGroundIamageFileToDirectory(sceneIconPath, $"{Config.Instance.FullPath}/{sceneIconPath}");
                    fullPath = $"{Config.Instance.FullPath}/{sceneIconPath}";
                }
                var sceneUI = new SceneUI
                {
                    Name = sceneName,
                    Id = getSceneIdData.NewScenesId,
                    IconPath = fullPath,
                    IconPathType = iconPathType,
                    AddSceneMemberDataList= commons
                };
                SceneUIList.Add(sceneUI);
                SceneUIFilePathList.Add(sceneUI.FileName);
                sceneUI.Save();
                Save();
                HdlAutoBackupLogic.AddOrEditorFile(sceneUI.FileName);
                return 1;
            }
            return 0;
        }
        #region ◆ 保存____________________________

        /// <summary>
        /// 添加场景
        /// </summary>
        /// <param name="scene">Scene.</param>
        public void AddScene(SceneUI scene)
        {
            var sceneUI = new SceneUI
            {
                Name = scene.Name,
                Id = scene.Id,
                IconPath = scene.IconPath,
                IconPathType = scene.IconPathType,
                AddSceneMemberDataList = scene.AddSceneMemberDataList
            };
            SceneUIList.Add(sceneUI);
            SceneUIFilePathList.Add(sceneUI.FileName);
            sceneUI.Save();
            Save();
        }
        /// <summary>
        /// 保存
        /// </summary>
        /// <param name="autoBackup">是否自动备份，默认true</param>
        public void Save(bool autoBackup = true)
        {
            //保存房间信息
            Global.WriteFileByBytesByHomeId(FileName, System.Text.Encoding.UTF8.GetBytes(Newtonsoft.Json.JsonConvert.SerializeObject(this)));
            if (autoBackup == true)
            {
                HdlAutoBackupLogic.AddOrEditorFile(FileName);
            }
        }

        #endregion
        #endregion

        #region ◆ 设备是否收藏______________________
        #region ◆ 楼层和房间顺序相关_______________

        /// <summary>
        /// 是否是收藏设备
        /// </summary>
        /// <param name="room"></param>
        /// <param name="filePath"></param>
        /// <returns></returns>
        public bool IsCollectInRoom(Room room,string filePath)
        {
            if(room.IsLove)
            {
                return true;
            }
            if (GetLoveRoom().DeviceUIFilePathList.Find((obj) => obj == filePath) == null)
            {
                return false;
            }
            return true;
        }
        #endregion
        /// <summary>
        /// 根据楼层的主键获取排序后的房间列表
        /// </summary>
        /// <param name="i_floorKeys">楼层的主键</param>
        /// <param name="getShard">分享的房间是否也获取</param>
        /// <returns></returns>
        public List<Room> GetFloorSortRoom(string i_floorKeys, bool getShard = true)
        {
            Dictionary<string, List<string>> dicAllSort = new Dictionary<string, List<string>>();
            //读取房间顺序
            string fullName = UserCenterLogic.CombinePath(DirNameResourse.LocalMemoryDirectory, DirNameResourse.RoomSortFile);
            var strData = UserCenterLogic.LoadFileContent(fullName);
            if (strData != null)
            {
                dicAllSort = Newtonsoft.Json.JsonConvert.DeserializeObject<Dictionary<string, List<string>>>(strData);
            }

        #region ◆ 修改场景________________________
            var listRoomSort = new List<string>();
            if (dicAllSort.ContainsKey(i_floorKeys) == true)
            {
                listRoomSort = dicAllSort[i_floorKeys];
            }
            else
            {
                dicAllSort[i_floorKeys] = listRoomSort;
            }

        /// <summary>
        /// 修改场景设备 0失败 1成功
        /// </summary>
        /// <returns>The scene.</returns>
        /// <param name="sceneUI">Scene user interface.</param>
        /// <param name="sceneRemoveMemberData">Scene remove member data.</param>
        /// <param name="addCommons">Add commons.</param>
        public async System.Threading.Tasks.Task<int> ModifyScene(SceneUI sceneUI, Scene.SceneRemoveMemberData sceneRemoveMemberData, List<Scene.AddSceneMemberData> addCommons)
        {
            if (AllRoomSceneUIList.Find(s => s.Name == sceneUI.Name) == null)
            {
                return 0;
            }
            var dicRoom = new Dictionary<string, Common.Room>();
            foreach (var room in Common.Room.Lists)
            {
                if (room.FloorId != i_floorKeys || room.IsLove == true)
                {
                    //不是同一个楼层
                    continue;
                }
                if (listRoomSort.Contains(room.Id) == false)
                {
                    //新添加的房间
                    listRoomSort.Add(room.Id);
                }
                if (getShard == false && room.IsSharedRoom == true)
                {
                    //不要分享的房间
                    continue;
                }
                dicRoom[room.Id] = room;
            }

            bool result = true;
            //移除成员 返回结果
            var removeSceneMemberResponseAllData = await ZigBee.Device.Scene.RemoveSceneMemberAsync(sceneRemoveMemberData);
            if (removeSceneMemberResponseAllData == null || removeSceneMemberResponseAllData.removeSceneMemberResponseData == null)
            {
                return 0;
            }
            var removeSceneMemberResponseData = removeSceneMemberResponseAllData.removeSceneMemberResponseData;
            if (removeSceneMemberResponseData == null)
            {
                return 0;
            }
            if (removeSceneMemberResponseData.Result != 0)
            {
                result = false;
            }
            //添加
            foreach (var addCommon in addCommons)
            {
                //添加新成员
                var addSceneMemberData = new ZigBee.Device.Scene.AddSceneMemberData
                {
                    DeviceAddr = addCommon.DeviceAddr,
                    Type = addCommon.Type,
                    Epoint = addCommon.Epoint,
                    ScenesId = sceneUI.Id,
                    TaskList = addCommon.TaskList,
                    DelayTime = addCommon.DelayTime,
                    ElseScenesId = addCommon.ElseScenesId
                };
                //添加新成员 返回结果
                var addSceneMemberResponseAllData = await ZigBee.Device.Scene.AddSceneMemberAsync(addSceneMemberData);
                if (addSceneMemberResponseAllData == null || addSceneMemberResponseAllData.addSceneMemberResponseData == null)
                {
                    result = false;
                    System.Console.WriteLine("添加场景失败");
                    continue;
                }
                var addSceneMemberResponseData = addSceneMemberResponseAllData.addSceneMemberResponseData;
                if (addSceneMemberResponseData == null && addSceneMemberResponseData.Result != 1)
                {
                    result = false;
                }
            }
            //加入成功
            if (result)
            {
                sceneUI.AddSceneMemberDataList = addCommons;
                sceneUI.Save();
                return 1;
            }
            return 0;
        }
            var listSortRoom = new List<Room>();
            for (int i = 0; i < listRoomSort.Count; i++)
            {
                if (dicRoom.ContainsKey(listRoomSort[i]) == true)
                {
                    listSortRoom.Add(dicRoom[listRoomSort[i]]);
                }
            }

        #endregion
            //保存顺序
            UserCenterLogic.SaveFileContent(fullName, dicAllSort);
            return listSortRoom;
        }

        #region ◆ 删除场景________________________
        /// <summary>
        /// 保存房间的顺序
        /// </summary>
        /// <param name="i_floorKeys">楼层主键</param>
        /// <param name="listSort">房间顺序(房间的主键)</param>
        public void SaveRoomSort(string i_floorKeys, List<string> listSort)
        {
            Dictionary<string, List<string>> dicAllSort = new Dictionary<string, List<string>>();
            //读取房间顺序
            string fullName = UserCenterLogic.CombinePath(DirNameResourse.LocalMemoryDirectory, DirNameResourse.RoomSortFile);
            var strData = UserCenterLogic.LoadFileContent(fullName);
            if (strData != null)
            {
                dicAllSort = Newtonsoft.Json.JsonConvert.DeserializeObject<Dictionary<string, List<string>>>(strData);
            }

        /// <summary>
        /// 移除场景--该仅进行了对本地场景数据的删除
        /// </summary>
        /// <param name="sceneUI">Scene user interface.</param>
        public void RemoveScene(SceneUI sceneUI)
        {
            if(Global.IsExistsByHomeId(sceneUI.FileName)==false)
            {
                return;
            }
            SceneUIList.Remove(sceneUI);
            SceneUIFilePathList.Remove(sceneUI.FileName);
            Save();
            Global.DeleteFilebyHomeId(sceneUI.FileName);
            HdlAutoBackupLogic.DeleteFile(sceneUI.FileName);
            HdlAutoBackupLogic.AddOrEditorFile(FileName);
        }
            //保存顺序
            dicAllSort[i_floorKeys] = listSort;
            UserCenterLogic.SaveFileContent(fullName, dicAllSort);
            dicAllSort.Clear();
        }

        #endregion
        /// <summary>
        /// 获取排序后的楼层
        /// </summary>
        /// <returns></returns>
        public Dictionary<string, string> GetFloorSortList()
        {
            //读取楼层顺序
            var listFloorSort = new List<string>();
            string fullName = UserCenterLogic.CombinePath(DirNameResourse.LocalMemoryDirectory, DirNameResourse.FloorSortFile);
            var strData = UserCenterLogic.LoadFileContent(fullName);
            if (strData != null)
            {
                listFloorSort = Newtonsoft.Json.JsonConvert.DeserializeObject<List<string>>(strData);
            }
            foreach (string keys in Common.Config.Instance.Home.FloorDics.Keys)
            {
                if (listFloorSort.Contains(keys) == false)
                {
                    //新添加的楼层
                    listFloorSort.Add(keys);
                }
            }

        #region ◆ 获取场景________________________
            var dic = new Dictionary<string, string>();
            for (int i = 0; i < listFloorSort.Count; i++)
            {
                if (Config.Instance.Home.FloorDics.ContainsKey(listFloorSort[i]) == true)
                {
                    dic[listFloorSort[i]] = Config.Instance.Home.FloorDics[listFloorSort[i]];
                }
            }

        /// <summary>
        /// 通过场景id获取场景
        /// </summary>
        /// <returns>The scene UIB y scene identifier.</returns>
        /// <param name="sceneId">Scene identifier.</param>
        public SceneUI GetSceneUIBySceneId(int sceneId)
        {
            foreach (var r in Lists)
            {
                foreach (var sceneUI in r.SceneUIList)
                {
                    if (sceneUI.Id == sceneId)
                    {
                        return sceneUI;
                    }
                }
            }
            return null;
        }
            //保存顺序
            UserCenterLogic.SaveFileContent(fullName, listFloorSort);
            return dic;
        }

        #endregion
        /// <summary>
        /// 保存楼层的顺序
        /// </summary>
        /// <param name="listSort">楼层的主键</param>
        public void SaveFloorSort(List<string> listSort)
        {
            string fullName = UserCenterLogic.CombinePath(DirNameResourse.LocalMemoryDirectory, DirNameResourse.FloorSortFile);
            //保存顺序
            UserCenterLogic.SaveFileContent(fullName, listSort);
        }

        #region ◆ 刷新场景_________________________
        #endregion

        /// <summary>
        /// 刷新房间的场景列表
        /// </summary>
        public async System.Threading.Tasks.Task<bool> RefreshSceneUIList()
        {
            return false;
            //System.Console.WriteLine($"开始请求网关场景****{DateTime.Now.ToString("yyMMdd hhmmss fff")}*****");
            //bool result = true;
            //var sceneList = await ZigBee.Device.Scene.GetSceneListAsync();
            //System.Console.WriteLine($"结束请求网关场景****{DateTime.Now.ToString("yyMMdd hhmmss fff")}*****");
            //if (sceneList == null)
            //{
            //    return false;
            //}
            //List<int> sceneIDList = new List<int> { };
            //System.Console.WriteLine($"开始本地场景****{DateTime.Now.ToString("yyMMdd hhmmss fff")}*****");
            //foreach (var scene in sceneList)
            //{
            //    if (scene == null)
            //    {
            //        continue;
            //    }
            //    sceneIDList.Add(scene.ScenesId);
            //}
            //foreach(var r in Lists)
            //{
            //    if(r.SceneUIList==null || r.SceneUIList.Count==0)
            //    {
            //        continue;
            //    }
            //    foreach(var rScene in r.SceneUIList)
            //    {
            //        if(rScene==null)
            //        {
            //            continue;
            //        }
            //        //var scene = sceneList.Find((obj) => rScene.ScenesId == obj.ScenesId);
            //        if(sceneIDList.Contains(rScene.ScenesId)==false)
            //        {
            //            var removeResult = r.SceneUIList.Remove(rScene);
            //            r.Save();
            //            if (removeResult == false)
            //            {
            //                result = false;
            //            }
            //        }
            //    }
            //}
            //System.Console.WriteLine($"结束本地场景****{DateTime.Now.ToString("yyMMdd hhmmss fff")}*****");
            //return result;
        }
        #region ◆ 克隆房间对象_____________________

        #endregion
        /// <summary>
        /// 克隆房间对象
        /// </summary>
        /// <returns></returns>
        public Room CloneRoomClass()
        {
            var newRoom = new Room();
            //克隆属性
            newRoom.Id = this.Id;
            newRoom.FloorId = this.FloorId;
            newRoom.TemperatrueDevice = this.TemperatrueDevice;
            newRoom.HumidityDevice = this.HumidityDevice;
            newRoom.Name = this.Name;
            newRoom.BackgroundImage = this.BackgroundImage;
            newRoom.BackgroundImageType = this.BackgroundImageType;

        #region ◆ 保存____________________________
            return newRoom;
        }

        /// <summary>
        /// 保存
        /// </summary>
        /// <param name="autoBackup">是否自动备份，默认true</param>
        public void Save(bool autoBackup = true)
        {
            //保存房间信息
            Global.WriteFileByBytesByHomeId(FileName, System.Text.Encoding.UTF8.GetBytes(Newtonsoft.Json.JsonConvert.SerializeObject(this)));
            if (autoBackup == true)
            {
                HdlAutoBackupLogic.AddOrEditorFile(FileName);
            }
        }



        #endregion


        #region ◆ 楼层和房间顺序相关_______________



        /// <summary>

        /// 根据楼层的主键获取排序后的房间列表

        /// </summary>

        /// <param name="i_floorKeys">楼层的主键</param>

        /// <param name="getShard">分享的房间是否也获取</param>

        /// <returns></returns>

        public List<Room> GetFloorSortRoom(string i_floorKeys, bool getShard = true)

        {

            Dictionary<string, List<string>> dicAllSort = new Dictionary<string, List<string>>();

            //读取房间顺序

            string fullName = UserCenterLogic.CombinePath(DirNameResourse.LocalMemoryDirectory, DirNameResourse.RoomSortFile);

            var strData = UserCenterLogic.LoadFileContent(fullName);

            if (strData != null)

            {

                dicAllSort = Newtonsoft.Json.JsonConvert.DeserializeObject<Dictionary<string, List<string>>>(strData);

            }



            var listRoomSort = new List<string>();

            if (dicAllSort.ContainsKey(i_floorKeys) == true)

            {

                listRoomSort = dicAllSort[i_floorKeys];

            }

            else

            {

                dicAllSort[i_floorKeys] = listRoomSort;

            }



            var dicRoom = new Dictionary<string, Common.Room>();

            foreach (var room in Common.Room.Lists)

            {

                if (room.FloorId != i_floorKeys || room.IsLove == true)

                {

                    //不是同一个楼层

                    continue;

                }

                if (listRoomSort.Contains(room.Id) == false)

                {

                    //新添加的房间

                    listRoomSort.Add(room.Id);

                }

                if (getShard == false && room.IsSharedRoom == true)

                {

                    //不要分享的房间

                    continue;

                }

                dicRoom[room.Id] = room;

            }



            var listSortRoom = new List<Room>();

            for (int i = 0; i < listRoomSort.Count; i++)

            {

                if (dicRoom.ContainsKey(listRoomSort[i]) == true)

                {

                    listSortRoom.Add(dicRoom[listRoomSort[i]]);

                }

            }



            //保存顺序

            UserCenterLogic.SaveFileContent(fullName, dicAllSort);

            return listSortRoom;

        }



        /// <summary>

        /// 保存房间的顺序

        /// </summary>

        /// <param name="i_floorKeys">楼层主键</param>

        /// <param name="listSort">房间顺序(房间的主键)</param>

        public void SaveRoomSort(string i_floorKeys, List<string> listSort)

        {

            Dictionary<string, List<string>> dicAllSort = new Dictionary<string, List<string>>();

            //读取房间顺序

            string fullName = UserCenterLogic.CombinePath(DirNameResourse.LocalMemoryDirectory, DirNameResourse.RoomSortFile);

            var strData = UserCenterLogic.LoadFileContent(fullName);

            if (strData != null)

            {

                dicAllSort = Newtonsoft.Json.JsonConvert.DeserializeObject<Dictionary<string, List<string>>>(strData);

            }



            //保存顺序

            dicAllSort[i_floorKeys] = listSort;

            UserCenterLogic.SaveFileContent(fullName, dicAllSort);

            dicAllSort.Clear();

        }



        /// <summary>

        /// 获取排序后的楼层

        /// </summary>

        /// <returns></returns>

        public Dictionary<string, string> GetFloorSortList()

        {

            //读取楼层顺序

            var listFloorSort = new List<string>();

            string fullName = UserCenterLogic.CombinePath(DirNameResourse.LocalMemoryDirectory, DirNameResourse.FloorSortFile);

            var strData = UserCenterLogic.LoadFileContent(fullName);

            if (strData != null)

            {

                listFloorSort = Newtonsoft.Json.JsonConvert.DeserializeObject<List<string>>(strData);

            }

            foreach (string keys in Common.Config.Instance.Home.FloorDics.Keys)

            {

                if (listFloorSort.Contains(keys) == false)

                {

                    //新添加的楼层

                    listFloorSort.Add(keys);

                }

            }



            var dic = new Dictionary<string, string>();

            for (int i = 0; i < listFloorSort.Count; i++)

            {

                if (Config.Instance.Home.FloorDics.ContainsKey(listFloorSort[i]) == true)

                {

                    dic[listFloorSort[i]] = Config.Instance.Home.FloorDics[listFloorSort[i]];

                }

            }



            //保存顺序

            UserCenterLogic.SaveFileContent(fullName, listFloorSort);

            return dic;

        }



        /// <summary>

        /// 保存楼层的顺序

        /// </summary>

        /// <param name="listSort">楼层的主键</param>

        public void SaveFloorSort(List<string> listSort)

        {

            string fullName = UserCenterLogic.CombinePath(DirNameResourse.LocalMemoryDirectory, DirNameResourse.FloorSortFile);

            //保存顺序

            UserCenterLogic.SaveFileContent(fullName, listSort);

        }



        #endregion



        #region ◆ 克隆房间对象_____________________



        /// <summary>

        /// 克隆房间对象

        /// </summary>

        /// <returns></returns>

        public Room CloneRoomClass()

        {

            var newRoom = new Room();

            //克隆属性

            newRoom.Id = this.Id;

            newRoom.FloorId = this.FloorId;

            newRoom.TemperatrueDevice = this.TemperatrueDevice;

            newRoom.HumidityDevice = this.HumidityDevice;

            newRoom.Name = this.Name;

            newRoom.BackgroundImage = this.BackgroundImage;

            newRoom.BackgroundImageType = this.BackgroundImageType;



            return newRoom;

        }



        #endregion
        #endregion

        #region ◆ 楼层___________________________
        #region ◆ 楼层___________________________

        /// <summary>
        /// 获取楼层名称
        /// </summary>
        /// <param name="floorId"></param>
        /// <returns></returns>
        public string GetFloorNameById(string floorId)
        {
            if (Config.Instance.Home.FloorDics.Count == 0)
            {
                return null;
            }
        /// <summary>
        /// 获取楼层名称
        /// </summary>
        /// <param name="floorId"></param>
        /// <returns></returns>
        public string GetFloorNameById(string floorId)
        {
            if (Config.Instance.Home.FloorDics.Count == 0)
            {
                return null;
            }

            foreach (var floor in Config.Instance.Home.FloorDics)
            {
                if (floorId == floor.Key)
                {
                    return floor.Value;
                }
            }
            return null;
        }
            foreach (var floor in Config.Instance.Home.FloorDics)
            {
                if (floorId == floor.Key)
                {
                    return floor.Value;
                }
            }
            return null;
        }

        #endregion
        #endregion

       
    }
    }
}

 ZigbeeApp/Shared/Phone/Device/Category/Category.cs

@@ -22,7 +22,7 @@
        /// <summary>
        /// low_High
        /// </summary>
        private const int low_High= 127;
        private const int low_High = 127;
        /// <summary>
        /// 功能
        /// </summary>
@@ -547,7 +547,7 @@
                {
                    foreach (var floor in Config.Instance.Home.FloorDics)
                    {
                        Config.Instance.Home.CurrentFloorId=floor.Key;
                        Config.Instance.Home.CurrentFloorId = floor.Key;
                        break;
                    }
                }
@@ -561,7 +561,7 @@
        /// <param name="selectedBtn">选中那个界面 0--功能 1--场景 2--自动化 </param>
        public void Show(int selectedBtn = 1)
        {
           

            ZbGateway.StatusList.Add(this);
            RemoveAll();

@@ -664,16 +664,16 @@

            var roomFL = new HorizontalScrolViewLayout()
            {
                X= Application.GetRealWidth(CommonFormResouce.X_Left),
                X = Application.GetRealWidth(CommonFormResouce.X_Left),
                Y = functionSceneAutoBG.Bottom,
                Height = Application.GetRealHeight(167),
                Width=Application.GetRealWidth(CommonPage.AppRealWidth-CommonFormResouce.X_Left),
                Width = Application.GetRealWidth(CommonPage.AppRealWidth - CommonFormResouce.X_Left),
                BackgroundColor = ZigbeeColor.Current.GXCGrayBackgroundColor
            };
            midFL.AddChidren(roomFL);

            Button curBtn = new Button();
            for(int i=0;i<Config.Instance.Home.RoomFilePathList.Count;i++)
            for (int i = 0; i < Config.Instance.Home.RoomFilePathList.Count; i++)
            {
                var roomFilePath = Config.Instance.Home.RoomFilePathList[i];
                var room = Shared.Common.Room.GetRoomByFilePath(roomFilePath);
@@ -683,9 +683,9 @@
                }
                var row = new RowLayout()
                {
                    Width = Application.GetRealWidth(187+50),
                    Width = Application.GetRealWidth(187 + 50),
                    Height = Application.GetRealHeight(167),
                    LineColor= ZigbeeColor.Current.GXCGrayBackgroundColor
                    LineColor = ZigbeeColor.Current.GXCGrayBackgroundColor
                };
                roomFL.AddChidren(row);

@@ -693,21 +693,22 @@
                {
                    Width = Application.GetRealWidth(187),
                    Height = Application.GetRealHeight(78),
                    Radius=(uint)Application.GetRealHeight(78/2),
                    Radius = (uint)Application.GetRealHeight(78 / 2),
                    Gravity = Gravity.Center,
                    Text=room.Name,
                    TextColor=ZigbeeColor.Current.GXCTextGrayColor,
                    SelectedTextColor=ZigbeeColor.Current.GXCTextWhiteColor,
                    BackgroundColor=ZigbeeColor.Current.GXCButtonUnSelectedColor3,
                    SelectedBackgroundColor=ZigbeeColor.Current.GXCButtonSelectedColor,
                    BorderColor=ZigbeeColor.Current.GXCBorderUnSelectedColor,
                    BorderWidth=1
                    Text = room.Name,
                    TextColor = ZigbeeColor.Current.GXCTextGrayColor,
                    SelectedTextColor = ZigbeeColor.Current.GXCTextWhiteColor,
                    BackgroundColor = ZigbeeColor.Current.GXCButtonUnSelectedColor3,
                    SelectedBackgroundColor = ZigbeeColor.Current.GXCButtonSelectedColor,
                    BorderColor = ZigbeeColor.Current.GXCBorderUnSelectedColor,
                    BorderWidth = 1
                };
                row.AddChidren(roomBtn);
                if (Shared.Common.Room.CurrentRoom==null) {
                if (Shared.Common.Room.CurrentRoom == null)
                {
                    continue;
                }
                if(Shared.Common.Room.CurrentRoom.FileName==roomFilePath)
                if (Shared.Common.Room.CurrentRoom.FileName == roomFilePath)
                {
                    roomBtn.IsSelected = true;
                    curBtn = roomBtn;
@@ -725,7 +726,7 @@
                    Shared.Common.Room.CurrentRoom = room;
                };
            }
            


            //功能和场景bodyView
            functionSceneBodyView = new FrameLayout()
@@ -776,7 +777,7 @@
            addBtn.MouseUpEventHandler += AddBtn_MouseUpEventHandler;

            selectFloorBtn.MouseUpEventHandler += SelectedFloor_MouseUpEventHandler;
            floorBtn.MouseUpEventHandler+= SelectedFloor_MouseUpEventHandler;
            floorBtn.MouseUpEventHandler += SelectedFloor_MouseUpEventHandler;

        }

@@ -787,9 +788,9 @@
        /// <param name="mouseEventArgs">The ${ParameterType} instance containing the event data.</param>
        private void SelectedFloor_MouseUpEventHandler(object sender, MouseEventArgs mouseEventArgs)
        {
            var floors = new SelectFloor ();
            var floors = new SelectFloor();
            AddChidren(floors);
            floors.Init(599,357);
            floors.Init(599, 357);
            floors.FloorAction += (floorName) =>
            {
                floorBtn.Text = floorName;
@@ -941,10 +942,10 @@
            {
                functionTypeScrowView = new HorizontalScrolViewLayout
                {
                    X=Application.GetRealWidth(CommonFormResouce.X_Left),
                    X = Application.GetRealWidth(CommonFormResouce.X_Left),
                    Height = Application.GetRealHeight(279),
                    Width = Application.GetRealWidth(1028),
                    BackgroundColor=ZigbeeColor.Current.GXCBackgroundColor
                    BackgroundColor = ZigbeeColor.Current.GXCBackgroundColor
                };
                functionSceneBodyView.AddChidren(functionTypeScrowView);

@@ -953,13 +954,13 @@
                    X = Application.GetRealWidth(CommonFormResouce.X_Left),
                    Y = functionTypeScrowView.Bottom + Application.GetRealHeight(50),
                    Width = Application.GetRealWidth(1028),
                    Height = functionSceneBodyView.Height - Application.GetRealHeight(279+50) - 1,
                    Height = functionSceneBodyView.Height - Application.GetRealHeight(279 + 50) - 1,
                    BackgroundColor = ZigbeeColor.Current.GXCBackgroundColor

                };
                functionSceneBodyView.AddChidren(deviceListScrolView);
                tempFunctionTypeBtn = new FunctionButton();
                

                foreach (var deviceType in Common.Room.AllRoomDeviceTypeList)
                {
                    typeRowLayout = new RowLayout()
@@ -1003,7 +1004,7 @@
            tempFunctionTypeBtn.IsSelected = false;
            tempFunctionTypeBtn = (typeSender as Button).Parent as FunctionButton;
            ((typeSender as Button).Parent as FunctionButton).IsSelected = true;
          

            deviceListScrolView.RemoveAll();

            var sameTypeList = new List<DeviceUI> { };
@@ -1081,7 +1082,7 @@

                    var deviceTypeRowLayout = new RowLayout()
                    {
                        Height = Application.GetRealHeight(127+35),
                        Height = Application.GetRealHeight(127 + 35),
                        LineColor = ZigbeeColor.Current.GXCBackgroundColor,
                        Tag = deviceUI
                    };
@@ -1315,7 +1316,7 @@
                    };
                    deviceTypeRowLayout.AddRightView(delBtn);
                    delBtn.MouseUpEventHandler += delEvent;
                   

                }
                else if (deviceUI.CommonDevice.Type == ZigBee.Device.DeviceType.Thermostat)
                {
@@ -1470,7 +1471,7 @@
                    deviceTypeRowLayout.AddRightView(delBtn);
                    delBtn.MouseUpEventHandler += delEvent;

                  

                    deviceRow.SwitchBtn.MouseUpEventHandler += (sender, e) =>
                    {
                        zbGateway = deviceUI.CommonDevice.Gateway;
@@ -1505,7 +1506,7 @@
                }
                else
                {
                    

                }
            }
        }
@@ -1517,10 +1518,10 @@
        {
            var noFunction = new Button()
            {
                Y=Application.GetRealHeight(320),
                Width=Application.GetMinRealAverage(757),
                Y = Application.GetRealHeight(320),
                Width = Application.GetMinRealAverage(757),
                Height = Application.GetMinRealAverage(435),
                UnSelectedImagePath="Item/NoFunction.png",
                UnSelectedImagePath = "Item/NoFunction.png",
                Gravity = Gravity.CenterHorizontal
            };
            functionSceneBodyView.AddChidren(noFunction);
@@ -1535,7 +1536,7 @@
                //Text = "没有功能 \n 请在个人中心中--设备管理处添加",
                TextColor = ZigbeeColor.Current.GXCPlaceHolderTextColor,
                TextAlignment = TextAlignment.Center,
                IsMoreLines=true
                IsMoreLines = true
            };
            functionSceneBodyView.AddChidren(noFunctionTip);
        }
@@ -1565,7 +1566,7 @@
            {
                var sceneScrolView = new VerticalScrolViewLayout
                {
                    Y=Application.GetRealHeight(58)
                    Y = Application.GetRealHeight(58)
                };
                functionSceneBodyView.AddChidren(sceneScrolView);
                foreach (var sceneRoomUI in sceneList)
@@ -1590,9 +1591,9 @@

                    var sceneImg = new Button()
                    {
                        X=Application.GetRealWidth(179),
                        Width=Application.GetMinReal(844),
                        Height=Application.GetMinReal(400),
                        X = Application.GetRealWidth(179),
                        Width = Application.GetMinReal(844),
                        Height = Application.GetMinReal(400),
                        Gravity = Gravity.CenterVertical,
                        UnSelectedImagePath = sceneRoomUI.sceneUI.IconPath,
                        Radius = (uint)Application.GetRealHeight(CommonFormResouce.BigFormRadius)
@@ -1601,22 +1602,22 @@

                    var leftFL = new FrameLayout
                    {
                        X=Application.GetRealWidth(CommonFormResouce.X_Left),
                        X = Application.GetRealWidth(CommonFormResouce.X_Left),
                        Width = Application.GetRealWidth(251),
                        Height = Application.GetRealHeight(282),
                        Gravity=Gravity.CenterVertical,
                        Gravity = Gravity.CenterVertical,
                        BackgroundColor = ZigbeeColor.Current.GXCBlackBackgroundColor2
                    };
                    sceneRowLayout.AddChidren(leftFL);

                    var collectionBtn = new Button
                    {
                        X=Application.GetRealWidth(23),
                        Y=Application.GetRealHeight(23),
                        Width=Application.GetMinRealAverage(65),
                        Height=Application.GetMinRealAverage(65),
                        UnSelectedImagePath="Item/Collection.png",
                        SelectedImagePath="Item/CollectionSelected.png"
                        X = Application.GetRealWidth(23),
                        Y = Application.GetRealHeight(23),
                        Width = Application.GetMinRealAverage(65),
                        Height = Application.GetMinRealAverage(65),
                        UnSelectedImagePath = "Item/Collection.png",
                        SelectedImagePath = "Item/CollectionSelected.png"
                    };
                    leftFL.AddChidren(collectionBtn);

@@ -1627,7 +1628,7 @@
                        TextColor = ZigbeeColor.Current.GXCTextWhiteColor,
                        Text = sceneRoomUI.sceneUI.Name,
                        Gravity = Gravity.Center,
                        IsMoreLines=true
                        IsMoreLines = true
                    };
                    leftFL.AddChidren(sceneNameBtn);

@@ -1642,7 +1643,7 @@
                    //编辑
                    var settingBtn = new Device.CommonForm.RowLayoutEditButton()
                    {
                        TextID=R.MyInternationalizationString.Setting,
                        TextID = R.MyInternationalizationString.Setting,
                        Tag = sceneRoomUI.sceneUI.SceneDelayTime
                    };
                    //删除
@@ -1696,7 +1697,7 @@
                        var tip = new CustomAlert { };
                        AddChidren(tip);
                        tip.Show(Language.StringByID(R.MyInternationalizationString.ConfirmDelete));
                        

                        //var alert = new Alert(Language.StringByID(R.MyInternationalizationString.TIP), Language.StringByID(R.MyInternationalizationString.ConfirmDelete), Language.StringByID(R.MyInternationalizationString.Cancel), Language.StringByID(R.MyInternationalizationString.Confrim));
                        //alert.Show();
                        tip.ResultEventHandler += async (e1) =>

 ZigbeeApp/Shared/Phone/Device/Logic/DeviceStateCondition.cs

@@ -1416,29 +1416,87 @@

                case DeviceType.TemperatureSensor:
                    {
                    
                        devicefra.Y = Application.GetRealHeight(1920 - 140 - 160 * 2 - 20 - 50);
                        devicefra.Height = Application.GetRealHeight(140 + 160 * 2 + 20 + 50);
                        var temperatureSensor = common as TemperatureSensor;
                        var Btntemperaturevalue = new Button
                        {
                            TextColor = ZigbeeColor.Current.LogicBtnCancelColor,
                            Height = Application.GetRealHeight(60),
                            Width = Application.GetRealWidth(400),
                            TextAlignment = TextAlignment.CenterLeft,
                            X = Application.GetRealWidth(80),
                            Y = timetype.Bottom + Application.GetRealHeight(70),
                        };
                        devicefra.AddChidren(Btntemperaturevalue);

                        var horizontalSeekBarVol = new HorizontalSeekBar
                        {
                            Width = Application.GetRealWidth(920),
                            Height = Application.GetRealHeight(80),
                            Radius = (uint)Application.GetRealHeight(25),
                            Y = timetype.Bottom + Application.GetRealHeight(70 + 60 + 70),
                            X = Application.GetRealWidth(80),
                            ProgressColor = ZigbeeColor.Current.LogicProgressColorSelected,
                            Max = 100,
                            SleepTime = 1000,
                            ThumbRadius = 9,
                        };
                        devicefra.AddChidren(horizontalSeekBarVol);
                        horizontalSeekBarVol.MouseUpEventHandler += (sender, e) =>
                        {
                            SelectedDeviceStatuscondition = "TemperatureSensor";
                            if (temperatureSensor.SensorDiv == 1)
                            {
                                dictionary(deviceConditionsInfo, "AttriButeData1", horizontalSeekBarVol.Progress.ToString());

                                Btntemperaturevalue.Text = "当前>" + horizontalSeekBarVol.Progress.ToString() + "℃";

                            }
                            else
                            {
                                Btntemperaturevalue.Text = "当前<" + horizontalSeekBarVol.Progress.ToString() + "%";
                                dictionary(deviceConditionsInfo, "AttriButeData1", horizontalSeekBarVol.Progress.ToString());//温度值
                            }
                        };



                        if (temperatureSensor.SensorDiv == 1)
                        {
                            dictionary(deviceConditionsInfo, "Cluster_ID", "1026");
                            dictionary(deviceConditionsInfo, "AttriButeId", "0");
                            dictionary(deviceConditionsInfo, "Range", "0");
                            dictionary(deviceConditionsInfo, "Range", "0");//0大于AttriButeData1时触发动作
                            dictionary(deviceConditionsInfo, "AttriButeData1", "0");
                            dictionary(deviceConditionsInfo, "AttriButeData2", "0");


                            Btntemperaturevalue.Text = "当前>0℃";

                        }
                        else
                        {

                            Btntemperaturevalue.Text = "当前<0%";
                            dictionary(deviceConditionsInfo, "Cluster_ID", "1029");
                            dictionary(deviceConditionsInfo, "AttriButeId", "0");
                            dictionary(deviceConditionsInfo, "Range", "0");//表示大于值
                            dictionary(deviceConditionsInfo, "Range", "2");//2小于AttriButeData1时触发动作
                            dictionary(deviceConditionsInfo, "AttriButeData1", "0");//温度值
                            dictionary(deviceConditionsInfo, "AttriButeData2", "0");
                        }

                        if (edit && devices != null)
                        {
                            horizontalSeekBarVol.Progress = int.Parse(devices["AttriButeData1"]);
                            if (temperatureSensor.SensorDiv == 1)
                            {

                                Btntemperaturevalue.Text = "当前>" + devices["AttriButeData1"] + "℃";

                            }
                            else
                            {
                                Btntemperaturevalue.Text = "当前<" + devices["AttriButeData1"] + "%";
                            }
                        }

                    }
                    break;
            }

 ZigbeeApp/Shared/Phone/Device/Logic/LogicCommunalPage.cs

@@ -529,7 +529,6 @@
                                deviceedit.MouseUpEventHandler += (sender, e) =>
                                {


                                    if (deviceinof.Type != DeviceType.DoorLock)
                                    {
                                        var flMain = new FrameLayout { BackgroundColor = ZigbeeColor.Current.LogicViewBackgroundColor };
@@ -734,6 +733,25 @@
                                            }
                                        }
                                        break;
                                    case DeviceType.TemperatureSensor:
                                       // conditionIcon.UnSelectedImagePath = "ZigeeLogic/temperature.png";
                                        var dev = deviceinof as TemperatureSensor;
                                        if (conditions["Cluster_ID"]=="1026") {
                                            dev.SensorDiv = 1;
                                        } else {
                                            dev.SensorDiv = 2;
                                        }
                                        if (conditions["Cluster_ID"] == "1026")
                                        {
                                            conditionIcon.UnSelectedImagePath = "ZigeeLogic/temperature.png";
                                            devicestatus.Text = ">" + conditions["AttriButeData1"] + "℃";
                                        }
                                        else
                                        {
                                            conditionIcon.UnSelectedImagePath = "ZigeeLogic/humidity.png";
                                            devicestatus.Text = "<" + conditions["AttriButeData1"] + "%";
                                        }
                                        break;

                                }


 ZigbeeApp/Shared/Phone/Device/Logic/LogicIfon.cs

@@ -1,6 +1,8 @@
using System;
using System.Collections.Generic;
using Shared;
using ZigBee.Device;

namespace Shared.Phone.Device.Logic
{
    public class LogicIfon
@@ -11,7 +13,7 @@
        /// </summary>
        /// <param name="common">Common.</param>
        /// <param name="objecttype">Objecttype.</param>
        public static void AddDeviceconditions(ZigBee.Device.CommonDevice common, Dictionary<string, string> objecttype)
        public static void AddDeviceconditions(CommonDevice common, Dictionary<string, string> objecttype)
        {
            for (int i = 0; i < Common.Logic.CurrentLogic.Conditions.Count; i++)
            {
@@ -19,9 +21,32 @@
                {
                    if ((Common.Logic.CurrentLogic.Conditions[i]["MacAddr"] == common.DeviceAddr) && (Common.Logic.CurrentLogic.Conditions[i]["Epoint"] == common.DeviceEpoint.ToString()))
                    {
                        Common.Logic.CurrentLogic.Conditions.RemoveAt(i);
                        Common.Logic.CurrentLogic.Conditions.Insert(i, objecttype);
                        return;
                        if (common.Type == DeviceType.TemperatureSensor)//设备温度传感器有点特别
                        {
                            var dev = common as TemperatureSensor;
                            string str = "";
                            if (dev.SensorDiv == 1)
                            {
                                str = "1026";
                            }
                            else
                            {
                                str = "1029";
                            }
                            if (Common.Logic.CurrentLogic.Conditions[i]["Cluster_ID"] == str)
                            {
                                Common.Logic.CurrentLogic.Conditions.RemoveAt(i);
                                Common.Logic.CurrentLogic.Conditions.Insert(i, objecttype);
                                return;
                            }

                        }
                        else
                        {
                            Common.Logic.CurrentLogic.Conditions.RemoveAt(i);
                            Common.Logic.CurrentLogic.Conditions.Insert(i, objecttype);
                            return;
                        }
                    }

                }

 ZigbeeApp/Shared/Phone/UserCenter/Device/DeviceListMainForm.cs

old mode 100755
new mode 100644
@@ -19,7 +19,7 @@
        /// <summary>

        /// 列表控件

        /// </summary>

        private VerticalListControl listView = null;

        private VerticalScrolViewLayout listView = null;

        /// <summary>

        /// 行控件的信息(Keys：Mac地址)

        /// </summary>

@@ -127,7 +127,7 @@
            txtSearchControl.BindEvent(this.SetRowDataBySearchKeys);



            //列表控件

            listView = new VerticalListControl(29);

            listView = new VerticalScrolViewLayout();

            listView.Y = txtSearchControl.Bottom + Application.GetRealHeight(29);

            listView.Height = frame.Height - txtSearchControl.Bottom - Application.GetRealHeight(29);

            frame.AddChidren(listView);

@@ -208,7 +208,7 @@
            rowInfo.frameTable = frameTable;



            //控件

            var rowMenu = new DeviceObjectControl(deviceMac, listView.rowSpace / 2);

            var rowMenu = new DeviceObjectControl(deviceMac, 0);

            frameTable.AddChidren(rowMenu);

            rowMenu.InitControl();

            rowInfo.MenuRow = rowMenu;