@flexem/fc-gui 3.0.0-alpha.90 → 3.0.0-alpha.91

package/src/remote/communication/variable/remote-variable-communicator.ts

@@ -0,0 +1,254 @@
+import { each, remove, uniq } from 'lodash';
+import { Observable, Subscriber, Subscription } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { VariableCommunicator, VariableValue, VariableState } from '../../../communication';
+import { StringifyingMap } from '../../../core';
+import { LoggerService } from '../../../logger';
+import { RemoteVariableProtocol } from './remote-variable-protocol';
+
+export class RemoteVariableCommunicator implements VariableCommunicator {
+
+    private observers = new Map<string, Subscriber<VariableValue[]>[]>();
+    private appIdVariablesMap = new Map<string, string[]>();
+    private connectedSubscription: Subscription;
+    private variableValuesChangedSubscription: Subscription;
+    private variablesToBeOpened: string[];
+    private variablesToBeClosed: string[];
+    private variableValueCache: StringifyingMap<string, VariableValue>;
+
+    private variableStateObservers = new Map<string, Subscriber<VariableState[]>[]>();
+    private variableStatesChangedSubscription: Subscription;
+    private variableStateCache = new Map<string, VariableState>();
+    private variableStatesToBeOpened: string[];
+    private variableStatesToBeClosed: string[];
+
+    private alarmObservers: Subscriber<any[]>[] = [];
+    private alarmChangedSubscription: Subscription;
+
+    constructor(private readonly remoteVariableProtocol: RemoteVariableProtocol, private readonly logger: LoggerService) {
+        this.variableValueCache = new StringifyingMap<string, VariableValue>(k => JSON.stringify(k));
+        this.connectedSubscription = this.remoteVariableProtocol.connected.subscribe(() => {
+
+            const variableNamesToStart: Array<string> = [];
+            this.variableStateObservers.forEach((__, variableName) => {
+                variableNamesToStart.push(variableName);
+            });
+            this.remoteVariableProtocol.subscribeVariableStates(variableNamesToStart);
+
+            this.appIdVariablesMap.forEach((variableNames, appId) => {
+                this.remoteVariableProtocol.tryOpenVariables(variableNames, appId);
+            });
+        });
+        this.doVariableStatesChanged();
+        this.doVariableValuesChanged();
+        this.doAlarmChanged();
+    }
+
+    private doAlarmChanged() {
+        if (this.alarmChangedSubscription !== undefined) {
+            this.alarmChangedSubscription.unsubscribe();
+        }
+        this.alarmChangedSubscription = this.remoteVariableProtocol.virtualDeviceAlarmsChanged.subscribe((alarms) => {
+            each(this.alarmObservers, ob => {
+                ob.next(alarms);
+            });
+
+        });
+    }
+
+    private doVariableValuesChanged() {
+        if (this.variableValuesChangedSubscription !== undefined) {
+            this.variableValuesChangedSubscription.unsubscribe();
+        }
+        this.variableValuesChangedSubscription =
+            this.remoteVariableProtocol.variableValuesChanged.subscribe((values: VariableValue[]) => {
+                each(values, variableValue => {
+                    const variableName = variableValue.variableName;
+                    this.variableValueCache.set(variableName, variableValue);
+                    if (this.observers.has(variableName)) {
+                        each(this.observers.get(variableName), ob => {
+                            // TODO 同一个ob监听多个变量的情况，组合成数组一次推送。
+                            ob.next([variableValue]);
+                        });
+                    }
+                });
+            });
+    }
+
+    private doVariableStatesChanged() {
+        if (this.variableStatesChangedSubscription !== undefined) {
+            this.variableStatesChangedSubscription.unsubscribe();
+        }
+        this.variableStatesChangedSubscription =
+            this.remoteVariableProtocol.variableStatesChanged.subscribe((states: VariableState[]) => {
+                each(states, state => {
+                    const variableName = state.variableName;
+                    this.variableStateCache.set(variableName, state);
+                    if (this.variableStateObservers.has(variableName)) {
+                        each(this.variableStateObservers.get(variableName), ob => {
+                            // TODO 同一个ob监听多个变量的情况，组合成数组一次推送。
+                            ob.next([state]);
+                        });
+                    }
+                });
+            });
+    }
+
+    subscribeVariableStates(variableNames: string[]): Observable<VariableState[]> {
+        return new Observable<VariableState[]>(observer => {
+            let variableNamesToStart: string[] = [];
+            each(variableNames, variableName => {
+                if (!this.variableStateObservers.has(variableName)) {
+                    this.variableStateObservers.set(variableName, []);
+                    variableNamesToStart.push(variableName);
+                } else {
+                    if (this.variableStateCache.has(variableName)) {
+                        observer.next([this.variableStateCache.get(variableName)]);
+                    }
+                }
+                this.variableStateObservers.get(variableName).push(observer);
+            });
+            variableNamesToStart = uniq(variableNamesToStart);
+            if (variableNamesToStart && variableNamesToStart.length > 0) {
+                if (!this.variableStatesToBeOpened) {
+                    this.variableStatesToBeOpened = [];
+                    setTimeout(() => {
+                        this.remoteVariableProtocol.subscribeVariableStates(this.variableStatesToBeOpened);
+                        delete this.variableStatesToBeOpened;
+                    });
+                }
+                this.variableStatesToBeOpened.push(...variableNamesToStart);
+            }
+            return () => {
+                const stopedVariableStates = [];
+                each(variableNames, variableName => {
+                    const obs = this.variableStateObservers.get(variableName);
+                    if (obs) {
+                        remove(obs, item => item === observer);
+                        if (obs.length <= 0) {
+                            this.variableStateObservers.delete(variableName);
+                            stopedVariableStates.push(variableName);
+                        }
+                    }
+                });
+                if (!stopedVariableStates.length) { return; }
+                if (!this.variableStatesToBeClosed) {
+                    this.variableStatesToBeClosed = [];
+                    setTimeout(() => {
+                        this.remoteVariableProtocol.unsubscribeVariableStates(this.variableStatesToBeClosed);
+                        delete this.variableStatesToBeClosed;
+                    });
+                }
+                this.variableStatesToBeClosed.push(...stopedVariableStates);
+            };
+        });
+    }
+
+    subscribeVariableState(variableName: string): Observable<VariableState> {
+        return this.subscribeVariableStates([variableName]).pipe(map<VariableState[], VariableState>(values => values[0]));
+    }
+
+    openVariables(variableNames: string[], appId = ''): Observable<VariableValue[]> {
+        return new Observable<VariableValue[]>(observer => {
+            let variablesToStart: string[] = [];
+            each(variableNames, variableName => {
+                if (variableName) {
+                    if (!this.observers.has(variableName)) {
+                        this.observers.set(variableName, []);
+                        variablesToStart.push(variableName);
+                    } else {
+                        if (this.variableValueCache.has(variableName)) {
+                            observer.next([this.variableValueCache.get(variableName)]);
+                        }
+                    }
+                    this.observers.get(variableName).push(observer);
+
+                    if (!this.appIdVariablesMap.get(appId)) {
+                        this.appIdVariablesMap.set(appId, []);
+                    } else {
+                        if (this.appIdVariablesMap.get(appId).indexOf(variableName) === -1) {
+                            this.appIdVariablesMap.get(appId).push(variableName);
+                        }
+                    }
+                }
+            });
+            variablesToStart = uniq(variablesToStart);
+            if (variablesToStart && variablesToStart.length > 0) {
+                if (!this.variablesToBeOpened) {
+                    this.variablesToBeOpened = [];
+                    setTimeout(() => {
+                        this.remoteVariableProtocol.tryOpenVariables(this.variablesToBeOpened, appId);
+                        delete this.variablesToBeOpened;
+                    });
+                }
+                this.variablesToBeOpened.push(...variablesToStart);
+            }
+            return () => {
+                const stopedDataMonitorPoints = [];
+                each(variableNames, variableName => {
+                    const obs = this.observers.get(variableName);
+                    if (obs) {
+                        remove(obs, item => item === observer);
+                        if (obs.length <= 0) {
+                            this.observers.delete(variableName);
+                            stopedDataMonitorPoints.push(variableName);
+                        }
+                    }
+                });
+                if (!stopedDataMonitorPoints.length) { return; }
+                if (!this.variablesToBeClosed) {
+                    this.variablesToBeClosed = [];
+                    setTimeout(() => {
+                        this.remoteVariableProtocol.tryStopVariables(this.variablesToBeClosed, appId);
+                        delete this.variablesToBeClosed;
+                    });
+                }
+                this.variablesToBeClosed.push(...stopedDataMonitorPoints);
+            };
+        });
+    }
+
+    openVariable(variableName: string, appId = ''): Observable<VariableValue> {
+        if (!variableName) { return; }
+        return this.openVariables([variableName], appId).pipe(map(values => values[0]));
+    }
+
+    write(variableName: string, value: any): Observable<VariableValue> {
+        if (!variableName) { return; }
+        this.remoteVariableProtocol.writeVariable(variableName, value);
+        return new Observable<VariableValue>(__ => {
+            /* do nothing right now, if want value change immediately, can use this code below:
+              observer.next(new VariableValue(variable, VariableStateEnum.DataNormal, value))*/
+        });
+    }
+
+    writeWordByBit(variableName: string, index: number, value: number): Observable<VariableValue> {
+        if (!variableName) { return; }
+        this.remoteVariableProtocol.writeVariableWordByBit(variableName, index, value);
+        return new Observable<VariableValue>(__ => {
+            /* do nothing right now, if want value change immediately, can use this code below:
+              observer.next(new VariableValue(variable, VariableStateEnum.DataNormal, value))*/
+        });
+    }
+
+    subscribeUserDeviceAlarms(appId = '') {
+        return new Observable<any[]>(observer => {
+            this.alarmObservers.push(observer);
+            this.remoteVariableProtocol.subscribeVirtualDeviceAlarms(appId);
+            return () => {
+                this.remoteVariableProtocol.unsubscribeVirtualDeviceAlarms(appId);
+            };
+        });
+    }
+
+    dispose() {
+        // TODO调用所有的ob.complete()。
+        this.connectedSubscription.unsubscribe();
+        this.variableStatesChangedSubscription.unsubscribe();
+        this.variableValuesChangedSubscription.unsubscribe();
+        this.alarmChangedSubscription.unsubscribe();
+        if (this.logger && this.logger.isDebugEnabled()) {
+            this.logger.debug('[VariableCommunicator] RemoteVariableCommunicator disposed.');
+        }
+    }
+}

