using System;
|
using System.Collections.Generic;
|
using System.Text;
|
using ZigBee.Device;
|
|
namespace Shared.Phone
|
{
|
/// <summary>
|
/// 固件升级的逻辑类
|
/// </summary>
|
public class HdlFirmwareUpdateLogic
|
{
|
#region ■ 变量声明___________________________
|
|
/// <summary>
|
/// 固件升级的逻辑类
|
/// </summary>
|
private static HdlFirmwareUpdateLogic m_Current = null;
|
/// <summary>
|
/// 固件升级的逻辑类
|
/// </summary>
|
public static HdlFirmwareUpdateLogic Current
|
{
|
get
|
{
|
if (m_Current == null)
|
{
|
m_Current = new HdlFirmwareUpdateLogic();
|
}
|
return m_Current;
|
}
|
}
|
|
#endregion
|
|
#region ■ 执行固件更新_______________________
|
|
/// <summary>
|
/// 执行下一个固件的更新
|
/// </summary>
|
public void DoUpdateNextFirmware()
|
{
|
//下一个要执行更新的网关
|
DeviceUpdateCommon gwControl = null;
|
//下一个要执行更新的设备
|
DeviceUpdateCommon deviceControl = null;
|
foreach (var contr in HdlFirmwareUpdateResourse.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 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 int GetFirmwareVersionAndSetToMemmory(FirmwareLevelType levelType, GetFirmwareVersionPra pra)
|
{
|
var result = this.RequestZigbeeHttps("FirmwareMana/DetectionPlatformUploadFirmware", pra, 4);
|
if (result == null || result.Length == 0)
|
{
|
return -1;
|
}
|
var jobject = Newtonsoft.Json.Linq.JObject.Parse(Encoding.UTF8.GetString(result));
|
if (jobject.Property("StateCode") == null || jobject["StateCode"].ToString().ToUpper() != "SUCCESS")
|
{
|
return -1;
|
}
|
|
string resultValue = jobject["ResponseData"].ToString();
|
|
var verResult = Newtonsoft.Json.JsonConvert.DeserializeObject<FirmwareVersionResult>(resultValue);
|
if (verResult.PageData.Count == 0)
|
{
|
return 1;
|
}
|
|
//硬件版本
|
if (HdlFirmwareUpdateResourse.dicFirmwareInfo.ContainsKey(levelType) == false)
|
{
|
HdlFirmwareUpdateResourse.dicFirmwareInfo[levelType] = new Dictionary<string, FirmwareHardInfo>();
|
}
|
var dicHardData = HdlFirmwareUpdateResourse.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 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 List<FirmwareVersionInfo> GetFirmwareVersionListInfo(FirmwareLevelType levelType, string HardwareVersion, string imgType)
|
{
|
if (HdlFirmwareUpdateResourse.dicFirmwareInfo == null || HdlFirmwareUpdateResourse.dicFirmwareInfo.ContainsKey(levelType) == false)
|
{
|
return new List<FirmwareVersionInfo>();
|
}
|
//硬件版本号级别
|
var dicHard = HdlFirmwareUpdateResourse.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 Dictionary<string, FirmwareImgTypeInfo> GetImageVersionListInfo(FirmwareLevelType levelType, string HardwareVersion)
|
{
|
if (HdlFirmwareUpdateResourse.dicFirmwareInfo == null || HdlFirmwareUpdateResourse.dicFirmwareInfo.ContainsKey(levelType) == false)
|
{
|
return new Dictionary<string, FirmwareImgTypeInfo>();
|
}
|
//硬件版本号级别
|
var dicHard = HdlFirmwareUpdateResourse.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 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 bool IsEsixtFirmwareVersionInfo(FirmwareLevelType levelType, string HardwareVersion, string imgType)
|
{
|
//第一大类
|
if (HdlFirmwareUpdateResourse.dicFirmwareInfo == null || HdlFirmwareUpdateResourse.dicFirmwareInfo.ContainsKey(levelType) == false)
|
{
|
return false;
|
}
|
//硬件
|
if (HdlFirmwareUpdateResourse.dicFirmwareInfo[levelType].ContainsKey(HardwareVersion) == false)
|
{
|
return false;
|
}
|
//镜像
|
if (HdlFirmwareUpdateResourse.dicFirmwareInfo[levelType][HardwareVersion].dicImgType.ContainsKey(imgType) == false)
|
{
|
return false;
|
}
|
return true;
|
}
|
|
/// <summary>
|
/// 检测该Ota设备的升级固件是否存在
|
/// </summary>
|
/// <param name="device">设备对象</param>
|
/// <returns></returns>
|
public bool IsEsixtDeviceFirmwareFile(OTADevice device)
|
{
|
var fileFullName = GetDeviceFirmwareFile(device);
|
return System.IO.File.Exists(fileFullName);
|
}
|
|
/// <summary>
|
/// 获取ota指定的升级固件名字(全路径)
|
/// </summary>
|
/// <param name="device">设备对象</param>
|
/// <returns></returns>
|
public string GetDeviceFirmwareFile(OTADevice device)
|
{
|
//硬件版本_镜像ID_固件版本
|
string fileName = device.HwVersion + "_" + device.ImgTypeId + "_" + device.ImgVersion;
|
return System.IO.Path.Combine(HdlFileNameResourse.FirmwareUpdateDirectory, "Device_" + fileName + ".ota");
|
}
|
|
/// <summary>
|
/// 获取网关Linux的升级固件名字(全路径)
|
/// </summary>
|
/// <param name="zbGateway">网关对象</param>
|
/// <returns></returns>
|
public string GetGatewayLinuxFirmwareFile(ZbGateway zbGateway)
|
{
|
string fileName = zbGateway.LinuxHardVersion + "_" + zbGateway.LinuxImageType + "_" + zbGateway.LinuxFirmwareVersion;
|
return System.IO.Path.Combine(HdlFileNameResourse.FirmwareUpdateDirectory, "Linux_" + fileName + ".ota");
|
}
|
|
/// <summary>
|
/// 获取网关协调器的升级固件名字(全路径)
|
/// </summary>
|
/// <param name="zbGateway">网关对象</param>
|
/// <returns></returns>
|
public string GetGatewayCoordinatorFirmwareFile(ZbGateway zbGateway)
|
{
|
string fileName = zbGateway.CoordinatorHardVersion + "_" + zbGateway.CoordinatorImageId + "_" + zbGateway.CoordinatorFirmwareVersion;
|
return System.IO.Path.Combine(HdlFileNameResourse.FirmwareUpdateDirectory, "Coordinator_" + fileName + ".ota");
|
}
|
|
/// <summary>
|
/// 获取网关虚拟驱动的升级固件名字(全路径)
|
/// </summary>
|
/// <param name="codeObj">虚拟驱动数据</param>
|
/// <returns></returns>
|
public string GetGatewayDriveCodeFirmwareFile(ZbGatewayData.DriveCodeObj codeObj)
|
{
|
string fileName = codeObj.DriveHwVersion + "_" + codeObj.DriveImageType + "_" + codeObj.DriveFwVersion;
|
return System.IO.Path.Combine(HdlFileNameResourse.FirmwareUpdateDirectory, "DriveCode_" + fileName + ".ota");
|
}
|
|
#endregion
|
|
#region ■ 下载模板固件_______________________
|
|
/// <summary>
|
/// 下载模板中网关和设备的固件
|
/// </summary>
|
/// <param name="fullFileName"></param>
|
/// <param name="i_Msg"></param>
|
public int DownLoadTemplateDeviceFirmware(string fullFileName, string i_Msg)
|
{
|
//从模板当中获取设备和网关对象
|
var listTempDevice = new List<OTADevice>();
|
var listTempGateway = new List<ZbGateway>();
|
HdlTemplateCommonLogic.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(HdlFileNameResourse.FirmwareUpdateList);
|
if (fileData != null)
|
{
|
//本地存放的固件原来的名字(因为设备升级时,它需要识别文件名字里面包含的特殊字符)
|
//key:全路径,硬件版本_镜像ID_固件版本 value:固件原来的名字
|
dicFirmwareName = Newtonsoft.Json.JsonConvert.DeserializeObject<Dictionary<string, string>>(fileData);
|
}
|
|
//固件存储路径
|
string firmwareDir = HdlFileNameResourse.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(HdlFileNameResourse.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 byteData = this.DowLoadFirmware(versionData.levelType, versionFirmware.DistributedMark);
|
if (byteData == null)
|
{
|
ProgressFormBar.Current.Close();
|
//保存列表名字
|
HdlFileLogic.Current.SaveFileContent(HdlFileNameResourse.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 deviceFirmwareByte = this.DowLoadFirmware(FirmwareLevelType.A设备, listAcUpdate[i].DistributedMark);
|
if (deviceFirmwareByte == null)
|
{
|
ProgressFormBar.Current.Close();
|
//保存列表名字
|
HdlFileLogic.Current.SaveFileContent(HdlFileNameResourse.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(HdlFileNameResourse.FirmwareUpdateList, dicFirmwareName);
|
ProgressFormBar.Current.Close();
|
|
return 1;
|
}
|
|
/// <summary>
|
/// 获取需要下载的固件数据
|
/// </summary>
|
/// <param name="listDevice">设备列表</param>
|
/// <param name="listGateway">网关列表</param>
|
/// <returns></returns>
|
private List<TemplateDeviceVersion> GetNeedToDownLoadVersionData(List<OTADevice> listDevice, List<ZbGateway> listGateway)
|
{
|
//存储路径
|
string firmwareDir = HdlFileNameResourse.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 List<FirmwareVersionInfo> GetNeedDownLoadAirConditionerModule(List<OTADevice> listDevice, ref List<OTADevice> listTaget)
|
{
|
var listUpdate = new List<FirmwareVersionInfo>();
|
//固件存储路径
|
string firmwareDir = HdlFileNameResourse.FirmwareUpdateDirectory;
|
|
foreach (var otaDevice in listDevice)
|
{
|
var myType = HdlDeviceCommonLogic.Current.GetMyDeviceEnumInfo(new List<CommonDevice> { otaDevice });
|
if (myType.ConcreteType != 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>
|
/// <param name="levelType">下载的类型</param>
|
/// <param name="i_Mainkey">主键</param>
|
/// <returns></returns>
|
public byte[] DowLoadFirmware(FirmwareLevelType levelType, string i_Mainkey)
|
{
|
var pra = new { RequestVersion = Common.CommonPage.RequestVersion, DistributedMark = i_Mainkey };
|
|
//默认为10秒
|
int waitTime = 10;
|
if (levelType != FirmwareLevelType.A设备)
|
{
|
//网关的比较大,给多一点时间
|
waitTime = 25;
|
}
|
|
int count = 3;
|
while (count > 0)
|
{
|
var result = this.RequestZigbeeHttps("FirmwareMana/DownloadPlatformUploadFirmware", pra, waitTime);
|
if (result != null)
|
{
|
return result.Length == 0 ? null : result;
|
}
|
count--;
|
}
|
return null;
|
}
|
|
/// <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 ■ 访问云端的方法_____________________
|
|
/// <summary>
|
/// 云端固件的网址
|
/// </summary>
|
public string RequestHttpsHost = "https://global.hdlcontrol.com/ProposedProductionApi";
|
|
/// <summary>
|
/// 访问云端固件的方法
|
/// </summary>
|
/// <param name="i_interfaceName">接口名字</param>
|
/// <param name="i_body">body数据</param>
|
/// <param name="i_waitTime">超时时间</param>
|
/// <returns></returns>
|
public byte[] RequestZigbeeHttps(string i_interfaceName, object i_body, int i_waitTime)
|
{
|
string fullUrl = this.RequestHttpsHost + "/" + i_interfaceName;
|
|
var result = HdlHttpLogic.Current.DoRequestZigbeeHttps(fullUrl, null, RestSharp.Method.POST, i_body, null, null, CheckMode.A不检测, i_waitTime, false);
|
|
return result;
|
}
|
|
#endregion
|
|
#region ■ 一般方法___________________________
|
|
/// <summary>
|
/// 固件的信息处理
|
/// </summary>
|
/// <param name="Info"></param>
|
/// <param name="remark"></param>
|
private 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
|
}
|
}
|
