@tarojs/plugin-platform-harmony-cpp 4.1.0 → 4.1.1-alpha.1

package/dist/runtime/runtime-harmony/apis/network/request.ets

@@ -0,0 +1,206 @@
+import type { IEtsMethodsOptions } from '../../index'
+import type { TaroAny } from '../../../../../../runtime'
+
+import { rcp } from '@kit.RemoteCommunicationKit';
+import { url, util } from '@kit.ArkTS';
+
+import {
+  IGeneralCallbackResult,
+  IHeaderCallBackArgs,
+  convertHeaders
+} from './common';
+
+
+interface IChunkCallBackArgs { data: ArrayBuffer }
+
+interface IRequestTask {
+  abort: () => void;
+  onHeadersReceived: (callback: (res: IHeaderCallBackArgs) => void) => void;
+  offHeadersReceived: (callback?: (res: IHeaderCallBackArgs) => void) => void;
+  onChunkReceived: (callback: (res: IChunkCallBackArgs) => void) => void;
+  offChunkReceived: (callback?: (res: IChunkCallBackArgs) => void) => void;
+}
+
+interface ISuccessCallbackResult {
+  data: TaroAny;
+  statusCode: number;
+  header: Record<string, string>;
+  errMsg: string;
+}
+
+interface IRequestOptions {
+  url: string;
+  method?: 'GET' | 'POST' | 'PUT' | 'DELETE' | 'HEAD' | 'OPTIONS';
+  data?: TaroAny;
+  header?: Record<string, string>;
+  timeout?: number;
+  dataType?: 'json' | 'text';
+  success?: (res: ISuccessCallbackResult) => void;
+  fail?: (res: IGeneralCallbackResult) => void;
+  complete?: (res: IGeneralCallbackResult) => void;
+}
+
+export default function handleRequestRcp(optionss: IEtsMethodsOptions): IRequestTask {
+  const option = (optionss?.args?.[0] || {}) as IRequestOptions
+
+  const session = rcp.createSession();
+  const method = (option.method || 'GET').toUpperCase() as rcp.HttpMethod;
+  const request = new rcp.Request(option.url, method);
+
+  // 设置请求配置
+  if (option.timeout) {
+    request.configuration = {
+      transfer: {
+        timeout: {
+          transferMs: option.timeout
+        }
+      }
+    };
+  }
+
+  // 设置请求头
+  request.headers = option.header || {};
+
+  // 处理请求数据
+  if (option.data) {
+    if (method === 'GET') {
+      // GET 请求处理查询参数
+      const params = new url.URLParams();
+      Object.keys(option.data).forEach(key => {
+        params.append(key, option.data![key]);
+      });
+      request.url.search = params.toString();
+    } else {
+      // 处理 POST/PUT 等请求体
+      const contentType = request.headers?.['Content-Type'] || 'application/json';
+
+      if (typeof option.data === 'string') {
+        request.content = option.data;
+      } else if (option.data instanceof ArrayBuffer) {
+        request.content = option.data;
+      } else {
+        // 对象类型数据序列化
+        request.content = contentType.includes('json')
+          ? JSON.stringify(option.data)
+          : new url.URLParams();
+        (option.data).toString();
+      }
+
+      // 设置内容类型头
+      if (!request.headers?.['Content-Type']) {
+        request.headers['Content-Type'] = contentType;
+      }
+    }
+  }
+
+  // 事件处理器配置
+  let chunkCallbacks: Array<(res: IChunkCallBackArgs) => void> = [];
+  let headersCallbacks: Array<(res: IHeaderCallBackArgs) => void> = [];
+  let responseBuffer: ArrayBuffer[] = []; // 新增缓冲区存储分块数据
+
+  if (request.configuration) {
+    const tracingConfig = request.configuration.tracing ??= {};
+    const httpEvents = tracingConfig.httpEventsHandler ??= {};
+
+    httpEvents.onHeaderReceive = (headers: rcp.ResponseHeaders) => {
+      const converted: IHeaderCallBackArgs = {
+        header: convertHeaders(headers)
+      };
+      headersCallbacks.forEach(callback => callback(converted));
+    };
+
+    // 添加分块数据接收处理
+    httpEvents.onDataReceive = (incomingData: ArrayBuffer) => {
+      // 新增分块数据缓冲
+      responseBuffer.push(incomingData);
+
+      chunkCallbacks.forEach(callback => {
+        const res: IChunkCallBackArgs = { data: incomingData }
+        callback(res);
+      });
+      return incomingData.byteLength;
+    };
+  }
+
+  // 发起请求
+  session.fetch(request)
+    .then(response => {
+      let responseData: TaroAny;
+
+      // 处理响应数据（改为使用缓冲数据）
+      if (responseBuffer.length > 0) {
+        const totalLength = responseBuffer.reduce((sum, buf) => sum + buf.byteLength, 0);
+        const mergedBuffer = new Uint8Array(totalLength);
+        let offset = 0;
+
+        responseBuffer.forEach(buf => {
+          mergedBuffer.set(new Uint8Array(buf), offset);
+          offset += buf.byteLength;
+        });
+
+        // 处理分块编码（示例响应中包含 chunked 数据）
+        const rawData = new util.TextDecoder().decodeToString(mergedBuffer);
+        const cleanedData = rawData.replace(/^b\r\n|\r\n0$/, ''); // 移除chunked头尾
+
+        if (option.dataType === 'json') {
+          try {
+            responseData = JSON.parse(rawData);
+          } catch (e) {
+            console.warn('JSON parse failed:', e);
+            responseData = rawData;
+          }
+        } else {
+          responseData = cleanedData; // 直接使用处理后的字符串
+        }
+      }
+
+      const result: ISuccessCallbackResult = {
+        data: responseData,
+        statusCode: response.statusCode,
+        header: convertHeaders(response.headers),
+        errMsg: 'request:ok'
+      };
+
+      option.success?.(result);
+      option.complete?.({
+        errMsg: 'request:ok'
+      });
+      return result;
+    })
+    .catch((error: TaroAny) => {
+      const errMsg = `request:fail ${error.message || ''}`;
+      option.fail?.({
+        errMsg
+      });
+      option.complete?.({
+        errMsg
+      });
+    });
+
+  // 返回任务对象
+  const requestTask: IRequestTask = {
+    abort: () => session.cancel(request),
+    onHeadersReceived: (callback) => {
+      headersCallbacks.push(callback);
+    },
+    offHeadersReceived: (callback?) => {
+      if (callback) {
+        headersCallbacks = headersCallbacks.filter(cb => cb !== callback);
+      } else {
+        headersCallbacks = [];
+      }
+    },
+    onChunkReceived: (callback) => {
+      chunkCallbacks.push(callback);
+    },
+    offChunkReceived: (callback?) => {
+      if (callback) {
+        chunkCallbacks = chunkCallbacks.filter(cb => cb !== callback);
+      } else {
+        chunkCallbacks = [];
+      }
+    }
+  };
+
+  return requestTask;
+}