package/src/remote/communication/variable/remote-variable-protocol.ts

@@ -0,0 +1,29 @@
+import { Observable } from 'rxjs';
+import { VariableValue } from '../../../communication';
+
+export interface RemoteVariableProtocol {
+
+    connected: Observable<void>;
+
+    variableStatesChanged: Observable<VariableValue[]>;
+
+    variableValuesChanged: Observable<VariableValue[]>;
+
+    virtualDeviceAlarmsChanged: Observable<any>;
+
+    tryOpenVariables(variableNames: string[], appId: string): Observable<void>;
+
+    tryStopVariables(variableNames: string[], appId: string): Observable<void>;
+
+    writeVariable(variableName: string, value: any): Observable<void>;
+
+    writeVariableWordByBit(variableName: string, index: number, value: number): Observable<void>;
+
+    subscribeVariableStates(variableNames: string[]): Observable<void>;
+
+    unsubscribeVariableStates(variableNames: string[]): Observable<void>;
+
+    subscribeVirtualDeviceAlarms(appId: string);
+
+    unsubscribeVirtualDeviceAlarms(appId: string);
+}

package/src/remote/config/graph/get-released-graph-state-result.ts

@@ -0,0 +1,7 @@
+import { GraphStateResult } from './graph-state-result';
+
+export interface GetReleasedGraphStateResult {
+    graphId: number;
+    stateIndex: number;
+    result?: GraphStateResult;
+}

