~xm/HomeApp.git

New file
			@@ -0,0 +1,957 @@
			using System;
			using System.Collections.Generic;
			using System.Linq;
			using System.Text;
			using ZigBee.Device;

			namespace Shared.Phone.UserCenter
			{
			/// <summary>
			/// 固件升级的逻辑类
			/// </summary>
			public class HdlFirmwareUpdateLogic
			{
			#region ■ 执行固件更新_______________________

			/// <summary>
			/// 执行下一个固件的更新
			/// </summary>
			public static void DoUpdateNextFirmware()
			{
			//下一个要执行更新的网关
			HdlDeviceUpdateCommonLogic gwControl = null;
			//下一个要执行更新的设备
			HdlDeviceUpdateCommonLogic deviceControl = null;
			foreach (var contr in FirmwareUpdateResourse.dicUpdateList.Values)
			{
			//如果别的还在升级中,则不再处理
			if (contr.IsFinishUpdate == false)
			{
			return;
			}
			//如果这个在等待列表的话
			if (contr.UpdateStatu == UpdateStatuMode.Wait && gwControl == null)
			{
			if (contr.ClassDiv == 1 && gwControl == null)
			{
			//下一个升级的就是它了
			gwControl = contr;
			}
			else if (contr.ClassDiv == 2 && deviceControl == null)
			{
			//下一个升级的就是它了
			deviceControl = contr;
			}
			}
			}

			HdlThreadLogic.Current.RunThread(() =>
			{
			if (gwControl != null)
			{
			//开始执行更新操作
			gwControl.DoStartUpdate();
			return;
			}

			if (deviceControl != null)
			{
			//开始执行更新操作
			deviceControl.DoStartUpdate();
			}
			});
			}

			#endregion

			#region ■ 添加升级固件信息___________________

			/// <summary>
			/// 添加升级固件信息 1:正常 -1:没网,获取不到东西
			/// </summary>
			/// <param name="levelType">固件阶级分类</param>
			/// <param name="HardwareVersion">硬件版本</param>
			/// <param name="imgType">镜像类型</param>
			/// <returns></returns>
			public static int AddFirmwareVersionInfo(FirmwareLevelType levelType, string HardwareVersion, string imgType)
			{
			//检测本地是否已经有这个缓存了
			if (IsEsixtFirmwareVersionInfo(levelType, HardwareVersion, imgType) == true)
			{
			return 1;
			}
			var Pra = new GetFirmwareVersionPra();
			Pra.PageSetting.Page = 1;
			Pra.PageSetting.PageSize = 9999;

			if (levelType == FirmwareLevelType.Linux)
			{
			//获取网关Linux模块升级信息
			Pra.FirmwareManaFirstType = 1;
			Pra.FirmwareManaSecondType = 0;
			Pra.HardwareVersion = HardwareVersion;
			Pra.DeviceType = imgType;
			var result = GetFirmwareVersionAndSetToMemmory(FirmwareLevelType.Linux, Pra);
			return result;
			}
			else if (levelType == FirmwareLevelType.A协调器)
			{
			//协调器模块
			Pra.FirmwareManaFirstType = 1;
			Pra.FirmwareManaSecondType = 1;
			Pra.HardwareVersion = HardwareVersion;
			Pra.DeviceType = imgType;
			var result = GetFirmwareVersionAndSetToMemmory(FirmwareLevelType.A协调器, Pra);
			return result;
			}
			else if (levelType == FirmwareLevelType.A虚拟驱动)
			{
			//虚拟设备模块
			Pra.FirmwareManaFirstType = 1;
			Pra.FirmwareManaSecondType = 2;
			Pra.HardwareVersion = HardwareVersion;
			Pra.DeviceType = imgType;
			var result = GetFirmwareVersionAndSetToMemmory(FirmwareLevelType.A虚拟驱动, Pra);
			return result;
			}
			else
			{
			//一般设备
			Pra.FirmwareManaFirstType = 2;
			Pra.FirmwareManaSecondType = null;
			Pra.HardwareVersion = HardwareVersion;
			Pra.DeviceType = imgType;
			var result = GetFirmwareVersionAndSetToMemmory(FirmwareLevelType.A设备, Pra);
			return result;
			}
			}

			/// <summary>
			/// 获取云端的固件，然后存入缓存中 1:正常 -1:没网,获取不到东西
			/// </summary>
			/// <param name="levelType"></param>
			/// <param name="pra"></param>
			/// <returns></returns>
			private static int GetFirmwareVersionAndSetToMemmory(FirmwareLevelType levelType, GetFirmwareVersionPra pra)
			{
			var listCheck = new List<string> { "NotCheck" };
			string resultValue = UserCenterLogic.GetResponseDataByRequestHttps("FirmwareMana/DetectionPlatformUploadFirmware", false, pra, listCheck, false);
			if (string.IsNullOrEmpty(resultValue) == true)
			{
			return -1;
			}
			var verResult = Newtonsoft.Json.JsonConvert.DeserializeObject<FirmwareVersionResult>(resultValue);
			if (verResult.PageData.Count == 0)
			{
			return 1;
			}

			//硬件版本
			Dictionary<string, FirmwareHardInfo> dicHardData = null;
			if (FirmwareUpdateResourse.dicFirmwareInfo.ContainsKey(levelType) == false)
			{
			FirmwareUpdateResourse.dicFirmwareInfo[levelType] = new Dictionary<string, FirmwareHardInfo>();
			}
			dicHardData = FirmwareUpdateResourse.dicFirmwareInfo[levelType];

			foreach (var data in verResult.PageData)
			{
			//固件版本显示：
			//10101 3个byte 显示为：ver.1.01.01
			if (data.FirmwareVersion.Length != 6 && data.FirmwareVersion.Length != 5)
			{
			//非正规的固件版本,不再考虑范围内
			continue;
			}
			//硬件分类
			FirmwareHardInfo hardInfo = null;
			string hardCode = data.HardwareVersion;
			if (dicHardData.ContainsKey(hardCode) == false)
			{
			//添加
			hardInfo = new FirmwareHardInfo();
			dicHardData[hardCode] = hardInfo;
			}
			hardInfo = dicHardData[hardCode];

			//镜像分类
			string imgType = data.DeviceType;
			Dictionary<string, FirmwareImgTypeInfo> dicimgType = hardInfo.dicImgType;
			FirmwareImgTypeInfo imgTypeInfo = null;
			if (dicimgType.ContainsKey(imgType) == false)
			{
			//添加
			imgTypeInfo = new FirmwareImgTypeInfo();
			dicimgType[imgType] = imgTypeInfo;
			}
			imgTypeInfo = dicimgType[imgType];

			try
			{
			//固件版本
			var info = new FirmwareVersionInfo();
			info.DistributedMark = data.DistributedMark;
			info.FirmwareVersion = Convert.ToInt32(data.FirmwareVersion);
			info.ShowName = data.Name;
			info.Name = data.Name;
			info.HardwareVersion = hardCode;
			info.ImagType = imgType;
			info.CreatedOnUtc = data.CreatedOnUtc;
			imgTypeInfo.listVeison.Add(info);
			//固件的信息处理
			DoAdjustFirmwareInformation(info, data.Remarks);
			}
			catch { continue; }
			}

			return 1;
			}

			#endregion

			#region ■ 获取最新固件版本信息_______________

			/// <summary>
			/// 获取固件的最新版本信息(如果返回Null,则表示没有最新版本,或者当前已经是最新版本)
			/// </summary>
			/// <param name="levelType">固件阶级分类</param>
			/// <param name="HardwareVersion">硬件版本</param>
			/// <param name="imgType">镜像类型</param>
			/// <param name="nowVersion">现在的版本</param>
			/// <returns></returns>
			public static FirmwareVersionInfo GetFirmwareMostVersionInfo(FirmwareLevelType levelType, string HardwareVersion, string imgType, int nowVersion)
			{
			//镜像类型
			var listdata = GetFirmwareVersionListInfo(levelType, HardwareVersion, imgType);
			FirmwareVersionInfo newFirInfo = null;
			foreach (var verInfo in listdata)
			{
			if (verInfo.Name.EndsWith(".bin") == true)
			{
			//它不是升级固件, .bin是特殊的
			continue;
			}
			int testVersion = Convert.ToInt32(verInfo.FirmwareVersion.ToString().PadLeft(6, '0').Substring(2, 2));
			if (testVersion % 2 != 0)
			{
			//中间那个byte为奇数时，代表是测试版本,在显示最新版本时,不需要显示，但是在历史版本那里可以显示
			//中间那个byte为偶数时,代表是正式版本
			continue;
			}

			if (verInfo.FirmwareVersion > nowVersion)
			{
			nowVersion = verInfo.FirmwareVersion;
			newFirInfo = verInfo;
			}
			}
			return newFirInfo;
			}

			/// <summary>
			/// 获取固件列表的固件版本信息
			/// </summary>
			/// <param name="levelType">固件阶级分类</param>
			/// <param name="HardwareVersion">硬件版本</param>
			/// <param name="imgType">镜像类型</param>
			/// <returns></returns>
			public static List<FirmwareVersionInfo> GetFirmwareVersionListInfo(FirmwareLevelType levelType, string HardwareVersion, string imgType)
			{
			if (FirmwareUpdateResourse.dicFirmwareInfo == null \|\| FirmwareUpdateResourse.dicFirmwareInfo.ContainsKey(levelType) == false)
			{
			return new List<FirmwareVersionInfo>();
			}
			//硬件版本号级别
			var dicHard = FirmwareUpdateResourse.dicFirmwareInfo[levelType];

			//硬件版本
			if (dicHard.ContainsKey(HardwareVersion) == false)
			{
			return new List<FirmwareVersionInfo>();
			}
			//镜像类型
			var dicImgInfo = GetImageVersionListInfo(levelType, HardwareVersion);
			if (dicImgInfo.ContainsKey(imgType) == false)
			{
			return new List<FirmwareVersionInfo>();
			}

			var listData = new List<FirmwareVersionInfo>();
			var imgInfo = dicImgInfo[imgType];
			foreach (var verInfo in imgInfo.listVeison)
			{
			listData.Add(verInfo);
			}

			return listData;
			}

			/// <summary>
			/// 获取固件列表的镜像版本信息
			/// </summary>
			/// <param name="levelType">固件阶级分类</param>
			/// <param name="HardwareVersion">硬件版本</param>
			/// <returns></returns>
			public static Dictionary<string, FirmwareImgTypeInfo> GetImageVersionListInfo(FirmwareLevelType levelType, string HardwareVersion)
			{
			if (FirmwareUpdateResourse.dicFirmwareInfo == null \|\| FirmwareUpdateResourse.dicFirmwareInfo.ContainsKey(levelType) == false)
			{
			return new Dictionary<string, FirmwareImgTypeInfo>();
			}
			//硬件版本号级别
			var dicHard = FirmwareUpdateResourse.dicFirmwareInfo[levelType];

			//硬件版本
			if (dicHard.ContainsKey(HardwareVersion) == false)
			{
			return new Dictionary<string, FirmwareImgTypeInfo>();
			}
			//镜像类型
			return dicHard[HardwareVersion].dicImgType;
			}

			#endregion

			#region ■ 获取指定固件版本信息_______________

			/// <summary>
			/// 获取指定固件的版本信息(如果返回Null,则表示没有这个固件)
			/// </summary>
			/// <param name="levelType">固件阶级分类</param>
			/// <param name="HardwareVersion">硬件版本</param>
			/// <param name="imgType">镜像类型</param>
			/// <param name="nowVersion">现在的版本</param>
			/// <returns></returns>
			public static FirmwareVersionInfo GetFirmwareVersionInfo(FirmwareLevelType levelType, string HardwareVersion, string imgType, int nowVersion)
			{
			//镜像类型
			var listdata = GetFirmwareVersionListInfo(levelType, HardwareVersion, imgType);
			foreach (var verInfo in listdata)
			{
			if (verInfo.Name.EndsWith(".bin") == true)
			{
			//它不是升级固件, .bin是特殊的
			continue;
			}
			if (verInfo.FirmwareVersion == nowVersion)
			{
			return verInfo;
			}
			}
			return null; ;
			}

			#endregion

			#region ■ 固件存在检测_______________________

			/// <summary>
			/// 固件缓存存在检测
			/// </summary>
			/// <param name="levelType">固件阶级分类</param>
			/// <param name="HardwareVersion">硬件版本</param>
			/// <param name="imgType">镜像类型</param>
			/// <returns></returns>
			private static bool IsEsixtFirmwareVersionInfo(FirmwareLevelType levelType, string HardwareVersion, string imgType)
			{
			//第一大类
			if (FirmwareUpdateResourse.dicFirmwareInfo == null \|\| FirmwareUpdateResourse.dicFirmwareInfo.ContainsKey(levelType) == false)
			{
			return false;
			}
			//硬件
			if (FirmwareUpdateResourse.dicFirmwareInfo[levelType].ContainsKey(HardwareVersion) == false)
			{
			return false;
			}
			//镜像
			if (FirmwareUpdateResourse.dicFirmwareInfo[levelType][HardwareVersion].dicImgType.ContainsKey(imgType) == false)
			{
			return false;
			}
			return true;
			}

			/// <summary>
			/// 检测该Ota设备的升级固件是否存在
			/// </summary>
			/// <param name="device">设备对象</param>
			/// <returns></returns>
			public static bool IsEsixtDeviceFirmwareFile(OTADevice device)
			{
			var fileFullName = GetDeviceFirmwareFile(device);
			return System.IO.File.Exists(fileFullName);
			}

			/// <summary>
			/// 获取ota指定的升级固件名字(全路径)
			/// </summary>
			/// <param name="device">设备对象</param>
			/// <returns></returns>
			public static string GetDeviceFirmwareFile(OTADevice device)
			{
			//硬件版本_镜像ID_固件版本
			string fileName = device.HwVersion + "_" + device.ImgTypeId + "_" + device.ImgVersion;
			return System.IO.Path.Combine(DirNameResourse.FirmwareUpdateDirectory, "Device_" + fileName + ".ota");
			}

			/// <summary>
			/// 获取网关Linux的升级固件名字(全路径)
			/// </summary>
			/// <param name="zbGateway">网关对象</param>
			/// <returns></returns>
			public static string GetGatewayLinuxFirmwareFile(ZbGateway zbGateway)
			{
			string fileName = zbGateway.LinuxHardVersion + "_" + zbGateway.LinuxImageType + "_" + zbGateway.LinuxFirmwareVersion;
			return System.IO.Path.Combine(DirNameResourse.FirmwareUpdateDirectory, "Linux_" + fileName + ".ota");
			}

			/// <summary>
			/// 获取网关协调器的升级固件名字(全路径)
			/// </summary>
			/// <param name="zbGateway">网关对象</param>
			/// <returns></returns>
			public static string GetGatewayCoordinatorFirmwareFile(ZbGateway zbGateway)
			{
			string fileName = zbGateway.CoordinatorHardVersion + "_" + zbGateway.CoordinatorImageId + "_" + zbGateway.CoordinatorFirmwareVersion;
			return System.IO.Path.Combine(DirNameResourse.FirmwareUpdateDirectory, "Coordinator_" + fileName + ".ota");
			}

			/// <summary>
			/// 获取网关虚拟驱动的升级固件名字(全路径)
			/// </summary>
			/// <param name="codeObj">虚拟驱动数据</param>
			/// <returns></returns>
			public static string GetGatewayDriveCodeFirmwareFile(ZbGatewayData.DriveCodeObj codeObj)
			{
			string fileName = codeObj.DriveHwVersion + "_" + codeObj.DriveImageType + "_" + codeObj.DriveFwVersion;
			return System.IO.Path.Combine(DirNameResourse.FirmwareUpdateDirectory, "DriveCode_" + fileName + ".ota");
			}

			#endregion

			#region ■ 下载模板固件_______________________

			/// <summary>
			/// 下载模板中网关和设备的固件
			/// </summary>
			/// <param name="fullFileName"></param>
			/// <param name="i_Msg"></param>
			public static int DownLoadTemplateDeviceFirmware(string fullFileName, string i_Msg)
			{
			//从模板当中获取设备和网关对象
			var listTempDevice = new List<OTADevice>();
			var listTempGateway = new List<ZbGateway>();
			TemplateData.TemplateCommonLogic.Current.GetDeviceObjectFromTemplate(fullFileName, ref listTempDevice, ref listTempGateway);

			//获取需要下载的固件数据
			var listVersion = GetNeedToDownLoadVersionData(listTempDevice, listTempGateway);
			//获取需要下载的空调模块
			var listAcOta = new List<OTADevice>();
			var listAcUpdate = GetNeedDownLoadAirConditionerModule(listTempDevice, ref listAcOta);

			if (listVersion.Count == 0 && listAcUpdate.Count == 0)
			{
			return 0;
			}
			//打开进度条
			ProgressFormBar.Current.Start();
			ProgressFormBar.Current.SetMsg(i_Msg);
			ProgressFormBar.Current.SetValue(0, 1);

			System.Threading.Thread.Sleep(1000);

			var dicFirmwareName = new Dictionary<string, string>();
			var fileData = HdlFileLogic.Current.ReadFileTextContent(DirNameResourse.FirmwareUpdateList);
			if (fileData != null)
			{
			//本地存放的固件原来的名字(因为设备升级时,它需要识别文件名字里面包含的特殊字符)
			//key:全路径,硬件版本_镜像ID_固件版本 value:固件原来的名字
			dicFirmwareName = Newtonsoft.Json.JsonConvert.DeserializeObject<Dictionary<string, string>>(fileData);
			}

			//固件存储路径
			string firmwareDir = DirNameResourse.FirmwareUpdateDirectory;
			int nowCount = 0;
			int macCount = listVersion.Count + listAcUpdate.Count;

			foreach (var versionData in listVersion)
			{
			nowCount++;
			//获取升级固件信息
			var result = AddFirmwareVersionInfo(versionData.levelType, versionData.HwVersion, versionData.ImageType);
			if (result == -1)
			{
			ProgressFormBar.Current.Close();
			//保存列表名字
			HdlFileLogic.Current.SaveFileContent(DirNameResourse.FirmwareUpdateList, dicFirmwareName);
			return -1;
			}
			//获取当前这个版本的固件信息
			var versionFirmware = GetFirmwareVersionInfo(versionData.levelType, versionData.HwVersion, versionData.ImageType, versionData.FirmwareVersion);
			if (versionFirmware == null)
			{
			//云端没有这个版本进度值
			ProgressFormBar.Current.SetValue(nowCount, macCount);
			continue;
			}
			//去下载这个固件
			var pra = new { RequestVersion = Common.CommonPage.RequestVersion, DistributedMark = versionFirmware.DistributedMark };
			var byteData = UserCenterLogic.GetByteResponseDataByRequestHttps("FirmwareMana/DownloadPlatformUploadFirmware", false, pra, new List<string> { "NotCheck" }, true);
			if (byteData == null)
			{
			ProgressFormBar.Current.Close();
			//保存列表名字
			HdlFileLogic.Current.SaveFileContent(DirNameResourse.FirmwareUpdateList, dicFirmwareName);
			return -1;
			}
			//保存固件
			var saveFile = System.IO.Path.Combine(firmwareDir, versionData.FileDiv + versionData.HwVersion + "_" + versionData.ImageType + "_" + versionData.FirmwareVersion + ".ota");
			HdlFileLogic.Current.SaveByteToFile(saveFile, byteData);
			dicFirmwareName[saveFile] = versionFirmware.Name;

			//进度值
			ProgressFormBar.Current.SetValue(nowCount, macCount);
			}
			for (int i = 0; i < listAcUpdate.Count; i++)
			{
			//下载空调模块
			var pra = new { RequestVersion = Common.CommonPage.RequestVersion, DistributedMark = listAcUpdate[i].DistributedMark };
			var deviceFirmwareByte = UserCenterLogic.GetByteResponseDataByRequestHttps("FirmwareMana/DownloadPlatformUploadFirmware", false, pra, new List<string> { "NotCheck" }, true);
			if (deviceFirmwareByte == null)
			{
			ProgressFormBar.Current.Close();
			//保存列表名字
			HdlFileLogic.Current.SaveFileContent(DirNameResourse.FirmwareUpdateList, dicFirmwareName);
			return -1;
			}
			//保存固件
			string fileName = "AC_" + listAcOta[i].HwVersion + "_" + listAcOta[i].ImgTypeId + "_" + listAcUpdate[i].Name;
			var saveFile = System.IO.Path.Combine(firmwareDir, fileName);
			HdlFileLogic.Current.SaveByteToFile(saveFile, deviceFirmwareByte);

			//进度值
			ProgressFormBar.Current.SetValue(nowCount, macCount);
			}

			//保存列表名字
			HdlFileLogic.Current.SaveFileContent(DirNameResourse.FirmwareUpdateList, dicFirmwareName);
			ProgressFormBar.Current.Close();

			return 1;
			}

			/// <summary>
			/// 获取需要下载的固件数据
			/// </summary>
			/// <param name="listDevice">设备列表</param>
			/// <param name="listGateway">网关列表</param>
			/// <returns></returns>
			private static List<TemplateDeviceVersion> GetNeedToDownLoadVersionData(List<OTADevice> listDevice, List<ZbGateway> listGateway)
			{
			//存储路径
			string firmwareDir = DirNameResourse.FirmwareUpdateDirectory;
			HdlFileLogic.Current.CreateDirectory(firmwareDir);

			var listVersion = new List<TemplateDeviceVersion>();
			var listCheck = new HashSet<string>();
			foreach (var device in listDevice)
			{
			//设备的升级固件名字
			var fileFullName = GetDeviceFirmwareFile(device);
			if (System.IO.File.Exists(fileFullName) == false && listCheck.Contains(fileFullName) == false)
			{
			listCheck.Add(fileFullName);
			//设备
			listVersion.Add(new TemplateDeviceVersion
			{
			FileDiv = "Device_",
			levelType = FirmwareLevelType.A设备,
			HwVersion = device.HwVersion.ToString(),
			ImageType = device.ImgTypeId.ToString(),
			FirmwareVersion = device.ImgVersion
			});
			}
			}
			foreach (var gateway in listGateway)
			{
			//Linux的升级固件名字
			var fileFullName = GetGatewayLinuxFirmwareFile(gateway);
			if (System.IO.File.Exists(fileFullName) == false && listCheck.Contains(fileFullName) == false)
			{
			listCheck.Add(fileFullName);
			//Linux
			listVersion.Add(new TemplateDeviceVersion
			{
			FileDiv = "Linux_",
			levelType = FirmwareLevelType.Linux,
			HwVersion = gateway.LinuxHardVersion.ToString(),
			ImageType = gateway.LinuxImageType.ToString(),
			FirmwareVersion = gateway.LinuxFirmwareVersion
			});
			}
			//协调器的升级固件名字
			fileFullName = GetGatewayCoordinatorFirmwareFile(gateway);
			if (System.IO.File.Exists(fileFullName) == false && listCheck.Contains(fileFullName) == false)
			{
			listCheck.Add(fileFullName);
			//协调器
			listVersion.Add(new TemplateDeviceVersion
			{
			FileDiv = "Coordinator_",
			levelType = FirmwareLevelType.A协调器,
			HwVersion = gateway.CoordinatorHardVersion.ToString(),
			ImageType = gateway.CoordinatorImageId.ToString(),
			FirmwareVersion = gateway.CoordinatorFirmwareVersion
			});
			}
			//这个网关需要有虚拟驱动这个东西才行
			if (HdlGatewayLogic.Current.CheckGatewayHadDriveCode(gateway) == true)
			{
			//虚拟驱动号
			foreach (var data in gateway.DriveCodeList)
			{
			//虚拟驱动号的升级固件名字
			fileFullName = GetGatewayDriveCodeFirmwareFile(data);
			if (System.IO.File.Exists(fileFullName) == false && listCheck.Contains(fileFullName) == false)
			{
			listCheck.Add(fileFullName);
			//虚拟驱动号
			listVersion.Add(new TemplateDeviceVersion
			{
			FileDiv = "DriveCode_",
			levelType = FirmwareLevelType.A虚拟驱动,
			HwVersion = data.DriveHwVersion.ToString(),
			ImageType = data.DriveImageType.ToString(),
			FirmwareVersion = data.DriveFwVersion
			});
			}
			}
			}
			}
			return listVersion;
			}

			/// <summary>
			/// 获取需要下载的空调模块
			/// </summary>
			/// <param name="listDevice">设备列表</param>
			/// <param name="listTaget">与返回值对应的东西</param>
			private static List<FirmwareVersionInfo> GetNeedDownLoadAirConditionerModule(List<OTADevice> listDevice, ref List<OTADevice> listTaget)
			{
			var listUpdate = new List<FirmwareVersionInfo>();
			//固件存储路径
			string firmwareDir = DirNameResourse.FirmwareUpdateDirectory;

			foreach (var otaDevice in listDevice)
			{
			var myType = Common.LocalDevice.Current.GetMyDeviceEnumInfo(new List<CommonDevice> { otaDevice });
			if (myType.ConcreteType != Common.DeviceConcreteType.AirConditioner_ZbGateway)
			{
			//只处理中央空调
			continue;
			}
			var list = GetFirmwareVersionListInfo(FirmwareLevelType.A设备, otaDevice.HwVersion.ToString(), otaDevice.ImgTypeId.ToString());
			foreach (var data in list)
			{
			if (data.Name.EndsWith(".bin") == true && System.IO.File.Exists(firmwareDir) == false)
			{
			//只要.bin文件
			listUpdate.Add(data);
			listTaget.Add(otaDevice);
			}
			}
			}
			return listUpdate;
			}

			/// <summary>
			/// 模板设备的版本信息
			/// </summary>
			private class TemplateDeviceVersion
			{
			/// <summary>
			/// 文件区分
			/// </summary>
			public string FileDiv = string.Empty;
			/// <summary>
			/// 固件阶级区分
			/// </summary>
			public FirmwareLevelType levelType;
			/// <summary>
			/// 硬件版本
			/// </summary>
			public string HwVersion = string.Empty;
			/// <summary>
			/// 镜像ID
			/// </summary>
			public string ImageType = string.Empty;
			/// <summary>
			/// 固件版本
			/// </summary>
			public int FirmwareVersion = 0;
			}

			#endregion

			#region ■ 读取App最低版本____________________

			/// <summary>
			/// 读取App最低版本
			/// </summary>
			public static void ReadAppLestVersion()
			{
			if (FirmwareUpdateResourse.AppNeedUpdateUrl != null)
			{
			//已经读取过了,则不再读取
			return;
			}
			var pra = new Dictionary<string, string>();
			pra["version"] = Common.CommonPage.CodeIDString;
			pra["appName"] = "EvoyoHome";
			var bodyData = GetSignRequestJson(Newtonsoft.Json.JsonConvert.SerializeObject(pra));
			//var url = "https://china-gateway.hdlcontrol.com/smart-footstone/app/appVersion/check";
			var url = "https://test-gz.hdlcontrol.com/smart-footstone/app/appVersion/check";
			var byteData = Common.CommonPage.Instance.DoRequestZigbeeHttpsInterface(url, Encoding.UTF8.GetBytes(bodyData), null);
			if (byteData == null)
			{
			return;
			}
			try
			{
			var jobject = Newtonsoft.Json.Linq.JObject.Parse(Encoding.UTF8.GetString(byteData));
			if (jobject["code"].ToString() != "0")
			{
			return;
			}
			var strData = jobject["data"].ToString();
			FirmwareUpdateResourse.AppNeedUpdateUrl = string.Empty;
			if (string.IsNullOrEmpty(strData) == true) { return; }

			var jobData = Newtonsoft.Json.Linq.JObject.Parse(strData);
			//如果是强制升级的话
			if (jobData["isEnforce"].ToString().ToLower() == "true")
			{
			#if iOS
			FirmwareUpdateResourse.AppNeedUpdateUrl = jobData["iosUrl"].ToString();
			#endif
			#if Android
			FirmwareUpdateResourse.AppNeedUpdateUrl = jobData["androidUrl"].ToString();
			#endif
			}
			}
			catch { }
			}

			#endregion

			#region ■ 读取网关最低版本___________________

			/// <summary>
			/// 读取网关最低版本
			/// </summary>
			public static void ReadGatewayLestVersion()
			{
			//每次切换住宅,都会去读取一次
			FirmwareUpdateResourse.ListGatewayNeedUpdate = new List<string>();

			var listGateway = HdlGatewayLogic.Current.GetAllLocalGateway();
			foreach (var gw in listGateway)
			{
			var pra = new Dictionary<string, string>();
			pra["hardwareId"] = gw.LinuxHardVersion.ToString();
			pra["imagesId"] = gw.LinuxImageType.ToString();
			pra["version"] = gw.LinuxFirmwareVersion.ToString();
			var bodyData = GetSignRequestJson(Newtonsoft.Json.JsonConvert.SerializeObject(pra));
			//var url = "https://china-gateway.hdlcontrol.com/smart-footstone/app/appVersion/check";
			var url = "https://test-gz.hdlcontrol.com/smart-footstone/app/gateway-hardware/check";
			var byteData = Common.CommonPage.Instance.DoRequestZigbeeHttpsInterface(url, Encoding.UTF8.GetBytes(bodyData), null);
			if (byteData == null)
			{
			return;
			}
			try
			{
			var jobject = Newtonsoft.Json.Linq.JObject.Parse(Encoding.UTF8.GetString(byteData));
			if (jobject["code"].ToString() != "0")
			{
			continue;
			}
			var strData = jobject["data"].ToString();
			if (string.IsNullOrEmpty(strData) == true) { return; }

			var jobData = Newtonsoft.Json.Linq.JObject.Parse(strData);
			//如果是强制升级的话
			if (jobData["isEnforce"].ToString().ToLower() == "true")
			{
			FirmwareUpdateResourse.ListGatewayNeedUpdate.Add(gw.GwId);
			}
			}
			catch { }
			}
			}

			#endregion

			#region ■ 检测能够显示公告___________________

			/// <summary>
			/// 检测能够显示公告
			/// </summary>
			public static bool CheckCanShowNotice()
			{
			//不管成不成功,读过一次之后就不再读取
			if (FirmwareUpdateResourse.ReadedNotice == true)
			{
			return false;
			}
			FirmwareUpdateResourse.ReadedNotice = true;
			#if Android
			var url = "https://developer.hdlcontrol.com/AnnouncementAndriod.html";
			#endif
			#if iOS
			var url = "https://developer.hdlcontrol.com/AnnouncementIos.html";
			#endif

			var byteData = Common.CommonPage.Instance.DoRequestZigbeeHttpsInterface(url, null, null, "GET");
			if (byteData == null)
			{
			//如果是404,则返回false
			return false;
			}
			//加载系统公告
			var fileData = HdlFileLogic.Current.ReadFileTextContent(DirNameResourse.AppNoticeFile);
			if (fileData == null) { fileData = string.Empty; }

			//加上当天日期
			var strNotice = DateTime.Now.ToString("yyyyMMdd") + "\r\n" + Encoding.UTF8.GetString(byteData);
			if (fileData == strNotice)
			{
			//公告内容一致,则不提示
			return false;
			}
			//如果公告不一致,或者已经过了一天,则显示
			HdlFileLogic.Current.SaveTextToFile(DirNameResourse.AppNoticeFile, strNotice);

			return true;
			}

			#endregion

			#region ■ 新云端访问密匙_____________________

			/// <summary>
			/// appKey(访问云端固定的东西)
			/// </summary>
			private const string APP_KEY = "HDL-HOME-APP-TEST";
			/// <summary>
			/// 我也不知道这是什么鬼东西
			/// </summary>
			private const string SECRET_KEY = "WeJ8TY88vbakCcnvH8G1tDUqzLWY8yss";
			/// <summary>
			/// 获取当前时间戳值(访问云端使用)
			/// </summary>
			/// <returns></returns>
			private static string GetTimestamp()
			{
			System.DateTime startTime = TimeZone.CurrentTimeZone.ToLocalTime(new System.DateTime(1970, 1, 1)); // 当地时区
			return ((long)(DateTime.Now - startTime).TotalSeconds).ToString(); // 相差秒数
			}

			/// <summary>
			/// MD5加密
			/// </summary>
			/// <param name="signstr"></param>
			/// <returns></returns>
			private static string SignMD5Encrypt(string s)
			{
			byte[] sign = System.Security.Cryptography.MD5.Create().ComputeHash(Encoding.UTF8.GetBytes(s));
			string signstr = string.Empty;
			foreach (byte item in sign)
			{
			signstr += item.ToString("X2");
			}
			return signstr.ToLower();
			}

			/// <summary>
			/// 基础服务的接口都要校验sign,计算sign签名
			/// </summary>
			/// <param name="i_BodyData">body的数据</param>
			/// <returns></returns>
			private static string GetSignRequestJson(string i_BodyData)
			{
			try
			{
			//1. 将model实体转为Dictionary<string, object>
			var paramDictionary = Newtonsoft.Json.JsonConvert.DeserializeObject<Dictionary<string, object>>(i_BodyData);
			//2. 计算sign
			if (paramDictionary != null)
			{
			paramDictionary.Add("appKey", APP_KEY);
			paramDictionary.Add("timestamp", GetTimestamp());
			//2.1 字典升序
			paramDictionary = paramDictionary.OrderBy(o => o.Key).ToDictionary(o => o.Key, p => p.Value);
			//2.2 拼接按URL键值对
			string str = string.Empty;
			foreach (KeyValuePair<string, object> item in paramDictionary)
			{
			if (item.Value == null)
			{
			//不校验
			continue;
			}
			string myValue = item.Value.ToString();
			if (myValue == string.Empty)
			{
			//空字符也不校验
			continue;
			}
			if (item.Value is bool)
			{
			//云端那帮沙雕说bool类型必须用小写
			myValue = myValue.ToLower();
			}
			str += item.Key + "=" + myValue + "&";
			}
			//2.3 拼接SECRET_KEY
			str = str.Substring(0, str.Length - 1) + SECRET_KEY;
			//2.4 MD5转换+转小写
			var signstr = SignMD5Encrypt(str);
			paramDictionary.Add("sign", signstr);
			return Newtonsoft.Json.JsonConvert.SerializeObject(paramDictionary);
			}
			else
			{
			return "";
			}
			}
			catch
			{
			return "";
			}
			}

			#endregion

			#region ■ 一般方法___________________________

			/// <summary>
			/// 固件的信息处理
			/// </summary>
			/// <param name="Info"></param>
			/// <param name="remark"></param>
			private static void DoAdjustFirmwareInformation(FirmwareVersionInfo Info, string remark)
			{
			if (string.IsNullOrEmpty(remark) == true)
			{
			return;
			}
			//更新内容
			string[] Arry = remark.Split(new string[] { "\r\n", "\r", "\n" }, StringSplitOptions.None);
			Info.UpdateContent.AddRange(Arry);
			}

			#endregion
			}
			}