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

import { ipcRenderer, remote } from 'electron';

import { Observable, Subject } from 'rxjs';

import {
  NativeService,
  WindowState,
  NotificationRequest,
  WindowIdle,
} from '@ucap-webmessenger/native';
import { share } from 'rxjs/operators';
import {
  NotificationChannel,
  UpdaterChannel,
  FileChannel,
  WindowStateChannel,
  IdleStateChannel,
  ChatChannel,
} from '../types/channel.type';
import { Injectable } from '@angular/core';
import { TranslateLoaderService } from '../translate/electron-loader';
import { TranslateLoader } from '@ngx-translate/core';

@Injectable({
  providedIn: 'root',
})
export class ElectronNativeService implements NativeService {
  private ipcRenderer: typeof ipcRenderer;
  private remote: typeof remote;

  private windowStateChangedSubject: Subject<WindowState> | null = null;
  private windowStateChanged$: Observable<WindowState> | null = null;

  private idleStateChangedSubject: Subject<WindowIdle> | null = null;
  private idleStateChanged$: Observable<WindowIdle> | null = null;

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

  postAppInit(): void {}

  notify(noti: NotificationRequest): void {
    this.ipcRenderer.send(NotificationChannel.Notify, noti);
  }

  closeAllNotify(): void {
    this.ipcRenderer.send(NotificationChannel.CloseAllNotify);
  }

  checkForUpdates(): Observable<boolean> {
    return new Observable<boolean>(subscriber => {
      try {
        subscriber.next(this.ipcRenderer.sendSync(UpdaterChannel.Check));
      } catch (error) {
        subscriber.error(error);
      } finally {
        subscriber.complete();
      }
    });
  }

  showImageViewer(): void {
    this.ipcRenderer.send(FileChannel.ShowImageViewer);
  }

  readFile(path: string): Observable<Buffer> {
    return new Observable<Buffer>(subscriber => {
      try {
        subscriber.next(this.ipcRenderer.sendSync(FileChannel.ReadFile, path));
      } catch (error) {
        subscriber.error(error);
      } finally {
        subscriber.complete();
      }
    });
  }

  saveFile(
    buffer: Buffer,
    fileName: string,
    path?: string
  ): Observable<string> {
    return new Observable<string>(subscriber => {
      try {
        subscriber.next(
          this.ipcRenderer.sendSync(
            FileChannel.SaveFile,
            buffer,
            fileName,
            path
          )
        );
      } catch (error) {
        subscriber.error(error);
      } finally {
        subscriber.complete();
      }
    });
  }

  windowStateChanged(): Observable<WindowState> {
    if (!this.windowStateChangedSubject) {
      this.windowStateChangedSubject = new Subject<WindowState>();
      this.windowStateChanged$ = this.windowStateChangedSubject
        .asObservable()
        .pipe(share());
    }

    this.ipcRenderer.on(
      WindowStateChannel.Changed,
      (event: any, windowState: WindowState) => {
        this.windowStateChangedSubject.next(windowState);
      }
    );
    return this.windowStateChanged$;
  }

  windowClose(): void {
    const currentWindow = this.remote.getCurrentWindow();
    if (!currentWindow) {
      return;
    }

    currentWindow.close();
  }

  windowMinimize(): void {
    const currentWindow = this.remote.getCurrentWindow();
    if (!currentWindow) {
      return;
    }

    currentWindow.minimize();
  }

  windowMaximize(): void {
    const currentWindow = this.remote.getCurrentWindow();
    if (!currentWindow) {
      return;
    }

    if (currentWindow.isMaximized()) {
      currentWindow.unmaximize();
    } else {
      currentWindow.maximize();
    }
  }

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

    this.ipcRenderer.send(IdleStateChannel.StartCheck);

    this.ipcRenderer.on(
      IdleStateChannel.Changed,
      (event: any, idleState: WindowIdle) => {
        this.idleStateChangedSubject.next(idleState);
      }
    );
    return this.idleStateChanged$;
  }

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

    this.ipcRenderer.on(ChatChannel.OpenRoom, (event: any, roomSeq: string) => {
      this.chatOpenRoomSubject.next(roomSeq);
    });
    return this.chatOpenRoom$;
  }

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

  get isElectron() {
    return window && (window as any).process && (window as any).process.type;
  }

  constructor() {
    if (this.isElectron) {
      this.ipcRenderer = (window as any).require('electron').ipcRenderer;
      this.remote = (window as any).require('electron').remote;
    }
  }
}