package/src/remote/config/graph/get-released-graph-states.ts

@@ -0,0 +1,5 @@
+import { GraphState } from './graph-state';
+
+export interface GetReleasedGraphStates {
+    readonly states: GraphState[];
+}

package/src/remote/config/graph/graph-state-key.ts

@@ -0,0 +1,7 @@
+import { GraphExtendedStyle } from '../../../shared/graph-extended-style';
+
+export interface GraphStateKey {
+    readonly graphId: string | number;
+    readonly stateId: number;
+    readonly extendedStyle?: GraphExtendedStyle;
+}

package/src/remote/config/graph/graph-state-result.ts

@@ -0,0 +1,6 @@
+import { GraphType } from '../../../config/graph/graph-type';
+
+export interface GraphStateResult {
+    type: GraphType;
+    url: string;
+}

package/src/remote/config/graph/remote-graph-protocol.ts

@@ -0,0 +1,19 @@
+import { Observable } from 'rxjs';
+
+import { GetReleasedGraphStates } from './get-released-graph-states';
+import { GetReleasedGraphStateResult } from './get-released-graph-state-result';
+
+export interface RemoteGraphProtocol {
+
+    readonly version: number;
+
+    readonly remoteServiceBaseUrl: string;
+
+    getSystemGraphConfig(graphId: string): any;
+
+    getAbsoluteStateUrl(graphId: string, stateUrl: string): string;
+
+    getReleasedGraphStates(input: GetReleasedGraphStates): Observable<GetReleasedGraphStateResult[]>;
+
+    getGraphStateUrl(graphId: number, stateIndex: number, fill: string, stroke: string): string;
+}

