lavva.exalushome.extalife
Version:
Library implementing communication and abstraction layers for ExtaLife API in ExalusHome system
473 lines • 31.5 kB
JavaScript
var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
return new (P || (P = Promise))(function (resolve, reject) {
function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
step((generator = generator.apply(thisArg, _arguments || [])).next());
});
};
import { UpdatesProvider } from 'lavva.exalushome/build/js/Services/Updates/UpdatesProvider';
import { Api } from 'lavva.exalushome';
import { LoggerService } from 'lavva.exalushome/build/js/Services/Logging/LoggerService';
import { DataFrame, Method, Status } from 'lavva.exalushome/build/js/DataFrame';
import { ExalusConnectionService } from 'lavva.exalushome/build/js/Services/ExalusConnectionService';
import { ProviderType, Update, UpdateInfo } from 'lavva.exalushome/build/js/Services/Updates/IUpdatesProvider';
import { ResponseResult } from 'lavva.exalushome/build/js/Services/FieldChangeResult';
import { ExtaLifeService } from '../../ExtaLife';
import { BulkUpdateResult, UpdateErrorCode } from 'lavva.exalushome/build/js/Services/Updates/IUpdatesService';
import { UpdateProgressInfo, UpdateStatus } from 'lavva.exalushome/build/js/Services/Updates/IUpdatesService';
import { DevicesService } from 'lavva.exalushome/build/js/Services/Devices/DevicesService';
import { UpdatesService } from 'lavva.exalushome/build/js/Services/Updates/UpdatesService';
import { ControllerUpdateType } from 'lavva.exalushome/build/js/Services/Updates/IUpdateInfo';
import { ParseObjToMap } from 'lavva.exalushome/build/js/Helpers';
export class ExtaLifeDevicesUpdatesProvider {
constructor(extInfo, runtimeInfo) {
this._apiVersion = extInfo.APIVersion;
this._extenstionVersion = extInfo.ExtensionVersion;
this._protocolExtGuid = extInfo.ExtensionGuid;
this._runtimeInfo = runtimeInfo;
this._logger = Api.Get(LoggerService.ServiceName);
this._connection = Api.Get(ExalusConnectionService.ServiceName);
this._devices = Api.Get(DevicesService.ServiceName);
this._updateProvider = Api.Get(UpdatesProvider.ServiceName);
}
get ProtocolGuid() {
return ExtaLifeService.ExtaLifeProtocolGuid;
}
get ExtensionGuid() {
return this._protocolExtGuid;
}
get AvailableApiVersion() {
return this._apiVersion;
}
get AvailableExtensionVersion() {
return this._extenstionVersion;
}
get ProviderType() {
return ProviderType.Device;
}
GetUpdateProviderName() {
return `${ExtaLifeDevicesUpdatesProvider.ProviderName}_${this._apiVersion}_${this._extenstionVersion}`;
}
GetAvailableUpdateAsync(device) {
return __awaiter(this, void 0, void 0, function* () {
var _a, _b, _c, _d;
try {
if (device.ProtocolGuid != ExtaLifeService.ExtaLifeProtocolGuid) {
this._logger.Debug(`Cannot get available updates! Device ${device.Name} does not support the ExtaLife protocol.`);
return new ResponseResult(UpdateErrorCode.UnsupportedDevice, `Cannot get available updates! Device ${device.Name} does not support the ExtaLife protocol.`);
}
if (parseFloat(this._apiVersion) < 2.0) {
this._logger.Debug(`Cannot get available updates! Unsupported API version: ${this._apiVersion}`);
return new ResponseResult(UpdateErrorCode.UnsupportedApiVersion, `Cannot get available updates! Unsupported API version: ${this._apiVersion}`);
}
else if (parseFloat(this._apiVersion) < 3.0) {
const currentDeviceFv = yield this.GetFirmwareVersionAsync(device);
if (currentDeviceFv.Type != null) {
this._logger.Debug(`Cannot get available updates! Error: ${currentDeviceFv.Type}`);
return currentDeviceFv;
}
let upd = Api.Get(UpdatesService.ServiceName);
let branch = yield upd.GetControllerUpdateBranchAsync();
let variant = "lavva";
if (document.location.hostname.endsWith("tr7.pl"))
variant = "portos";
const url = `https://exalus-updates.tr7.pl/firmware/${variant}/${branch}/${device.ModelGuid}/update.json`;
let fv = currentDeviceFv;
let fvs = `${fv.Major}.${fv.Minor}.${fv.Revision}.${fv.Build}`;
try {
this._logger.Debug(`Checking for firmware update, device: ${device.ModelGuid} name: ${device.Name} firmware ver.: ${JSON.stringify(fv)} ver: ${fvs} \n url: ${url} protocol: ${document.location.protocol}`);
const response = yield fetch(url);
let updateData;
let updateInfo = new UpdateInfo();
switch (response.status) {
case 200:
if (response.body != null) {
updateData = (yield response.json());
this._logger.Debug(`Recived update data: ${JSON.stringify(updateData)}`);
}
else {
this._logger.Warning(`Cannot get updates! Response body is null.`);
return new ResponseResult(UpdateErrorCode.CannotGetUpdates, `Cannot get updates! Response body is null.`);
}
break;
case 404:
this._logger.Debug(`Updates not found, device ${device.Name} is already up-to-date.`);
return new ResponseResult(UpdateErrorCode.DeviceIsUpToDate, `Updates not found, device ${device.Name} is already up-to-date.`);
default:
this._logger.Debug(`Cannot get updates! Response status code does not indicate success. Status: ${response.status}`);
return new ResponseResult(UpdateErrorCode.CannotGetUpdates, `Response status code does not indicate success. Status: ${response.status}`);
}
if (updateData != null) {
if (updateData.DownloadUri.startsWith("/"))
updateData.DownloadUri = `https://exalus-updates.tr7.pl${updateData.DownloadUri}`;
let minControllerSoftwareVer = updateData.RequiredMinimumControllerSoftwareVersion;
let minContrSoftVerAsString = `${minControllerSoftwareVer.Major}.${minControllerSoftwareVer.Minor}.${minControllerSoftwareVer.Revision}.${minControllerSoftwareVer.Build}`;
let currentControllerSoftwareVersion = yield upd.CheckControllerVersionAsync();
this._logger.Debug(`Checking for controller software version. Required: ${minContrSoftVerAsString}`);
if (currentControllerSoftwareVersion instanceof ResponseResult)
return new ResponseResult(UpdateErrorCode.CannotGetUpdates, `Failed to get controller software version. Error: ${JSON.stringify(currentControllerSoftwareVersion)}`);
else {
let v = currentControllerSoftwareVersion.first(v => v.Type == ControllerUpdateType.SoftwareUpdate);
if (v == null) {
this._logger.Debug(`Cannot get controller software version. Controller software version not found.`);
return new ResponseResult(UpdateErrorCode.CannotGetUpdates, `Failed to get controller software version. Error: Controller software version not found.`);
}
else
this._logger.Debug(`Current controller software version: ${v.Version}`);
let ve = new FirmwareVersion();
let ver = v.Version.split(".");
ve.Major = parseInt(ver[0]);
ve.Minor = parseInt(ver[1]);
ve.Revision = parseInt(ver[2]);
ve.Build = parseInt(ver[3]);
if (ve.Revision < minControllerSoftwareVer.Revision || (ve.Revision == minControllerSoftwareVer.Revision && ve.Build <= minControllerSoftwareVer.Build)) {
this._logger.Debug(`Cannot get update! Required minimum controller software version is higher than current. Required: ${minContrSoftVerAsString} Current: ${v.Version}`);
return new ResponseResult(UpdateErrorCode.CannotGetUpdates, `Cannot get update! Required minimum controller software version is higher than current. Required: ${minContrSoftVerAsString} Current: ${v.Version}`);
}
}
let currentDeviceFirmwareVersion = `${currentDeviceFv.Major}.${currentDeviceFv.Minor}.${currentDeviceFv.Revision}.${currentDeviceFv.Build}`;
let updateFirmwareversionString = `${updateData.Version.Major}.${updateData.Version.Minor}.${updateData.Version.Revision}.${updateData.Version.Build}`;
if (currentDeviceFirmwareVersion == updateFirmwareversionString) {
this._logger.Debug(`Device ${device.Name} is already up-to-date. Version: ${currentDeviceFirmwareVersion}`);
return new ResponseResult(UpdateErrorCode.DeviceIsUpToDate, `Device ${device.Name} is already up-to-date. Version: ${currentDeviceFirmwareVersion}`);
}
updateInfo.CurrentResourceVersion = currentDeviceFirmwareVersion;
updateInfo.Update = new Update();
updateInfo.Update.UpdateGuid = updateData.UpdateGuid;
updateInfo.Update.Channel = updateData.Branch;
updateInfo.Update.Version = updateFirmwareversionString;
updateInfo.Update.DownloadUri = updateData.DownloadUri;
updateInfo.Update.Name = (_b = (_a = updateData.Name["en-US"]) !== null && _a !== void 0 ? _a : updateData.Name["pl-PL"]) !== null && _b !== void 0 ? _b : "Unknown";
updateInfo.Update.Description = (_d = (_c = updateData.Description["en-US"]) !== null && _c !== void 0 ? _c : updateData.Description["pl-PL"]) !== null && _d !== void 0 ? _d : "Unknown";
updateInfo.Update.ResourceGuid = device.Guid;
updateInfo.UpdatedResourceName = device.Name;
updateInfo.UpdateDescription = new Map(Object.entries(updateData.Description));
return updateInfo;
}
else {
this._logger.Warning(`Cannot get Update Data from response. Response status: ${response.status}`);
return new ResponseResult(UpdateErrorCode.CannotGetUpdates, `Cannot get Update Data from response. Status: ${response.status}`);
}
}
catch (error) {
this._logger.Warning(`Cannot get available updates! Error: ${error}`);
return new ResponseResult(UpdateErrorCode.CannotGetUpdates, `Request failed. Error: ${error}`);
}
}
else {
this._logger.Warning(`Cannot get available updates! Unsupported API version: ${this._apiVersion}`);
return new ResponseResult(UpdateErrorCode.UnsupportedApiVersion, `Cannot get available updates! Unsupported API version: ${this._apiVersion}`);
}
}
catch (error) {
this._logger.Warning(`Cannot get available updates! Error: ${error}`);
return new ResponseResult(UpdateErrorCode.CannotGetUpdates, `Cannot get available updates! Error: ${error}`);
}
});
}
CheckUpdateBulkAsync(reloadCache) {
return __awaiter(this, void 0, void 0, function* () {
const devs = yield Api.Get(DevicesService.ServiceName).GetDevicesAsync();
const devsNum = devs.where(d => d.ProtocolGuid == ExtaLifeService.ExtaLifeProtocolGuid).count();
const result = yield this._connection.SendAndWaitForResponseAsync(new CheckUpdatesRequest(reloadCache), devsNum * 1500, false);
if (result == null || result.Status == null)
return new ResponseResult(UpdateErrorCode.CannotGetUpdates, `Cannot check updates! Response does not contain data.`);
if (result.Status != Status.OK)
return new ResponseResult(UpdateErrorCode.CannotGetUpdates, `Cannot check updates! Controler responded with status ${result.Status}.`);
if (result.Data == null)
return new ResponseResult(UpdateErrorCode.CannotGetUpdates, `Cannot check updates! Response does not contain data.`);
return result.Data.map(d => {
var _a, _b, _c;
d.FirmwareUpdate.Name = new Map(Object.entries(d.FirmwareUpdate.Name));
const updateInfo = new UpdateInfo();
updateInfo.CurrentResourceVersion = d.CurrentVersion;
updateInfo.UpdatedResourceName = (_a = devs.first(a => a.Guid == d.DeviceGuid).Name) !== null && _a !== void 0 ? _a : "Unknown";
updateInfo.UpdateDescription = new Map(Object.entries(d.FirmwareUpdate.Description));
updateInfo.Update = new Update();
updateInfo.Update.Channel = d.FirmwareUpdate.Branch;
updateInfo.Update.DownloadUri = d.FirmwareUpdate.DownloadUri;
updateInfo.Update.CurrentVersion = d.CurrentVersion;
updateInfo.Update.Version = d.NewVersion;
updateInfo.Update.Name = (_c = (_b = d.FirmwareUpdate.Name.get("en-US")) !== null && _b !== void 0 ? _b : d.FirmwareUpdate.Name.get("pl-PL")) !== null && _c !== void 0 ? _c : "Unknown";
updateInfo.Update.ResourceGuid = d.DeviceGuid;
updateInfo.Update.UpdateGuid = d.FirmwareUpdate.UpdateGuid;
return updateInfo;
});
});
}
GetSoftwareVersionAsync(device) {
return __awaiter(this, void 0, void 0, function* () {
if (device.ProtocolGuid != ExtaLifeService.ExtaLifeProtocolGuid)
return new ResponseResult(UpdateErrorCode.UnsupportedDevice, `Cannot get available updates! Device ${device.Name} does not support the ExtaLife protocol.`);
const result = yield this.GetFirmwareVersionAsync(device);
if (result.Type != null)
return result;
return `${result.Major}.${result.Minor}.${result.Revision}.${result.Build}`;
});
}
GetFirmwareVersionAsync(device) {
return __awaiter(this, void 0, void 0, function* () {
var _a;
const result = yield ((_a = this._connection) === null || _a === void 0 ? void 0 : _a.SendAndWaitForResponseAsync(new GetFirmwareVersion(device.Guid), 12000, false));
if (result == null || result.Status == null)
return new ResponseResult(UpdateErrorCode.CannotGetFirmwareVersion, `Cannot get firmware version! Response does not contain data.`);
if (result.Status != Status.OK)
return new ResponseResult(UpdateErrorCode.CannotGetFirmwareVersion, `Cannot get firmware version! Controler responded with status ${result.Status}.`);
if (result.Data == null)
return new ResponseResult(UpdateErrorCode.CannotGetFirmwareVersion, `Cannot get firmware version! Response does not contain data.`);
const fv = new FirmwareVersion();
fv.Major = result.Data.Major;
fv.Minor = result.Data.Minor;
fv.Revision = result.Data.Revision;
fv.Build = result.Data.Build;
return fv;
});
}
InstallUpdateAsync(update_1, updateProgress_1, updateAction_1) {
return __awaiter(this, arguments, void 0, function* (update, updateProgress, updateAction, force = false) {
var _a, _b, _c;
if (updateAction != null)
return new ResponseResult(UpdateErrorCode.UpdateActionsNotSupported, `Update service for given resource: ${update.UpdatedResourceName} does not support custom update actions.`);
if (parseFloat(this._apiVersion) < 2.0) {
return new ResponseResult(UpdateErrorCode.UnsupportedApiVersion, `Cannot install update! Unsupported API version: ${this._apiVersion}`);
}
else if (parseFloat(this._apiVersion) < 3.0) {
if ((yield this._devices.GetDevicesAsync()).find(d => d.ModelGuid == "952ddc14-76c4-4f47-b0bc-5d106c1f9b02") != null) {
if (!force)
return new ResponseResult(UpdateErrorCode.RetransmitterFound, `Cannot install update! Retransmitter found! Use force option to install update if you are sure what you are doing.`);
}
var extaLifeProvider = (yield this._updateProvider.GetUpdatesProvidersByProtocolAsync(ExtaLifeService.ExtaLifeProtocolGuid, ProviderType.Controller)).firstOrDefault();
var hwInfo = yield this._updateProvider.GetHardwareInfoAsync();
//For new hardware version (cpu IMX6UL) we need to check if radio version is supported due to radio bug.
if (((_a = hwInfo.GetAvailableHardware.find(h => h.DevicePath === "/proc")) === null || _a === void 0 ? void 0 : _a.DisplayName) === "IMX6UL") {
if (parseFloat((_b = yield (extaLifeProvider === null || extaLifeProvider === void 0 ? void 0 : extaLifeProvider.GetCurrentRadioVersionAsync())) !== null && _b !== void 0 ? _b : '1.0') < 1.4) {
return new ResponseResult(UpdateErrorCode.ProtocolRadioUnsupported, `Cannot install update! Unsupported API version: ${this._apiVersion}`);
}
}
const requestData = new DeviceFirmware(update.Update.ResourceGuid, update.Update.DownloadUri);
try {
yield ((_c = this._connection) === null || _c === void 0 ? void 0 : _c.SendAndHandleResponseAsync(new UpgradeFirmwareVersion(requestData), 60000, (resp) => {
var _a, _b;
const progressInfo = new UpdateProgressInfo();
progressInfo.UpdatedResourceName = new Map([["pl-PL", update.UpdatedResourceName], ["en-US", update.UpdatedResourceName]]);
switch (resp.Status) {
case Status.MultiDataResponseStart:
progressInfo.Status = UpdateStatus.PreparingForUpgrade;
break;
case Status.MultiDataResponse:
if (resp.Data == null) {
this._logger.Warning(ExtaLifeDevicesUpdatesProvider.ProviderName, `Recived update response without data! URI: ${update.Update.DownloadUri}`);
return;
}
progressInfo.Percentage = resp.Data.CurrentProgress;
progressInfo.PercentageTotal = progressInfo.Percentage;
switch ((_a = resp.Data) === null || _a === void 0 ? void 0 : _a.FirmwareUpgradeStatus) {
case FirmwareUpgradeStatus.Error:
progressInfo.Status = UpdateStatus.InstallationError;
break;
case FirmwareUpgradeStatus.OK:
if (progressInfo.Percentage == 100)
progressInfo.Status = UpdateStatus.Upgraded;
else
progressInfo.Status = UpdateStatus.OK;
break;
case FirmwareUpgradeStatus.PreparingForUpgrade:
progressInfo.Status = UpdateStatus.PreparingForUpgrade;
break;
case FirmwareUpgradeStatus.Upgraded:
progressInfo.Status = UpdateStatus.Upgraded;
break;
default:
progressInfo.Status = UpdateStatus.Upgrading;
}
break;
case Status.MultiDataResponseStop:
if (((_b = resp.Data) === null || _b === void 0 ? void 0 : _b.CurrentProgress) == 100)
progressInfo.Status = UpdateStatus.Upgraded;
else
progressInfo.Status = UpdateStatus.Error;
}
this._logger.Debug(ExtaLifeDevicesUpdatesProvider.ProviderName, `Recived update progress response, percentage: ${progressInfo.Percentage}, status: ${progressInfo.Status}, resource name: ${update.UpdatedResourceName}`);
updateProgress(progressInfo);
}, false));
return Status.OK;
}
catch (error) {
return new ResponseResult(UpdateErrorCode.CannotProcessUpdate, `Cannot process update, error: ${error}`);
}
}
else {
return new ResponseResult(UpdateErrorCode.UnsupportedApiVersion, `Cannot install update! Unsupported API version: ${this._apiVersion}`);
}
});
}
InstalUpdateBulkAsync(deviceGuids, updateProgress, updateAction) {
return __awaiter(this, void 0, void 0, function* () {
const resultPromise = new Promise((resolve, reject) => __awaiter(this, void 0, void 0, function* () {
try {
yield this._connection.SendAndHandleResponseAsync(new UpgradeFirmwareVersionBulk(deviceGuids), 60000, (resp) => {
var _a, _b, _c, _d;
const progressInfo = new UpdateProgressInfo();
switch (resp.Status) {
case Status.MultiDataResponseStart: {
return;
}
case Status.MultiDataResponse: {
const data = resp.Data;
const dev = Api.Get(DevicesService.ServiceName).GetDevice((_a = data === null || data === void 0 ? void 0 : data.DeviceGuid) !== null && _a !== void 0 ? _a : "");
progressInfo.UpdatedResourceName = new Map([["pl-PL", ((dev === null || dev === void 0 ? void 0 : dev.Name) ? dev.Name : "n/a")], ["en-US", ((dev === null || dev === void 0 ? void 0 : dev.Name) ? dev.Name : "n/a")]]);
switch (data === null || data === void 0 ? void 0 : data.Status) {
case FirmwareUpgradeStatus.Error:
progressInfo.Status = UpdateStatus.InstallationError;
break;
case FirmwareUpgradeStatus.OK:
progressInfo.Status = UpdateStatus.OK;
break;
case FirmwareUpgradeStatus.PreparingForUpgrade:
case FirmwareUpgradeStatus.UnpairingRetransmitters:
progressInfo.Status = UpdateStatus.PreparingForUpgrade;
break;
case FirmwareUpgradeStatus.Upgraded:
progressInfo.Status = UpdateStatus.Upgraded;
break;
case FirmwareUpgradeStatus.DownloadingFirmware:
progressInfo.Status = UpdateStatus.DownloadingPackage;
break;
case FirmwareUpgradeStatus.Upgrading:
progressInfo.Status = UpdateStatus.Upgrading;
break;
case FirmwareUpgradeStatus.CheckingVersionsOfUpdatedDevices:
case FirmwareUpgradeStatus.PairingRetransmitters:
progressInfo.Status = UpdateStatus.Reloading;
break;
}
progressInfo.Percentage = ((_b = data === null || data === void 0 ? void 0 : data.DeviceUpdatePercentage) !== null && _b !== void 0 ? _b : 0);
progressInfo.PercentageTotal = data === null || data === void 0 ? void 0 : data.TotalUpdatePercentage;
progressInfo.AvailableUpdates = (_c = data === null || data === void 0 ? void 0 : data.DevicesToUpdate) !== null && _c !== void 0 ? _c : 0;
progressInfo.UpdateNumber = (_d = data === null || data === void 0 ? void 0 : data.CurrentDeviceUpdate) !== null && _d !== void 0 ? _d : 0;
this._logger.Debug(ExtaLifeDevicesUpdatesProvider.ProviderName, `Recived update progress response, percentage: ${progressInfo.Percentage}, status: ${progressInfo.Status}, resource name: ${dev === null || dev === void 0 ? void 0 : dev.Name}`);
break;
}
case Status.MultiDataResponseStop: {
const data = resp.Data;
const result = new BulkUpdateResult();
result.BulkUpdateStatus = data.BulkUpdateStatus;
result.DevicesUpdateResults = ParseObjToMap(data.DevicesUpdateResults);
resolve(result);
return;
}
case Status.Error:
reject(new ResponseResult(UpdateErrorCode.CannotFindDevice, `Cannot process update, recived error response.`));
return;
default:
reject(new ResponseResult(UpdateErrorCode.CannotProcessUpdate, `Cannot process update, recived unsupported response status: ${resp.Status}.`));
return;
}
updateProgress(progressInfo);
}, true);
}
catch (error) {
reject(new ResponseResult(UpdateErrorCode.CannotProcessUpdate, `Cannot process update, error: ${error}`));
}
}));
return resultPromise;
});
}
}
ExtaLifeDevicesUpdatesProvider.ProviderName = "ExtaLifeDeviceUpdateProvider";
class CheckUpdatesRequest extends DataFrame {
constructor(reloadCache) {
super();
this.Resource = "/extalife/device/firmware/upgrade/check";
this.Method = Method.Put;
this.Data = reloadCache;
}
}
class GetFirmwareVersion extends DataFrame {
constructor(data) {
super();
this.Resource = "/extalife/device/firmware/version/complete";
this.Method = Method.Get;
this.Data = data;
}
}
class UpgradeFirmwareVersion extends DataFrame {
constructor(data) {
super();
this.Resource = "/extalife/device/firmware/upgrade";
this.Method = Method.Put;
this.Data = data;
}
}
class UpgradeFirmwareVersionBulk extends DataFrame {
constructor(devGuids) {
super();
this.Resource = "/extalife/device/firmware/upgrade/bulk";
this.Method = Method.Put;
this.Data = devGuids;
}
}
class BulkFirmwareUpgradeStatus {
constructor() {
this.DevicesToUpdate = 0;
this.CurrentDeviceUpdate = 0;
this.DeviceGuid = "";
this.Status = FirmwareUpgradeStatus.Error;
this.DeviceUpdatePercentage = 0;
this.TotalUpdatePercentage = 0;
}
}
class FirmwareVersion {
constructor() {
this.Revision = 0;
this.Build = 0;
this.Minor = 0;
this.Major = 0;
}
}
class DeviceFirmware {
constructor(deviceGuid, uri) {
this.DeviceGuid = deviceGuid;
this.Uri = uri;
}
}
class Progress {
constructor() {
this.CurrentProgress = 0;
this.FirmwareUpgradeStatus = FirmwareUpgradeStatus.Error;
}
}
var FirmwareUpgradeStatus;
(function (FirmwareUpgradeStatus) {
FirmwareUpgradeStatus[FirmwareUpgradeStatus["Error"] = -1] = "Error";
FirmwareUpgradeStatus[FirmwareUpgradeStatus["OK"] = 0] = "OK";
FirmwareUpgradeStatus[FirmwareUpgradeStatus["Upgrading"] = 1] = "Upgrading";
FirmwareUpgradeStatus[FirmwareUpgradeStatus["PreparingForUpgrade"] = 2] = "PreparingForUpgrade";
FirmwareUpgradeStatus[FirmwareUpgradeStatus["Upgraded"] = 3] = "Upgraded";
FirmwareUpgradeStatus[FirmwareUpgradeStatus["DownloadingFirmware"] = 4] = "DownloadingFirmware";
FirmwareUpgradeStatus[FirmwareUpgradeStatus["UnpairingRetransmitters"] = 5] = "UnpairingRetransmitters";
FirmwareUpgradeStatus[FirmwareUpgradeStatus["PairingRetransmitters"] = 6] = "PairingRetransmitters";
FirmwareUpgradeStatus[FirmwareUpgradeStatus["CheckingVersionsOfUpdatedDevices"] = 7] = "CheckingVersionsOfUpdatedDevices";
})(FirmwareUpgradeStatus || (FirmwareUpgradeStatus = {}));
class UpdateInfoResponse {
constructor() {
this.DeviceGuid = "";
this.IsAvailable = false;
this.NewVersion = "";
this.CurrentVersion = "";
this.FirmwareUpdate = new FirmwareUpdateResponse();
}
}
class FirmwareUpdateResponse {
constructor() {
this.UpdateGuid = "";
this.Branch = "";
this.DownloadUri = "";
this.Name = new Map();
this.Description = new Map();
this.PublicationDateTime = "";
}
}
//# sourceMappingURL=ExtaLifeDevicesUpdatesProvider.js.map