lavva.exalushome.webcams/build/js/WebCamsService.js

Library implementing webcams and abstraction layers for webcams configuration API in ExalusHome system

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 { WebCamConfiguration } from "./IWebCamsService";
import { DataFrame, Method, Status } from "lavva.exalushome/build/js/DataFrame";
import { ExalusConnectionService } from 'lavva.exalushome/build/js/Services/ExalusConnectionService';
import { Api } from 'lavva.exalushome';
import { DevicesService } from 'lavva.exalushome/build/js/Services/Devices/DevicesService';
import { WebApiCacheService } from 'lavva.exalushome/build/js/Services/WebApi/WebApiCacheService';
import { WebCam } from "./WebCam";
import { DependencyContainer } from "lavva.exalushome/build/js/DependencyContainer";
import { LoggerService } from "lavva.exalushome/build/js/Services/Logging/LoggerService";
export class WebCamsService {
    constructor() {
        this._connection = Api.Get(ExalusConnectionService.ServiceName);
        this._devices = Api.Get(DevicesService.ServiceName);
        this._cache = Api.Get(WebApiCacheService.ServiceName);
    }
    GetServiceName() {
        return WebCamsService.ServiceName;
    }
    static Init() {
        DependencyContainer.Instance.RegisterService(new WebCamsService());
        Api.Get(LoggerService.ServiceName).Debug(WebCamsService.ServiceName, "Initialized WebCamsService");
    }
    GetWebCamAsync(device) {
        return __awaiter(this, void 0, void 0, function* () {
            let cam = new WebCam();
            cam.SetDeviceChannel(device.Channels.first());
            return cam;
        });
    }
    GetWebCamConfigurationAsync(device) {
        return __awaiter(this, void 0, void 0, function* () {
            let result = yield this._connection.SendAndWaitForResponseAsync(new GetWebCamConfigurationRequest(device), 10000, false, true);
            switch (result.Status) {
                case Status.OK:
                    return result.Data;
                default:
                    throw new Error(`Failed to get camera configuration. Status: ${result.Status}.`);
            }
        });
    }
    CreateNewWebCamAsync(data) {
        return __awaiter(this, void 0, void 0, function* () {
            let result = yield this._connection.SendAndWaitForResponseAsync(new CreateNewCameraRequest(data.RtspUrl, data.UserName, data.Password), 10000, false, true);
            switch (result.Status) {
                case Status.OK:
                    this._cache.ClearCache();
                    yield this._devices.GetDevicesAsync();
                    var cameraDeviceGuid = result.Data;
                    return this._devices.GetDevice(cameraDeviceGuid);
                default:
                    throw new Error(`Failed to create new camera. Status: ${result.Status}.`);
            }
        });
    }
    SetWebCamConfigurationAsync(device, configuration) {
        return __awaiter(this, void 0, void 0, function* () {
            let result = yield this._connection.SendAndWaitForResponseAsync(new UpdateCameraDataRequest(device, configuration.RtspUrl, configuration.UserName, configuration.Password), 10000, false, true);
            if (result.Status == Status.OK) {
                this._cache.ClearCache();
                yield this._devices.GetDevicesAsync();
            }
            return result.Status;
        });
    }
}
WebCamsService.ServiceName = "WebCamsService";
class GetWebCamConfigurationRequest extends DataFrame {
    constructor(device) {
        super();
        this.Method = Method.Get;
        this.Resource = `/webcams/webcam/get`;
        this.Data = device.Guid;
    }
}
class UpdateCameraDataRequest extends DataFrame {
    constructor(device, url, user, password) {
        super();
        this.Method = Method.Put;
        this.Resource = "/webcams/webcam/upsert";
        this.Data = new WebCamConfiguration();
        this.Data.Guid = device.Guid;
        this.Data.RtspUrl = url;
        this.Data.UserName = user;
        this.Data.Password = password;
    }
}
class CreateNewCameraRequest extends DataFrame {
    constructor(url, user, password) {
        super();
        this.Method = Method.Put;
        this.Resource = "/webcams/webcam/upsert";
        this.Data = new WebCamConfiguration();
        this.Data.RtspUrl = url;
        this.Data.UserName = user;
        this.Data.Password = password;
    }
}
//# sourceMappingURL=WebCamsService.js.map