package/src/remote/config/graph/remote-graph-store.ts

@@ -0,0 +1,112 @@
+import { find } from 'lodash';
+import { Observable, of, Subject } from 'rxjs';
+import { map } from 'rxjs/operators';
+import { Graph, GraphResult, GraphStore, GraphType } from '../../../config';
+import { StringifyingMap } from '../../../core/stringifying-map';
+import { GraphExtendedStyle } from '../../../shared';
+import { GraphState } from './graph-state';
+import { GraphStateKey } from './graph-state-key';
+import { RemoteGraphProtocol } from './remote-graph-protocol';
+
+export class RemoteGraphStore implements GraphStore {
+
+    private readonly graphStateCache = new StringifyingMap<GraphStateKey, GraphResult>(k => JSON.stringify(k));
+
+    private graphStateToBeResolved: StringifyingMap<GraphStateKey, Subject<GraphResult>>;
+
+    constructor(private readonly remoteGraphProtocol: RemoteGraphProtocol) {
+    }
+
+    getGraph(graphId: string | number, stateId: number, extendedStyle?: GraphExtendedStyle): Observable<GraphResult> {
+        const graphStateKey: GraphStateKey = { graphId, stateId, extendedStyle };
+        if (this.graphStateCache.has(graphStateKey)) {
+            return of(this.graphStateCache.get(graphStateKey));
+        }
+        const version = this.remoteGraphProtocol.version;
+        if (version >= 1) {
+            return this.getReleasedGraphState(graphStateKey);
+        } else {
+            return this.getSystemGraph(graphStateKey);
+        }
+    }
+
+    private getSystemGraph(graphStateKey: GraphStateKey): Observable<GraphResult> {
+        const graphId = String(graphStateKey.graphId);
+        return this.remoteGraphProtocol.getSystemGraphConfig(graphId).pipe(map((graphConfig: any) => {
+            let result: GraphResult;
+            const stateConfig: any = find(graphConfig.states, s => (<any>s).id === graphStateKey.stateId);
+            if (stateConfig) {
+                const graphType = stateConfig.type === 'svg' ? GraphType.SVG : GraphType.Image;
+                const graph = new Graph(graphType, this.remoteGraphProtocol.getAbsoluteStateUrl(graphId, stateConfig.url));
+                result = GraphResult.success(graph);
+            } else {
+                result = GraphResult.failed();
+            }
+            this.graphStateCache.set(graphStateKey, result);
+            return result;
+        }));
+    }
+
+    private getImageUrl(url: string) {
+        if (!url) {
+            return url;
+        }
+        if (url.indexOf('http://') === 0 || url.indexOf('https://') === 0) {
+            return url;
+        }
+        return this.remoteGraphProtocol.remoteServiceBaseUrl + url;
+    }
+
+    private getReleasedGraphState(graphStateKey: GraphStateKey): Observable<GraphResult> {
+        if (graphStateKey.extendedStyle) { return this.getReleaseGraphStateWithExtendedStyle(graphStateKey); }
+        if (!this.graphStateToBeResolved) {
+            this.graphStateToBeResolved =
+                new StringifyingMap<GraphStateKey, Subject<GraphResult>>(k => JSON.stringify(k));
+            setTimeout(() => { this.resolvePendingStates(); });
+        }
+        if (!this.graphStateToBeResolved.has(graphStateKey)) {
+            this.graphStateToBeResolved.set(graphStateKey, new Subject<GraphResult>());
+        }
+        return this.graphStateToBeResolved.get(graphStateKey);
+    }
+
+    private getReleaseGraphStateWithExtendedStyle(graphStateKey: GraphStateKey): Observable<GraphResult> {
+        const graphId = Number(graphStateKey.graphId);
+        const fill = encodeURIComponent(graphStateKey.extendedStyle.fill);
+        const stroke = encodeURIComponent(graphStateKey.extendedStyle.stroke);
+        const url = this.remoteGraphProtocol.getGraphStateUrl(graphId, graphStateKey.stateId, fill, stroke);
+        const graph = new Graph(GraphType.SVG, url);
+        return of(GraphResult.success(graph));
+    }
+
+    private resolvePendingStates() {
+        const graphStateToBeResolved = this.graphStateToBeResolved;
+        const states: GraphState[] = [];
+        graphStateToBeResolved.forEach((__, key) => {
+            const graphState: GraphStateKey = JSON.parse(key);
+            states.push({ graphId: graphState.graphId as number, stateIndex: graphState.stateId });
+        });
+        const dto = { states: states };
+        this.remoteGraphProtocol.getReleasedGraphStates(dto).subscribe(
+            result => {
+                result.forEach(value => {
+                    const key: GraphStateKey = { graphId: value.graphId, stateId: value.stateIndex };
+                    let graphResult: GraphResult;
+                    if (value.result) {
+                        const url = this.getImageUrl(value.result.url);
+                        graphResult = GraphResult.success(new Graph(value.result.type, url));
+                    } else {
+                        graphResult = GraphResult.failed();
+                    }
+                    this.graphStateCache.set(key, graphResult);
+                    const subject = graphStateToBeResolved.get(key);
+                    if (subject) {
+                        subject.next(graphResult);
+                        subject.complete();
+                    }
+                });
+            });
+        delete this.graphStateToBeResolved;
+    }
+
+}

