@hxa-rn/rn-fetch-blob 0.12.0

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

@@ -0,0 +1,246 @@
+/*
+ * Copyright (c) 2026. All rights reserved.
+ * HarmonyOS adaptation of rn-fetch-blob (RNFetchBlob TurboModule).
+ *
+ * Orchestration layer: owns the task map (taskId -> Req) and delegates to the
+ * FS / Stream / Req modules. Android/iOS-only APIs are mapped to the closest
+ * HarmonyOS capability or rejected with 'not supported'.
+ */
+
+import common from '@ohos.app.ability.common';
+import { BusinessError } from '@ohos.base';
+import { picker } from '@kit.CoreFileKit';
+import { UITurboModuleContext } from '@rnoh/react-native-openharmony/ts';
+import RNFetchBlobFS from './RNFetchBlobFS';
+import RNFetchBlobReq, { FormData, ReqCallback } from './RNFetchBlobReq';
+import RNFetchBlobStream from './RNFetchBlobStream';
+import { RNFetchBlobConfig } from './RNFetchBlobConfig';
+import hilog from '@ohos.hilog';
+
+const DOMAIN: number = 0xFF00;
+const TAG: string = 'RNFetchBlob';
+
+export type SimpleCallback = (err: string | null) => void;
+export type DataCallback = (err: string | null, data?: Object | null) => void;
+export type ExistsCallback = (value: boolean, isDir?: boolean) => void;
+export type WriteStreamCallback = (errCode: string | null, errMsg: string | null, streamId?: string) => void;
+export type CancelCallback = (value: Object[]) => void;
+
+export default class RNFetchBlobImpl {
+  private context: common.UIAbilityContext;
+  private ctx: UITurboModuleContext;
+  private fs: RNFetchBlobFS;
+  private stream: RNFetchBlobStream;
+  private taskMap: Map<string, RNFetchBlobReq> = new Map();
+
+  constructor(context: common.UIAbilityContext, ctx: UITurboModuleContext) {
+    this.context = context;
+    this.ctx = ctx;
+    this.fs = new RNFetchBlobFS(context);
+    this.stream = new RNFetchBlobStream(ctx);
+  }
+
+  getSystemFolders(): Object {
+    return this.fs.getSystemFolders();
+  }
+
+  fetchBlob(options: RNFetchBlobConfig, taskId: string, method: string, url: string, headers: Object,
+    form: FormData, callback: ReqCallback): void {
+    let req = new RNFetchBlobReq(this.ctx, this.context);
+    this.taskMap.set(taskId, req);
+    req.startHttp(options, taskId, method, url, headers, form, callback);
+  }
+
+  fetchBlobForm(options: RNFetchBlobConfig, taskId: string, method: string, url: string, headers: Object,
+    form: FormData, callback: ReqCallback): void {
+    this.fetchBlob(options, taskId, method, url, headers, form, callback);
+  }
+
+  cancelRequest(taskId: string, callback: CancelCallback): void {
+    let req = this.taskMap.get(taskId);
+    if (req) {
+      req.cancelRequest();
+      this.taskMap.delete(taskId);
+    }
+    callback([]);
+  }
+
+  enableProgressReport(taskId: string, interval: number, count: number): void {
+    let req = this.taskMap.get(taskId);
+    if (req) {
+      req.onProgressReport(interval, count);
+    }
+  }
+
+  enableUploadProgressReport(taskId: string, interval: number, count: number): void {
+    let req = this.taskMap.get(taskId);
+    if (req) {
+      req.onUploadProgressReport(interval, count);
+    }
+  }
+
+  removeSession(paths: string[], callback: SimpleCallback): void {
+    this.fs.removeSession(paths, callback);
+  }
+
+  createFile(path: string, data: string, encoding: string): Promise<string> {
+    return this.fs.createFile(path, data, encoding);
+  }
+
+  createFileASCII(path: string, data: number[]): Promise<void> {
+    return this.fs.createFileASCII(path, data);
+  }
+
+  writeFile(path: string, encoding: string, data: string, append: boolean): Promise<number> {
+    return this.fs.writeFile(path, encoding, data, append);
+  }
+
+  writeFileArray(path: string, data: number[], append: boolean): Promise<number> {
+    return this.fs.writeFileArray(path, data, append);
+  }
+
+  readFile(path: string, encoding: string): Promise<Object> {
+    return this.fs.readFile(path, encoding);
+  }
+
+  unlink(path: string, callback: SimpleCallback): void {
+    this.fs.unlink(path, callback);
+  }
+
+  mkdir(path: string): Promise<void> {
+    return this.fs.mkdir(path);
+  }
+
+  exists(path: string, callback: ExistsCallback): void {
+    this.fs.exists(path, callback);
+  }
+
+  cp(path: string, dest: string, callback: DataCallback): void {
+    this.fs.cp(path, dest, callback);
+  }
+
+  mv(path: string, dest: string, callback: DataCallback): void {
+    this.fs.mv(path, dest, callback);
+  }
+
+  ls(path: string): Promise<string[]> {
+    return this.fs.ls(path);
+  }
+
+  stat(path: string, callback: DataCallback): void {
+    this.fs.stat(path, callback);
+  }
+
+  lstat(path: string, callback: DataCallback): void {
+    this.fs.lstat(path, callback);
+  }
+
+  hash(path: string, algorithm: string): Promise<string> {
+    return this.fs.hash(path, algorithm);
+  }
+
+  slice(src: string, dest: string, start: number, end: number): Promise<string> {
+    return this.fs.slice(src, dest, start, end);
+  }
+
+  df(callback: DataCallback): void {
+    this.fs.df(callback);
+  }
+
+  writeStream(path: string, encoding: string, append: boolean, callback: WriteStreamCallback): void {
+    this.stream.writeStream(path, encoding, append, callback);
+  }
+
+  readStream(filePath: string, encoding: string, bufferSize: number, tick: number, streamId: string): void {
+    this.stream.readStream(filePath, encoding, bufferSize, tick, streamId);
+  }
+
+  writeChunk(streamId: string, data: string, callback: SimpleCallback): void {
+    this.stream.writeChunk(streamId, data, callback);
+  }
+
+  writeArrayChunk(streamId: string, data: number[], callback: SimpleCallback): void {
+    this.stream.writeArrayChunk(streamId, data, callback);
+  }
+
+  closeStream(streamId: string, callback: SimpleCallback): void {
+    this.stream.close(streamId, callback);
+  }
+
+  // ---- Android-only APIs, mapped or degraded on HarmonyOS ----
+
+  actionViewIntent(path: string, mime: string): Promise<void> {
+    return this.fs.presentPreview(path).then(() => {
+      return Promise.resolve();
+    }).catch((err: Object) => {
+      return Promise.reject(err);
+    });
+  }
+
+  getContentIntent(mime: string): Promise<string> {
+    return new Promise((resolve, reject) => {
+      try {
+        let documentViewPicker = new picker.DocumentViewPicker(this.context);
+        let options = new picker.DocumentSelectOptions();
+        documentViewPicker.select(options).then((uris: string[]) => {
+          if (uris.length > 0) {
+            resolve(uris[0]);
+          } else {
+            reject('user canceled file selection');
+          }
+        }).catch((err: BusinessError) => {
+          hilog.error(DOMAIN, TAG, '%{public}s', `getContentIntent select failed: ${err.message}`);
+          reject(`getContentIntent failed: ${err.message}`);
+        });
+      } catch (err) {
+        hilog.error(DOMAIN, TAG, '%{public}s', 'getContentIntent is not supported on HarmonyOS');
+        reject('getContentIntent is not supported on HarmonyOS');
+      }
+    });
+  }
+
+  addCompleteDownload(config: Object): Promise<void> {
+    // HarmonyOS has no DownloadManager.addCompletedDownload equivalent.
+    return Promise.reject('addCompleteDownload is not supported on HarmonyOS');
+  }
+
+  getSDCardDir(): Promise<string> {
+    // HarmonyOS sandbox has no external SD card concept; return app filesDir.
+    return Promise.resolve(this.context.filesDir);
+  }
+
+  getSDCardApplicationDir(): Promise<string> {
+    return Promise.resolve(this.context.filesDir);
+  }
+
+  scanFile(pairs: Object[], callback: SimpleCallback): void {
+    // Baseline: not supported (would require ohos.permission.WRITE_IMAGEVIDEO user_grant).
+    callback('scanFile is not supported on HarmonyOS');
+  }
+
+  // ---- iOS-only APIs, rejected on HarmonyOS ----
+
+  pathForAppGroup(groupName: string): Promise<string> {
+    return Promise.reject('pathForAppGroup is not supported on HarmonyOS');
+  }
+
+  syncPathAppGroup(groupName: string): string {
+    return '';
+  }
+
+  previewDocument(uri: string, scheme: string): Promise<void> {
+    return Promise.reject('previewDocument is not supported on HarmonyOS');
+  }
+
+  openDocument(uri: string, scheme: string): Promise<void> {
+    return Promise.reject('openDocument is not supported on HarmonyOS');
+  }
+
+  excludeFromBackupKey(url: string): Promise<void> {
+    return Promise.reject('excludeFromBackupKey is not supported on HarmonyOS');
+  }
+
+  emitExpiredEvent(callback: () => void): void {
+    // Only used on iOS via AppState listener; no-op on HarmonyOS.
+  }
+}