@hxa-rn/rn-fetch-blob 0.12.0

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

@@ -0,0 +1,530 @@
+/*
+ * Copyright (c) 2026. All rights reserved.
+ * HarmonyOS adaptation of rn-fetch-blob (RNFetchBlob TurboModule).
+ *
+ * HTTP request engine aligned with the original library's request module. Uses
+ * @ohos.net.http requestInStream for streaming downloads (avoids OOM on large
+ * files) and multiFormDataList for multipart uploads. Progress / state events
+ * keep the original RNFetchBlob* event names so the JS layer is unchanged.
+ */
+
+import http from '@ohos.net.http';
+import connection from '@ohos.net.connection';
+import fs from '@ohos.file.fs';
+import buffer from '@ohos.buffer';
+import util from '@ohos.util';
+import wifiManager from '@ohos.wifiManager';
+import { BusinessError } from '@ohos.base';
+import common from '@ohos.app.ability.common';
+import { UITurboModuleContext } from '@rnoh/react-native-openharmony/ts';
+import { RNFetchBlobConfig, ResponseInfo, RespType } from './RNFetchBlobConfig';
+import hilog from '@ohos.hilog';
+
+const DOMAIN: number = 0xFF00;
+const TAG: string = 'RNFetchBlob';
+
+const FILE_PREFIX = 'RNFetchBlob-file://';
+const CONTENT_PREFIX = 'RNFetchBlob-content://';
+const CONTENT_FILE = 'file://';
+
+enum ResponseFormat {
+  Auto,
+  UTF8,
+  BASE64,
+}
+
+enum ResponseType {
+  KeepInMemory,
+  FileStorage,
+}
+
+enum RNFB_RESPONSE {
+  BASE64 = 'base64',
+  UTF8 = 'utf8',
+  PATH = 'path',
+}
+
+/**
+ * A single multipart form item. The bridge delivers plain objects from JS, so
+ * items are parsed via Record access in the request builder.
+ */
+export type FormData = Object[] | string;
+
+class DataReceiveProgressInfo {
+  receiveSize: number = 0;
+  totalSize: number = 0;
+}
+
+class DataSendProgressInfo {
+  sendSize: number = 0;
+  totalSize: number = 0;
+}
+
+export type ReqCallback = (err: string | null, rawType: string, data: string, responseInfo?: Object | null) => void;
+
+export default class RNFetchBlobReq {
+  private ctx: UITurboModuleContext;
+  private context: common.UIAbilityContext;
+
+  private destPath: string = '';
+  private httpRequest: http.HttpRequest;
+  private responseType: ResponseType = ResponseType.KeepInMemory;
+  private responseFormat: ResponseFormat = ResponseFormat.Auto;
+  private resHeaders: Object = {};
+  private totalReceiveData: ArrayBuffer[] = [];
+  private fileFd: number = -1;
+
+  private downloadTimer: number = 0;
+  private uploadTimer: number = 0;
+  private downloadInfo: DataReceiveProgressInfo = new DataReceiveProgressInfo();
+  private uploadInfo: DataSendProgressInfo = new DataSendProgressInfo();
+  private taskId: string = '';
+  private finished: boolean = false;
+
+  constructor(ctx: UITurboModuleContext, context: common.UIAbilityContext) {
+    this.ctx = ctx;
+    this.context = context;
+    this.httpRequest = http.createHttp();
+  }
+
+  startHttp(options: RNFetchBlobConfig, taskId: string, method: string, url: string, headers: Object,
+    form: FormData, callback: ReqCallback): void {
+    let config = this.mergeConfig(options);
+    this.taskId = taskId;
+    this.finished = false;
+
+    if ((config.fileCache || config.path) && !this.shouldTransformFile(config)) {
+      this.responseType = ResponseType.FileStorage;
+    } else {
+      this.responseType = ResponseType.KeepInMemory;
+    }
+
+    let ext = !config.appendExt ? '' : '.' + config.appendExt;
+    let tmpPath = this.context.cacheDir + '/RNFetchBlobTmp_' + taskId;
+
+    if (config.path !== undefined && config.path !== null && config.path.length > 0) {
+      this.destPath = config.path;
+    } else if (config.fileCache) {
+      this.destPath = tmpPath + ext;
+    }
+
+    try {
+      // wifiOnly: only allow when the *default* network bearer is WiFi
+      // (aligns with Android ConnectivityManager + TRANSPORT_WIFI).
+      // wifiManager.isConnected() alone is insufficient: WiFi STA may still
+      // report connected while traffic already uses cellular, or vice versa.
+      if (config.wifiOnly) {
+        if (!this.isDefaultNetworkWifi()) {
+          callback('No available Wifi connections', '', '', null);
+          return;
+        }
+      }
+
+      // RNFB-Response header lets the caller force a specific response format.
+      let headerKeys: string[] = Object.keys(headers);
+      headerKeys.forEach((name: string) => {
+        let lowerName = name.toLowerCase();
+        if (lowerName === 'rnfb-response') {
+          let resValue: string = this.headerValue(headers, name).toLowerCase();
+          if (resValue === 'base64') {
+            this.responseFormat = ResponseFormat.BASE64;
+          } else if (resValue === 'utf8') {
+            this.responseFormat = ResponseFormat.UTF8;
+          }
+        }
+      });
+
+      let reqOptions: http.HttpRequestOptions = {
+        method: method.toUpperCase() as http.RequestMethod,
+        header: headers,
+        readTimeout: config.timeout,
+        connectTimeout: config.timeout,
+      };
+
+      if (form) {
+        if (Array.isArray(form)) {
+          let multiFormDataList: http.MultiFormData[] = [];
+          form.forEach((itemRaw: Object) => {
+            let item = itemRaw as Record<string, Object>;
+            let itemData: string = item['data'] !== undefined ? String(item['data']) : '';
+            let itemBuf: ArrayBuffer = this.getABData(this.isPathStr(itemData), itemData);
+            let multiForm: http.MultiFormData = {
+              name: item['name'] !== undefined ? String(item['name']) : undefined,
+              contentType: item['type'] !== undefined ? String(item['type']) : undefined,
+              remoteFileName: item['filename'] !== undefined ? String(item['filename']) : undefined,
+              data: itemBuf,
+            };
+            multiFormDataList.push(multiForm);
+          });
+          reqOptions.multiFormDataList = multiFormDataList;
+        } else {
+          let buf: ArrayBuffer = this.getABData(this.isPathStr(form), form);
+          reqOptions.extraData = buf;
+        }
+      }
+
+      if (this.responseType === ResponseType.FileStorage) {
+        this.prepareDestDir();
+      }
+
+      this.httpRequest.on('dataReceive', (data: ArrayBuffer) => {
+        if (this.responseType === ResponseType.FileStorage && this.fileFd !== -1) {
+          // Write each chunk to disk immediately — avoids buffering large files in memory.
+          try {
+            fs.writeSync(this.fileFd, data);
+          } catch (err) {
+            let e: BusinessError = err as BusinessError;
+            hilog.error(DOMAIN, TAG, '%{public}s', `dataReceive write failed: ${e.message}`);
+          }
+        } else {
+          this.totalReceiveData.push(data);
+        }
+      });
+
+      // After the request ends, send the final progress tick and clear timers.
+      this.httpRequest.on('dataEnd', () => {
+        if (this.downloadTimer) {
+          this.sendDownloadProgress();
+          clearInterval(this.downloadTimer);
+          this.downloadTimer = 0;
+        } else if (this.uploadTimer) {
+          this.sendUploadProgress();
+          clearInterval(this.uploadTimer);
+          this.uploadTimer = 0;
+        }
+      });
+
+      this.httpRequest.on('headersReceive', (header: Object) => {
+        this.resHeaders = header;
+      });
+
+      this.httpRequest.requestInStream(url, reqOptions, (err: BusinessError, data: number) => {
+        if (!err) {
+          let isResBlob: boolean = this.isBlobResponse(this.resHeaders, config);
+          let resInfo: ResponseInfo = this.getRespInfo(taskId, this.resHeaders, data, isResBlob);
+          this.ctx.rnInstance.emitDeviceEvent('RNFetchBlobState', resInfo);
+
+          if (this.responseType === ResponseType.FileStorage) {
+            if (this.fileFd !== -1) {
+              fs.closeSync(this.fileFd);
+              this.fileFd = -1;
+            }
+            callback(null, RNFB_RESPONSE.PATH, this.destPath, resInfo);
+          } else {
+            let resData = this.mergeReceiveData();
+            if (this.responseFormat === ResponseFormat.BASE64) {
+              let base64Helper = new util.Base64Helper();
+              let b64 = base64Helper.encodeToStringSync(new Uint8Array(resData));
+              callback(null, RNFB_RESPONSE.BASE64, b64, resInfo);
+            } else {
+              let utf8 = buffer.from(resData).toString('utf-8');
+              callback(null, RNFB_RESPONSE.UTF8, utf8, resInfo);
+            }
+          }
+          this.cancelRequest();
+        } else {
+          this.cancelRequest();
+          let errMsg = `code=${err.code}, message=${err.message}`;
+          hilog.error(DOMAIN, TAG, '%{public}s', errMsg);
+          callback(errMsg, '', '', null);
+        }
+      });
+    } catch (err) {
+      let e: BusinessError = err as BusinessError;
+      hilog.error(DOMAIN, TAG, '%{public}s', `startHttp failed: code=${e.code}, message=${e.message}`);
+      this.cancelRequest();
+      callback(`code=${e.code}, message=${e.message}`, '', '', null);
+    }
+  }
+
+  private mergeConfig(options: RNFetchBlobConfig): RNFetchBlobConfig {
+    let base = new RNFetchBlobConfig();
+    let result = new RNFetchBlobConfig();
+    result.fileCache = options.fileCache !== undefined ? options.fileCache : base.fileCache;
+    result.path = options.path !== undefined ? options.path : base.path;
+    result.appendExt = options.appendExt !== undefined ? options.appendExt : base.appendExt;
+    result.session = options.session !== undefined ? options.session : base.session;
+    result.overwrite = options.overwrite !== undefined ? options.overwrite : base.overwrite;
+    result.timeout = options.timeout !== undefined ? options.timeout : base.timeout;
+    result.followRedirect = options.followRedirect !== undefined ? options.followRedirect : base.followRedirect;
+    // Bridge delivers a plain Object; read booleans via Record so JS true/false is reliable.
+    result.trusty = this.readConfigBool(options, 'trusty', false);
+    result.wifiOnly = this.readConfigBool(options, 'wifiOnly', false);
+    result.auto = options.auto !== undefined ? options.auto : base.auto;
+    result.key = options.key !== undefined ? options.key : base.key;
+    result.addAndroidDownloads = options.addAndroidDownloads !== undefined ?
+      options.addAndroidDownloads : base.addAndroidDownloads;
+    result.indicator = options.indicator !== undefined ? options.indicator : base.indicator;
+    result.binaryContentTypes = options.binaryContentTypes !== undefined ?
+      options.binaryContentTypes : base.binaryContentTypes;
+    return result;
+  }
+
+  private readConfigBool(options: Object, key: string, fallback: boolean): boolean {
+    try {
+      let rec = options as Record<string, Object | undefined>;
+      let value = rec[key];
+      if (value === undefined || value === null) {
+        return fallback;
+      }
+      if (typeof value === 'boolean') {
+        return value;
+      }
+      if (typeof value === 'number') {
+        return value !== 0;
+      }
+      if (typeof value === 'string') {
+        let lower = value.toLowerCase();
+        return lower === 'true' || lower === '1';
+      }
+      return Boolean(value);
+    } catch (_e) {
+      return fallback;
+    }
+  }
+
+  /**
+   * Whether the current default data network is WiFi.
+   * Prefer @ohos.net.connection (active bearer); fall back to wifiManager.
+   * Fail closed (return false) on errors so wifiOnly rejects safely.
+   */
+  private isDefaultNetworkWifi(): boolean {
+    try {
+      let netHandle = connection.getDefaultNetSync();
+      if (netHandle !== undefined && netHandle !== null && netHandle.netId !== 0) {
+        let caps = connection.getNetCapabilitiesSync(netHandle);
+        let bearers = caps.bearerTypes;
+        if (bearers !== undefined && bearers !== null && bearers.length > 0) {
+          for (let i = 0; i < bearers.length; i++) {
+            if (bearers[i] === connection.NetBearType.BEARER_WIFI) {
+              return true;
+            }
+          }
+          return false;
+        }
+      }
+    } catch (err) {
+      let e: BusinessError = err as BusinessError;
+      hilog.warn(DOMAIN, TAG, '%{public}s',
+        `isDefaultNetworkWifi via connection failed: code=${e.code}, message=${e.message}`);
+    }
+    try {
+      return wifiManager.isWifiActive() && wifiManager.isConnected();
+    } catch (err2) {
+      let e2: BusinessError = err2 as BusinessError;
+      hilog.warn(DOMAIN, TAG, '%{public}s',
+        `isDefaultNetworkWifi via wifiManager failed: code=${e2.code}, message=${e2.message}`);
+      return false;
+    }
+  }
+
+  private prepareDestDir(): void {
+    try {
+      let dir = this.destPath.substring(0, this.destPath.lastIndexOf('/'));
+      if (!fs.accessSync(dir)) {
+        fs.mkdirSync(dir, true);
+      }
+      let file = fs.openSync(this.destPath, fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE);
+      this.fileFd = file.fd;
+    } catch (err) {
+      let e: BusinessError = err as BusinessError;
+      hilog.error(DOMAIN, TAG, '%{public}s', `prepareDestDir failed: ${e.message}`);
+    }
+  }
+
+  private mergeReceiveData(): ArrayBuffer {
+    if (this.totalReceiveData.length === 0) {
+      return new ArrayBuffer(0);
+    }
+    let totalLength: number = 0;
+    this.totalReceiveData.forEach((arr: ArrayBuffer) => {
+      totalLength += arr.byteLength;
+    });
+    let totalBuffer = new ArrayBuffer(totalLength);
+    let result = new Uint8Array(totalBuffer);
+    let offset = 0;
+    this.totalReceiveData.forEach((arr: ArrayBuffer) => {
+      result.set(new Uint8Array(arr), offset);
+      offset += arr.byteLength;
+    });
+    return totalBuffer;
+  }
+
+  private headerValue(headers: Object, key: string): string {
+    let h = headers as Record<string, Object>;
+    let val = h[key];
+    return val !== undefined && val !== null ? String(val) : '';
+  }
+
+  isPathStr(str: string): boolean {
+    return str.startsWith(FILE_PREFIX) || str.startsWith(CONTENT_PREFIX) || str.startsWith('/');
+  }
+
+  getABData(isPath: boolean, data: string): ArrayBuffer {
+    let file: fs.File | undefined = undefined;
+    try {
+      if (isPath) {
+        let filePath: string = data;
+        if (!filePath.startsWith('/')) {
+          filePath = filePath.replace(FILE_PREFIX, '').replace(CONTENT_PREFIX, '').replace(CONTENT_FILE, '');
+        }
+        let fileInfo = fs.statSync(filePath);
+        file = fs.openSync(filePath, fs.OpenMode.READ_ONLY);
+        let buf = new ArrayBuffer(fileInfo.size);
+        fs.readSync(file.fd, buf);
+        return buf;
+      } else {
+        return buffer.alloc(data.length, data, 'base64').buffer;
+      }
+    } catch (err) {
+      let e: BusinessError = err as BusinessError;
+      hilog.error(DOMAIN, TAG, '%{public}s', `getABData failed with error message: ${e.message}, error code: ${e.code}`);
+      return new ArrayBuffer(0);
+    } finally {
+      if (file !== undefined) {
+        try {
+          fs.closeSync(file);
+        } catch (e) {
+          let ce: BusinessError = e as BusinessError;
+          hilog.error(DOMAIN, TAG, '%{public}s', 'getABData close failed: ' + ce.message);
+        }
+      }
+    }
+  }
+
+  onProgressReport(interval: number, count: number): void {
+    this.httpRequest.on('dataReceiveProgress', (data: DataReceiveProgressInfo) => {
+      this.downloadInfo = data;
+      if (count !== -1 && (data.totalSize > 0) && ((data.receiveSize / data.totalSize) > (count / 10))) {
+        this.sendDownloadProgress();
+      }
+      if (count === -1) {
+        if (this.downloadTimer) {
+          clearInterval(this.downloadTimer);
+        }
+        this.downloadTimer = setInterval(() => {
+          if (!this.downloadInfo.totalSize) {
+            return;
+          }
+          this.sendDownloadProgress();
+        }, interval);
+      }
+    });
+  }
+
+  sendDownloadProgress(): void {
+    this.ctx.rnInstance.emitDeviceEvent('RNFetchBlobProgress', {
+      taskId: this.taskId,
+      written: this.downloadInfo.receiveSize,
+      total: this.downloadInfo.totalSize,
+      chunk: '',
+    });
+  }
+
+  onUploadProgressReport(interval: number, count: number): void {
+    this.httpRequest.on('dataSendProgress', (data: DataSendProgressInfo) => {
+      this.uploadInfo = data;
+      if (count !== -1 && (data.totalSize > 0) && ((data.sendSize / data.totalSize) > (count / 10))) {
+        this.sendUploadProgress();
+      }
+      if (count === -1) {
+        if (this.uploadTimer) {
+          clearInterval(this.uploadTimer);
+        }
+        this.uploadTimer = setInterval(() => {
+          if (!this.uploadInfo.totalSize) {
+            return;
+          }
+          this.sendUploadProgress();
+        }, interval);
+      }
+    });
+  }
+
+  sendUploadProgress(): void {
+    this.ctx.rnInstance.emitDeviceEvent('RNFetchBlobProgress-upload', {
+      taskId: this.taskId,
+      written: this.uploadInfo.sendSize,
+      total: this.uploadInfo.totalSize,
+    });
+  }
+
+  isBlobResponse(headers: Object, options: RNFetchBlobConfig): boolean {
+    let cType: string = this.headerValue(headers, 'content-type');
+    if (cType.length === 0) {
+      cType = this.headerValue(headers, 'Content-Type');
+    }
+    cType = cType.toLowerCase();
+    let isText: boolean = cType.indexOf('text/') !== -1;
+    let isJson: boolean = cType.indexOf('application/json') !== -1;
+    let isCustomBinary: boolean = (options.binaryContentTypes !== undefined && options.binaryContentTypes !== null
+      && options.binaryContentTypes.length > 0);
+    return !(isText || isJson) || isCustomBinary;
+  }
+
+  getRespInfo(taskId: string, headers: Object, status: number, isBlob: boolean): ResponseInfo {
+    let respInfo = new ResponseInfo();
+    respInfo.taskId = taskId;
+    respInfo.status = status;
+    respInfo.state = 2;
+    respInfo.headers = headers;
+    respInfo.timeout = false;
+    respInfo.redirects = [];
+    let cType: string = this.headerValue(headers, 'content-type');
+    if (cType.length === 0) {
+      cType = this.headerValue(headers, 'Content-Type');
+    }
+    respInfo.respType = this.getRespType(isBlob, cType);
+    return respInfo;
+  }
+
+  getRespType(isBlob: boolean, headerType: string): RespType {
+    if (isBlob) {
+      return 'blob';
+    } else if (headerType.indexOf('application/json') !== -1) {
+      return 'json';
+    } else if (headerType.indexOf('text/') !== -1) {
+      return 'text';
+    } else {
+      return '';
+    }
+  }
+
+  shouldTransformFile(options: RNFetchBlobConfig): boolean {
+    return false;
+  }
+
+  cancelRequest(): void {
+    if (this.finished) {
+      return;
+    }
+    this.finished = true;
+    this.totalReceiveData = [];
+    if (this.fileFd !== -1) {
+      try {
+        fs.closeSync(this.fileFd);
+      } catch (err) {
+        let ce: BusinessError = err as BusinessError;
+        hilog.error(DOMAIN, TAG, '%{public}s', 'cancelRequest close fd failed: ' + ce.message);
+      }
+      this.fileFd = -1;
+    }
+    try {
+      this.httpRequest.destroy();
+      this.httpRequest.off('dataReceiveProgress');
+      this.httpRequest.off('dataSendProgress');
+      this.httpRequest.off('dataReceive');
+      this.httpRequest.off('headersReceive');
+    } catch (err) {
+      // httpRequest may already be destroyed
+    }
+    if (this.downloadTimer) {
+      clearInterval(this.downloadTimer);
+      this.downloadTimer = 0;
+    }
+    if (this.uploadTimer) {
+      clearInterval(this.uploadTimer);
+      this.uploadTimer = 0;
+    }
+  }
+}

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