package/src/remote/config/image/remote-image-protocol.ts

@@ -0,0 +1,6 @@
+export interface RemoteImageProtocol {
+
+    readonly remoteServiceBaseUrl: string;
+
+    readonly appBaseUrl: string;
+}

package/src/remote/config/image/remote-image-store.ts

@@ -0,0 +1,29 @@
+import { ImageStore } from '../../../config';
+import { RemoteImageProtocol } from './remote-image-protocol';
+
+const defaultImageId = 'defaultImage';
+
+const defaultImageSource = '/assets/common/images/configure/defaultImage.png';
+
+// 获取组态图片Controller方法的Url路径
+const getDiagramImageMethodPath = '/ConfigureComponent/GetImage';
+
+const idQueryStringPrefix = 'id=';
+
+export class RemoteImageStore implements ImageStore {
+
+    constructor(private readonly remoteImageProtocol: RemoteImageProtocol) {
+    }
+
+    private getDiagramImageUrlPrefix() {
+        return this.remoteImageProtocol.remoteServiceBaseUrl + getDiagramImageMethodPath + '?';
+    }
+
+    getImageUrl(imageId: string): string {
+        if (!imageId || imageId === defaultImageId) {
+            return this.remoteImageProtocol.appBaseUrl + defaultImageSource;
+        }
+        return this.getDiagramImageUrlPrefix() + idQueryStringPrefix + imageId;
+    }
+
+}

