async uploadPhoto(imageFileUri: any): Promise<void> {
    this.myPhoto = imageFileUri;

    this.error = null;
    this.loading = this.loadingCtrl.create({
      content: 'Uploading...'
    });

    await this.loading.present();

    const fileTransfer: FileTransferObject = this.transfer.create();

    const fileEntry = await this.file.resolveLocalFilesystemUrl(imageFileUri);

    const options: FileUploadOptions = {
      fileKey: 'file',
      fileName: fileEntry.name,
      headers: {}
    };

    try {
      const result = await fileTransfer.upload(imageFileUri, 'http://192.168.178.84:8080/upload', options);
      console.log(result.bytesSent);
      console.log(result.responseCode);
      this.showToast(true);
    }
    catch (e) {
      console.log(e);
      this.showToast(false);
    }
    finally {
      this.loading.dismiss();
    }
  }

const existsFile = (path, filename) =>
	FILE.checkFile(path, filename).catch((e) => {
		if (e.code === 1) {
			return false
		}
		return Bluebird.reject(e)
	})

 return new Promise<void>((resolve, reject) => {
   this.file.removeFile(this.dir.nativeURL, k).then( () => {
     this.log.debug('File removed: ' + k);
     resolve();
   }).catch( (e) => {
     this.log.error(e);
     reject(e);
   });
 });

		return Bluebird.try(async () => {
			const cacheDir = await getCacheDirectory()
			const blobFile = idToFileName(blobID)
			const path = isAndroid() ? `${FILE.externalRootDirectory}Download/` : `${FILE.documentsDirectory}`
			const existsSource = await existsFile(cacheDir, blobFile)
			const existsDestination = await existsFile(path, filename)

			if (!existsSource) {
				throw new Error(`cannot copy blob, blob does not exist: ${filename}`)
			}

			if (existsDestination) {
				await FILE.removeFile(path, filename)
			}

			await FILE.copyFile(cacheDir, blobFile, path, filename)

			return `${path}${filename}`
		})

  // http://ngcordova.com/docs/plugins/file/
  public copyFile(fullFilePath:string, destinationDirectory: string, newFileName? :string) : void {
    let fileName: string = fullFilePath.split('/').pop();
    let cachedImagePath: string = fullFilePath.substring(0, fullFilePath.lastIndexOf('/') + 1);
    let newName: string = newFileName ? newFileName: fileName;

    this.file.copyFile(cachedImagePath, fileName, destinationDirectory, newName).then((result: any) => {
      console.log('File: ' + fileName + ' copied to path: ' + destinationDirectory);
    }).catch(error => {
      console.log('Error when copy file: ' + fileName + ' to path: ' + destinationDirectory + ' - ' + error.message);
    });
  }

 // here is the method is used to write a file in storage
 // https://www.c-sharpcorner.com/article/how-to-save-picture-to-specific-path-in-ionic-3-using-native-camera-plugin/
 public writeFileFromBase64(base64Data: any, filePath: string, fileName?: string): void {
   let contentType: any = this.getContentType(base64Data);
   let dataBlob: Blob = this.base64toBlob(base64Data.split(',')[1], contentType);
   // TODO dummy random name implementation
   let newFileName: string = fileName ? fileName : Math.floor(Math.random()*Number.MAX_SAFE_INTEGER)+'.jpeg';
   this.file.writeFile(filePath, newFileName, dataBlob, contentType).then((success) => {
     console.log('File Writed Successfully to location: ' + filePath + newFileName);
   }).catch((err) => {
     console.log('Error Occured While Writing File: '+ filePath + newFileName, err.message);
   })
 }

		}).catch(error => {
			return FILE.createDir(basePath, BLOB_CACHE_DIR, true).then(dirEntry => {
				return desiredPath
			}).catch(error => {
				throw new Error('Could not create blob cache directory.')
			})
		})

 return new Observable(observer => {
   this.file.resolveDirectoryUrl(this.file.dataDirectory).then((directory: DirectoryEntry) => {
     this.file.getDirectory(directory, dirPath, {})
       .then((dir: DirectoryEntry) => observer.next(dir))
       .catch((error) => observer.error(error));
   });
 });

 abrir(directorio){
   console.log(directorio.fullPath)
   this.file.listDir(this.file.externalRootDirectory, directorio.fullPath.substring(1, directorio.fullPath.length)).then(
     (list) => {
       console.log(list);
       this.directorios = list;
     }
   ).catch(e => console.log(e));
 }

  retroceder(){
    console.log(this.file.externalRootDirectory)
    this.file.listDir(this.file.externalRootDirectory, '').then(
      (list) => {
        console.log(list);
        this.directorios = list;
      }
    ).catch(e => console.log(e));

  }