@@ -0,0 +1,169 @@
+/*
+ * Copyright (c) 2026. All rights reserved.
+ * HarmonyOS adaptation of rn-fetch-blob (RNFetchBlob TurboModule).
+ *
+ * File read/write streams. readStream emits data chunks to the JS side using
+ * the streamId as the dynamic DeviceEventEmitter event name (matching the
+ * original RNFetchBlobReadStream.js `addListener(streamId)`); write streams
+ * are tracked by a globally keyed streamId map.
+ */
+
+import fs from '@ohos.file.fs';
+import util from '@ohos.util';
+import HashMap from '@ohos.util.HashMap';
+import { BusinessError } from '@ohos.base';
+import buffer from '@ohos.buffer';
+import { UITurboModuleContext } from '@rnoh/react-native-openharmony/ts';
+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;
+
+export type StreamEncoding = 'utf8' | 'ascii' | 'base64';
+
+export class StreamEntry {
+  encoding: string = 'utf8';
+  stream: fs.Stream | undefined = undefined;
+}
+
+export default class RNFetchBlobStream {
+  private ctx: UITurboModuleContext;
+  private static fileStreams: HashMap<string, StreamEntry> = new HashMap();
+
+  constructor(ctx: UITurboModuleContext) {
+    this.ctx = ctx;
+  }
+
+  writeStream(filePath: string, encoding: string, append: boolean,
+    callback: (errCode: string | null, errMsg: string | null, streamId?: string) => void): void {
+    let appends = append ? 'a+' : 'w+';
+    try {
+      let stream: fs.Stream = fs.createStreamSync(filePath, appends);
+      let uuid: string = util.generateRandomUUID(true);
+      let entry = new StreamEntry();
+      entry.encoding = encoding;
+      entry.stream = stream;
+      RNFetchBlobStream.fileStreams.set(uuid, entry);
+      callback(null, null, uuid);
+    } catch (err) {
+      let e: BusinessError = err as BusinessError;
+      if (e.code === FILE_OR_DIR_NOT_EXIST) {
+        try {
+          let dir = filePath.substring(0, filePath.lastIndexOf('/'));
+          fs.mkdirSync(dir, true);
+          this.writeStream(filePath, encoding, append, callback);
+        } catch (e2) {
+          let e3: BusinessError = e2 as BusinessError;
+          hilog.error(DOMAIN, TAG, '%{public}s', `writeStream mkdir failed: ${e3.message}, code ${e3.code}`);
+          callback('EUNSPECIFIED', `Failed to create write stream at path \`${filePath}\`; ${e3.code}`);
+        }
+      } else {
+        hilog.error(DOMAIN, TAG, '%{public}s', `writeStream failed: ${e.message}, code ${e.code}`);
+        callback('EUNSPECIFIED', `Failed to create write stream at path \`${filePath}\`; ${e.code}`);
+      }
+    }
+  }
+
+  readStream(filePath: string, encoding: string, bufferSize: number, tick: number, streamId: string): void {
+    try {
+      let inputStream: fs.Stream = fs.createStreamSync(filePath, 'r+');
+      let buf = new ArrayBuffer(bufferSize <= 0 ? 4096 : bufferSize);
+      let readLen: number = inputStream.readSync(buf);
+      while (readLen > 0) {
+        let bytes = buffer.from(buf, 0, readLen);
+        let detail = this.encodeChunk(bytes, encoding);
+        this.ctx.rnInstance.emitDeviceEvent(streamId, { event: 'data', detail: detail });
+        readLen = inputStream.readSync(buf);
+      }
+      inputStream.closeSync();
+      this.ctx.rnInstance.emitDeviceEvent(streamId, { event: 'end', detail: '' });
+    } catch (err) {
+      let e: BusinessError = err as BusinessError;
+      let errMsg = '';
+      if (Number(e.code) === 13900042) {
+        errMsg = 'readStream failed with error message: No such file or directory, error code: 13900002';
+      } else {
+        errMsg = `readStream failed with error message: ${e.message}, error code: ${e.code}`;
+      }
+      hilog.error(DOMAIN, TAG, '%{public}s', errMsg);
+      this.ctx.rnInstance.emitDeviceEvent(streamId, { event: 'error', code: 'EUNSPECIFIED', detail: errMsg });
+    }
+  }
+
+  private encodeChunk(bytes: buffer.Buffer, encoding: string): string {
+    let enc: string = encoding.toLowerCase();
+    if (enc === 'base64') {
+      return bytes.toString('base64');
+    } else if (enc === 'ascii') {
+      return bytes.toString('latin1');
+    } else {
+      return bytes.toString('utf-8');
+    }
+  }
+
+  writeChunk(streamId: string, data: string, callback: (err: string | null) => void): void {
+    let ss: StreamEntry | undefined = RNFetchBlobStream.fileStreams.get(streamId);
+    if (!ss || ss.stream === undefined) {
+      callback('writeChunk failed: stream not found');
+      return;
+    }
+    try {
+      ss.stream.write(data, {
+        encoding: (ss.encoding === 'utf8' || ss.encoding === '') ? 'utf-8' : ss.encoding,
+      }, (err: BusinessError, bytesWritten: number) => {
+        if (err) {
+          callback(`writeChunk failed with error message: ${err.message}, error code: ${err.code}`);
+        } else {
+          callback('');
+        }
+      });
+    } catch (err) {
+      let e: BusinessError = err as BusinessError;
+      hilog.error(DOMAIN, TAG, '%{public}s', `writeChunk failed: ${e.message}`);
+      callback(`writeChunk failed with error message: ${e.message}, error code: ${e.code}`);
+    }
+  }
+
+  writeArrayChunk(streamId: string, data: number[], callback: (err: string | null) => void): void {
+    let ss: StreamEntry | undefined = RNFetchBlobStream.fileStreams.get(streamId);
+    if (!ss || ss.stream === undefined) {
+      callback('writeArrayChunk failed: stream not found');
+      return;
+    }
+    try {
+      let buf = buffer.from(data);
+      ss.stream.write(buf.toString('utf-8'), { encoding: 'utf-8' }, (err: BusinessError, bytesWritten: number) => {
+        if (err) {
+          callback(`writeArrayChunk failed with error message: ${err.message}, error code: ${err.code}`);
+        } else {
+          callback('');
+        }
+      });
+    } catch (err) {
+      let e: BusinessError = err as BusinessError;
+      hilog.error(DOMAIN, TAG, '%{public}s', `writeArrayChunk failed: ${e.message}`);
+      callback(`writeArrayChunk failed with error message: ${e.message}, error code: ${e.code}`);
+    }
+  }
+
+  close(streamId: string, callback: (err: string | null) => void): void {
+    let ss: StreamEntry | undefined = RNFetchBlobStream.fileStreams.get(streamId);
+    if (!ss || ss.stream === undefined) {
+      callback('close failed: stream not found');
+      return;
+    }
+    RNFetchBlobStream.fileStreams.remove(streamId);
+    ss.stream.close((err: BusinessError) => {
+      if (err) {
+        hilog.error(DOMAIN, TAG, '%{public}s', `close stream failed with error message: ${err.message}, error code: ${err.code}`);
+        callback(`close failed with error message: ${err.message}, error code: ${err.code}`);
+      } else {
+        Logger.info('close stream succeed');
+        callback('');
+      }
+    });
+  }
+}