doneit-web/src/app/services/functions/file.service.ts

import { Injectable } from '@angular/core';
import { FileLoaderService } from '../file/file-loader.service';
import { FileToBase64Service } from '../file/file-to-base64.service';
import { InAppBrowser } from '@ionic-native/in-app-browser/ngx';
import { ChatService } from '../chat.service';
import { LoadingController, ModalController, Platform } from '@ionic/angular';
import { SearchPage } from 'src/app/pages/search/search.page';
import { ProcessesService } from '../processes.service';
import { ToastService } from '../toast.service';
import { Camera,  CameraResultType, CameraSource, Photo} from '@capacitor/camera';
import { FileType } from 'src/app/models/fileType';

import { Filesystem, Directory } from '@capacitor/filesystem';
const IMAGE_DIR = 'stored-images';


interface LocalFile {
  name: string;
  path: string;
  data: string;
}

@Injectable({
  providedIn: 'root'
})
export class FileService {

  images: LocalFile[] = [];
  capturedImage:any;
  capturedImageTitle:any;
  showLoader: boolean;

  files: Set<File>;
  photos: any[] = [];
  idroom: any;

  downloadProgess = 0;
  downloadFilename: any;

  constructor(
    private fileLoaderService: FileLoaderService,
    private fileToBase64Service: FileToBase64Service,
    private iab: InAppBrowser,
    private chatService: ChatService,
    private modalController: ModalController,
    private processesService: ProcessesService,
    private toastService: ToastService,
    
    private loadingCtrl: LoadingController,
    private platform: Platform,
  ) {}


  convertBlobToBase64 = (blob: Blob) => new Promise((resolve, reject) => {
    const reader = new FileReader;
    reader.onerror = reject;
    reader.onload = () => {
        resolve(reader.result);
    };
    reader.readAsDataURL(blob);
  });


  getFileFromDevice(types: typeof FileType[]) {
    return new Promise<any>((resolve, reject)=>{
      const input = this.fileLoaderService.createInput({
        accept: types
      })
  
      input.onchange = async () => {
        const file = this.fileLoaderService.getFirstFile(input)
        
        resolve(file)
      };
    })
  }


  viewDocumentByUrl(url) {
    const browser = this.iab.create(url,"_parent");
    browser.show();
  }


  async saveImage(photo: Photo) {
    const base64Data = await this.readAsBase64(photo);

    const fileName = new Date().getTime() + '.jpeg';
    const savedFile = await Filesystem.writeFile({
      path: `${IMAGE_DIR}/${fileName}`,
      data: base64Data,
      directory: Directory.Data
    });
    
  }

  //new method 3
  async loadFiles() {

    const loading = await this.loadingCtrl.create({
      message: 'Loading data...',
    });
    await loading.present();

    return new Promise((resolve, reject)=>{
      Filesystem.readdir({
        path: IMAGE_DIR,
        directory: Directory.Data,
      }).then(result => {
        console.log('ALL RESULTS', result.files[0])
        let lastphoto = result.files[result.files.length - 1]
        resolve(lastphoto)
      },
        async (err) => {
          console.log('ERROR FILE DOSENT EXIST', err)
          reject('ERROR FILE DOSENT EXIST')
          // Folder does not yet exists!
          await Filesystem.mkdir({
            path: IMAGE_DIR,
            directory: Directory.Data,
            recursive: true
          });
        }
      ).then(_ => {
        loading.dismiss();
      });
    })
  }


  //new method 2
  private async readAsBase64(photo: Photo) {
    if (this.platform.is('hybrid')) {
      const file = await Filesystem.readFile({
        path: photo.path
      });

      return file.data;
    }
    else {
      // Fetch the photo, read as a blob, then convert to base64 format
      const response = await fetch(photo.webPath);
      const blob = await response.blob();

      return await this.convertBlobToBase64(blob) as string;
    }
  }


  async readFile(filePath) {
    return await Filesystem.readFile({
      path: filePath,
      directory: Directory.Data,
    });
  }

  //new method 4
  async loadFileData(fileName: string) {
    console.log('ALL PHOTOT FILE', fileName)
    // for (let f of fileNames) {
    const filePath = `${IMAGE_DIR}/${fileName}`;

    const readFile = await this.readFile(filePath)

    const image ={
      name: fileName,
      path: filePath,
      data: `data:image/jpeg;base64,${readFile.data}`,
    };

    console.log('ALL IMAGE', image)

    const capturedImage = image.data

    const capturedImageTitle = new Date().getTime() + '.jpeg';


    return { capturedImage, capturedImageTitle}

  }

}