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
|
}
|
}
|
