318 lines
7.3 KiB
TypeScript
Raw Normal View History

import { Observable, Subject } from 'rxjs';
2019-11-01 11:25:54 +09:00
import {
NativeService,
WindowState,
2019-11-09 17:29:02 +09:00
NotificationRequest,
2019-12-12 17:15:09 +09:00
WindowIdle,
UpdateInfo,
2019-12-17 16:39:02 +09:00
UpdateCheckConfig,
2019-12-24 11:41:50 +09:00
NotificationType,
NativePathName,
NativeType
2019-11-01 11:25:54 +09:00
} from '@ucap-webmessenger/native';
import { HttpClient } from '@angular/common/http';
2019-12-24 11:41:50 +09:00
import { map, share, take } from 'rxjs/operators';
2019-11-11 18:09:47 +09:00
import { TranslateLoader } from '@ngx-translate/core';
import { TranslateLoaderService } from '../translate/browser-loader';
import { NotificationService } from '../notification/notification.service';
2019-11-12 18:54:21 +09:00
import { Injectable } from '@angular/core';
2019-11-19 16:44:50 +09:00
import { FileUtil, StatusCode } from '@ucap-webmessenger/core';
2019-11-11 15:53:39 +09:00
@Injectable({
2019-11-19 16:44:50 +09:00
providedIn: 'root'
2019-11-11 15:53:39 +09:00
})
2019-11-12 18:54:21 +09:00
export class BrowserNativeService extends NativeService {
2019-11-11 18:09:47 +09:00
private notificationService: NotificationService;
private chatOpenRoomSubject: Subject<string> | null = null;
private chatOpenRoom$: Observable<string> | null = null;
2019-12-17 16:39:02 +09:00
private msgOpenMessageSubject: Subject<string> | null = null;
private msgOpenMessage$: Observable<string> | null = null;
2019-12-24 11:41:50 +09:00
type(): NativeType {
return NativeType.Browser;
}
2019-11-11 18:09:47 +09:00
postAppInit(): void {
this.notificationService.requestPermission();
}
2019-11-19 16:44:50 +09:00
logout(): Observable<void> {
return new Observable<void>(subscriber => {
try {
} catch (error) {
subscriber.error(error);
} finally {
subscriber.complete();
}
});
}
changeStatus(): Observable<StatusCode> {
return new Observable<StatusCode>(subscriber => {
try {
} catch (error) {
subscriber.error(error);
} finally {
subscriber.complete();
}
});
}
showSetting(): Observable<void> {
return new Observable<void>(subscriber => {
try {
} catch (error) {
subscriber.error(error);
} finally {
subscriber.complete();
}
});
}
getNetworkInfo(): Promise<any> {
return new Promise<any>((resolve, reject) => {
resolve([{ ip: 'Browser', mac: 'browser' }]);
});
}
2020-01-13 15:41:35 +09:00
getVersionInfo(): Promise<string> {
return new Promise<any>((resolve, reject) => {
resolve('');
});
}
clearAppStorage(): void {}
2019-12-17 17:27:08 +09:00
changeAutoLaunch(autoLaunch: boolean): Promise<boolean> {
return new Promise<boolean>((resolve, reject) => {
resolve(true);
});
}
2019-12-18 17:11:58 +09:00
changeStartupHideWindow(startupHideWindow: boolean): Promise<boolean> {
return new Promise<boolean>((resolve, reject) => {
resolve(true);
});
}
changeDownloadPath(downloadPath: string): Promise<string> {
return new Promise<string>((resolve, reject) => {
resolve(downloadPath);
});
}
2019-11-11 18:09:47 +09:00
notify(noti: NotificationRequest): void {
this.notificationService.notify(noti, () => {
window.focus();
2019-12-17 16:39:02 +09:00
if (noti.type === NotificationType.Event) {
this.chatOpenRoomSubject.next(noti.seq);
} else if (noti.type === NotificationType.Message) {
this.msgOpenMessageSubject.next(noti.seq);
}
});
2019-11-11 18:09:47 +09:00
}
2019-11-09 17:29:02 +09:00
closeAllNotify(): void {}
2020-01-23 14:15:08 +09:00
checkForUpdates(currentVersion: string): void {}
2019-12-12 17:15:09 +09:00
checkForInstantUpdates(config: UpdateCheckConfig): Observable<UpdateInfo> {
return new Observable<UpdateInfo>(subscriber => {
try {
} catch (error) {
subscriber.error(error);
} finally {
subscriber.complete();
}
});
}
applyInstantUpdates(): void {}
showImageViewer(): void {}
2019-11-13 15:28:33 +09:00
readFile(path: string): Promise<Buffer> {
return new Promise<Buffer>((resolve, reject) => {
2019-12-24 11:41:50 +09:00
this.httpClient
.get(path, { responseType: 'arraybuffer' })
.pipe(take(1))
.subscribe(arraybuffer => {
resolve(Buffer.from(arraybuffer));
});
2019-11-13 15:28:33 +09:00
});
}
2019-11-07 11:37:33 +09:00
saveFile(
buffer: Buffer,
fileName: string,
2019-11-13 15:28:33 +09:00
mimeType: string,
2019-11-07 11:37:33 +09:00
path?: string
2019-11-13 15:28:33 +09:00
): Promise<string> {
return new Promise<string>((resolve, reject) => {
try {
FileUtil.save(buffer, fileName, mimeType).then(fn => {
resolve(fn);
});
} catch (error) {
reject(error);
}
});
}
openDefaultDownloadFolder(): Promise<boolean> {
return new Promise<boolean>((resolve, reject) => {
resolve(true);
});
}
openTargetFolder(folderPath?: string, make?: boolean): Promise<boolean> {
return new Promise<boolean>((resolve, reject) => {
resolve(true);
});
}
openTargetItem(filePath?: string): Promise<boolean> {
return new Promise<boolean>((resolve, reject) => {
resolve(true);
});
}
2019-12-24 11:41:50 +09:00
getPath(name: NativePathName): Promise<string> {
return new Promise<string>((resolve, reject) => {
resolve('');
});
}
2019-12-24 16:16:13 +09:00
selectDirectory(): Promise<string> {
return new Promise<string>((resolve, reject) => {
resolve('');
});
}
selectSaveFilePath(
defaultPath?: string
): Promise<{
canceled: boolean;
filePath: string;
}> {
return new Promise<{
canceled: boolean;
filePath: string;
}>((resolve, reject) => {
resolve({
canceled: false,
filePath: ''
});
});
}
2020-01-09 18:52:08 +09:00
executeProcess(executableName: string): Promise<number> {
return new Promise<number>((resolve, reject) => {
resolve(-1);
});
}
windowStateChanged(): Observable<WindowState> {
return new Observable<WindowState>(subscriber => {
try {
subscriber.next(WindowState.Normal);
} catch (error) {
subscriber.error(error);
} finally {
subscriber.complete();
}
});
}
windowClose(): void {}
windowMinimize(): void {}
windowMaximize(): void {}
getWindowState(): WindowState {
return WindowState.Normal;
}
2020-01-23 11:23:31 +09:00
appExit(): void {}
2020-03-12 16:16:04 +09:00
appLogging(error: any): void {
console.error('[G]', error);
}
2020-01-23 11:23:31 +09:00
2020-01-13 13:55:54 +09:00
zoomTo(factor: number): Promise<number> {
return new Promise<number>((resolve, reject) => {
resolve(-1);
});
}
idleStateChanged(): Observable<WindowIdle> {
return new Observable<WindowIdle>(subscriber => {
try {
} catch (error) {
subscriber.error(error);
} finally {
subscriber.complete();
}
});
}
idleStateStop(): void {}
2020-01-10 16:49:53 +09:00
changeLimitOfIdleState(limitTime: number): void {}
chatOpenRoom(): Observable<string> {
if (!this.chatOpenRoomSubject) {
this.chatOpenRoomSubject = new Subject<WindowIdle>();
this.chatOpenRoom$ = this.chatOpenRoomSubject
.asObservable()
.pipe(share());
}
return this.chatOpenRoom$;
}
2019-12-17 16:39:02 +09:00
msgOpenMessage(): Observable<string> {
if (!this.msgOpenMessageSubject) {
this.msgOpenMessageSubject = new Subject<WindowIdle>();
this.msgOpenMessage$ = this.msgOpenMessageSubject
.asObservable()
.pipe(share());
}
return this.msgOpenMessage$;
}
2019-11-11 18:09:47 +09:00
getTranslateLoader(prefix?: string, suffix?: string): TranslateLoader {
return new TranslateLoaderService(this, prefix, suffix);
}
2020-02-12 17:25:06 +09:00
openDefaultBrowser(
url: string,
options?: { name?: string; features?: string; replace?: boolean }
): void {
2019-11-19 19:34:53 +09:00
open(url);
}
2020-02-04 17:13:09 +09:00
readFromClipboard(): Promise<{
text?: string;
rtf?: string;
html?: string;
image?: Buffer;
imageDataUrl?: string;
}> {
return new Promise<{
text?: string;
rtf?: string;
html?: string;
image?: Buffer;
imageDataUrl?: string;
}>((resolve, reject) => {
resolve({});
});
}
2019-11-11 18:09:47 +09:00
constructor(private httpClient: HttpClient) {
2019-11-12 18:54:21 +09:00
super();
2019-11-11 18:09:47 +09:00
this.notificationService = new NotificationService();
}
}