next-ucap-messenger/projects/ucap-webmessenger-native-browser/src/lib/services/browser-native.service.ts

import { Observable, Subject } from 'rxjs';

import {
  NativeService,
  WindowState,
  NotificationRequest,
  WindowIdle,
} from '@ucap-webmessenger/native';
import { HttpClient } from '@angular/common/http';
import { map, share } from 'rxjs/operators';
import { TranslateLoader } from '@ngx-translate/core';
import { TranslateLoaderService } from '../translate/browser-loader';
import { NotificationService } from '../notification/notification.service';
import { Injectable } from '@angular/core';

@Injectable({
  providedIn: 'root',
})
export class BrowserNativeService extends NativeService {
  private notificationService: NotificationService;

  private chatOpenRoomSubject: Subject<string> | null = null;
  private chatOpenRoom$: Observable<string> | null = null;

  postAppInit(): void {
    this.notificationService.requestPermission();
  }

  notify(noti: NotificationRequest): void {
    this.notificationService.notify(noti, () => {
      window.focus();
      this.chatOpenRoomSubject.next(noti.roomSeq);
    });
  }
  closeAllNotify(): void {}

  checkForUpdates(): Observable<boolean> {
    return new Observable<boolean>(subscriber => {
      try {
        subscriber.next(false);
      } catch (error) {
        subscriber.error(error);
      } finally {
        subscriber.complete();
      }
    });
  }

  showImageViewer(): void {}

  readFile(path: string): Observable<Buffer> {
    return this.httpClient.get(path, { responseType: 'arraybuffer' }).pipe(
      map(arrayBuffer => {
        return Buffer.from(arrayBuffer);
      })
    );
  }

  saveFile(
    buffer: Buffer,
    fileName: string,
    path?: string
  ): Observable<string> {
    return this.httpClient.post<string>(path, buffer, {});
  }

  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 {}

  idleStateChanged(): Observable<WindowIdle> {
    return new Observable<WindowIdle>(subscriber => {
      try {
        subscriber.next(WindowIdle.Active);
      } catch (error) {
        subscriber.error(error);
      } finally {
        subscriber.complete();
      }
    });
  }

  chatOpenRoom(): Observable<string> {
    if (!this.chatOpenRoomSubject) {
      this.chatOpenRoomSubject = new Subject<WindowIdle>();
      this.chatOpenRoom$ = this.chatOpenRoomSubject
        .asObservable()
        .pipe(share());
    }

    return this.chatOpenRoom$;
  }

  getTranslateLoader(prefix?: string, suffix?: string): TranslateLoader {
    return new TranslateLoaderService(this, prefix, suffix);
  }

  constructor(private httpClient: HttpClient) {
    super();
    this.notificationService = new NotificationService();
  }
}