package/dist/runtime/runtime-harmony/apis/network/uploadFile.ets

@@ -0,0 +1,190 @@
+import type { IEtsMethodsOptions } from '../../index'
+import type { TaroAny } from '../../../../../../runtime'
+
+import { rcp } from '@kit.RemoteCommunicationKit';
+import { util } from '@kit.ArkTS';
+
+import {
+  IGeneralCallbackResult,
+  IHeaderCallBackArgs,
+  IProgressCallbackArgs,
+  convertHeaders
+} from './common';
+
+interface IUploadTask {
+  abort: () => void;
+  onProgressUpdate: (callback: (res: IProgressCallbackArgs) => void) => void;
+  offProgressUpdate: (callback?: (res: IProgressCallbackArgs) => void) => void;
+  onHeadersReceived: (callback: (res: IHeaderCallBackArgs) => void) => void;
+  offHeadersReceived: (callback?: (res: IHeaderCallBackArgs) => void) => void;
+}
+
+interface ISuccessCallbackResult {
+  data: string;
+  statusCode: number;
+  header: Record<string, string>;
+  errMsg: string;
+}
+
+
+
+
+interface IOptions {
+  url: string;
+  filePath: string;
+  name: string;
+  header?: Record<string, string>;
+  formData?: Record<string, TaroAny>;
+  timeout?: number;
+  success?: (res: ISuccessCallbackResult) => void;
+  fail?: (res: IGeneralCallbackResult) => void;
+  complete?: (res: IGeneralCallbackResult) => void;
+}
+
+
+
+export default function handleUploadFileRcp(optionss: IEtsMethodsOptions): IUploadTask {
+  const option = (optionss?.args?.[0] || {}) as IOptions
+
+  // 创建一个RCP会话
+  const session = rcp.createSession();
+
+  // 创建一个request对象
+  const request = new rcp.Request(option.url, 'POST');
+
+  // 设置超时
+  if (option.timeout) {
+    request.configuration = {
+      transfer: {
+        timeout: {
+          transferMs: option.timeout
+        }
+      }
+    };
+  }
+
+  // 设置header
+  if (option.header) {
+    request.headers = option.header;
+  }
+
+  // 创建表单数据
+  const formFields: rcp.MultipartFormFields = {};
+
+  // 添加formData字段
+  if (option.formData) {
+    Object.keys(option.formData).forEach(key => {
+      formFields[key] = option.formData![key];
+    });
+  }
+
+  // 添加文件字段
+  formFields[option.name] = {
+    contentType: 'application/octet-stream',
+    remoteFileName: option.filePath.split('/').pop() || 'file',
+    contentOrPath: option.filePath
+  };
+
+  // 设置请求内容为MultipartForm
+  request.content = new rcp.MultipartForm(formFields);
+
+  // 改为使用数组存储回调
+  let progressCallbacks: Array<(res: IProgressCallbackArgs) => void> = [];
+  let headersCallbacks: Array<(res: IHeaderCallBackArgs) => void> = [];
+
+  // 设置事件处理器
+  if (request.configuration) {
+    const tracingConfig = request.configuration.tracing ??= {};
+    const httpEvents = tracingConfig.httpEventsHandler ??= {};
+
+    httpEvents.onUploadProgress = (totalSize, transferredSize) => {
+      const progress = Math.floor((transferredSize / totalSize) * 100);
+      progressCallbacks.forEach(callback => {
+        callback({
+          progress
+        });
+      });
+    };
+
+    httpEvents.onHeaderReceive = (headers: rcp.ResponseHeaders) => {
+      const converted: IHeaderCallBackArgs = {
+        header: convertHeaders(headers)
+      };
+      headersCallbacks.forEach(callback => {
+        callback(converted);
+      });
+    };
+  }
+
+
+  // 发起请求并处理响应
+  session.fetch(request)
+    .then(response => {
+      const result: ISuccessCallbackResult = {
+        data: response.body ? new util.TextDecoder().decodeToString(new Uint8Array(response.body)) : '',
+        statusCode: response.statusCode,
+        header: convertHeaders(response.headers),
+        errMsg: 'uploadFile:ok'
+      };
+
+      if (option.success) {
+        option.success(result);
+      }
+
+      if (option.complete) {
+        option.complete({
+          errMsg: 'uploadFile:ok'
+        });
+      }
+
+      return result;
+    })
+    .catch((error: TaroAny) => {
+      const errMsg = `uploadFile:fail ${error.message || ''}`;
+
+      if (option.fail) {
+        option.fail({
+          errMsg
+        });
+      }
+
+      if (option.complete) {
+        option.complete({
+          errMsg
+        });
+      }
+
+      // throw error;
+    });
+
+
+
+  // 返回任务对象
+  const uploadTask: IUploadTask = {
+    abort: () => {
+      session.cancel(request);
+    },
+    onProgressUpdate: (callback) => {
+      progressCallbacks.push(callback);
+    },
+    offProgressUpdate: (callback?) => {
+      if (callback) {
+        progressCallbacks = progressCallbacks.filter(cb => cb !== callback);
+      } else {
+        progressCallbacks = [];
+      }
+    },
+    onHeadersReceived: (callback) => {
+      headersCallbacks.push(callback);
+    },
+    offHeadersReceived: (callback?) => {
+      if (callback) {
+        headersCallbacks = headersCallbacks.filter(cb => cb !== callback);
+      } else {
+        headersCallbacks = [];
+      }
+    }
+  };
+
+  return uploadTask;
+}

