@hxa-rn/rn-fetch-blob 0.12.0

package/harmony/fetch_blob/src/main/ets/RNFetchBlobFS.ts

@@ -0,0 +1,673 @@
+/*
+ * Copyright (c) 2026. All rights reserved.
+ * HarmonyOS adaptation of rn-fetch-blob (RNFetchBlob TurboModule).
+ *
+ * File system operations aligned with the original library's FS module.
+ * All file APIs use @ohos.file.fs (Core File Kit) with sandbox paths.
+ */
+
+import common from '@ohos.app.ability.common';
+import fs from '@ohos.file.fs';
+import { BusinessError } from '@ohos.base';
+import buffer from '@ohos.buffer';
+import hash from '@ohos.file.hash';
+import statvfs from '@ohos.file.statvfs';
+import { filePreview } from '@kit.PreviewKit';
+import fileUri from '@ohos.file.fileuri';
+import Logger from './Logger';
+import hilog from '@ohos.hilog';
+
+const DOMAIN: number = 0xFF00;
+const TAG: string = 'RNFetchBlob';
+
+const FILE_OR_DIR_NOT_EXIST: number = 13900002;
+const FOLDER_EXISTS: number = 13900015;
+
+/**
+ * Callback types used across FS methods. `err` is a human readable message or
+ * null; `data` is the result object (stat / dir entries / df result).
+ */
+export type ErrorCallback = (err: string | null) => void;
+export type DataErrorCallback = (err: string | null, data?: Object | null) => void;
+
+/**
+ * Stat object shape expected by the JS side (RNFetchBlobStat in fs.js).
+ */
+export class RNFetchBlobStat {
+  filename: string = '';
+  path: string = '';
+  type: string = '';
+  size: number = 0;
+  lastModified: number = 0;
+}
+
+export default class RNFetchBlobFS {
+  private context: common.UIAbilityContext;
+
+  constructor(context: common.UIAbilityContext) {
+    this.context = context;
+  }
+
+  getSystemFolders(): Object {
+    let res: Record<string, Object> = {};
+    res['CacheDir'] = this.context.cacheDir;
+    res['DocumentDir'] = this.context.filesDir;
+    res['DownloadDir'] = this.context.filesDir;
+    res['MainBundleDir'] = this.context.bundleCodeDir;
+    // Align with Android getExternalFilesDir(type): return typed sandbox
+    // subdirs and create them if missing (string concat alone does not).
+    let movieDir: string = this.context.filesDir + '/movie';
+    let musicDir: string = this.context.filesDir + '/music';
+    let pictureDir: string = this.context.filesDir + '/picture';
+    this.ensureDirExists(movieDir);
+    this.ensureDirExists(musicDir);
+    this.ensureDirExists(pictureDir);
+    res['MovieDir'] = movieDir;
+    res['MusicDir'] = musicDir;
+    res['PictureDir'] = pictureDir;
+    // Android-only / iOS-only constants have no sandbox equivalent on HarmonyOS.
+    res['DCIMDir'] = '';
+    res['SDCardDir'] = '';
+    res['SDCardApplicationDir'] = '';
+    res['LibraryDir'] = '';
+    return res;
+  }
+
+  private ensureDirExists(path: string): void {
+    try {
+      if (fs.accessSync(path)) {
+        return;
+      }
+    } catch (accessErr) {
+      // path does not exist yet
+    }
+    try {
+      fs.mkdirSync(path, true);
+    } catch (mkdirErr) {
+      let e: BusinessError = mkdirErr as BusinessError;
+      if (e.code !== FOLDER_EXISTS) {
+        hilog.error(DOMAIN, TAG, '%{public}s',
+          `ensureDirExists failed: ${e.message}, code ${e.code}, path ${path}`);
+      }
+    }
+  }
+
+  createFile(path: string, data: string, encoding: string): Promise<string> {
+    return new Promise((resolve, reject) => {
+      let file: fs.File | undefined = undefined;
+      try {
+        if (encoding.toLowerCase() !== 'utf8' && encoding.toLowerCase() !== 'utf-8') {
+          reject(null);
+          return;
+        }
+        // Align with Android File.createNewFile / EEXIST: createFile must not overwrite.
+        let exists: boolean = false;
+        try {
+          exists = fs.accessSync(path);
+        } catch (e) {
+          exists = false;
+        }
+        if (exists) {
+          reject(`File \`${path}\` already exists`);
+          return;
+        }
+        file = fs.openSync(path, fs.OpenMode.CREATE | fs.OpenMode.READ_WRITE);
+        fs.writeSync(file.fd, data, { encoding: 'utf-8' });
+        resolve(path);
+      } catch (err) {
+        let e: BusinessError = err as BusinessError;
+        hilog.error(DOMAIN, TAG, '%{public}s', `createFile failed with error message: ${e.message}, error code: ${e.code}`);
+        reject(e.message);
+      } finally {
+        if (file !== undefined) {
+          try {
+            fs.closeSync(file);
+          } catch (e) {
+            let ce: BusinessError = e as BusinessError;
+            hilog.error(DOMAIN, TAG, '%{public}s', 'close failed: ' + ce.message);
+          }
+        }
+      }
+    });
+  }
+
+  createFileASCII(path: string, data: number[]): Promise<void> {
+    return new Promise((resolve, reject) => {
+      let file: fs.File | undefined = undefined;
+      try {
+        // Align with Android createFileASCII: refuse if destination already exists.
+        let exists: boolean = false;
+        try {
+          exists = fs.accessSync(path);
+        } catch (e) {
+          exists = false;
+        }
+        if (exists) {
+          reject(`create file error: failed to create file at path \`${path}\`, file already exists.`);
+          return;
+        }
+        file = fs.openSync(path, fs.OpenMode.CREATE | fs.OpenMode.READ_WRITE);
+        let buf = buffer.from(data);
+        let writeLen: number = fs.writeSync(file.fd, buf.toString('utf-8'), { encoding: 'utf-8' });
+        if (writeLen < 0) {
+          reject('write failed');
+        } else {
+          Logger.info(`createFileASCII write data to file succeed and size is: ${writeLen}`);
+          resolve();
+        }
+      } catch (err) {
+        let e: BusinessError = err as BusinessError;
+        hilog.error(DOMAIN, TAG, '%{public}s', `createFileASCII failed with error message: ${e.message}, error code: ${e.code}`);
+        reject(e.message);
+      } finally {
+        if (file !== undefined) {
+          try {
+            fs.closeSync(file);
+          } catch (e) {
+            let ce: BusinessError = e as BusinessError;
+            hilog.error(DOMAIN, TAG, '%{public}s', 'close failed: ' + ce.message);
+          }
+        }
+      }
+    });
+  }
+
+  writeFile(path: string, encoding: string, data: string, append: boolean): Promise<number> {
+    return new Promise((resolve, reject) => {
+      let file: fs.File | undefined = undefined;
+      try {
+        if (append) {
+          file = fs.openSync(path, fs.OpenMode.READ_WRITE | fs.OpenMode.APPEND);
+        } else {
+          // Align with Android FileOutputStream(path, false): truncate then write.
+          file = fs.openSync(path, fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE | fs.OpenMode.TRUNC);
+        }
+        let writeLen: number = -1;
+        if (encoding.toLowerCase() === 'base64') {
+          let base64Reg = new RegExp('data:image/\\w+;base64,');
+          let base64Data = data.replace(base64Reg, '');
+          let dataBuffer = buffer.from(base64Data, 'base64');
+          writeLen = fs.writeSync(file.fd, dataBuffer.buffer);
+        } else {
+          writeLen = fs.writeSync(file.fd, data, { encoding: encoding === 'utf8' ? 'utf-8' : encoding });
+        }
+        Logger.info(`writeFile succeed and size is: ${writeLen}`);
+        resolve(writeLen);
+      } catch (err) {
+        let e: BusinessError = err as BusinessError;
+        if (e.code === FILE_OR_DIR_NOT_EXIST) {
+          try {
+            let dir = path.substring(0, path.lastIndexOf('/'));
+            fs.mkdirSync(dir, true);
+            this.writeFile(path, encoding, data, append).then((len: number) => {
+              resolve(len);
+            }).catch((e2: Object) => {
+              reject(e2);
+            });
+          } catch (e3) {
+            let e4: BusinessError = e3 as BusinessError;
+            hilog.error(DOMAIN, TAG, '%{public}s', `writeFile mkdir failed: ${e4.message}, code ${e4.code}`);
+            reject(`writeFile failed with error message: ${e4.message}, error code: ${e4.code}`);
+          }
+        } else {
+          hilog.error(DOMAIN, TAG, '%{public}s', `writeFile failed with error message: ${e.message}, error code: ${e.code}`);
+          reject(`writeFile failed with error message: ${e.message}, error code: ${e.code}`);
+        }
+      } finally {
+        if (file !== undefined) {
+          try {
+            fs.closeSync(file);
+          } catch (e) {
+            let ce: BusinessError = e as BusinessError;
+            hilog.error(DOMAIN, TAG, '%{public}s', 'close failed: ' + ce.message);
+          }
+        }
+      }
+    });
+  }
+
+  writeFileArray(path: string, data: number[], append: boolean): Promise<number> {
+    return new Promise((resolve, reject) => {
+      let file: fs.File | undefined = undefined;
+      try {
+        let buf = buffer.from(data);
+        if (append) {
+          file = fs.openSync(path, fs.OpenMode.READ_WRITE | fs.OpenMode.APPEND);
+        } else {
+          // Align with Android FileOutputStream(path, false): truncate then write.
+          file = fs.openSync(path, fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE | fs.OpenMode.TRUNC);
+        }
+        let writeLen: number = fs.writeSync(file.fd, buf.toString('utf-8'), { encoding: 'utf-8' });
+        Logger.info(`writeFileArray succeed and size is: ${writeLen}`);
+        resolve(writeLen);
+      } catch (err) {
+        let e: BusinessError = err as BusinessError;
+        hilog.error(DOMAIN, TAG, '%{public}s', `writeFileArray failed with error message: ${e.message}, error code: ${e.code}`);
+        reject(`writeFileArray failed with error message: ${e.message}, error code: ${e.code}`);
+      } finally {
+        if (file !== undefined) {
+          try {
+            fs.closeSync(file);
+          } catch (e) {
+            let ce: BusinessError = e as BusinessError;
+            hilog.error(DOMAIN, TAG, '%{public}s', 'close failed: ' + ce.message);
+          }
+        }
+      }
+    });
+  }
+
+  readFile(path: string, encoding: string): Promise<Object> {
+    return new Promise((resolve, reject) => {
+      let file: fs.File | undefined = undefined;
+      try {
+        let fileInfo = fs.statSync(path);
+        file = fs.openSync(path, fs.OpenMode.READ_ONLY);
+        let buf = new ArrayBuffer(fileInfo.size);
+        let readLen: number = fs.readSync(file.fd, buf);
+        let bytes = buffer.from(buf, 0, readLen);
+        let enc: string = encoding.toLowerCase();
+        if (enc === 'base64') {
+          resolve(bytes.toString('base64'));
+        } else if (enc === 'ascii') {
+          let ascUInt8Array: Uint8Array = new Uint8Array(bytes.buffer);
+          let ascArr: number[] = Array.from(ascUInt8Array);
+          resolve(ascArr);
+        } else {
+          resolve(bytes.toString('utf-8'));
+        }
+      } catch (err) {
+        let e: BusinessError = err as BusinessError;
+        hilog.error(DOMAIN, TAG, '%{public}s', `readFile failed with error message: ${e.message}, error code: ${e.code}`);
+        reject(`readFile failed with error message: ${e.message}, error code: ${e.code}`);
+      } finally {
+        if (file !== undefined) {
+          try {
+            fs.closeSync(file);
+          } catch (e) {
+            let ce: BusinessError = e as BusinessError;
+            hilog.error(DOMAIN, TAG, '%{public}s', 'close failed: ' + ce.message);
+          }
+        }
+      }
+    });
+  }
+
+  unlink(path: string, callback: ErrorCallback): void {
+    try {
+      fs.unlink(path, (err: BusinessError) => {
+        if (err) {
+          hilog.error(DOMAIN, TAG, '%{public}s', `remove file failed with error message: ${err.message}`);
+          callback(`remove file failed with error message: ${err.message}`);
+        } else {
+          Logger.info('remove file succeed');
+          callback(null);
+        }
+      });
+    } catch (err) {
+      let e: BusinessError = err as BusinessError;
+      let errMsg = `unlink failed with error message: ${e.message}, error code: ${e.code}`;
+      hilog.error(DOMAIN, TAG, '%{public}s', errMsg);
+      callback(errMsg);
+    }
+  }
+
+  removeSession(paths: string[], callback: ErrorCallback): void {
+    // Align with Android removeSession: skip missing paths; only fail when an
+    // existing file cannot be deleted.
+    try {
+      let failuresToDelete: string[] = [];
+      for (let i = 0; i < paths.length; i++) {
+        let p: string = paths[i];
+        let exists: boolean = false;
+        try {
+          exists = fs.accessSync(p);
+        } catch (accessErr) {
+          exists = false;
+        }
+        if (!exists) {
+          continue;
+        }
+        try {
+          fs.unlinkSync(p);
+        } catch (unlinkErr) {
+          let e: BusinessError = unlinkErr as BusinessError;
+          if (e.code === FILE_OR_DIR_NOT_EXIST) {
+            continue;
+          }
+          hilog.error(DOMAIN, TAG, '%{public}s',
+            `removeSession unlink failed: ${e.message}, code ${e.code}`);
+          failuresToDelete.push(p);
+        }
+      }
+      if (failuresToDelete.length === 0) {
+        callback(null);
+      } else {
+        callback('Failed to delete: ' + failuresToDelete.join(', '));
+      }
+    } catch (err) {
+      let e: BusinessError = err as BusinessError;
+      callback(e.message);
+    }
+  }
+
+  cp(path: string, dest: string, callback: DataErrorCallback): void {
+    try {
+      if (fs.accessSync(path)) {
+        fs.copyFileSync(path, dest);
+        callback(null, '');
+      } else {
+        callback('file is not exist', null);
+      }
+    } catch (err) {
+      hilog.error(DOMAIN, TAG, '%{public}s', 'cp failed');
+      callback('cp failed', null);
+    }
+  }
+
+  mv(path: string, dest: string, callback: DataErrorCallback): void {
+    try {
+      fs.moveFileSync(path, dest);
+      callback(null, '');
+    } catch (err) {
+      let e: BusinessError = err as BusinessError;
+      let errMsg = `move file failed with error message: ${e.message}, error code: ${e.code}`;
+      hilog.error(DOMAIN, TAG, '%{public}s', errMsg);
+      callback(errMsg, null);
+    }
+  }
+
+  mkdir(path: string): Promise<void> {
+    return new Promise((resolve, reject) => {
+      try {
+        fs.mkdir(path, true, (err: BusinessError) => {
+          if (err) {
+            if (err.code === FOLDER_EXISTS) {
+              reject('floder exists');
+            } else {
+              reject(`Directory could not be created ${err.message} ${err.code}`);
+            }
+          } else {
+            resolve();
+          }
+        });
+      } catch (err) {
+        let e: BusinessError = err as BusinessError;
+        hilog.error(DOMAIN, TAG, '%{public}s', `mkdir failed: ${e.message}, code ${e.code}`);
+        reject(`Directory could not be created ${e.message} ${e.code}`);
+      }
+    });
+  }
+
+  ls(path: string): Promise<string[]> {
+    return new Promise((resolve, reject) => {
+      try {
+        let exists: boolean = false;
+        try {
+          exists = fs.accessSync(path);
+        } catch (e) {
+          exists = false;
+        }
+        if (!exists) {
+          reject('file not exists');
+          return;
+        }
+        if (!fs.statSync(path).isDirectory()) {
+          reject('directory not exists');
+          return;
+        }
+        let filenames: string[] = fs.listFileSync(path);
+        resolve(filenames);
+      } catch (err) {
+        let e: BusinessError = err as BusinessError;
+        hilog.error(DOMAIN, TAG, '%{public}s', `ls failed: ${e.message}, code ${e.code}`);
+        reject(`ls failed with error message: ${e.message}, error code: ${e.code}`);
+      }
+    });
+  }
+
+  exists(path: string, callback: (value: boolean, isDir?: boolean) => void): void {
+    try {
+      fs.stat(path, (err: BusinessError, res: fs.Stat) => {
+        if (err) {
+          callback(false, false);
+        } else {
+          fs.access(path, (accessErr: BusinessError, result: boolean) => {
+            if (accessErr) {
+              callback(false, false);
+            } else {
+              callback(result, res.isDirectory());
+            }
+          });
+        }
+      });
+    } catch (err) {
+      let e: BusinessError = err as BusinessError;
+      hilog.error(DOMAIN, TAG, '%{public}s', `exists failed: ${e.message}, code ${e.code}`);
+      callback(false, false);
+    }
+  }
+
+  stat(path: string, callback: DataErrorCallback): void {
+    try {
+      fs.stat(path, (err: BusinessError, stat: fs.Stat) => {
+        if (err) {
+          callback(`failed to stat path \`${path}\` because it does not exist or it is not a folder`, null);
+        } else {
+          let statObj = new RNFetchBlobStat();
+          statObj.filename = path.substring(path.lastIndexOf('/') + 1);
+          statObj.path = path;
+          statObj.type = stat.isDirectory() ? 'dir' : 'file';
+          statObj.size = stat.size;
+          statObj.lastModified = stat.mtime;
+          callback(null, statObj);
+        }
+      });
+    } catch (err) {
+      let e: BusinessError = err as BusinessError;
+      hilog.error(DOMAIN, TAG, '%{public}s', `stat failed: ${e.message}, code ${e.code}`);
+      callback(`stat failed with error message: ${e.message}, error code: ${e.code}`, null);
+    }
+  }
+
+  lstat(path: string, callback: DataErrorCallback): void {
+    try {
+      fs.lstat(path, (err: BusinessError, stat: fs.Stat) => {
+        if (err) {
+          let errMsg = `lstat failed with error message: ${err.message}, error code: ${err.code}`;
+          hilog.error(DOMAIN, TAG, '%{public}s', errMsg);
+          callback(errMsg, null);
+        } else {
+          let statObj = new RNFetchBlobStat();
+          statObj.filename = path.substring(path.lastIndexOf('/') + 1);
+          statObj.path = path;
+          statObj.type = stat.isDirectory() ? 'dir' : 'file';
+          statObj.size = stat.size;
+          statObj.lastModified = stat.mtime;
+          callback(null, statObj);
+        }
+      });
+    } catch (err) {
+      let e: BusinessError = err as BusinessError;
+      hilog.error(DOMAIN, TAG, '%{public}s', `lstat failed: ${e.message}, code ${e.code}`);
+      callback(`lstat failed with error message: ${e.message}, error code: ${e.code}`, null);
+    }
+  }
+
+  hash(path: string, algorithm: string): Promise<string> {
+    return new Promise((resolve, reject) => {
+      try {
+        let alg: string = algorithm.toLowerCase();
+        if (alg !== 'md5' && alg !== 'sha1' && alg !== 'sha256') {
+          reject('Invalid hash algorithm');
+          return;
+        }
+        if (fs.statSync(path).isDirectory()) {
+          reject('file IsDirectory');
+          return;
+        }
+        let exists: boolean = false;
+        try {
+          exists = fs.accessSync(path);
+        } catch (e) {
+          exists = false;
+        }
+        if (!exists) {
+          reject('file not exists');
+          return;
+        }
+        hash.hash(path, alg, (err: BusinessError, str: string) => {
+          if (err) {
+            reject(`calculate file hash failed with error message: ${err.message}, error code: ${err.code}`);
+          } else {
+            resolve(str);
+          }
+        });
+      } catch (err) {
+        let e: BusinessError = err as BusinessError;
+        let errMsg = `hash failed with error message: ${e.message}, error code: ${e.code}`;
+        hilog.error(DOMAIN, TAG, '%{public}s', errMsg);
+        reject(errMsg);
+      }
+    });
+  }
+
+  slice(path: string, dest: string, start: number, end: number): Promise<string> {
+    return new Promise((resolve, reject) => {
+      let readFile: fs.File | undefined = undefined;
+      let writeFile: fs.File | undefined = undefined;
+      try {
+        let fileInfo = fs.statSync(path);
+        readFile = fs.openSync(path, fs.OpenMode.READ_ONLY);
+        writeFile = fs.openSync(dest, fs.OpenMode.WRITE_ONLY | fs.OpenMode.CREATE);
+        let buf = new ArrayBuffer(fileInfo.size);
+        let readLen: number = fs.readSync(readFile.fd, buf);
+        let max = end < readLen ? end : readLen;
+        let bytes = buf.slice(start, max);
+        let writeLen: number = fs.writeSync(writeFile.fd, bytes);
+        if (writeLen < 0) {
+          reject('write failed');
+        } else {
+          resolve(bytes.toString());
+        }
+      } catch (err) {
+        let e: BusinessError = err as BusinessError;
+        let errMsg = `slice failed with error message: ${e.message}, error code: ${e.code}`;
+        hilog.error(DOMAIN, TAG, '%{public}s', errMsg);
+        reject(errMsg);
+      } finally {
+        if (readFile !== undefined) {
+          try {
+            fs.closeSync(readFile);
+          } catch (e) {
+            let ce: BusinessError = e as BusinessError;
+            hilog.error(DOMAIN, TAG, '%{public}s', 'close failed: ' + ce.message);
+          }
+        }
+        if (writeFile !== undefined) {
+          try {
+            fs.closeSync(writeFile);
+          } catch (e) {
+            let ce: BusinessError = e as BusinessError;
+            hilog.error(DOMAIN, TAG, '%{public}s', 'close failed: ' + ce.message);
+          }
+        }
+      }
+    });
+  }
+
+  df(callback: (err: string | null, stat?: Object | null) => void): void {
+    try {
+      let totalSize: number = statvfs.getTotalSizeSync(this.context.filesDir);
+      let freeSize: number = statvfs.getFreeSizeSync(this.context.filesDir);
+      let res: Record<string, Object> = {};
+      res['free'] = freeSize;
+      res['total'] = totalSize;
+      callback(null, res);
+    } catch (err) {
+      let e: BusinessError = err as BusinessError;
+      hilog.error(DOMAIN, TAG, '%{public}s', `df failed: ${e.message}, code ${e.code}`);
+      callback(`df failed with error message: ${e.message}, error code: ${e.code}`, null);
+    }
+  }
+
+  /**
+   * File preview (mapped from Android actionViewIntent). Uses Preview Kit.
+   * Non-media paths are copied into the sandbox first, then converted to a uri.
+   */
+  presentPreview(path: string): Promise<string> {
+    return new Promise((resolve, reject) => {
+      try {
+        let uiContext = this.context;
+        let previewPath: string = path;
+        if (!path.startsWith('file://media')) {
+          let srcPath = path;
+          let dstPath = uiContext.filesDir + '/' + path.substring(path.lastIndexOf('/') + 1);
+          try {
+            fs.copyFileSync(srcPath.replace('file://', ''), dstPath);
+          } catch (e) {
+            // source may already be a sandbox path; ignore copy error
+          }
+          previewPath = fileUri.getUriFromPath(dstPath);
+        }
+        filePreview.canPreview(uiContext, previewPath).then((result: boolean) => {
+          if (result) {
+            let fileInfo: filePreview.PreviewInfo = {
+              title: previewPath.substring(previewPath.lastIndexOf('/') + 1),
+              uri: previewPath,
+              mimeType: this.getMainType(previewPath.substring(previewPath.lastIndexOf('.') + 1)),
+            };
+            filePreview.openPreview(uiContext, fileInfo).then(() => {
+              Logger.info('success to openpreview');
+              resolve('succeeded in opening preview');
+            }).catch((err: BusinessError) => {
+              hilog.error(DOMAIN, TAG, '%{public}s', `failed to open preview, err.code = ${err.code}, err.message = ${err.message}`);
+              reject(`failed to open preview, err.code = ${err.code}, err.message = ${err.message}`);
+            });
+          } else {
+            reject('path can not Preview, please check');
+          }
+        }).catch((err: BusinessError) => {
+          hilog.error(DOMAIN, TAG, '%{public}s', `failed to preview, err.code = ${err.code}, err.message = ${err.message}`);
+          reject(`failed to preview, err.code = ${err.code}, err.message = ${err.message}`);
+        });
+      } catch (err) {
+        let e: BusinessError = err as BusinessError;
+        hilog.error(DOMAIN, TAG, '%{public}s', `presentPreview failed, err.code = ${e.code}, err.message = ${e.message}`);
+        reject(`presentPreview failed, err.code = ${e.code}, err.message = ${e.message}`);
+      }
+    });
+  }
+
+  getMainType(value: string): string {
+    let mainType: string = '';
+    let objType: Record<string, string> = {
+      'txt': 'text/plain',
+      'cpp': 'text/x-c++src',
+      'c': 'text/x-csrc',
+      'h': 'text/x-chdr',
+      'java': 'text/x-java',
+      'xhtml': 'application/xhtml+xml',
+      'xml': 'text/xml',
+      'html': 'text/html',
+      'htm': 'text/html',
+      'jpg': 'image/jpeg',
+      'jpeg': 'image/jpeg',
+      'png': 'image/png',
+      'gif': 'image/gif',
+      'webp': 'image/webp',
+      'bmp': 'image/bmp',
+      'svg': 'image/svg+xml',
+      'm4a': 'audio/mp4a-latm',
+      'aac': 'audio/aac',
+      'mp3': 'audio/mpeg',
+      'ogg': 'audio/ogg',
+      'wav': 'audio/x-wav',
+      'mp4': 'video/mp4',
+      'mkv': 'video/x-matroska',
+      'ts': 'video/mp2ts',
+    };
+    mainType = objType[value];
+    return mainType;
+  }
+}