~xm/HomeApp.git

old mode 100755 new mode 100644

			@@ -1,1185 +1,1643 @@
			using Shared.Common;
			using System;
			using System.Collections.Generic;
			using System.Text;
			using ZigBee.Device;

			namespace Shared.Phone.UserCenter
			{
			/// <summary>
			/// 房间的逻辑
			/// </summary>
			public class HdlRoomLogic
			{
			#region ■ 变量声明___________________________

			/// <summary>
			/// 房间的逻辑
			/// </summary>
			private static HdlRoomLogic m_Current = null;
			/// <summary>
			/// 房间的逻辑
			/// </summary>
			public static HdlRoomLogic Current
			{
			get
			{
			if (m_Current == null)
			{
			m_Current = new HdlRoomLogic();
			}
			return m_Current;
			}
			}
			/// <summary>
			/// 当前主页选择的房间对象
			/// </summary>
			public Room NowMainPageRoom = null;
			/// <summary>
			/// 当前分类选择的房间对象
			/// </summary>
			public Room NowCategoryRoom = null;
			/// <summary>
			/// 所有的房间信息
			/// </summary>
			private Dictionary<string, Room> dicRooms = new Dictionary<string, Room>();

			#endregion

			#region ■ 初始化_____________________________

			/// <summary>
			/// 初始化房间信息
			/// 从文件中全部读取所有的房间数据到内存
			/// </summary>
			public void InitAllRoom()
			{
			this.NowMainPageRoom = null;
			this.NowCategoryRoom = null;

			//清空本地缓存
			this.dicRooms.Clear();
			//检测我的喜爱这个房间对象
			this.CheckLoveRoom();

			var listFile = Global.FileListByHomeId();
			foreach (var fileName in listFile)
			{
			if (fileName.StartsWith("Room_") == true)
			{
			//从文件里面获取房间对象
			var room = this.GetRoomByFilePath(fileName);
			if (room != null)
			{
			this.dicRooms[room.Id] = (room);
			}
			}
			}
			//设置当前楼层的ID
			Config.Instance.Home.SetCurrentFloorId();
			//顺便刷新场景
			HdlSceneLogic.Current.ReFreshByLocal();
			//刷新房间视图列表
			this.RefreshRoomListView();
			}

			/// <summary>
			/// 从本地重新加载全部的房间
			/// </summary>
			public void RefreshAllRoomByLocation()
			{
			var listFile = Global.FileListByHomeId();

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

			var listRoomFile = new List<string>();
			foreach (string fileName in listFile)
			{
			if (fileName.StartsWith("Room_"))
			{
			string roomId = fileName.Replace("Room_", string.Empty).Replace(".json", string.Empty);
			listRoomFile.Add(fileName);
			}
			}
			//检测楼层数据的合法性
			if (UserCenterResourse.UserInfo.AuthorityNo == 3)
			{
			this.CheckMemberFloorData(listRoomFile);
			}
			else
			{
			this.CheckAdminFloorData(listRoomFile);
			}

			this.InitAllRoom();
			}

			/// <summary>
			/// 刷新房间视图列表
			/// </summary>
			public void RefreshRoomListView()
			{
			Application.RunOnMainThread(() =>
			{
			MainPage.LeftListRoomViewFrom.Instance?.RefreshListRoom();
			});
			}

			/// <summary>
			/// 检测楼层数据的合法性
			/// </summary>
			/// <param name="listRoomFile"></param>
			private void CheckAdminFloorData(List<string> listRoomFile)
			{
			//没有楼层,则无需处理
			if (Config.Instance.Home.FloorDics.Count == 0) { return; }

			//主人或者管理员的话,就检测是否存在未分配楼层的房间
			for (int i = 0; i < listRoomFile.Count; i++)
			{
			try
			{
			var byteData = Global.ReadFileByHomeId(listRoomFile[i]);
			string valueData = System.Text.Encoding.UTF8.GetString(byteData);
			var roomTemp = Newtonsoft.Json.JsonConvert.DeserializeObject<Common.Room>(valueData);

			//检测多个手机来回创建,然后又删除之后,楼层数据不能保证100%同步的问题
			if (roomTemp.FloorId != string.Empty && Config.Instance.Home.FloorDics.ContainsKey(roomTemp.FloorId) == false)
			{
			//未知楼层
			Config.Instance.Home.FloorDics[roomTemp.FloorId] = Language.StringByID(R.MyInternationalizationString.uUnKnownFloor);
			}
			}
			catch (Exception ex) { HdlLogLogic.Current.WriteLog(ex); }
			}
			}

			/// <summary>
			/// 检测楼层数据的合法性
			/// </summary>
			/// <param name="listRoomFile"></param>
			private void CheckMemberFloorData(List<string> listRoomFile)
			{
			//没有楼层,则无需处理
			if (Config.Instance.Home.FloorDics.Count == 0) { return; }

			//成员的话,就检测是否存在没有房间的楼层
			var listEsixtFloor = new List<string>();
			for (int i = 0; i < listRoomFile.Count; i++)
			{
			try
			{
			var byteData = Global.ReadFileByHomeId(listRoomFile[i]);
			string valueData = System.Text.Encoding.UTF8.GetString(byteData);
			var roomTemp = Newtonsoft.Json.JsonConvert.DeserializeObject<Common.Room>(valueData);
			if (roomTemp.FloorId != string.Empty && listEsixtFloor.Contains(roomTemp.FloorId) == false)
			{
			//收集楼层
			listEsixtFloor.Add(roomTemp.FloorId);
			}
			}
			catch (Exception ex) { HdlLogLogic.Current.WriteLog(ex); }
			}
			var listDeleteId = new List<string>();
			foreach (var flootId in Config.Instance.Home.FloorDics.Keys)
			{
			if (listEsixtFloor.Contains(flootId) == false)
			{
			//如果这个id不存在于任何房间的话,收集它
			listDeleteId.Add(flootId);
			}
			}
			foreach (var deleteId in listDeleteId)
			{
			//删除这个id
			Config.Instance.Home.FloorDics.Remove(deleteId);
			}
			Config.Instance.Home.Save(false);
			}

			#endregion

			#region ■ 添加房间___________________________

			/// <summary>
			/// 增加房间
			/// </summary>
			/// <param name="room">Room.</param>
			/// <param name="rorefreshRoomViewom">是否刷新房间视图列表界面</param>
			public void AddRoom(Room room, bool refreshRoomView = true)
			{
			if (Global.IsExistsByHomeId(room.FileName) == true)
			{
			return;
			}
			//添加到缓存
			this.dicRooms[room.Id] = room;
			//生成文件
			room.Save();
			//备份
			HdlAutoBackupLogic.AddOrEditorFile(room.FileName);
			if (refreshRoomView == true)
			{
			//刷新房间视图列表
			this.RefreshRoomListView();
			}
			}

			#endregion

			#region ■ 删除房间___________________________

			/// <summary>
			/// 删除房间
			/// </summary>
			/// <param name="roomId">房间ID</param>
			/// <param name="refreshLeftView">是否刷新左滑界面(此变量目前是给删除全部房间用的)</param>
			/// <returns></returns>
			public void RemoveRoom(string roomId, bool refreshLeftView = true)
			{
			//根据房间Id，获取房间对象
			var room = this.GetRoomById(roomId);
			if (room == null)
			{
			return;
			}
			//删除来自拍照或者系统图库的房间背景图片
			if (room.BackgroundImageType == 1 \|\| room.BackgroundImageType == 2)
			{
			//删除掉原来的自定义图片
			if (Global.IsExistsByHomeId(room.BackgroundImage) == true)
			{
			Global.DeleteFilebyHomeId(room.BackgroundImage);
			//删除备份
			HdlAutoBackupLogic.DeleteFile(room.BackgroundImage);
			}
			}
			//我的喜爱
			var loveRoom = this.GetLoveRoom();
			if (loveRoom != null)
			{
			//移除我的喜爱里面的设备
			for (int i = 0; i < room.ListDevice.Count; i++)
			{
			loveRoom.ListDevice.Remove(room.ListDevice[i]);
			}
			//移除我的喜爱里面的场景
			for (int i = 0; i < room.ListSceneId.Count; i++)
			{
			loveRoom.ListSceneId.Remove(room.ListSceneId[i]);
			}
			loveRoom.Save(false);
			}
			this.dicRooms.Remove(roomId);

			string roomFilePath = room.FileName;
			if (Global.IsExistsByHomeId(roomFilePath) == true)
			{
			//删除文件
			Global.DeleteFilebyHomeId(roomFilePath);
			}
			HdlAutoBackupLogic.DeleteFile(roomFilePath);

			//根据房间ID,移除指定的真实物理设备的所属房间记录
			Common.LocalDevice.Current.DeleteRealDeviceByRoomId(roomId);
			if (refreshLeftView == true)
			{
			//HdlAutoBackupLogic.DeleteFile(roomFilePath);
			//刷新房间视图列表
			this.RefreshRoomListView();
			}
			}

			/// <summary>
			/// 删除全部的房间
			/// </summary>
			public void DeleteAllRoom()
			{
			var listRoomId = new List<string>();
			foreach (var room in this.dicRooms.Values)
			{
			if (room.IsLove == false)
			{
			listRoomId.Add(room.Id);
			}
			}
			foreach (var roomId in listRoomId)
			{
			this.RemoveRoom(roomId, false);
			}
			}

			#endregion

			#region ■ 获取房间___________________________

			/// <summary>
			/// 获取喜爱房间
			/// </summary>
			/// <returns></returns>
			public Room GetLoveRoom()
			{
			//检测我的喜爱这个房间对象
			this.CheckLoveRoom();

			return this.dicRooms["Favorite"];
			}

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

			return nowRoom;
			}
			catch (Exception ex)
			{
			HdlLogLogic.Current.WriteLog(ex);
			return null;
			}
			}

			/// <summary>
			/// 根据房间Id，获取房间对象
			/// </summary>
			/// <returns>The room by name.</returns>
			/// <param name="roomId">房间ID</param>
			public Room GetRoomById(string roomId)
			{
			if (this.dicRooms.ContainsKey(roomId) == false)
			{
			return null;
			}
			return this.dicRooms[roomId];
			}

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

			/// <summary>
			/// 获取房间名字(楼层+房间名)
			/// </summary>
			/// <returns>房间名</returns>
			/// <param name="room">房间对象</param>
			public string GetRoomName(Room room)
			{
			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>
			/// 获取设备所在的房间(没有设置有房间则返回null)
			/// </summary>
			/// <returns>The room by device.</returns>
			/// <param name="device">设备对象</param>
			public Room GetRoomByDevice(CommonDevice device)
			{
			string mainKeys = LocalDevice.Current.GetDeviceMainKeys(device);
			foreach (var room in this.dicRooms.Values)
			{
			if (room.IsLove == true)
			{
			//喜爱房间不处理
			continue;
			}
			if (room.ListDevice.Contains(mainKeys) == true)
			{
			return room;
			}
			}
			return null;
			}

			/// <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>
			/// 通过场景id获取房间对象
			/// </summary>
			/// <returns>The room by scene identifier.</returns>
			/// <param name="sceneId">Scene identifier.</param>
			public Room GetRoomBySceneId(int sceneId)
			{
			foreach (var room in this.dicRooms.Values)
			{
			if (room.IsLove == true)
			{
			//喜爱房间不处理
			continue;
			}
			if (room.ListSceneId.Contains(sceneId) == true)
			{
			return room;
			}
			}
			return null;
			}

			/// <summary>
			/// 获取当前楼层的房间
			/// </summary>
			/// <param name="id"></param>
			/// <returns></returns>
			public List<Room> GetRoomsByFloorId(string id)
			{
			var listRoom = new List<Room>();
			if (Config.Instance.Home.FloorDics.Count == 0)
			{
			//没有楼层
			foreach (var room in this.dicRooms.Values)
			{
			listRoom.Add(room);
			}
			}
			else
			{
			foreach (var room in this.dicRooms.Values)
			{
			if (room.FloorId == id)
			{
			listRoom.Add(room);
			}
			}
			}
			return listRoom;
			}

			/// <summary>
			/// 获取全部的房间
			/// </summary>
			/// <returns></returns>
			public List<Room> GetAllListRooms()
			{
			var listRoom = new List<Room>();
			foreach (var room in this.dicRooms.Values)
			{
			listRoom.Add(room);
			}
			return this.SortRoom(listRoom);
			}

			/// <summary>
			/// 获取当前楼层的房间名称
			/// </summary>
			/// <param name="id"></param>
			/// <returns></returns>
			public List<string> GetRoomNamesByFloorId(string id)
			{
			var listName = new List<string>();
			if (Config.Instance.Home.FloorDics.Count == 0)
			{
			//没有楼层
			foreach (var room in this.dicRooms.Values)
			{
			listName.Add(room.Name);
			}
			}
			else
			{
			foreach (var room in this.dicRooms.Values)
			{
			if (room.FloorId == id)
			{
			listName.Add(room.Name);
			}
			}
			}
			return listName;
			}

			/// <summary>
			/// 获取当前楼层的房间(拼接了【常用】在第一位)
			/// </summary>
			/// <param name="id"></param>
			/// <returns></returns>
			public List<Room> GetRoomsByFloorIdAppendLoveRoom(string id)
			{
			var listRoom = new List<Room>();
			if (Config.Instance.Home.FloorDics.Count == 0)
			{
			//没有楼层
			foreach (var room in this.dicRooms.Values)
			{
			if (room.IsLove == false)
			{
			listRoom.Add(room);
			}
			}
			}
			else
			{
			foreach (var room in this.dicRooms.Values)
			{
			if (room.FloorId == id && room.IsLove == false)
			{
			listRoom.Add(room);
			}
			}
			}
			listRoom.Insert(0, GetLoveRoom());
			return listRoom;
			}

			/// <summary>
			/// 获取当前楼层的房间(拼接了【常用】在第一位)
			/// </summary>
			/// <returns></returns>
			public List<Room> GetRoomsByCurrentFloorIdAppendLoveRoom()
			{
			return this.GetRoomsByFloorIdAppendLoveRoom(Config.Instance.Home.CurrentFloorId);
			}

			#endregion

			#region ■ 房间方法___________________________

			/// <summary>
			/// 设备的房间变更
			/// </summary>
			/// <param name="device">设备对象</param>
			/// <param name="roomId">新房间Id</param>
			/// <param name="saveRealRoom">是否修改真实物理设备的房间,不出意外,这个值默认为true即可</param>
			public void ChangedRoom(CommonDevice device, string roomId, bool saveRealRoom = true)
			{
			//选择的是未分配
			if (roomId == string.Empty)
			{
			//从原来的房间移除设备
			this.DeleteDevice(device);
			//移除我的喜爱
			this.DeleteLoveDevice(device);
			//设备改变房间的话,主页需要重新刷新
			UserView.UserPage.Instance.RefreshForm = true;
			return;
			}
			//房间是否修改
			if (this.IsRoomChanged(device, roomId) == false)
			{
			return;
			}
			//从原来的房间移除设备,这里不删除真实设备的房间
			this.DeleteDevice(device, false);

			//添加到新的房间
			var room = this.GetRoomById(roomId);
			if (room != null)
			{
			this.AddDevice(room, device, saveRealRoom);
			}
			//设备改变房间的话,主页需要重新刷新
			UserView.UserPage.Instance.RefreshForm = true;
			}

			/// <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>
			/// 添加设备
			/// </summary>
			/// <param name="i_room">房间对象</param>
			/// <param name="device">要添加的设备对象</param>
			/// <param name="saveRealRoom">是否修改真实物理设备的房间,不出意外,这个值默认为true即可</param>
			public void AddDevice(Room i_room, CommonDevice device, bool saveRealRoom)
			{
			if (device == null)
			{
			return;
			}
			//设备信息保存到本地
			device.Save();

			string mainkeys = LocalDevice.Current.GetDeviceMainKeys(device);
			if (i_room.ListDevice.Contains(mainkeys) == false)
			{
			//保存到本地
			i_room.ListDevice.Add(mainkeys);
			i_room.Save();

			if (i_room.IsLove == false && saveRealRoom == true && LocalDevice.Current.GetDevicesCountByMac(device.DeviceAddr) == 1)
			{
			//如果只有一个回路,则修改真实物理设备的房间
			LocalDevice.Current.SaveRealDeviceRoomId(new List<CommonDevice>() { device }, i_room.Id, false);
			}
			}
			}

			/// <summary>
			/// 添加喜爱设备
			/// </summary>
			/// <param name="device">要添加的设备对象</param>
			public void AddLoveDevice(CommonDevice device)
			{
			if (device == null)
			{
			return;
			}
			//我的喜爱
			var loveRoom = this.GetLoveRoom();
			if (loveRoom != null)
			{
			string mainkeys = LocalDevice.Current.GetDeviceMainKeys(device);
			if (loveRoom.ListDevice.Contains(mainkeys) == false)
			{
			//保存到本地
			loveRoom.ListDevice.Add(mainkeys);
			loveRoom.Save();
			}
			}
			}

			#endregion

			#region ■ 删除设备___________________________

			/// <summary>
			/// 删除设备(这个函数不删除我的喜爱)
			/// </summary>
			/// <param name="device">要删除的设备对象</param>
			/// <param name="deleteReal">是否删除真实物理设备的房间</param>
			public void DeleteDevice(CommonDevice device, bool deleteReal = true)
			{
			if (device == null)
			{
			return;
			}
			//如果它只有一个回路
			if (deleteReal == true && LocalDevice.Current.GetDevicesCountByMac(device.DeviceAddr) == 1)
			{
			//删除掉它的真实物理设备的所在位置
			LocalDevice.Current.DeleteRealDeviceFromRoom(device);
			}

			//根据设备，获取所在的房间
			var room = this.GetRoomByDevice(device);
			if (room == null)
			{
			return;
			}
			//移除缓存
			string mainkeys = LocalDevice.Current.GetDeviceMainKeys(device);
			room.ListDevice.Remove(mainkeys);
			room.Save();
			//更改自动备份
			HdlAutoBackupLogic.AddOrEditorFile(room.FileName);

			//递归：删除掉以前的旧数据导致的多个房间的问题
			this.DeleteDevice(device, deleteReal);
			}

			/// <summary>
			/// 删除我的喜爱的设备
			/// </summary>
			/// <param name="device">要删除的设备对象</param>
			public void DeleteLoveDevice(CommonDevice device)
			{
			if (device == null)
			{
			return;
			}
			//我的喜爱
			var loveRoom = this.GetLoveRoom();
			if (loveRoom != null)
			{
			//移除缓存
			string mainkeys = LocalDevice.Current.GetDeviceMainKeys(device);
			loveRoom.ListDevice.Remove(mainkeys);
			loveRoom.Save();
			//更改自动备份
			HdlAutoBackupLogic.AddOrEditorFile(loveRoom.FileName);
			}
			}

			#endregion

			#region ■ 获取设备___________________________

			/// <summary>
			/// 获取当前房间下的全部设备
			/// </summary>
			/// <returns></returns>
			public List<CommonDevice> GetRoomListDevice(Room i_room)
			{
			var dicSort = new Dictionary<string, List<int>>();
			foreach (var mainKeys in i_room.ListDevice)
			{
			var device = LocalDevice.Current.GetDevice(mainKeys);
			if (device != null)
			{
			if (dicSort.ContainsKey(device.DeviceAddr) == false)
			{
			dicSort[device.DeviceAddr] = new List<int>();
			}
			dicSort[device.DeviceAddr].Add(device.DeviceEpoint);
			}
			}
			var listDevice = new List<CommonDevice>();
			foreach (var strMac in dicSort.Keys)
			{
			var listEpont = dicSort[strMac];
			//排序
			listEpont.Sort();
			for (int i = 0; i < listEpont.Count; i++)
			{
			var device = LocalDevice.Current.GetDevice(strMac, listEpont[i]);
			listDevice.Add(device);
			}
			}
			return listDevice;
			}

			/// <summary>
			/// 获取房间设备类型
			/// </summary>
			/// <param name="room"></param>
			/// <returns></returns>
			public List<DeviceType> GetDeviceTypes(Room i_room)
			{
			var typeList = new List<DeviceType>();
			foreach (var mainKeys in i_room.ListDevice)
			{
			var device = LocalDevice.Current.GetDevice(mainKeys);
			if (device != null)
			{
			typeList.Add(device.Type);
			}
			}
			return typeList;
			}

			/// <summary>
			/// 获取该类型的设备
			/// </summary>
			/// <param name="room"></param>
			/// <param name="deviceType"></param>
			/// <returns></returns>
			public List<CommonDevice> GetRoomListDevice(Room room, DeviceType deviceType)
			{
			List<CommonDevice> typeList = new List<CommonDevice>();
			foreach (var mainKeys in room.ListDevice)
			{
			var device = LocalDevice.Current.GetDevice(mainKeys);
			if (device != null && device.Type == deviceType)
			{
			typeList.Add(device);
			}
			}

			return typeList;
			}

			/// <summary>
			/// 获取未分配区域设备
			/// </summary>
			/// <returns></returns>
			public List<CommonDevice> GetUnalloctedDevice()
			{
			var listDevice = new List<CommonDevice>();

			//已经存在的设备
			var listEsxit = new HashSet<string>();
			foreach (var room in this.dicRooms.Values)
			{
			if (room.IsLove == true)
			{
			//不包含收藏房间
			continue;
			}
			foreach (string mainkeys in room.ListDevice)
			{
			if (listEsxit.Contains(mainkeys) == false)
			{
			listEsxit.Add(mainkeys);
			}
			}
			}

			//所有设备
			var commonDeviceList = LocalDevice.Current.listAllDevice;
			foreach (var device in commonDeviceList)
			{
			//判断该设备能否显示在主页
			if (LocalDevice.Current.CanShowInHomeHomeMainPage(device) == false)
			{
			continue;
			}
			string mainkeys = LocalDevice.Current.GetDeviceMainKeys(device);
			if (listEsxit.Contains(mainkeys) == false)
			{
			listDevice.Add(device);
			}
			}
			return listDevice;
			}

			/// <summary>
			/// 获取全部房间全部的设备
			/// </summary>
			/// <returns></returns>
			public List<CommonDevice> GetAllRoomListDevice()
			{
			var listDevice = new List<CommonDevice>();
			foreach (var room in this.dicRooms.Values)
			{
			if (room.IsSharedRoom \|\| room.IsLove)
			{
			continue;
			}
			listDevice.AddRange(this.GetRoomListDevice(room));
			}
			return listDevice;
			}

			#endregion

			#region ■ 设备是否收藏_______________________

			/// <summary>
			/// 是否是收藏设备
			/// </summary>
			/// <param name="filePath"></param>
			/// <returns></returns>
			public bool IsCollectInRoom(CommonDevice device)
			{
			string mainkeys = LocalDevice.Current.GetDeviceMainKeys(device);
			//喜爱房间
			var room = this.GetLoveRoom();
			return room.ListDevice.Contains(mainkeys);
			}

			/// <summary>
			/// 是否是收藏设备
			/// </summary>
			/// <param name="filePath"></param>
			/// <returns></returns>
			public bool IsCollectInRoom(SceneUI scene)
			{
			//喜爱房间
			var room = this.GetLoveRoom();
			return room.ListSceneId.Contains(scene.Id);
			}

			#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)
			{
			if (i_floorKeys == null)
			{
			i_floorKeys = string.Empty;
			}
			var listRoom = new List<Room>();
			foreach (var room in this.dicRooms.Values)
			{
			if (room.FloorId != i_floorKeys && i_floorKeys != string.Empty
			\|\| room.IsLove == true)
			{
			//不是同一个楼层,不要我的喜爱
			continue;
			}
			if (getShard == false && room.IsSharedRoom == true)
			{
			//不要分享的房间
			continue;
			}
			listRoom.Add(room);
			}
			return this.SortRoom(listRoom);
			}

			/// <summary>
			/// 排序房间对象
			/// </summary>
			/// <param name="listRoom"></param>
			/// <returns></returns>
			public List<Room> SortRoom(List<Room> listRoom)
			{
			//从一堆文字中,获取这一堆文字里面数字字符串的最长长度
			var listName = new List<string>();
			foreach (var room in listRoom)
			{
			listName.Add(room.Name);
			}
			int numberLength = this.GetNumberMaxLength(listName);

			var listSort = new List<string[]>();
			foreach (var room in listRoom)
			{
			var strArry = new string[2];
			strArry[0] = room.Id;
			strArry[1] = string.Empty;

			string value = string.Empty;
			foreach (var c in room.Name)
			{
			if (char.IsNumber(c) == true)
			{
			//数字
			value += c.ToString();
			continue;
			}
			else if (value != string.Empty)
			{
			//如果房间名字带有数字的话,则左边加零,因为这里有个排序的问题
			strArry[1] += value.PadLeft(numberLength, '0');
			value = string.Empty;
			}
			strArry[1] += c.ToString();
			}
			if (value != string.Empty)
			{
			//以数字结尾的话
			strArry[1] += value.PadLeft(numberLength, '0');
			}
			listSort.Add(strArry);
			}
			//排序
			listSort.Sort((obj1, obj2) =>
			{
			if (obj1[1].CompareTo(obj2[1]) > 0)
			{
			return 1;
			}
			return -1;
			});
			var listSortRoom = new List<Room>();
			foreach (var strArry in listSort)
			{
			var room = this.GetRoomById(strArry[0]);
			listSortRoom.Add(room);
			}
			return listSortRoom;
			}

			/// <summary>
			/// 获取排序后的楼层
			/// </summary>
			/// <returns></returns>
			public Dictionary<string, string> GetFloorSortList()
			{
			//从一堆文字中,获取这一堆文字里面数字字符串的最长长度
			var listName = new List<string>();
			foreach (var floorName in Config.Instance.Home.FloorDics.Values)
			{
			listName.Add(floorName);
			}
			int numberLength = this.GetNumberMaxLength(listName);

			var listSort = new List<string[]>();
			foreach (var floorId in Config.Instance.Home.FloorDics.Keys)
			{
			var strArry = new string[2];
			strArry[0] = floorId;
			strArry[1] = string.Empty;

			string value = string.Empty;
			string floorName = Config.Instance.Home.FloorDics[floorId];
			foreach (var c in floorName)
			{
			if (char.IsNumber(c) == true)
			{
			//数字
			value += c.ToString();
			continue;
			}
			else if (value != string.Empty)
			{
			//如果房间名字带有数字的话,则左边加零,因为这里有个排序的问题
			strArry[1] += value.PadLeft(numberLength, '0');
			value = string.Empty;
			}
			strArry[1] += c.ToString();
			}
			if (value != string.Empty)
			{
			//以数字结尾的话
			strArry[1] += value.PadLeft(numberLength, '0');
			}
			listSort.Add(strArry);
			}
			//楼层排序
			listSort.Sort((obj1, obj2) =>
			{
			if (obj1[1].CompareTo(obj2[1]) > 0)
			{
			return 1;
			}
			return -1;
			});
			var dic = new Dictionary<string, string>();
			foreach (var strArry in listSort)
			{
			dic[strArry[0]] = Config.Instance.Home.FloorDics[strArry[0]];
			}
			return dic;
			}

			#endregion

			#region ■ 克隆房间对象_______________________

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

			return newRoom;
			}

			#endregion

			#region ■ 一般方法___________________________

			/// <summary>
			/// 获取房间总数
			/// </summary>
			/// <returns></returns>
			public int GetRoomCount()
			{
			return this.dicRooms.Count;
			}

			/// <summary>
			/// 检测我的喜爱这个房间对象
			/// </summary>
			private void CheckLoveRoom()
			{
			if (this.dicRooms.ContainsKey("Favorite") == true)
			{
			return;
			}
			//读取本地我的喜爱文件
			string favoriteFile = System.IO.Path.Combine(Common.Config.Instance.FullPath, "Room_Favorite.json");
			var fileContent = HdlFileLogic.Current.ReadFileTextContent(favoriteFile);
			if (fileContent != null)
			{
			var love = Newtonsoft.Json.JsonConvert.DeserializeObject<Room>(fileContent);
			this.dicRooms["Favorite"] = love;
			}
			else
			{
			//默认添加喜爱的房间--禁止修改房间名
			var love = new Room { Name = Language.StringByID(R.MyInternationalizationString.Favorite), BackgroundImage = "RoomIcon/0.jpg", Id = "Favorite" };
			love.Save(false);
			this.dicRooms["Favorite"] = love;
			}
			}

			/// <summary>
			/// 从一堆文字中,获取这一堆文字里面数字字符串的最长长度
			/// </summary>
			/// <param name="listText"></param>
			/// <returns></returns>
			private int GetNumberMaxLength(List<string> listText)
			{
			int maxLength = 0;
			foreach (var text in listText)
			{
			string value = string.Empty;
			foreach (var c in text)
			{
			if (char.IsNumber(c) == true)
			{
			//数字
			value += c.ToString();
			continue;
			}
			else if (value != string.Empty)
			{
			//判断数字长度
			if (maxLength <= value.Length)
			{
			maxLength = value.Length;
			}
			value = string.Empty;
			}
			}
			//判断数字长度
			if (maxLength <= value.Length)
			{
			maxLength = value.Length;
			}
			}
			return maxLength;
			}

			#endregion
			}
			}
			using Shared.Common;
			using System;
			using System.Collections.Generic;
			using System.Text;
			using ZigBee.Device;

			namespace Shared.Phone.UserCenter
			{
			/// <summary>
			/// 房间的逻辑
			/// </summary>
			public class HdlRoomLogic
			{
			#region ■ 变量声明___________________________

			/// <summary>
			/// 房间的逻辑
			/// </summary>
			private static HdlRoomLogic m_Current = null;
			/// <summary>
			/// 房间的逻辑
			/// </summary>
			public static HdlRoomLogic Current
			{
			get
			{
			if (m_Current == null)
			{
			m_Current = new HdlRoomLogic();
			}
			return m_Current;
			}
			}
			/// <summary>
			/// 当前主页选择的房间对象
			/// </summary>
			public Room NowMainPageRoom = null;
			/// <summary>
			/// 当前分类选择的房间对象
			/// </summary>
			public Room NowCategoryRoom = null;
			/// <summary>
			/// 所有的房间信息
			/// </summary>
			private Dictionary<string, Room> dicRooms = new Dictionary<string, Room>();
			/// <summary>
			/// 物理设备属于哪个房间的记录
			/// </summary>
			private Dictionary<string, string> dicDeviceRoomId = null;

			#endregion

			#region ■ 初始化_____________________________

			/// <summary>
			/// 初始化房间信息
			/// 从文件中全部读取所有的房间数据到内存
			/// </summary>
			public void InitAllRoom()
			{
			this.NowMainPageRoom = null;
			this.NowCategoryRoom = null;

			//清空本地缓存
			this.dicRooms.Clear();
			//检测我的喜爱这个房间对象
			this.CheckLoveRoom();

			var listFile = HdlFileLogic.Current.GetRootPathListFile();
			foreach (var fileName in listFile)
			{
			if (fileName.StartsWith("Room_") == true)
			{
			//从文件里面获取房间对象
			var room = this.GetRoomByFilePath(fileName);
			if (room != null)
			{
			this.dicRooms[room.Id] = (room);
			}
			}
			}
			//顺便刷新场景
			HdlSceneLogic.Current.ReFreshByLocal();
			//刷新房间视图列表
			this.RefreshRoomListView();
			}

			/// <summary>
			/// 从本地重新加载全部的房间
			/// </summary>
			public void RefreshAllRoomByLocation()
			{
			var listFile = HdlFileLogic.Current.GetRootPathListFile();

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

			var listRoomFile = new List<string>();
			foreach (string fileName in listFile)
			{
			if (fileName.StartsWith("Room_"))
			{
			string roomId = fileName.Replace("Room_", string.Empty).Replace(".json", string.Empty);
			listRoomFile.Add(fileName);
			}
			}
			//检测楼层数据的合法性
			if (UserCenterResourse.UserInfo.AuthorityNo == 3)
			{
			this.CheckMemberFloorData(listRoomFile);
			}
			else
			{
			this.CheckAdminFloorData(listRoomFile);
			}

			this.InitAllRoom();
			}

			/// <summary>
			/// 刷新房间视图列表
			/// </summary>
			public void RefreshRoomListView()
			{
			Application.RunOnMainThread(() =>
			{
			MainPage.LeftListRoomViewFrom.Instance?.RefreshListRoom();
			});
			}

			/// <summary>
			/// 检测楼层数据的合法性
			/// </summary>
			/// <param name="listRoomFile"></param>
			private void CheckAdminFloorData(List<string> listRoomFile)
			{
			//没有楼层,则无需处理
			if (Config.Instance.Home.FloorDics.Count == 0) { return; }

			//主人或者管理员的话,就检测是否存在未分配楼层的房间
			for (int i = 0; i < listRoomFile.Count; i++)
			{
			try
			{
			var byteData = Global.ReadFileByHomeId(listRoomFile[i]);
			string valueData = System.Text.Encoding.UTF8.GetString(byteData);
			var roomTemp = Newtonsoft.Json.JsonConvert.DeserializeObject<Common.Room>(valueData);

			//检测多个手机来回创建,然后又删除之后,楼层数据不能保证100%同步的问题
			if (roomTemp.FloorId != string.Empty && Config.Instance.Home.FloorDics.ContainsKey(roomTemp.FloorId) == false)
			{
			//未知楼层
			Config.Instance.Home.FloorDics[roomTemp.FloorId] = Language.StringByID(R.MyInternationalizationString.uUnKnownFloor);
			}
			}
			catch (Exception ex) { HdlLogLogic.Current.WriteLog(ex); }
			}
			}

			/// <summary>
			/// 检测楼层数据的合法性
			/// </summary>
			/// <param name="listRoomFile"></param>
			private void CheckMemberFloorData(List<string> listRoomFile)
			{
			//没有楼层,则无需处理
			if (Config.Instance.Home.FloorDics.Count == 0) { return; }

			//成员的话,就检测是否存在没有房间的楼层
			var listEsixtFloor = new List<string>();
			for (int i = 0; i < listRoomFile.Count; i++)
			{
			try
			{
			var byteData = Global.ReadFileByHomeId(listRoomFile[i]);
			string valueData = System.Text.Encoding.UTF8.GetString(byteData);
			var roomTemp = Newtonsoft.Json.JsonConvert.DeserializeObject<Common.Room>(valueData);
			if (roomTemp.FloorId != string.Empty && listEsixtFloor.Contains(roomTemp.FloorId) == false)
			{
			//收集楼层
			listEsixtFloor.Add(roomTemp.FloorId);
			}
			}
			catch (Exception ex) { HdlLogLogic.Current.WriteLog(ex); }
			}
			var listDeleteId = new List<string>();
			foreach (var flootId in Config.Instance.Home.FloorDics.Keys)
			{
			if (listEsixtFloor.Contains(flootId) == false)
			{
			//如果这个id不存在于任何房间的话,收集它
			listDeleteId.Add(flootId);
			}
			}
			foreach (var deleteId in listDeleteId)
			{
			//删除这个id
			Config.Instance.Home.FloorDics.Remove(deleteId);
			}
			Config.Instance.Home.Save(false);
			}

			#endregion

			#region ■ 添加房间___________________________

			/// <summary>
			/// 增加房间
			/// </summary>
			/// <param name="room">Room.</param>
			/// <param name="rorefreshRoomViewom">是否刷新房间视图列表界面</param>
			public void AddRoom(Room room, bool refreshRoomView = true)
			{
			if (Global.IsExistsByHomeId(room.FileName) == true)
			{
			return;
			}
			//添加到缓存
			this.dicRooms[room.Id] = room;
			//生成文件
			room.Save();
			//备份
			HdlAutoBackupLogic.AddOrEditorFile(room.FileName);
			if (refreshRoomView == true)
			{
			//刷新房间视图列表
			this.RefreshRoomListView();
			}
			}

			#endregion

			#region ■ 删除房间___________________________

			/// <summary>
			/// 删除房间
			/// </summary>
			/// <param name="roomId">房间ID</param>
			/// <param name="refreshLeftView">是否刷新左滑界面(此变量目前是给删除全部房间用的)</param>
			/// <returns></returns>
			public void RemoveRoom(string roomId, bool refreshLeftView = true)
			{
			if (this.NowMainPageRoom != null && this.NowMainPageRoom.Id == roomId)
			{
			//当删除的是主页的房间的时候
			this.NowMainPageRoom = this.GetLoveRoom();
			}
			if (this.NowCategoryRoom != null && this.NowCategoryRoom.Id == roomId)
			{
			//当删除的是分类的房间的时候
			this.NowCategoryRoom = this.GetLoveRoom();
			}

			//根据房间Id，获取房间对象
			var room = this.GetRoomById(roomId);
			if (room == null)
			{
			return;
			}
			//删除来自拍照或者系统图库的房间背景图片
			if (room.BackgroundImageType == 1 \|\| room.BackgroundImageType == 2)
			{
			//删除掉原来的自定义图片
			if (Global.IsExistsByHomeId(room.BackgroundImage) == true)
			{
			Global.DeleteFilebyHomeId(room.BackgroundImage);
			//删除备份
			HdlAutoBackupLogic.DeleteFile(room.BackgroundImage);
			}
			}
			//我的喜爱
			var loveRoom = this.GetLoveRoom();
			if (loveRoom != null)
			{
			//移除我的喜爱里面的设备
			for (int i = 0; i < room.ListDevice.Count; i++)
			{
			loveRoom.ListDevice.Remove(room.ListDevice[i]);
			}
			//移除我的喜爱里面的场景
			for (int i = 0; i < room.ListSceneId.Count; i++)
			{
			loveRoom.ListSceneId.Remove(room.ListSceneId[i]);
			}
			loveRoom.Save(false);
			}
			this.dicRooms.Remove(roomId);

			string roomFilePath = room.FileName;
			if (Global.IsExistsByHomeId(roomFilePath) == true)
			{
			//删除文件
			Global.DeleteFilebyHomeId(roomFilePath);
			}
			HdlAutoBackupLogic.DeleteFile(roomFilePath);

			//根据房间ID,移除指定的真实物理设备的所属房间记录
			HdlRoomLogic.Current.DeleteRealDeviceByRoomId(roomId);
			if (refreshLeftView == true)
			{
			//刷新房间视图列表
			this.RefreshRoomListView();
			}
			}

			/// <summary>
			/// 删除全部的房间
			/// </summary>
			public void DeleteAllRoom()
			{
			var listRoomId = new List<string>();
			foreach (var room in this.dicRooms.Values)
			{
			if (room.IsLove == false)
			{
			listRoomId.Add(room.Id);
			}
			}
			foreach (var roomId in listRoomId)
			{
			this.RemoveRoom(roomId, false);
			}
			}

			#endregion

			#region ■ 获取房间___________________________

			/// <summary>
			/// 获取喜爱房间
			/// </summary>
			/// <returns></returns>
			public Room GetLoveRoom()
			{
			//检测我的喜爱这个房间对象
			this.CheckLoveRoom();

			return this.dicRooms["Favorite"];
			}

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

			return nowRoom;
			}
			catch (Exception ex)
			{
			HdlLogLogic.Current.WriteLog(ex);
			return null;
			}
			}

			/// <summary>
			/// 根据房间Id，获取房间对象
			/// </summary>
			/// <returns>The room by name.</returns>
			/// <param name="roomId">房间ID</param>
			public Room GetRoomById(string roomId)
			{
			if (this.dicRooms.ContainsKey(roomId) == false)
			{
			return null;
			}
			return this.dicRooms[roomId];
			}

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

			/// <summary>
			/// 获取房间名字(楼层+房间名)
			/// </summary>
			/// <returns>房间名</returns>
			/// <param name="room">房间对象</param>
			public string GetRoomName(Room room)
			{
			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>
			/// 获取设备所在的房间(没有设置有房间则返回null)
			/// </summary>
			/// <returns>The room by device.</returns>
			/// <param name="device">设备对象</param>
			public Room GetRoomByDevice(CommonDevice device)
			{
			string mainKeys = LocalDevice.Current.GetDeviceMainKeys(device);
			foreach (var room in this.dicRooms.Values)
			{
			if (room.IsLove == true)
			{
			//喜爱房间不处理
			continue;
			}
			if (room.ListDevice.Contains(mainKeys) == true)
			{
			return room;
			}
			}
			return null;
			}

			/// <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>
			/// 通过场景id获取房间对象
			/// </summary>
			/// <returns>The room by scene identifier.</returns>
			/// <param name="sceneId">Scene identifier.</param>
			public Room GetRoomBySceneId(int sceneId)
			{
			foreach (var room in this.dicRooms.Values)
			{
			if (room.IsLove == true)
			{
			//喜爱房间不处理
			continue;
			}
			if (room.ListSceneId.Contains(sceneId) == true)
			{
			return room;
			}
			}
			return null;
			}

			/// <summary>
			/// 获取当前楼层的房间
			/// </summary>
			/// <param name="id"></param>
			/// <returns></returns>
			public List<Room> GetRoomsByFloorId(string id)
			{
			var listRoom = new List<Room>();
			if (Config.Instance.Home.FloorDics.Count == 0)
			{
			//没有楼层
			foreach (var room in this.dicRooms.Values)
			{
			listRoom.Add(room);
			}
			}
			else
			{
			foreach (var room in this.dicRooms.Values)
			{
			if (room.FloorId == id)
			{
			listRoom.Add(room);
			}
			}
			}
			return this.SortRoom(listRoom);
			}

			/// <summary>
			/// 获取全部的房间
			/// </summary>
			/// <returns></returns>
			public List<Room> GetAllListRooms()
			{
			var listRoom = new List<Room>();
			foreach (var room in this.dicRooms.Values)
			{
			listRoom.Add(room);
			}
			return this.SortRoom(listRoom);
			}

			/// <summary>
			/// 获取当前楼层的房间(拼接了【常用】在第一位)
			/// </summary>
			/// <param name="id"></param>
			/// <returns></returns>
			public List<Room> GetRoomsByFloorIdAppendLoveRoom(string id)
			{
			var listRoom = new List<Room>();
			if (Config.Instance.Home.FloorDics.Count == 0)
			{
			//没有楼层
			foreach (var room in this.dicRooms.Values)
			{
			if (room.IsLove == false)
			{
			listRoom.Add(room);
			}
			}
			}
			else
			{
			foreach (var room in this.dicRooms.Values)
			{
			if (room.FloorId == id && room.IsLove == false)
			{
			listRoom.Add(room);
			}
			}
			}
			listRoom = this.SortRoom(listRoom);

			listRoom.Insert(0, GetLoveRoom());
			return listRoom;
			}

			/// <summary>
			/// 获取网关所在的房间
			/// </summary>
			/// <param name="zbGateway">网关对象</param>
			/// <returns></returns>
			public Room GetRoomByGateway(ZbGateway zbGateway)
			{
			return this.GetRoomByGateway(zbGateway.GwId);
			}

			/// <summary>
			/// 获取网关所在的房间
			/// </summary>
			/// <param name="gatewayId">网关ID</param>
			/// <returns></returns>
			public Room GetRoomByGateway(string gatewayId)
			{
			var localGateway = HdlGatewayLogic.Current.GetLocalGateway(gatewayId);
			if (localGateway == null)
			{
			return null;
			}
			return HdlRoomLogic.Current.GetRoomById(localGateway.RoomId);
			}

			/// <summary>
			/// 变更网关房间
			/// </summary>
			/// <param name="gwId">网关Id</param>
			/// <param name="roomId">房间ID</param>
			public void ChangedGatewayRoom(string gwId, string roomId)
			{
			var localGateway = HdlGatewayLogic.Current.GetLocalGateway(gwId);
			if (localGateway != null)
			{
			localGateway.RoomId = roomId;
			localGateway.ReSave();
			//添加备份
			HdlAutoBackupLogic.AddOrEditorFile(localGateway.FilePath);
			}
			}

			#endregion


			#region ■ 物理设备所属房间___________________

			/// <summary>
			/// 初始化物理设备所属房间的记录
			/// </summary>
			public void InitRealDeviceRoomId()
			{
			this.dicDeviceRoomId = new Dictionary<string, string>();
			string fullName = DirNameResourse.DeviceRoomIdFile;
			var strData = HdlFileLogic.Current.ReadFileTextContent(fullName);
			if (strData != null)
			{
			this.dicDeviceRoomId = Newtonsoft.Json.JsonConvert.DeserializeObject<Dictionary<string, string>>(strData);
			}
			}

			/// <summary>
			/// 获取全部物理设备所属房间的记录
			/// </summary>
			/// <returns></returns>
			public Dictionary<string, string> GetAllRealDeviceRoomData()
			{
			return this.dicDeviceRoomId;
			}

			/// <summary>
			/// 保存物理设备所属房间的记录
			/// </summary>
			/// <param name="listDevice">需要保存的设备对象</param>
			/// <param name="roomId">需要保存的哪个设备的房间ID</param>
			/// <param name="saveRoadDevice">如果只有一个回路,是否把回路的房间一起修改</param>
			public void SaveRealDeviceRoomId(List<CommonDevice> listDevice, string roomId, bool saveRoadDevice = true)
			{
			if (listDevice == null \|\| listDevice.Count == 0)
			{
			return;
			}
			//如果设备只有一个回路，如果改变了真实设备区域，则它的回路的区域也一起改了
			if (saveRoadDevice == true && listDevice.Count == 1)
			{
			if ((listDevice[0] is OTADevice) == false)
			{
			//ota设备不需要处理
			HdlRoomLogic.Current.ChangedRoom(listDevice[0], roomId, false);
			}
			}
			bool save = false;
			if (roomId == string.Empty)
			{
			//选择的是未分配
			this.dicDeviceRoomId.Remove(listDevice[0].DeviceAddr);
			save = true;
			}
			else
			{
			if (this.dicDeviceRoomId.ContainsKey(listDevice[0].DeviceAddr) == false)
			{
			this.dicDeviceRoomId[listDevice[0].DeviceAddr] = roomId;
			save = true;
			}
			else
			{
			//2020.05.18追加:如果记录的房间ID是不存在的话,则重新覆盖
			var room = HdlRoomLogic.Current.GetRoomById(this.dicDeviceRoomId[listDevice[0].DeviceAddr]);
			if (room == null \|\| this.dicDeviceRoomId[listDevice[0].DeviceAddr] != roomId)
			{
			this.dicDeviceRoomId[listDevice[0].DeviceAddr] = roomId;
			save = true;
			}
			}
			}

			if (save == true)
			{
			//保存记录
			HdlFileLogic.Current.SaveFileContent(DirNameResourse.DeviceRoomIdFile, this.dicDeviceRoomId);

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

			/// <summary>
			/// 获取真实物理设备的房间名字
			/// </summary>
			/// <param name="device">设备的某一个回路</param>
			/// <returns></returns>
			public string GeteRealDeviceRoomName(CommonDevice device)
			{
			if (this.dicDeviceRoomId.ContainsKey(device.DeviceAddr) == false)
			{
			//未分配区域
			return Language.StringByID(R.MyInternationalizationString.uDeviceNotAssignedRoom);
			}
			var room = HdlRoomLogic.Current.GetRoomById(this.dicDeviceRoomId[device.DeviceAddr]);
			return HdlRoomLogic.Current.GetRoomName(room);
			}

			/// <summary>
			/// 获取真实物理设备属于哪个房间
			/// </summary>
			/// <param name="device">设备的某一个回路</param>
			/// <returns></returns>
			public Room GeteRealDeviceRoom(CommonDevice device)
			{
			if (this.dicDeviceRoomId.ContainsKey(device.DeviceAddr) == false)
			{
			return null;
			}
			return HdlRoomLogic.Current.GetRoomById(this.dicDeviceRoomId[device.DeviceAddr]);
			}

			/// <summary>
			/// 将真实物理设备从房间中移除
			/// </summary>
			/// <param name="device">随便一个回路</param>
			public void DeleteRealDeviceFromRoom(CommonDevice device)
			{
			//将真实物理设备从房间中移除
			this.DeleteRealDeviceFromRoom(new List<string>() { device.DeviceAddr });
			}

			/// <summary>
			/// 将真实物理设备从房间中移除
			/// </summary>
			/// <param name="listMac">设备Mac地址</param>
			public void DeleteRealDeviceFromRoom(List<string> listMac)
			{
			bool save = false;
			foreach (var deviceMacAddr in listMac)
			{
			if (this.dicDeviceRoomId.ContainsKey(deviceMacAddr) == true)
			{
			this.dicDeviceRoomId.Remove(deviceMacAddr);
			save = true;
			}
			}
			if (save == false)
			{
			//没有改变,不需要保存
			return;
			}
			//保存记录
			HdlFileLogic.Current.SaveFileContent(DirNameResourse.DeviceRoomIdFile, this.dicDeviceRoomId);

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

			/// <summary>
			/// 根据房间ID,移除指定的真实物理设备的所属房间记录
			/// </summary>
			/// <param name="i_RoomId"></param>
			public void DeleteRealDeviceByRoomId(string i_RoomId)
			{
			var listDeleteKey = new List<string>();
			foreach (var deviceAddr in this.dicDeviceRoomId.Keys)
			{
			if (this.dicDeviceRoomId[deviceAddr] == i_RoomId
			&& listDeleteKey.Contains(deviceAddr) == false)
			{
			listDeleteKey.Add(deviceAddr);
			}
			}
			//将真实物理设备从房间中移除
			this.DeleteRealDeviceFromRoom(listDeleteKey);
			}

			#endregion

			#region ■ 房间方法___________________________

			/// <summary>
			/// 设备的房间变更
			/// </summary>
			/// <param name="device">设备对象</param>
			/// <param name="roomId">新房间Id</param>
			/// <param name="saveRealRoom">是否修改真实物理设备的房间,不出意外,这个值默认为true即可</param>
			public void ChangedRoom(CommonDevice device, string roomId, bool saveRealRoom = true)
			{
			//选择的是未分配
			if (roomId == string.Empty)
			{
			//从原来的房间移除设备
			this.DeleteDevice(device);
			//移除我的喜爱
			this.DeleteLoveDevice(device);
			//设备改变房间的话,主页需要重新刷新
			UserView.UserPage.Instance.RefreshAllForm = true;
			return;
			}
			//房间是否修改
			if (this.IsRoomChanged(device, roomId) == false)
			{
			return;
			}
			//从原来的房间移除设备,这里不删除真实设备的房间
			this.DeleteDevice(device, false);

			//添加到新的房间
			var room = this.GetRoomById(roomId);
			if (room != null)
			{
			this.AddDevice(room, device, saveRealRoom);
			}
			//设备改变房间的话,主页需要重新刷新
			UserView.UserPage.Instance.RefreshAllForm = true;
			}

			/// <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>
			/// 添加设备
			/// </summary>
			/// <param name="i_room">房间对象</param>
			/// <param name="device">要添加的设备对象</param>
			/// <param name="saveRealRoom">是否修改真实物理设备的房间,不出意外,这个值默认为true即可</param>
			public void AddDevice(Room i_room, CommonDevice device, bool saveRealRoom)
			{
			if (device == null)
			{
			return;
			}
			//设备信息保存到本地
			device.Save();

			string mainkeys = LocalDevice.Current.GetDeviceMainKeys(device);
			if (i_room.ListDevice.Contains(mainkeys) == false)
			{
			//保存到本地
			i_room.ListDevice.Add(mainkeys);
			i_room.Save();

			if (i_room.IsLove == false && saveRealRoom == true && LocalDevice.Current.GetDevicesCountByMac(device.DeviceAddr) == 1)
			{
			//如果只有一个回路,则修改真实物理设备的房间
			this.SaveRealDeviceRoomId(new List<CommonDevice>() { device }, i_room.Id, false);
			}
			}
			}

			/// <summary>
			/// 添加喜爱设备
			/// </summary>
			/// <param name="device">要添加的设备对象</param>
			public void AddLoveDevice(CommonDevice device)
			{
			if (device == null)
			{
			return;
			}
			//我的喜爱
			var loveRoom = this.GetLoveRoom();
			if (loveRoom != null)
			{
			string mainkeys = LocalDevice.Current.GetDeviceMainKeys(device);
			if (loveRoom.ListDevice.Contains(mainkeys) == false)
			{
			//保存到本地
			loveRoom.ListDevice.Add(mainkeys);
			loveRoom.Save();
			//添加收藏设备时,需要刷新主页
			UserView.UserPage.Instance.RefreshAllForm = true;
			}
			}
			}

			#endregion

			#region ■ 删除设备___________________________

			/// <summary>
			/// 删除设备(这个函数不删除我的喜爱)
			/// </summary>
			/// <param name="device">要删除的设备对象</param>
			/// <param name="deleteReal">是否删除真实物理设备的房间</param>
			public void DeleteDevice(CommonDevice device, bool deleteReal = true)
			{
			if (device == null)
			{
			return;
			}
			//如果它只有一个回路
			if (deleteReal == true && LocalDevice.Current.GetDevicesCountByMac(device.DeviceAddr) == 1)
			{
			//删除掉它的真实物理设备的所在位置
			HdlRoomLogic.Current.DeleteRealDeviceFromRoom(device);
			}

			//根据设备，获取所在的房间
			var room = this.GetRoomByDevice(device);
			if (room == null)
			{
			return;
			}
			//移除缓存
			string mainkeys = LocalDevice.Current.GetDeviceMainKeys(device);
			room.ListDevice.Remove(mainkeys);
			room.Save();
			//更改自动备份
			HdlAutoBackupLogic.AddOrEditorFile(room.FileName);

			//递归：删除掉以前的旧数据导致的多个房间的问题
			this.DeleteDevice(device, deleteReal);
			}

			/// <summary>
			/// 删除我的喜爱的设备
			/// </summary>
			/// <param name="device">要删除的设备对象</param>
			public void DeleteLoveDevice(CommonDevice device)
			{
			if (device == null)
			{
			return;
			}
			//我的喜爱
			var loveRoom = this.GetLoveRoom();
			if (loveRoom != null)
			{
			//移除缓存
			string mainkeys = LocalDevice.Current.GetDeviceMainKeys(device);
			loveRoom.ListDevice.Remove(mainkeys);
			loveRoom.Save();
			//更改自动备份
			HdlAutoBackupLogic.AddOrEditorFile(loveRoom.FileName);
			//添加收藏设备时,需要刷新主页
			UserView.UserPage.Instance.RefreshAllForm = true;
			}
			}

			#endregion

			#region ■ 获取设备___________________________

			/// <summary>
			/// 获取当前房间下的全部设备
			/// </summary>
			/// <returns></returns>
			public List<CommonDevice> GetRoomListDevice(Room i_room)
			{
			var dicSort = new Dictionary<string, List<int>>();
			foreach (var mainKeys in i_room.ListDevice)
			{
			var device = LocalDevice.Current.GetDevice(mainKeys);
			if (device != null)
			{
			if (dicSort.ContainsKey(device.DeviceAddr) == false)
			{
			dicSort[device.DeviceAddr] = new List<int>();
			}
			dicSort[device.DeviceAddr].Add(device.DeviceEpoint);
			}
			}
			var listDevice = new List<CommonDevice>();
			foreach (var strMac in dicSort.Keys)
			{
			var listEpont = dicSort[strMac];
			//排序
			listEpont.Sort();
			for (int i = 0; i < listEpont.Count; i++)
			{
			var device = LocalDevice.Current.GetDevice(strMac, listEpont[i]);
			listDevice.Add(device);
			}
			}
			return listDevice;
			}

			/// <summary>
			/// 获取房间设备类型
			/// </summary>
			/// <param name="room"></param>
			/// <returns></returns>
			public List<DeviceType> GetDeviceTypes(Room i_room)
			{
			var typeList = new List<DeviceType>();
			foreach (var mainKeys in i_room.ListDevice)
			{
			var device = LocalDevice.Current.GetDevice(mainKeys);
			if (device != null)
			{
			typeList.Add(device.Type);
			}
			}
			return typeList;
			}

			/// <summary>
			/// 获取该类型的设备
			/// </summary>
			/// <param name="room"></param>
			/// <param name="deviceType"></param>
			/// <returns></returns>
			public List<CommonDevice> GetRoomListDevice(Room room, DeviceType deviceType)
			{
			List<CommonDevice> typeList = new List<CommonDevice>();
			foreach (var mainKeys in room.ListDevice)
			{
			var device = LocalDevice.Current.GetDevice(mainKeys);
			if (device != null && device.Type == deviceType)
			{
			typeList.Add(device);
			}
			}

			return typeList;
			}

			/// <summary>
			/// 获取未分配区域设备
			/// </summary>
			/// <returns></returns>
			public List<CommonDevice> GetUnalloctedDevice()
			{
			var listDevice = new List<CommonDevice>();

			//已经存在的设备
			var listEsxit = new HashSet<string>();
			foreach (var room in this.dicRooms.Values)
			{
			if (room.IsLove == true)
			{
			//不包含收藏房间
			continue;
			}
			foreach (string mainkeys in room.ListDevice)
			{
			if (listEsxit.Contains(mainkeys) == false)
			{
			listEsxit.Add(mainkeys);
			}
			}
			}

			//所有设备
			var commonDeviceList = LocalDevice.Current.listAllDevice;
			foreach (var device in commonDeviceList)
			{
			//判断该设备能否显示在主页
			if (LocalDevice.Current.CanShowInHomeHomeMainPage(device) == false)
			{
			continue;
			}
			string mainkeys = LocalDevice.Current.GetDeviceMainKeys(device);
			if (listEsxit.Contains(mainkeys) == false)
			{
			listDevice.Add(device);
			}
			}
			return listDevice;
			}

			/// <summary>
			/// 获取全部房间全部的设备
			/// </summary>
			/// <returns></returns>
			public List<CommonDevice> GetAllRoomListDevice()
			{
			var listDevice = new List<CommonDevice>();
			foreach (var room in this.dicRooms.Values)
			{
			if (room.IsSharedRoom \|\| room.IsLove)
			{
			continue;
			}
			listDevice.AddRange(this.GetRoomListDevice(room));
			}
			return listDevice;
			}

			#endregion

			#region ■ 设备是否收藏_______________________

			/// <summary>
			/// 是否是收藏设备
			/// </summary>
			/// <param name="filePath"></param>
			/// <returns></returns>
			public bool IsCollectInRoom(CommonDevice device)
			{
			string mainkeys = LocalDevice.Current.GetDeviceMainKeys(device);
			//喜爱房间
			var room = this.GetLoveRoom();
			return room.ListDevice.Contains(mainkeys);
			}

			/// <summary>
			/// 是否是收藏设备
			/// </summary>
			/// <param name="filePath"></param>
			/// <returns></returns>
			public bool IsCollectInRoom(SceneUI scene)
			{
			//喜爱房间
			var room = this.GetLoveRoom();
			return room.ListSceneId.Contains(scene.Id);
			}

			#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)
			{
			if (i_floorKeys == null)
			{
			i_floorKeys = string.Empty;
			}
			var listRoom = new List<Room>();
			foreach (var room in this.dicRooms.Values)
			{
			if (room.FloorId != i_floorKeys && i_floorKeys != string.Empty
			\|\| room.IsLove == true)
			{
			//不是同一个楼层,不要我的喜爱
			continue;
			}
			if (getShard == false && room.IsSharedRoom == true)
			{
			//不要分享的房间
			continue;
			}
			listRoom.Add(room);
			}
			return this.SortRoom(listRoom);
			}

			/// <summary>
			/// 排序房间对象
			/// </summary>
			/// <param name="listRoom"></param>
			/// <returns></returns>
			public List<Room> SortRoom(List<Room> listRoom)
			{
			//从一堆文字中,获取这一堆文字里面数字字符串的最长长度
			var listName = new List<string>();
			foreach (var room in listRoom)
			{
			listName.Add(room.Name);
			}
			int numberLength = this.GetNumberMaxLength(listName);

			var listSort = new List<string[]>();
			foreach (var room in listRoom)
			{
			var strArry = new string[2];
			strArry[0] = room.Id;
			strArry[1] = string.Empty;

			string value = string.Empty;
			foreach (var c in room.Name)
			{
			if (char.IsNumber(c) == true)
			{
			//数字
			value += c.ToString();
			continue;
			}
			else if (value != string.Empty)
			{
			//如果房间名字带有数字的话,则左边加零,因为这里有个排序的问题
			strArry[1] += value.PadLeft(numberLength, '0');
			value = string.Empty;
			}
			strArry[1] += c.ToString();
			}
			if (value != string.Empty)
			{
			//以数字结尾的话
			strArry[1] += value.PadLeft(numberLength, '0');
			}
			listSort.Add(strArry);
			}
			//排序
			listSort.Sort((obj1, obj2) =>
			{
			if (obj1[1].CompareTo(obj2[1]) > 0)
			{
			return 1;
			}
			return -1;
			});
			var listSortRoom = new List<Room>();
			foreach (var strArry in listSort)
			{
			var room = this.GetRoomById(strArry[0]);
			listSortRoom.Add(room);
			}
			return listSortRoom;
			}

			/// <summary>
			/// 获取排序后的楼层
			/// </summary>
			/// <returns></returns>
			public Dictionary<string, string> GetFloorSortList()
			{
			//没有楼层
			if (Config.Instance.Home.FloorDics.Count == 0)
			{
			return new Dictionary<string, string>();
			}
			//从一堆文字中,获取这一堆文字里面数字字符串的最长长度
			var listName = new List<string>();
			foreach (var floorName in Config.Instance.Home.FloorDics.Values)
			{
			listName.Add(floorName);
			}
			int numberLength = this.GetNumberMaxLength(listName);

			var listSort = new List<string[]>();
			foreach (var floorId in Config.Instance.Home.FloorDics.Keys)
			{
			var strArry = new string[2];
			strArry[0] = floorId;
			strArry[1] = string.Empty;

			string value = string.Empty;
			string floorName = Config.Instance.Home.FloorDics[floorId];
			foreach (var c in floorName)
			{
			if (char.IsNumber(c) == true)
			{
			//数字
			value += c.ToString();
			continue;
			}
			else if (value != string.Empty)
			{
			//如果房间名字带有数字的话,则左边加零,因为这里有个排序的问题
			strArry[1] += value.PadLeft(numberLength, '0');
			value = string.Empty;
			}
			strArry[1] += c.ToString();
			}
			if (value != string.Empty)
			{
			//以数字结尾的话
			strArry[1] += value.PadLeft(numberLength, '0');
			}
			listSort.Add(strArry);
			}
			//楼层排序
			listSort.Sort((obj1, obj2) =>
			{
			if (obj1[1].CompareTo(obj2[1]) > 0)
			{
			return 1;
			}
			return -1;
			});
			var dic = new Dictionary<string, string>();
			foreach (var strArry in listSort)
			{
			dic[strArry[0]] = Config.Instance.Home.FloorDics[strArry[0]];
			}
			return dic;
			}

			#endregion

			#region ■ 发送房间信息给网关_________________

			/// <summary>
			/// 发送房间信息给网关
			/// </summary>
			public void SetRoomInfoToGateway()
			{
			if (UserCenterResourse.UserInfo.AuthorityNo != 1 && UserCenterResourse.UserInfo.AuthorityNo != 2)
			{
			//不是主人和管理员,则不处理
			return;
			}
			var realMain = ZbGateway.MainGateWay;
			if (realMain == null \|\| Common.Config.Instance.Home.IsVirtually == true)
			{
			//没有主网关,则不理
			return;
			}
			//获取房间全部的设备对象
			string strSendDeviceRoomInfo = string.Empty;
			foreach (var room in this.dicRooms.Values)
			{
			if (room.IsSharedRoom \|\| room.IsLove)
			{
			continue;
			}
			var listDevice = this.GetRoomListDevice(room);
			//发送给网关的设备房间json
			foreach (var device in listDevice)
			{
			if (strSendDeviceRoomInfo != string.Empty)
			{
			strSendDeviceRoomInfo += "\r\n";
			}
			strSendDeviceRoomInfo += " " + this.SetDoublMark(device.DeviceAddr) + " ";
			strSendDeviceRoomInfo += this.SetDoublMark("0x" + Convert.ToString(device.DeviceEpoint, 16).PadLeft(2, '0')) + " ";
			strSendDeviceRoomInfo += this.SetDoublMark(LocalDevice.Current.GetDeviceEpointName(device).Replace(UserCenterResourse.douMarks, string.Empty)) + " ";
			strSendDeviceRoomInfo += this.SetDoublMark(room.Id);
			}
			}

			var listAreaSpaceInfo = new List<AreaSpaceInfo>();
			//首先添加住宅
			var houseInfo = new AreaSpaceInfo();
			houseInfo.name = Common.Config.Instance.Home.Name;
			houseInfo.uid = Common.Config.Instance.Home.Id;
			houseInfo.parentId = null;
			listAreaSpaceInfo.Add(houseInfo);
			//然后添加楼层
			foreach (var floorId in Common.Config.Instance.Home.FloorDics.Keys)
			{
			var floorInfo = new AreaSpaceInfo();
			floorInfo.name = Common.Config.Instance.Home.FloorDics[floorId];
			floorInfo.uid = floorId;
			floorInfo.parentId = Common.Config.Instance.Home.Id;
			listAreaSpaceInfo.Add(floorInfo);
			}
			//然后添加房间
			var listRoom = this.GetAllListRooms();
			foreach (var room in listRoom)
			{
			if (room.IsLove == true) { continue; }

			var roomInfo = new AreaSpaceInfo();
			roomInfo.name = room.Name;
			roomInfo.uid = room.Id;
			if (Common.Config.Instance.Home.FloorDics.ContainsKey(room.FloorId) == true)
			{
			roomInfo.parentId = room.FloorId;
			}
			else
			{
			roomInfo.parentId = Common.Config.Instance.Home.Id;
			}
			listAreaSpaceInfo.Add(roomInfo);
			}
			//然后添加网关房间信息
			var gatewayInfo = new GatewayAreaSpaceInfo();

			var loaclGateway = HdlGatewayLogic.Current.GetLocalGateway(realMain.GwId);
			if (loaclGateway == null \|\| loaclGateway.GwMac == string.Empty)
			{
			//没有mac,或者找不到对象,则不上传
			return;
			}
			string gwMac = loaclGateway.GwMac.Replace(":", string.Empty);
			gatewayInfo.uid = "000101" + gwMac.Substring(2) + "07";
			gatewayInfo.name = HdlGatewayLogic.Current.GetGatewayName(loaclGateway);

			var roomGateway = HdlRoomLogic.Current.GetRoomByGateway(loaclGateway);
			if (roomGateway != null)
			{
			gatewayInfo.parentId = roomGateway.Id;
			}
			gatewayInfo.hwInfo = new GatewayHwInfo();
			gatewayInfo.pkgInfo = new GatewayPkgInfo { version = loaclGateway.LinuxFirmwareVersion.ToString() };
			gatewayInfo.swInfo = new List<GatewaySwInfo> { new GatewaySwInfo { ver = loaclGateway.LinuxFirmwareVersion.ToString() } };
			gatewayInfo.ip = loaclGateway.GwIP;
			gatewayInfo.mac = loaclGateway.GwMac;

			var data = new { spaces = listAreaSpaceInfo, gateway = gatewayInfo };
			string strSendRoomInfo = Newtonsoft.Json.JsonConvert.SerializeObject(data);

			HdlThreadLogic.Current.RunThread(async () =>
			{
			//发送设备区域信息
			if (strSendDeviceRoomInfo != string.Empty)
			{
			//创建文件对象
			var result0 = await realMain.CreateFileAsync("DeviceRoomInfo.json");
			if (result0 == null)
			{
			return;
			}
			if (result0.Result != 0 && result0.Result != 2)
			{
			//如果是2,允许上传
			return;
			}
			//发送数据流
			var byteData = ASCIIEncoding.UTF8.GetBytes(strSendDeviceRoomInfo);
			var result1 = await realMain.SendFileAsync(byteData);
			if (result1 == null \|\| result1.Result != 0)
			{
			return;
			}

			}

			//创建文件对象
			var result3 = await realMain.CreateFileAsync("space.json");
			if (result3 == null)
			{
			return;
			}
			if (result3.Result != 0 && result3.Result != 2)
			{
			//如果是2,允许上传
			return;
			}

			//发送区域信息
			var byteData2 = ASCIIEncoding.UTF8.GetBytes(strSendRoomInfo);
			var result4 = await realMain.SendFileAsync(byteData2);
			});
			}

			/// <summary>
			/// 设置双引号
			/// </summary>
			/// <param name="i_text"></param>
			/// <returns></returns>
			private string SetDoublMark(string i_text)
			{
			return UserCenterResourse.douMarks + i_text + UserCenterResourse.douMarks;
			}

			/// <summary>
			/// 空间区域信息
			/// </summary>
			private class AreaSpaceInfo
			{
			/// <summary>
			/// 住宅ID 或者楼层ID 或者房间ID
			/// </summary>
			public string uid = string.Empty;
			/// <summary>
			/// 住宅名称或者楼层名称或者房间名称
			/// </summary>
			public string name = string.Empty;
			/// <summary>
			/// 当前ID的父ID,如果没有,则为带双引号的"null" 比如楼层ID就填住宅ID 房间ID就填楼层ID
			/// </summary>
			public string parentId = string.Empty;
			}

			/// <summary>
			/// 网关空间区域信息
			/// </summary>
			private class GatewayAreaSpaceInfo
			{
			/// <summary>
			/// 【000101】+绑定网关的时间戳转16进制+【07】
			/// </summary>
			public string uid = string.Empty;
			/// <summary>
			/// 这个固定
			/// </summary>
			public string name = "hdl_bus_gatway";
			/// <summary>
			/// 网关所在的房间ID
			/// </summary>
			public string parentId = string.Empty;
			/// <summary>
			/// 这个固定
			/// </summary>
			public int deviceType = 61184;
			/// <summary>
			/// 网关硬件信息
			/// </summary>
			public GatewayHwInfo hwInfo = null;
			/// <summary>
			/// 网关标准信息
			/// </summary>
			public GatewayPkgInfo pkgInfo = null;
			/// <summary>
			/// 网关固件版本
			/// </summary>
			public List<GatewaySwInfo> swInfo = null;
			/// <summary>
			/// 网关IP
			/// </summary>
			public string ip = string.Empty;
			/// <summary>
			/// 网关的Mac
			/// </summary>
			public string mac = string.Empty;
			}

			/// <summary>
			/// 网关硬件信息
			/// </summary>
			private class GatewayHwInfo
			{
			/// <summary>
			/// 这个固定
			/// </summary>
			public string brand = "MIPS";
			/// <summary>
			/// 这个固定
			/// </summary>
			public string model = "MT7688";
			}

			/// <summary>
			/// 网关标准信息
			/// </summary>
			private class GatewayPkgInfo
			{
			/// <summary>
			/// 这个是Linux的固件版本
			/// </summary>
			public string version = string.Empty;
			}

			/// <summary>
			/// 网关固件版本
			/// </summary>
			private class GatewaySwInfo
			{
			/// <summary>
			/// 这个固定
			/// </summary>
			public string name = "HDL";
			/// <summary>
			/// 这个是Linux的固件版本
			/// </summary>
			public string ver = string.Empty;
			}

			#endregion

			#region ■ 克隆房间对象_______________________

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

			return newRoom;
			}

			#endregion

			#region ■ 一般方法___________________________

			/// <summary>
			/// 获取房间总数
			/// </summary>
			/// <returns></returns>
			public int GetRoomCount()
			{
			return this.dicRooms.Count;
			}

			/// <summary>
			/// 检测我的喜爱这个房间对象
			/// </summary>
			private void CheckLoveRoom()
			{
			if (this.dicRooms.ContainsKey("Favorite") == true)
			{
			return;
			}
			//读取本地我的喜爱文件
			string favoriteFile = System.IO.Path.Combine(Common.Config.Instance.FullPath, "Room_Favorite.json");
			var fileContent = HdlFileLogic.Current.ReadFileTextContent(favoriteFile);
			if (fileContent != null)
			{
			var love = Newtonsoft.Json.JsonConvert.DeserializeObject<Room>(fileContent);
			this.dicRooms["Favorite"] = love;
			}
			else
			{
			//默认添加喜爱的房间--禁止修改房间名
			var love = new Room { Name = Language.StringByID(R.MyInternationalizationString.Favorite), BackgroundImage = "RoomIcon/0.jpg", Id = "Favorite" };
			love.Save(false);
			this.dicRooms["Favorite"] = love;
			}
			}

			/// <summary>
			/// 从一堆文字中,获取这一堆文字里面数字字符串的最长长度
			/// </summary>
			/// <param name="listText"></param>
			/// <returns></returns>
			private int GetNumberMaxLength(List<string> listText)
			{
			int maxLength = 0;
			foreach (var text in listText)
			{
			string value = string.Empty;
			foreach (var c in text)
			{
			if (char.IsNumber(c) == true)
			{
			//数字
			value += c.ToString();
			continue;
			}
			else if (value != string.Empty)
			{
			//判断数字长度
			if (maxLength <= value.Length)
			{
			maxLength = value.Length;
			}
			value = string.Empty;
			}
			}
			//判断数字长度
			if (maxLength <= value.Length)
			{
			maxLength = value.Length;
			}
			}
			return maxLength;
			}

			#endregion
			}
			}