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

import { ipcRenderer, remote, IpcRendererEvent } from 'electron';

import { Observable, Subject } from 'rxjs';

import {
  NativeService,
  WindowState,
  NotiRequest
} from '@ucap-webmessenger/native';
import { Channel } from '../types/channel.type';
import { share } from 'rxjs/operators';

export class ElectronNativeService implements NativeService {
  private windowStateChangedSubject: Subject<WindowState> | null = null;
  private windowStateChanged$: Observable<WindowState> | null = null;

  showNotify(noti: NotiRequest): void {
    ipcRenderer.send(
      Channel.showNotify,
      noti.roomSeq,
      noti.title,
      noti.contents,
      noti.image,
      noti.useSound,
      noti.interval
    );
  }

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

  showImageViewer(): void {
    ipcRenderer.send(Channel.showImageViewer);
  }

  readFile(path: string): Observable<Buffer> {
    return new Observable<Buffer>(subscriber => {
      try {
        subscriber.next(ipcRenderer.sendSync(Channel.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(
          ipcRenderer.sendSync(Channel.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());
    }

    ipcRenderer.on(
      Channel.windowStateChanged,
      (event: IpcRendererEvent, windowState: WindowState) => {
        console.log('windowStateChanged', windowState);
        this.windowStateChangedSubject.next(windowState);
      }
    );
    return this.windowStateChanged$;
  }

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

    currentWindow.close();
  }

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

    currentWindow.minimize();
  }

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

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

  constructor() {}
}