~wjc/HomeApp.git

			@@ -77,7 +77,7 @@
			}

			/// <summary>
			/// 刷新房间的场景列表
			/// 刷新本地的全部场景
			/// </summary>
			public async Task<bool> RefreshSceneUIList()
			{
			@@ -120,78 +120,124 @@
			#region ■ 添加场景___________________________

			/// <summary>
			/// 添加场景(更新网关) 0失败 1成功 -1已经存在
			/// 添加新场景到网关(返回null代表出错)
			/// </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 Task<int> AddScene(Room i_room, string sceneName, string sceneIconPath, List<Scene.AddSceneMemberData> commons, int iconPathType)
			/// <param name="sceneName">场景名称</param>
			/// <param name="listAdjustTarget">执行目标</param>
			/// <returns></returns>
			public async Task<SceneUI> AddNewSceneToGateway(string sceneName, List<Scene.DeviceListData> listAdjustTarget)
			{
			var getSceneIdAllData = await Scene.GetSceneNewIdAsync(sceneName);
			if (getSceneIdAllData == null \|\| getSceneIdAllData.getSceneIdData == null)
			var result1 = await Scene.GetSceneNewIdAsync(sceneName);
			//共通错误检测
			string error = HdlCheckLogic.Current.CheckCommonErrorCode(result1);
			if (error != null)
			{
			return 0;
			this.ShowErrorMsg(error);
			return null;
			}
			var getSceneIdData = getSceneIdAllData.getSceneIdData;

			bool result = true;
			foreach (var common in commons)
			if (result1 == null \|\| result1.getSceneIdData == null)
			{
			//添加新成员
			var addSceneMemberData = new Scene.AddSceneMemberData
			//添加场景失败
			string msg1 = Language.StringByID(R.MyInternationalizationString.AddSceneFail);
			//拼接上【网关回复超时】的Msg
			msg1 = UserCenterLogic.CombineGatewayTimeOutMsg(msg1, result1);
			this.ShowTipMsg(msg1);
			return null;
			}
			//添加执行目标
			var listSuccess = await this.AddTargetToScene(result1.getSceneIdData.NewScenesId, listAdjustTarget);
			if (listSuccess == null)
			{
			return null;
			}

			//创建场景对象
			var newScene = new SceneUI();
			newScene.Name = sceneName;
			newScene.Id = result1.getSceneIdData.NewScenesId;
			newScene.AdjustTargetList.AddRange(listSuccess);
			//添加缓存
			newScene.Save();
			//加入缓存
			this.dicScenes[newScene.Id] = newScene;

			return newScene;
			}

			/// <summary>
			/// 添加执行目标到指定的场景(返回成功添加的执行目标)
			/// </summary>
			/// <param name="sceneId">场景Id</param>
			/// <param name="listAdjustTarget">执行目标</param>
			/// <returns></returns>
			private async Task<List<Scene.DeviceListData>> AddTargetToScene(int sceneId, List<Scene.DeviceListData> listAdjustTarget)
			{
			var listSuccess = new List<Scene.DeviceListData>();
			for (int i = 0; i < listAdjustTarget.Count; i++)
			{
			var data = listAdjustTarget[i];
			var addData = new Scene.AddSceneMemberData();
			if (data.Type == 0)
			{
			Type = common.Type,
			DeviceAddr = common.DeviceAddr,
			Epoint = common.Epoint,
			ScenesId = getSceneIdData.NewScenesId,
			TaskList = common.TaskList,
			DelayTime = common.DelayTime,
			MemberNumber = common.MemberNumber,
			ElseScenesId = common.ElseScenesId
			};
			//设备
			addData.Type = 0;
			addData.ScenesId = sceneId;
			addData.DeviceAddr = data.DeviceAddr;
			addData.Epoint = data.Epoint;
			addData.TaskList = data.TaskList;
			addData.DelayTime = 0;
			addData.MemberNumber = i + 1;
			}
			else if (data.Type == 1)
			{
			//场景
			addData.Type = 1;
			addData.ScenesId = sceneId;
			addData.ElseScenesId = data.ElseScenesId;
			addData.DelayTime = 0;
			addData.MemberNumber = i + 1;
			}
			else
			{
			//延时
			addData.Type = 2;
			addData.ScenesId = sceneId;
			addData.DelayTime = data.DelayTime;
			addData.MemberNumber = i + 1;
			}

			//添加新成员返回结果
			var addSceneMemberResponseAllData = await Scene.AddSceneMemberAsync(addSceneMemberData);
			if (addSceneMemberResponseAllData == null \|\| addSceneMemberResponseAllData.addSceneMemberResponseData == null)
			var result2 = await Scene.AddSceneMemberAsync(addData);
			if (result2 == null \|\| result2.addSceneMemberResponseData == null
			\|\| result2.addSceneMemberResponseData.Result != 1)
			{
			continue;
			}
			var addSceneMemberResponseData = addSceneMemberResponseAllData.addSceneMemberResponseData;
			if (addSceneMemberResponseData == null && addSceneMemberResponseData.Result != 1)
			{
			result = false;
			}
			//拥有成功的
			listSuccess.Add(data);
			}
			//加入成功
			if (result)
			if (listSuccess.Count == 0)
			{
			var sceneUI = new SceneUI
			{
			Name = sceneName,
			Id = getSceneIdData.NewScenesId,
			IconPath = sceneIconPath,
			IconPathType = iconPathType,
			AddSceneMemberDataList = commons
			};
			//添加缓存
			sceneUI.Save();
			this.dicScenes[sceneUI.Id] = sceneUI;
			if (i_room.ListSceneId.Contains(sceneUI.Id) == false)
			{
			i_room.ListSceneId.Add(sceneUI.Id);
			i_room.Save();
			}
			return 1;
			//添加执行目标失败
			string msg1 = Language.StringByID(R.MyInternationalizationString.uAddAdjustTargetFail);
			this.ShowTipMsg(msg1);
			return null;
			}
			return 0;
			//如果不是全部成功的话,提示
			if (listSuccess.Count != listAdjustTarget.Count)
			{
			//个别执行目标添加失败
			string msg1 = Language.StringByID(R.MyInternationalizationString.uSomeAdjustTargetAddFail);
			this.ShowTipMsg(msg1);
			}
			return listSuccess;
			}

			/// <summary>
			/// 添加场景(这个单纯只改房间)
			/// </summary>
			/// <param name="scene">Scene.</param>
			public void AddScene(Room i_room, SceneUI scene)
			public void AddSceneToRoom(Room i_room, SceneUI scene)
			{
			//添加缓存
			if (i_room.ListSceneId.Contains(scene.Id) == false)
			@@ -199,6 +245,29 @@
			i_room.ListSceneId.Add(scene.Id);
			i_room.Save();
			}
			}

			/// <summary>
			/// 改变场景房间
			/// </summary>
			/// <param name="scene">场景对象</param>
			/// <param name="newRoomId">新的房间的ID</param>
			public void ChangedSceneRoom(SceneUI scene, string newRoomId)
			{
			var room = HdlRoomLogic.Current.GetRoomBySceneId(scene.Id);
			if (room != null)
			{
			//房间没有改变
			if (room.Id == newRoomId)
			{
			return;
			}
			//从房间中移除缓存
			this.DeleteSceneFromRoom(room, scene);
			}
			//添加进新房间
			var newRoom = HdlRoomLogic.Current.GetRoomById(newRoomId);
			this.AddSceneToRoom(newRoom, scene);
			}

			/// <summary>
			@@ -220,7 +289,7 @@
			/// 删除场景(这个只移除内存)
			/// </summary>
			/// <param name="scene"></param>
			public void DeleteScene(Room i_room, SceneUI scene)
			public void DeleteSceneFromRoom(Room i_room, SceneUI scene)
			{
			//移除缓存
			if (i_room.ListSceneId.Contains(scene.Id) == true)
			@@ -250,67 +319,120 @@
			#region ■ 修改场景___________________________

			/// <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 Task<int> ModifyScene(SceneUI sceneUI, Scene.SceneRemoveMemberData sceneRemoveMemberData, List<Scene.AddSceneMemberData> addCommons)
			/// <param name="sceneUI">场景对象</param>
			/// <param name="listAdjustTarget">全部的执行目标</param>
			/// <returns></returns>
			public async Task<bool> EditorSceneFromGateway(SceneUI sceneUI, List<Scene.DeviceListData> listAdjustTarget)
			{
			bool result = true;
			//移除成员返回结果
			var removeSceneMemberResponseAllData = await ZigBee.Device.Scene.RemoveSceneMemberAsync(sceneRemoveMemberData);
			if (removeSceneMemberResponseAllData == null \|\| removeSceneMemberResponseAllData.removeSceneMemberResponseData == null)
			//先清空全部的执行目标
			var deleteData = new Scene.SceneRemoveMemberData();
			var deleteTargetData = new List<Scene.RemoveSceneDeviceListInfo>();
			for (int i = 0; i < sceneUI.AdjustTargetList.Count; i++)
			{
			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
			var data = sceneUI.AdjustTargetList[i];
			var removeData = new Scene.RemoveSceneDeviceListInfo();
			if (data.Type == 0)
			{
			DeviceAddr = addCommon.DeviceAddr,
			Type = addCommon.Type,
			Epoint = addCommon.Epoint,
			ScenesId = sceneUI.Id,
			TaskList = addCommon.TaskList,
			DelayTime = addCommon.DelayTime,
			ElseScenesId = addCommon.ElseScenesId,
			MemberNumber = addCommon.MemberNumber
			};
			//添加新成员返回结果
			var addSceneMemberResponseAllData = await ZigBee.Device.Scene.AddSceneMemberAsync(addSceneMemberData);
			if (addSceneMemberResponseAllData == null \|\| addSceneMemberResponseAllData.addSceneMemberResponseData == null)
			{
			result = false;
			System.Console.WriteLine("添加场景失败");
			continue;
			//设备
			removeData.Type = 0;
			removeData.DeviceAddr = data.DeviceAddr;
			removeData.Epoint = data.Epoint;
			removeData.MemberNumber = data.MemberNumber;
			}
			var addSceneMemberResponseData = addSceneMemberResponseAllData.addSceneMemberResponseData;
			if (addSceneMemberResponseData == null && addSceneMemberResponseData.Result != 1)
			else if (data.Type == 1)
			{
			result = false;
			//场景
			removeData.Type = 1;
			removeData.ElseScenesId = data.ElseScenesId;
			removeData.MemberNumber = data.MemberNumber;
			}
			else
			{
			//延时
			removeData.Type = 2;
			removeData.DelayTime = data.DelayTime;
			removeData.MemberNumber = i + 1;
			}
			//拥有成功的
			deleteTargetData.Add(removeData);
			}
			//加入成功
			if (result)
			deleteData.DeviceList = deleteTargetData;
			deleteData.ScenesId = sceneUI.Id;
			//执行清空
			var result = await Scene.RemoveSceneMemberAsync(deleteData);
			if (result == null \|\| result.removeSceneMemberResponseData == null)
			{
			sceneUI.AddSceneMemberDataList = addCommons;
			sceneUI.Save();
			return 1;
			//初始化执行目标失败
			string msg1 = Language.StringByID(R.MyInternationalizationString.uInitAdjustTargetFail);
			//拼接上【网关回复超时】的Msg
			msg1 = UserCenterLogic.CombineGatewayTimeOutMsg(msg1, result);
			this.ShowTipMsg(msg1);
			return false;
			}
			return 0;
			if (result.removeSceneMemberResponseData.Result != 0)
			{
			//初始化执行目标失败
			string msg1 = Language.StringByID(R.MyInternationalizationString.uInitAdjustTargetFail);
			this.ShowTipMsg(msg1);
			return false;
			}
			//清空场景的执行目标列表的缓存
			sceneUI.AdjustTargetList.Clear();

			//然后重新添加
			var listSuccess = await this.AddTargetToScene(sceneUI.Id, listAdjustTarget);
			if (listSuccess == null)
			{
			return false;
			}
			sceneUI.AdjustTargetList.AddRange(listSuccess);
			sceneUI.Save();

			return true;
			}

			/// <summary>
			/// 修改网关的场景名称
			/// </summary>
			/// <param name="scene">场景对象</param>
			/// <param name="newName">新的名字</param>
			/// <returns></returns>
			public async Task<bool> EditorSceneNameFromGateway(SceneUI scene, string newName)
			{
			var result1 = await Scene.RenameSceneAsync(scene.Id, newName);
			//共通错误检测
			string error = HdlCheckLogic.Current.CheckCommonErrorCode(result1);
			if (error != null)
			{
			this.ShowErrorMsg(error);
			return false;
			}
			if (result1 == null \|\| result1.sceneRenameResponseData == null)
			{
			//修改场景名称失败
			string msg1 = Language.StringByID(R.MyInternationalizationString.uEditorSceneNameFail);
			//拼接上【网关回复超时】的Msg
			msg1 = UserCenterLogic.CombineGatewayTimeOutMsg(msg1, result1);
			this.ShowTipMsg(msg1);
			return false;
			}
			if (result1.sceneRenameResponseData.Result == 2)
			{
			//目标场景不存在
			string msg1 = Language.StringByID(R.MyInternationalizationString.uTargetSceneIsNotExsit);
			this.ShowTipMsg(msg1);
			return false;
			}
			if (result1.sceneRenameResponseData.Result != 1)
			{
			//修改场景名称失败
			string msg1 = Language.StringByID(R.MyInternationalizationString.uEditorSceneNameFail);
			this.ShowTipMsg(msg1);
			return false;
			}
			return true;
			}

			#endregion
			@@ -550,6 +672,44 @@

			#endregion

			#region ■ 获取场景的执行目标列表_____________

			/// <summary>
			/// 获取场景的执行目标列表
			/// </summary>
			/// <param name="i_scene">场景对象</param>
			/// <returns></returns>
			public async Task<List<Scene.DeviceListData>> GetAdjustTargetList(SceneUI i_scene)
			{
			var result = await Scene.GetSceneDeviceListAsync(i_scene.Id);
			//共通错误检测
			string error = HdlCheckLogic.Current.CheckCommonErrorCode(result);
			if (error != null)
			{
			this.ShowErrorMsg(error);
			return null;
			}
			if (result == null \|\| result.getSceneDeviceListInfo == null)
			{
			//获取执行目标失败
			string msg = Language.StringByID(R.MyInternationalizationString.uGetAdjustTargetFail);
			//拼接上【网关回复超时】的Msg
			msg = UserCenterLogic.CombineGatewayTimeOutMsg(msg, result);

			this.ShowTipMsg(msg);
			return null;
			}
			i_scene.AdjustTargetList = result.getSceneDeviceListInfo.DeviceList;
			//保存缓存
			i_scene.Save(false);

			var listData = new List<Scene.DeviceListData>();
			listData.AddRange(result.getSceneDeviceListInfo.DeviceList);

			return listData;
			}
			#endregion

			#region ■ 延时时间线程_______________________

			/// <summary>
			@@ -599,6 +759,33 @@
			}
			return listSceneFile;
			}

			/// <summary>
			/// 显示错误信息窗口
			/// </summary>
			/// <param name="msg"></param>
			private void ShowErrorMsg(string msg)
			{
			Application.RunOnMainThread(() =>
			{
			var contr = new ShowMsgControl(ShowMsgType.Error, msg);
			contr.Show();
			});
			}

			/// <summary>
			/// 显示Tip信息窗口
			/// </summary>
			/// <param name="msg"></param>
			private void ShowTipMsg(string msg)
			{
			Application.RunOnMainThread(() =>
			{
			var contr = new ShowMsgControl(ShowMsgType.Tip, msg);
			contr.Show();
			});
			}

			#endregion
			}
			}