package/dist/runtime/runtime-harmony/apis/route.ets

@@ -0,0 +1,110 @@
+
+import type { TaroAny } from '../../../../../runtime'
+import type { IEtsMethodsOptions } from '../index'
+import router from '@ohos.router'
+import { queryToJson } from '../../../../../shared'
+
+
+export function handleRoute (option: IEtsMethodsOptions) {
+  const arg: TaroAny = option.args?.[0] || {}
+
+  // 新增 URL 解析逻辑
+  const parser = parseURL(arg.url)
+  const url = parser[0]
+  const params = parser[1]
+
+  try {
+    switch (option.name) {
+      case 'navigateTo':
+        router.pushUrl({
+          url: url,
+          params: params
+        }, (err) => {
+          if (err) {
+            option.errorHandler?.({
+              errCode: err.code,
+              errMsg: err.message,
+              data: err.data
+            })
+          } else {
+            option.successHandler?.()
+          }
+        })
+        break
+      case 'redirectTo':
+        router.replaceUrl({
+          url: url,
+          params: params
+        }, (err) => {
+          if (err) {
+            option.errorHandler?.({
+              errCode: err.code,
+              errMsg: err.message,
+              data: err.data
+            })
+          } else {
+            option.successHandler?.()
+          }
+        })
+        break
+      case 'navigateBack':
+        if (!url) {
+          router.back()
+        } else {
+          router.back({ url })
+        }
+        option.successHandler?.()
+        break
+      case 'switchTab':
+        router.replaceUrl({
+          url: url,
+          params: params
+        }, (err) => {
+          if (err) {
+            option.errorHandler?.({
+              errCode: err.code,
+              errMsg: err.message,
+              data: err.data
+            })
+          } else {
+            option.successHandler?.()
+          }
+        })
+        break
+      default:
+        if (("development" as string) !== 'production') {
+          console.warn(`Unhandled route method: ${option.name}`)
+        }
+    }
+  } catch (e) {
+    if (("development" as string) !== 'production') console.error('Error(TaroETS):', e.message, e)
+    if (option.errorHandler) option.errorHandler({
+      errCode: e.code,
+      errMsg: e.message,
+      data: e.data,
+    })
+  }
+}
+
+// 新增 URL 解析函数
+function parseURL(raw = ''): [string, Record<string, TaroAny>] {
+  // const [urlStr, queryStr = ''] = raw.split('?')
+  const splitRaw = raw.split('?')
+  const urlStr = splitRaw[0] || ''
+  const queryStr = splitRaw[1] || ''
+  const query = queryToJson(queryStr)
+  let url = urlStr.replace(/^\//, '')
+
+  // 处理相对路径逻辑
+  if (url.indexOf('.') === 0) {
+    const currentPage = router.getState()
+    const parts = currentPage.path.split('/')
+    parts.pop()
+    url.split('/').forEach((item) => {
+      item === '..' ? parts.pop() : parts.push(item)
+    })
+    url = parts.join('/')
+  }
+
+  return [url, query]
+}

package/dist/runtime/runtime-harmony/apis/taskpool.ets

@@ -0,0 +1,149 @@
+import { taskpool } from '@kit.ArkTS'
+import fs from '@ohos.file.fs';
+import image from '@ohos.multimedia.image';
+import type { TaroAny } from '@tarojs/runtime'
+import type { IEtsMethodsOptions } from '../index'
+
+@Concurrent
+function stringify (data: TaroAny) {
+  return JSON.stringify(data)
+}
+
+function handleTaskPoolStringify (option: IEtsMethodsOptions) {
+  const args: TaroAny = option.args
+
+  if (args) {
+    const data: TaroAny = args[0]
+
+    taskpool.execute(stringify, data)
+      .then(res => {
+        option.successHandler && option.successHandler({ data: res })
+      })
+      .catch((error: TaroAny) => {
+        option.errorHandler && option.errorHandler({
+          errCode: error?.code,
+          errMsg: error?.message,
+          data: error?.data,
+        })
+      })
+  }
+}
+
+@Concurrent
+function compressImage(data: Record<string, TaroAny>) {
+
+  const src = data[0] as string
+  const quality = (data[1] ?? 80) as number
+  const compressedWidth = data[2] as number
+  const compressedHeight = data[3] as number
+  const file = fs.openSync(src, fs.OpenMode.READ_ONLY);
+
+  const source = image.createImageSource(file.fd)
+
+  if (null === (source)) {
+    throw new Error('compressImage fail: createImageSource has failed')
+    return;
+  }
+  const width = source.getImageInfoSync().size.width;
+  const height = source.getImageInfoSync().size.height;
+  let wantWidth = compressedWidth || compressedHeight || 0;
+  let wantHeight = compressedHeight || compressedWidth || 0;
+  if (width > wantWidth || height > wantHeight) {
+    const heightRatio = height / wantHeight;
+    const widthRatio = width / wantWidth;
+    const finalRatio = heightRatio < widthRatio ? heightRatio : widthRatio;
+    wantWidth = Math.round(width / finalRatio);
+    wantHeight = Math.round(height / finalRatio);
+  }
+
+  try {
+    const pixelMap = source.createPixelMapSync({
+      editable: true,
+      desiredPixelFormat: image.PixelMapFormat.RGBA_8888,
+      desiredSize: { width: wantWidth, height: wantHeight },
+    })
+    fs.closeSync(file);
+    return pixelMap
+  } catch (e) {
+    fs.closeSync(file);
+    throw new Error("createPixelMapSync error: ")
+  } 
+
+
+}
+
+function handleTaskPoolCompressImage(option: IEtsMethodsOptions) {
+
+  taskpool.execute(compressImage, option.args as Record<string, TaroAny>)
+    .then(res => {
+      option?.successHandler?.(res)
+    })
+    .catch((error: TaroAny) => {
+      option?.errorHandler?.({
+        errCode: error?.code,
+        errMsg: error,
+        data: error?.data,
+      })
+    })
+
+}
+
+
+@Concurrent
+function getImageSize(uri: string) {
+  const file = fs.openSync(uri, fs.OpenMode.READ_ONLY);
+  const stat = fs.statSync(file.fd);
+  const size = stat.size;
+  fs.closeSync(file);
+  return size
+}
+
+function handleTaskPoolGetImageSize(option: IEtsMethodsOptions) {
+  const args: TaroAny = option.args
+
+  if (args) {
+    const data: TaroAny = args[0]
+
+    taskpool.execute(getImageSize, data)
+      .then(res => {
+        option.successHandler && option.successHandler({ data: res })
+      })
+      .catch((error: TaroAny) => {
+        option.errorHandler && option.errorHandler({
+          errCode: error?.code,
+          errMsg: error?.message,
+          data: error?.data,
+        })
+      })
+  }
+}
+
+
+export function handleTaskPool(option: IEtsMethodsOptions) {
+  const name = option.name
+
+  if (!name) {
+    return
+  }
+
+  try {
+    switch (option.name) {
+      case 'stringify':
+        handleTaskPoolStringify(option)
+        break
+      case 'compressImage':
+        handleTaskPoolCompressImage(option)
+        break
+      case 'getImageSize':
+        handleTaskPoolGetImageSize(option)
+        break
+    }
+  } catch (e) {
+    if (process.env.NODE_ENV !== 'production') console.error('Error(TaroETS):', e.message, e)
+    if (option.errorHandler) option.errorHandler({
+      errCode: e.code,
+      errMsg: e.message,
+      data: e.data,
+    })
+  }
+}

package/dist/runtime/runtime-harmony/index.ets

@@ -0,0 +1,41 @@
+import { Current, eventCenter } from '@tarojs/runtime'
+import BuildProfile from 'BuildProfile'
+
+import type { TaroAny } from '@tarojs/runtime'
+
+import { handleTaskPool } from './apis/taskpool'
+import { handleNetwork } from './apis/network/index'
+import { handleRoute } from './apis/route'
+
+export interface IEtsMethodsOptions {
+  methodName?: string
+  name?: string
+  scope?: string
+  type?: string
+  args?: TaroAny[]
+  successHandler?: (...args: TaroAny[]) => void
+  errorHandler?: (...args: TaroAny[]) => void
+  onInit?: (obj: TaroAny) => void
+}
+
+// Note: 监听 API 事件
+eventCenter?.on('__taroPluginEtsMethodsTrigger', (option: IEtsMethodsOptions) => {
+  switch (option.scope) {
+    case 'route':
+      handleRoute(option)
+      break
+    case 'network':
+      handleNetwork(option)
+      break
+    case 'taskpool':
+      handleTaskPool(option)
+      break
+    default:
+      console.error(`Error(TaroETS): cannot found ${option.type} ${option.name} in ${option.scope} scope.`)
+  }
+})
+
+if (BuildProfile.DEBUG) {
+  console.log('TARO_LOG(harmony_cpp): 当前是测试环境！')
+  Current.isDebug = true
+}