package/src/remote/config/view/remote-view-protocol.ts

@@ -0,0 +1,14 @@
+import { Observable } from 'rxjs';
+
+import { ViewResult } from './view-result';
+
+export interface RemoteViewProtocol {
+
+    getReleasedMainView(): Observable<ViewResult>;
+
+    getReleasedView(viewIndex: number): Observable<ViewResult>;
+
+    getViewConfigByConfigureViewId(configureViewId: number): Observable<ViewResult>;
+
+    getViewConfigByConfigureViewCode(configureViewCode: string): Observable<ViewResult>;
+}

package/src/remote/config/view/remote-view-store.ts

@@ -0,0 +1,52 @@
+import { Observable, of } from 'rxjs';
+import { map } from 'rxjs/operators';
+
+import { ViewStore } from '../../../config/view/view-store';
+import { ViewModel } from '../../../config/view/view.model';
+import { StringifyingMap } from '../../../core/stringifying-map';
+import { RemoteViewProtocol } from './remote-view-protocol';
+
+export class RemoteViewStore implements ViewStore {
+
+    private readonly viewConfigCache = new StringifyingMap<number, ViewModel>(k => JSON.stringify(k));
+
+    constructor(private readonly remoteViewProtocol: RemoteViewProtocol) {
+    }
+
+    getMainViewConfig(): Observable<ViewModel> {
+        return this.remoteViewProtocol.getReleasedMainView().pipe(
+            map(view => {
+                const result = new ViewModel(view.content);
+                this.viewConfigCache.set(view.viewIndex, result);
+                return result;
+            }));
+    }
+
+    getViewConfig(viewIndex: number): Observable<ViewModel> {
+        if (this.viewConfigCache.has(viewIndex)) {
+            return of(this.viewConfigCache.get(viewIndex));
+        }
+        return this.remoteViewProtocol.getReleasedView(viewIndex).pipe(
+            map(config => {
+                const result = new ViewModel(config.content);
+                this.viewConfigCache.set(viewIndex, result);
+                return result;
+            }));
+    }
+
+    getViewConfigByConfigureViewId(configureViewId: number): Observable<ViewModel> {
+        return this.remoteViewProtocol.getViewConfigByConfigureViewId(configureViewId).pipe(
+            map(config => {
+                const result = new ViewModel(config.content);
+                return result;
+            }));
+    }
+
+    getViewConfigByConfigureViewCode(configureViewCode: string): Observable<ViewModel> {
+        return this.remoteViewProtocol.getViewConfigByConfigureViewCode(configureViewCode).pipe(
+            map(config => {
+                const result = new ViewModel(config.content);
+                return result;
+            }));
+    }
+}

package/src/remote/index.ts

@@ -0,0 +1,17 @@
+export { GetReleasedGraphStateResult } from './config/graph/get-released-graph-state-result';
+export { GraphStateResult } from './config/graph/graph-state-result';
+export { GetReleasedGraphStates } from './config/graph/get-released-graph-states';
+export { GraphStateKey } from './config/graph/graph-state-key';
+export { GraphState } from './config/graph/graph-state';
+export { RemoteGraphProtocol } from './config/graph/remote-graph-protocol';
+export { RemoteGraphStore } from './config/graph/remote-graph-store';
+
+export { RemoteViewProtocol } from './config/view/remote-view-protocol';
+export { RemoteViewStore } from './config/view/remote-view-store';
+export { ViewResult } from './config/view/view-result';
+
+export { RemoteImageProtocol } from './config/image/remote-image-protocol';
+export { RemoteImageStore } from './config/image/remote-image-store';
+
+export { RemoteVariableCommunicator } from './communication/variable/remote-variable-communicator';
+export { RemoteVariableProtocol } from './communication/variable/remote-variable-protocol';

package/src/service/operation-record/create-operation-record-args.ts

@@ -0,0 +1,6 @@
+import { VariableOptionModel } from './variable-option.model';
+
+export interface CreateOperationRecordArgs {
+    readonly variableOptionModel?: VariableOptionModel;
+    readonly operationDescription: string;
+}

package/src/service/operation-record/index.ts

@@ -0,0 +1,5 @@
+export { CreateOperationRecordArgs } from './create-operation-record-args';
+
+export { OperationRecordService } from './operation-record.service';
+
+export { VariableOptionModel } from './variable-option.model';

package/src/service/operation-record/operation-record.service.ts

@@ -0,0 +1,5 @@
+import { CreateOperationRecordArgs } from './create-operation-record-args';
+
+export interface OperationRecordService {
+    record(args: CreateOperationRecordArgs): void;
+}

package/src/service/operation-record/variable-option.model.ts

@@ -0,0 +1,6 @@
+
+export interface VariableOptionModel {
+    readonly variableName: string;
+    readonly originValue: any;
+    newValue: any;
+}

package/src/service/released-variable/released-variable.service.ts

@@ -0,0 +1,5 @@
+import { Observable } from 'rxjs';
+
+export interface ReleasedVariableService {
+    getVariableWithValueTransform(variableName): Observable<any>;
+}

package/src/service/video/video.service.ts

@@ -0,0 +1,5 @@
+import { VideoUrl } from './video-url';
+
+export interface VideoService {
+    getVideoUrl(tag: string): Promise<VideoUrl>;
+}

package/src/service/weather.service.ts

@@ -0,0 +1,7 @@
+export interface WeatherService {
+
+    getWeatherInfo(): Promise<any>;
+
+    getAirQualityInfo(): Promise<any>;
+
+}

package/src/settings/display-mode.ts

@@ -0,0 +1,12 @@
+export enum DisplayMode {
+
+    /**
+     * 网页版显示模式
+     */
+    Web,
+
+    /**
+     * 移动端显示，优化部分元件在移动端中的显示效果
+     */
+    Mobile
+}

package/src/settings/global-settings.ts

@@ -0,0 +1,11 @@
+import { Injectable } from '@angular/core';
+import { DisplayMode } from './display-mode';
+
+@Injectable()
+export class GlobalSettings {
+
+    /**
+     * 元件展示模式：网页版、移动版
+     */
+    displayMode: DisplayMode;
+}

package/src/settings/view-resize-mode.ts

@@ -0,0 +1,12 @@
+export enum ViewResizeMode {
+
+    /**
+     * 在保持纵横比的同时等比缩放显示所有内容
+     */
+    Uniform,
+
+    /**
+     * 在保持纵横比的同时保证横向显示尽可能多的空间，
+     */
+    HorizontalUniform
+}