@react-native-ohos/react-native-audio 4.2.3-rc.1

package/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) [2016] [Joshua Sierles]
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/NativeAudio.ts

@@ -0,0 +1,43 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ */
+
+import type { TurboModule } from "react-native/Libraries/TurboModule/RCTExport";
+import { TurboModuleRegistry } from "react-native";
+import type { Int32, Double } from 'react-native/Libraries/Types/CodegenTypes';
+
+type AudioQualityType = 'Low' | 'Medium' | 'High';
+
+export interface RecordingOptions {
+    SampleRate: Double,
+    Channels: Int32,
+    AudioQuality?: AudioQualityType,
+    AudioEncoding: string,
+    MeteringEnabled?: boolean,
+    MeasurementMode?: boolean,
+    AudioEncodingBitRate: Double,
+    IncludeBase64: boolean,
+    OutputFormat: string,
+    AudioSource: Int32
+}
+
+export interface PathMap {
+    FilesDirectoryPath: string,
+    CacheDirectoryPath: string,
+    TempsDirectoryPath: string,
+}
+
+export interface Spec extends TurboModule {
+    prepareRecordingAtPath: (path: string, options: RecordingOptions) => Promise<void>;
+    requestAuthorization: () => Promise<boolean>;
+    startRecording: () => Promise<void>;
+    pauseRecording: () => Promise<void>;
+    resumeRecording: () => Promise<void>;
+    stopRecording: () => Promise<void>;
+    getAllPath: () => PathMap;
+    checkAuthorizationStatus: () => Promise<boolean>;
+}
+
+export default TurboModuleRegistry.getEnforcing<Spec>("RTNAudio");

package/README.md

@@ -0,0 +1,15 @@
+# @react-native-ohos/react-native-audio
+
+This project is based on [react-native-audio](https://github.com/jsierles/react-native-audio)
+
+## Documentation
+
+[中文](https://gitee.com/react-native-oh-library/usage-docs/blob/master/zh-cn/react-native-audio.md)
+
+[English](https://gitee.com/react-native-oh-library/usage-docs/blob/master/en/react-native-audio.md)
+
+
+## License
+
+This library is licensed under [The MIT License (MIT)](https://gitee.com/openharmony-sig/rntpc_react-native-audio/blob/master/LICENSE).
+

package/harmony/audio/build-profile.json5

@@ -0,0 +1,8 @@
+{
+  "apiType": "stageMode",
+  "targets": [
+    {
+      "name": "default"
+    }
+  ]
+}

package/harmony/audio/hvigorfile.ts

@@ -0,0 +1,2 @@
+// Script for compiling build behavior. It is built in the build plug-in and cannot be modified currently.
+export { harTasks } from '@ohos/hvigor-ohos-plugin';

package/harmony/audio/index.ets

@@ -0,0 +1,6 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ */
+export * from './ts';

package/harmony/audio/oh-package.json5

@@ -0,0 +1,12 @@
+{
+  license: 'MIT',
+  types: '',
+  name: '@react-native-ohos/react-native-audio',
+  description: '',
+  main: 'index.ets',
+  type: 'module',
+  version: '4.2.3-rc.1',
+  dependencies: {
+    "@rnoh/react-native-openharmony": "^0.72.38"
+  },
+}

package/harmony/audio/src/main/cpp/AudioPackage.h

@@ -0,0 +1,16 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ */
+
+#pragma once
+
+#include "generated/RNOH/generated/BaseReactNativeAudioPackage.h"
+namespace rnoh {
+
+class AudioPackage : public BaseReactNativeAudioPackage {
+    using Super = BaseReactNativeAudioPackage;
+    using Super::Super;
+};
+} // namespace rnoh

package/harmony/audio/src/main/cpp/CMakeLists.txt

@@ -0,0 +1,9 @@
+cmake_minimum_required(VERSION 3.13)
+set(CMAKE_VERBOSE_MAKEFILE on)
+
+set(rnoh_audio_generated_dir "${CMAKE_CURRENT_SOURCE_DIR}/generated")
+file(GLOB_RECURSE rnoh_audio_generated_SRC "${rnoh_audio_generated_dir}/**/*.cpp")
+file(GLOB rnoh_audio_SRC CONFIGURE_DEPENDS *.cpp)
+add_library(rnoh_audio SHARED ${rnoh_audio_SRC} ${rnoh_audio_generated_SRC})
+target_include_directories(rnoh_audio PUBLIC ${CMAKE_CURRENT_SOURCE_DIR} ${rnoh_audio_generated_dir})
+target_link_libraries(rnoh_audio PUBLIC rnoh)

package/harmony/audio/src/main/cpp/generated/RNOH/generated/BaseReactNativeAudioPackage.h

@@ -0,0 +1,65 @@
+/**
+ * This code was generated by "react-native codegen-lib-harmony"
+ */
+
+#pragma once
+
+#include "RNOH/Package.h"
+#include "RNOH/ArkTSTurboModule.h"
+#include "RNOH/generated/turbo_modules/RTNAudio.h"
+
+namespace rnoh {
+
+class BaseReactNativeAudioPackageTurboModuleFactoryDelegate : public TurboModuleFactoryDelegate {
+  public:
+    SharedTurboModule createTurboModule(Context ctx, const std::string &name) const override {
+        if (name == "RTNAudio") {
+            return std::make_shared<RTNAudio>(ctx, name);
+        }
+        return nullptr;
+    };
+};
+
+class BaseReactNativeAudioPackageEventEmitRequestHandler : public EventEmitRequestHandler {
+  public:
+    void handleEvent(Context const &ctx) override {
+        auto eventEmitter = ctx.shadowViewRegistry->getEventEmitter<facebook::react::EventEmitter>(ctx.tag);
+        if (eventEmitter == nullptr) {
+            return;
+        }
+
+        std::vector<std::string> supportedEventNames = {
+        };
+        if (std::find(supportedEventNames.begin(), supportedEventNames.end(), ctx.eventName) != supportedEventNames.end()) {
+            eventEmitter->dispatchEvent(ctx.eventName, ArkJS(ctx.env).getDynamic(ctx.payload));
+        }    
+    }
+};
+
+
+class BaseReactNativeAudioPackage : public Package {
+  public:
+    BaseReactNativeAudioPackage(Package::Context ctx) : Package(ctx){};
+
+    std::unique_ptr<TurboModuleFactoryDelegate> createTurboModuleFactoryDelegate() override {
+        return std::make_unique<BaseReactNativeAudioPackageTurboModuleFactoryDelegate>();
+    }
+
+    std::vector<facebook::react::ComponentDescriptorProvider> createComponentDescriptorProviders() override {
+        return {
+        };
+    }
+
+    ComponentJSIBinderByString createComponentJSIBinderByName() override {
+        return {
+        };
+    };
+
+    EventEmitRequestHandlers createEventEmitRequestHandlers() override {
+        return {
+            std::make_shared<BaseReactNativeAudioPackageEventEmitRequestHandler>(),
+        };
+    }
+};
+
+} // namespace rnoh

package/harmony/audio/src/main/cpp/generated/RNOH/generated/turbo_modules/RTNAudio.cpp

@@ -0,0 +1,23 @@
+/**
+ * This code was generated by "react-native codegen-lib-harmony"
+ */
+
+#include "RTNAudio.h"
+
+namespace rnoh {
+using namespace facebook;
+
+RTNAudio::RTNAudio(const ArkTSTurboModule::Context ctx, const std::string name) : ArkTSTurboModule(ctx, name) {
+    methodMap_ = {
+        ARK_ASYNC_METHOD_METADATA(prepareRecordingAtPath, 2),
+        ARK_ASYNC_METHOD_METADATA(requestAuthorization, 0),
+        ARK_ASYNC_METHOD_METADATA(startRecording, 0),
+        ARK_ASYNC_METHOD_METADATA(pauseRecording, 0),
+        ARK_ASYNC_METHOD_METADATA(resumeRecording, 0),
+        ARK_ASYNC_METHOD_METADATA(stopRecording, 0),
+        ARK_METHOD_METADATA(getAllPath, 0),
+        ARK_ASYNC_METHOD_METADATA(checkAuthorizationStatus, 0),
+    };
+}
+
+} // namespace rnoh

package/harmony/audio/src/main/cpp/generated/RNOH/generated/turbo_modules/RTNAudio.h

@@ -0,0 +1,16 @@
+/**
+ * This code was generated by "react-native codegen-lib-harmony"
+ */
+
+#pragma once
+
+#include "RNOH/ArkTSTurboModule.h"
+
+namespace rnoh {
+
+class JSI_EXPORT RTNAudio : public ArkTSTurboModule {
+  public:
+    RTNAudio(const ArkTSTurboModule::Context ctx, const std::string name);
+};
+
+} // namespace rnoh

package/harmony/audio/src/main/cpp/generated/react/renderer/components/react_native_audio/ComponentDescriptors.h

@@ -0,0 +1,22 @@
+
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @generated by codegen project: GenerateComponentDescriptorH.js
+ */
+
+#pragma once
+
+#include <react/renderer/components/react_native_audio/ShadowNodes.h>
+#include <react/renderer/core/ConcreteComponentDescriptor.h>
+
+namespace facebook {
+namespace react {
+
+
+
+} // namespace react
+} // namespace facebook

package/harmony/audio/src/main/cpp/generated/react/renderer/components/react_native_audio/EventEmitters.cpp

@@ -0,0 +1,18 @@
+
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @generated by codegen project: GenerateEventEmitterCpp.js
+ */
+
+#include <react/renderer/components/react_native_audio/EventEmitters.h>
+
+
+namespace facebook {
+namespace react {
+
+} // namespace react
+} // namespace facebook

package/harmony/audio/src/main/cpp/generated/react/renderer/components/react_native_audio/EventEmitters.h

@@ -0,0 +1,19 @@
+
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @generated by codegen project: GenerateEventEmitterH.js
+ */
+#pragma once
+
+#include <react/renderer/components/view/ViewEventEmitter.h>
+
+
+namespace facebook {
+namespace react {
+
+} // namespace react
+} // namespace facebook

package/harmony/audio/src/main/cpp/generated/react/renderer/components/react_native_audio/Props.cpp

@@ -0,0 +1,21 @@
+
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @generated by codegen project: GeneratePropsCpp.js
+ */
+
+#include <react/renderer/components/react_native_audio/Props.h>
+#include <react/renderer/core/PropsParserContext.h>
+#include <react/renderer/core/propsConversions.h>
+
+namespace facebook {
+namespace react {
+
+
+
+} // namespace react
+} // namespace facebook

package/harmony/audio/src/main/cpp/generated/react/renderer/components/react_native_audio/Props.h

@@ -0,0 +1,20 @@
+
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @generated by codegen project: GeneratePropsH.js
+ */
+#pragma once
+
+
+
+namespace facebook {
+namespace react {
+
+
+
+} // namespace react
+} // namespace facebook

package/harmony/audio/src/main/cpp/generated/react/renderer/components/react_native_audio/ShadowNodes.cpp

@@ -0,0 +1,19 @@
+
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @generated by codegen project: GenerateShadowNodeCpp.js
+ */
+
+#include <react/renderer/components/react_native_audio/ShadowNodes.h>
+
+namespace facebook {
+namespace react {
+
+
+
+} // namespace react
+} // namespace facebook

package/harmony/audio/src/main/cpp/generated/react/renderer/components/react_native_audio/ShadowNodes.h

@@ -0,0 +1,25 @@
+
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @generated by codegen project: GenerateShadowNodeH.js
+ */
+
+#pragma once
+
+#include <react/renderer/components/react_native_audio/EventEmitters.h>
+#include <react/renderer/components/react_native_audio/Props.h>
+#include <react/renderer/components/react_native_audio/States.h>
+#include <react/renderer/components/view/ConcreteViewShadowNode.h>
+#include <jsi/jsi.h>
+
+namespace facebook {
+namespace react {
+
+
+
+} // namespace react
+} // namespace facebook

package/harmony/audio/src/main/cpp/generated/react/renderer/components/react_native_audio/States.cpp

@@ -0,0 +1,18 @@
+
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @generated by codegen project: GenerateStateCpp.js
+ */
+#include <react/renderer/components/react_native_audio/States.h>
+
+namespace facebook {
+namespace react {
+
+
+
+} // namespace react
+} // namespace facebook

package/harmony/audio/src/main/cpp/generated/react/renderer/components/react_native_audio/States.h

@@ -0,0 +1,23 @@
+/**
+ * This code was generated by [react-native-codegen](https://www.npmjs.com/package/react-native-codegen).
+ *
+ * Do not edit this file as changes may cause incorrect behavior and will be lost
+ * once the code is regenerated.
+ *
+ * @generated by codegen project: GenerateStateH.js
+ */
+#pragma once
+
+#ifdef ANDROID
+#include <folly/dynamic.h>
+#include <react/renderer/mapbuffer/MapBuffer.h>
+#include <react/renderer/mapbuffer/MapBufferBuilder.h>
+#endif
+
+namespace facebook {
+namespace react {
+
+
+
+} // namespace react
+} // namespace facebook

package/harmony/audio/src/main/ets/AudioModule.ts

@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ */
+
+import { TurboModule } from "@rnoh/react-native-openharmony/ts";
+import type { TurboModuleContext } from "@rnoh/react-native-openharmony/ts";
+import { AudioRecordManager } from './AudioRecordManager';
+import { RecordingOptions, PathMap } from './AudioType';
+import { TM } from "./generated/ts";
+
+export class AudioModule extends TurboModule implements TM.RTNAudio.Spec {
+  ctx!: TurboModuleContext;
+  audioRecorderManager: AudioRecordManager = new AudioRecordManager(this.ctx);
+
+  prepareRecordingAtPath(path: string, options: RecordingOptions): Promise<void> {
+    return this.audioRecorderManager.prepareRecordingAtPath(path, options);
+  }
+
+  startRecording(): Promise<void> {
+    return this.audioRecorderManager.startRecording();
+  }
+
+  pauseRecording(): Promise<void> {
+    return this.audioRecorderManager.pauseRecording();
+  }
+
+  resumeRecording(): Promise<void> {
+    return this.audioRecorderManager.resumeRecording();
+  }
+
+  stopRecording(): Promise<void> {
+    return this.audioRecorderManager.stopRecording();
+  }
+
+  requestAuthorization(): Promise<boolean> {
+    return this.audioRecorderManager.requestAuthorization();
+  }
+
+  getAllPath(): PathMap {
+    return this.audioRecorderManager.getAllPath();
+  }
+
+  checkAuthorizationStatus(): Promise<boolean> {
+    return this.audioRecorderManager.checkAuthorizationStatus();
+  }
+}

package/harmony/audio/src/main/ets/AudioPackage.ts

@@ -0,0 +1,29 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ */
+
+import { RNPackage, TurboModulesFactory } from '@rnoh/react-native-openharmony/ts';
+import type { TurboModule, TurboModuleContext } from '@rnoh/react-native-openharmony/ts';
+import { AudioModule } from './AudioModule';
+import { TM } from "./generated/ts";
+
+class AudioModulesFactory extends TurboModulesFactory {
+  createTurboModule(name: string): TurboModule | null {
+    if (name === TM.RTNAudio.NAME) {
+      return new AudioModule(this.ctx)
+    }
+    return null;
+  }
+
+  hasTurboModule(name: string): boolean {
+    return name === TM.RTNAudio.NAME;
+  }
+}
+
+export class AudioPackage extends RNPackage {
+  createTurboModulesFactory(ctx: TurboModuleContext): TurboModulesFactory {
+    return new AudioModulesFactory(ctx);
+  }
+}

package/harmony/audio/src/main/ets/AudioRecordManager.ts

@@ -0,0 +1,352 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ */
+
+import media from '@ohos.multimedia.media';
+import { BusinessError } from '@ohos.base';
+import promptAction from '@ohos.promptAction';
+import { RecordingOptions, PathMap } from './AudioType';
+import fs from '@ohos.file.fs';
+import common from '@ohos.app.ability.common';
+import bundleManager from '@ohos.bundle.bundleManager';
+import abilityAccessCtrl, { Permissions } from '@ohos.abilityAccessCtrl';
+import type { RNOHContext,RNOHLogger } from '@rnoh/react-native-openharmony/ts';
+import { stopWatch } from './StopWatch';
+import util from '@ohos.util';
+
+const TIP_BOTTOM = 140;
+const TOAST_DURATION = 1500;
+const PERMISSION_LIST: Array<Permissions> = ['ohos.permission.MICROPHONE'];
+
+enum AVRecorderStateEnum {
+  IDLE = 'idle',
+  PREPARED = 'prepared',
+  STARTED = 'started',
+  PAUSED = 'paused',
+  STOPPED = 'stopped',
+  RELEASED = 'released',
+  ERROR = 'error'
+}
+
+export class AudioRecordManager {
+  private context: common.UIAbilityContext
+  private ctx!: RNOHContext;
+  private avRecorder: media.AVRecorder = {} as media.AVRecorder;
+  private isRecording: boolean = false;
+  private avProfile: media.AVRecorderProfile = {
+    audioBitrate: 100000, //音频比特率
+    audioChannels: 2, //音频声道数
+    audioCodec: media.CodecMimeType.AUDIO_AAC, // 音频编码格式，当前只支持aac
+    audioSampleRate: 48000, // 音频采样率
+    fileFormat: media.ContainerFormatType.CFT_MPEG_4A, //封装格式，当前只支持m4a
+  };
+  private avConfig: media.AVRecorderConfig = {
+    audioSourceType: media.AudioSourceType.AUDIO_SOURCE_TYPE_MIC, //音频输入源，这里设置为麦克风(1)
+    profile: this.avProfile,
+    url: 'fd://35', //使用fs.openSync()获取文件fd
+  };
+  private state: media.AVRecorderState = AVRecorderStateEnum.IDLE;
+  private timer: number | null = null;
+  private file: fs.File;
+  private includeBase64: boolean = false;
+  private filePath: string = '';
+  private logger: RNOHLogger
+
+  constructor(ctx: RNOHContext) {
+    this.ctx = ctx;
+    this.context = ctx.uiAbilityContext
+    this.logger = ctx.logger.clone("AudioRecorder");
+  }
+
+  //开始录制对应的配置
+  async prepareRecordingAtPath(path: string, options: RecordingOptions): Promise<void> {
+    if (this.isRecording) {
+      this.logger.error('Please call stopRecording before starting recording.');
+      return;
+    }
+    if (path === '') {
+      this.logger.error('Invalid path.');
+      return;
+    }
+    const isAuthorization = await this.checkAuthorizationStatus();
+    if (!isAuthorization) {
+      this.logger.error('Please obtain microphone authorization first.');
+      return;
+    }
+    try {
+      //创建录制实例
+      this.avRecorder = await media.createAVRecorder();
+      //监听状态改变
+      this.avRecorder.on('stateChange', (state: media.AVRecorderState) => {
+        this.state = state;
+        this.logger.info(`current state is ${state}.`);
+      })
+      //错误上报信息
+      this.avRecorder.on('error', (error: BusinessError) => {
+        this.logger.error(`AudioRecorder failed, code is ${error?.code}, message is ${error?.message}.`);
+        if (error.code === 5400107) {
+          this.logger.error(`Please call stopRecording before starting recording.`);
+        }
+      })
+      //初始化音频参数
+      this.avProfile.audioSampleRate = options.SampleRate;
+      this.avProfile.audioChannels = options.Channels;
+      this.avProfile.audioCodec = this.getAudioCodecFormatString(options.AudioEncoding);
+      this.avProfile.audioBitrate = options.AudioEncodingBitRate;
+      this.avProfile.fileFormat = this.getFileFormatFormatString(options.OutputFormat);
+      this.avConfig.audioSourceType = this.getAudioSourceFormatString(options.AudioSource);
+      //获取应用文件路径
+      this.filePath = path;
+      this.file = fs.openSync(path, fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE);
+      this.avConfig.url = `fd://${this.file.fd}`;
+      this.includeBase64 = options.IncludeBase64;
+      await this.avRecorder.prepare(this.avConfig).then((res) => {
+        this.logger.info(`${res}.`);
+      }).catch((err) => {
+        this.logger.error(`${err}.`);
+      });
+      this.logger.info(`Recording is prepared.`);
+      this.logger.debug('Recording is prepared.');
+    } catch (error) {
+      this.logger.error(`${JSON.stringify(error)}.`);
+    }
+  }
+
+  //请求麦克风权限
+  async requestAuthorization(): Promise<boolean> {
+    let grantStatus: boolean = await this.checkAuthorizationStatus(PERMISSION_LIST[0]);
+    let authorizationStatus: boolean = grantStatus;
+    if (grantStatus) {
+      //已经授权，可以继续访问目标操作
+      this.logger.info(`Already authorized.`);
+    } else {
+      this.logger.info(`No authorization.`);
+      await this.requestAuth(PERMISSION_LIST);
+      authorizationStatus = await this.checkAuthorizationStatus();
+    }
+    return authorizationStatus;
+  }
+
+  //请求权限
+  async requestAuth(permissions: Array<Permissions>) {
+    let atManager = abilityAccessCtrl.createAtManager();
+    try {
+      const data = await atManager.requestPermissionsFromUser(this.context, permissions);
+      let grantStatus: Array<number> = data.authResults;
+      let length: number = grantStatus.length;
+      for (let i = 0; i < length; i++) {
+        if (grantStatus[i] === 0) {
+          //用户授权，可以继续访问目标操作
+          this.logger.info(`Authorization successful.`);
+          this.logger.debug('Authorization successful.');
+        } else {
+          //用户拒绝授权，提示用户必须授权才能访问当前页面的功能，并引导用户到系统设置中打开相应的权限
+          this.logger.info(`Deny authorization.`);
+          this.logger.debug('Deny authorization! Recording requires authorization. Enter the system settings and turn on microphone permissions.');
+          return;
+        }
+      }
+    } catch (error) {
+      this.logger.error(`requestPermissionsFromUser failed, code is ${error?.code}, message is ${error?.message}.`);
+    }
+  }
+
+  //检查是否授权
+  async checkAuthorizationStatus(permission: Permissions = PERMISSION_LIST[0]): Promise<boolean> {
+    let atManager = abilityAccessCtrl.createAtManager();
+    let grantStatus: abilityAccessCtrl.GrantStatus;
+    //获取应用程序的accessTokenID
+    let tokenId: number;
+    try {
+      let bundleInfo: bundleManager.BundleInfo = await bundleManager.getBundleInfoForSelf(bundleManager.BundleFlag.GET_BUNDLE_INFO_WITH_APPLICATION);
+      let appInfo: bundleManager.ApplicationInfo = bundleInfo.appInfo;
+      tokenId = appInfo.accessTokenId;
+    } catch (error) {
+      this.logger.error(`getBundleInfoForSelf failed, code is ${error?.code}, message is ${error?.message}.`);
+    }
+    //检查应用是否被授予权限
+    try {
+      grantStatus = await atManager.checkAccessToken(tokenId, permission);
+    } catch (error) {
+      this.logger.error(`checkAccessToken failed, code is ${error?.code}, message is ${error?.message}.`);
+    }
+    return grantStatus === abilityAccessCtrl.GrantStatus.PERMISSION_GRANTED;
+  }
+
+  //格式化音频输入源
+  getAudioSourceFormatString(audioSource: number) {
+    switch (audioSource) {
+      case 0:
+        return media.AudioSourceType.AUDIO_SOURCE_TYPE_DEFAULT;
+      case 1:
+        return media.AudioSourceType.AUDIO_SOURCE_TYPE_MIC;
+      default:
+        this.logger.debug(`Using media.AudioSourceType.AUDIO_SOURCE_TYPE_MIC : ${media.AudioSourceType.AUDIO_SOURCE_TYPE_MIC}.`);
+        return media.AudioSourceType.AUDIO_SOURCE_TYPE_MIC;
+    }
+  }
+
+  //格式化音频编码格式，当前仅支持aac
+  getAudioCodecFormatString(audioEncoding: string) {
+    switch (audioEncoding) {
+      case 'aac':
+        return media.CodecMimeType.AUDIO_AAC;
+      default:
+        this.logger.debug(`Using media.CodecMimeType.AUDIO_AAC : ${media.CodecMimeType.AUDIO_AAC}.`);
+        return media.CodecMimeType.AUDIO_AAC;
+    }
+  }
+
+  //格式化封装格式，当前仅支持m4a
+  getFileFormatFormatString(fileFormat: string) {
+    switch (fileFormat) {
+      case 'm4a':
+        return media.ContainerFormatType.CFT_MPEG_4A;
+      default:
+        this.logger.debug(`Using media.ContainerFormatType.CFT_MPEG_4A : ${media.ContainerFormatType.CFT_MPEG_4A}.`);
+        return media.ContainerFormatType.CFT_MPEG_4A;
+    }
+  }
+
+  //开始录制
+  public async startRecording() {
+    try {
+      if (this.avRecorder.state === AVRecorderStateEnum.STARTED || this.avRecorder.state === AVRecorderStateEnum.PAUSED) {
+        this.logger.error('Please call stopRecording before starting recording.');
+        return;
+      }
+      if (this.avRecorder.state !== AVRecorderStateEnum.PREPARED) {
+        this.logger.error('Please call prepareRecording before starting recording.');
+        return;
+      }
+      await this.avRecorder.start();
+      this.isRecording = true;
+      this.logger.info(`start recording.`);
+      this.logger.debug('start recording.');
+      stopWatch.reset();
+      stopWatch.start();
+      this.startTimer();
+    } catch (error) {
+      this.logger.error(`startRecording failed, code is ${error?.code}, message is ${error?.message}.`);
+    }
+  }
+
+  //暂停录制
+  public async pauseRecording() {
+    if (this.avRecorder.state === AVRecorderStateEnum.STARTED) { //仅在started状态下调用pause为合理状态切换
+      try {
+        await this.avRecorder.pause();
+        stopWatch.stop();
+        this.logger.debug('pause recording.');
+      } catch (error) {
+        this.logger.error(`pauseRecording failed, code is ${error?.code}, message is ${error?.message}.`);
+      }
+    } else {
+      this.logger.error('It is reasonable to call pauseRecording only in the started state.');
+      return;
+    }
+  }
+
+  //恢复录制
+  public async resumeRecording() {
+    if (this.avRecorder.state === AVRecorderStateEnum.PAUSED) { //仅在paused状态下调用resume为合理状态切换
+      try {
+        await this.avRecorder.resume();
+        stopWatch.start();
+        this.logger.debug('resume recording.');
+      } catch (error) {
+        this.logger.error(`resumeRecording failed. code is ${error?.code}, message is ${error?.message}.`);
+      }
+    } else {
+      this.logger.error('It is reasonable to call resumeRecording only in the paused state.');
+      return;
+    }
+  }
+
+  //停止录制
+  public async stopRecording() {
+    if (this.avRecorder.state === AVRecorderStateEnum.STARTED || this.avRecorder.state === AVRecorderStateEnum.PAUSED) {
+      try {
+        //仅在started或者paused状态下调用stop为合理状态切换
+
+        await this.avRecorder.stop();
+        //重置
+        await this.avRecorder.reset();
+        //释放录制实例
+        await this.avRecorder.release();
+        this.isRecording = false;
+        this.stopTimer();
+        stopWatch.stop();
+      } catch (error) {
+        this.logger.error(`stopRecording failed. code is ${error?.code}, message is ${error?.message}.`);
+      } finally {
+        fs.closeSync(this.file);
+        this.convertM4aToBase64();
+        this.logger.debug('stop recording.');
+      }
+    } else {
+      this.logger.error('It is reasonable to call stopRecording only in the started or paused state.');
+      return;
+    }
+  }
+
+  //将音频文件转成base64格式
+  convertM4aToBase64() {
+    let currentTime: number = stopWatch.getTimeSeconds();
+    let base64: string = '';
+    let stat: fs.Stat = fs.lstatSync(this.filePath);
+    let flag: boolean = true;
+    if (this.includeBase64) {
+      let file: fs.File = fs.openSync(this.filePath, fs.OpenMode.READ_ONLY);
+      try {
+        let buffer = new ArrayBuffer(stat.size);
+        fs.readSync(file.fd, buffer);
+        let unit8Array: Uint8Array = new Uint8Array(buffer);
+        let base64Helper = new util.Base64Helper();
+        base64 = base64Helper.encodeToStringSync(unit8Array, util.Type.BASIC);
+      } catch (error) {
+        flag = false;
+        this.logger.error(`base64Helper encodeToString failed. code is ${error?.code}, message is ${error?.message}.`);
+      } finally {
+        fs.closeSync(file);
+      }
+    }
+    this.ctx.rnInstance.emitDeviceEvent('recordingFinished', {
+      base64,
+      duration: currentTime,
+      status: flag ? 'OK' : 'ERROR',
+      audioFileURL: this.filePath,
+      audioFileSize: stat.size
+    });
+  }
+
+  //获取存储路径
+  public getAllPath(): PathMap {
+    const pathMap: PathMap = {
+      FilesDirectoryPath: this.context.filesDir,
+      CacheDirectoryPath: this.context.cacheDir,
+      TempsDirectoryPath: this.context.tempDir,
+    }
+    this.logger.info(`return the pathMap.`);
+    return pathMap;
+  }
+
+  private startTimer() {
+    this.stopTimer();
+    this.timer = setInterval(() => {
+      if (this.avRecorder.state === AVRecorderStateEnum.STARTED) {
+        let currentTime: number = stopWatch.getTimeSeconds();
+        this.ctx.rnInstance.emitDeviceEvent('recordingProgress', { currentTime });
+      }
+    }, 1000)
+  }
+
+  private stopTimer() {
+    if (this.timer !== null) {
+      clearInterval(this.timer);
+      this.timer = null;
+    }
+  }
+}

package/harmony/audio/src/main/ets/AudioType.ts

@@ -0,0 +1,26 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ */
+
+type AudioQuality = 'Low' | 'Medium' | 'High';
+
+export interface RecordingOptions {
+  SampleRate: number,
+  Channels: number,
+  AudioQuality?: AudioQuality,
+  AudioEncoding: string,
+  MeteringEnabled?: boolean,
+  MeasurementMode?: boolean,
+  AudioEncodingBitRate: number,
+  IncludeBase64: boolean,
+  OutputFormat: string,
+  AudioSource: number
+}
+
+export interface PathMap {
+  FilesDirectoryPath: string,
+  CacheDirectoryPath: string,
+  TempsDirectoryPath: string,
+}

package/harmony/audio/src/main/ets/StopWatch.ts

@@ -0,0 +1,44 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ */
+
+class StopWatch {
+  private startTime: number = 0;
+  private elapsedTime: number = 0;
+  private paused: boolean = true;
+
+  public start(): void {
+    this.startTime = new Date().getTime();
+    this.paused = false;
+  }
+
+  public stop(): number {
+    if (!this.paused) {
+      let nowTime = new Date().getTime();
+      this.elapsedTime += (nowTime - this.startTime) / 1000;
+      this.paused = true;
+    }
+    return this.elapsedTime;
+  }
+
+  public reset(): void {
+    this.startTime = 0;
+    this.elapsedTime = 0;
+    this.paused = true;
+  }
+
+  public getTimeSeconds(): number {
+    let seconds: number = 0;
+    if (this.paused) {
+      seconds = this.elapsedTime;
+    } else {
+      let nowTime = new Date().getTime();
+      seconds = this.elapsedTime + (nowTime - this.startTime) / 1000;
+    }
+    return seconds;
+  }
+}
+
+export const stopWatch = new StopWatch();

package/harmony/audio/src/main/ets/generated/components/ts.ts

@@ -0,0 +1,5 @@
+
+/**
+ */
+
+export {}

package/harmony/audio/src/main/ets/generated/index.ets

@@ -0,0 +1,5 @@
+/**
+ * This code was generated by "react-native codegen-lib-harmony"
+ */
+
+export * from "./ts"

package/harmony/audio/src/main/ets/generated/ts.ts

@@ -0,0 +1,6 @@
+/**
+ * This code was generated by "react-native codegen-lib-harmony"
+ */
+
+export * as RNC from "./components/ts"
+export * as TM from "./turboModules/ts"

package/harmony/audio/src/main/ets/generated/turboModules/RTNAudio.ts

@@ -0,0 +1,32 @@
+/**
+ * This code was generated by "react-native codegen-lib-harmony"
+ */
+
+import { Tag } from "@rnoh/react-native-openharmony/ts"
+
+export namespace RTNAudio {
+  export const NAME = 'RTNAudio' as const
+
+  export type RecordingOptions = {SampleRate: number, Channels: number, AudioQuality?: string, AudioEncoding: string, MeteringEnabled?: boolean, MeasurementMode?: boolean, AudioEncodingBitRate: number, IncludeBase64: boolean, OutputFormat: string, AudioSource: number}
+  
+  export type PathMap = {FilesDirectoryPath: string, CacheDirectoryPath: string, TempsDirectoryPath: string}
+  
+  export interface Spec {
+    prepareRecordingAtPath(path: string, options: RecordingOptions): Promise<void>;
+  
+    requestAuthorization(): Promise<boolean>;
+  
+    startRecording(): Promise<void>;
+  
+    pauseRecording(): Promise<void>;
+  
+    resumeRecording(): Promise<void>;
+  
+    stopRecording(): Promise<void>;
+  
+    getAllPath(): PathMap;
+  
+    checkAuthorizationStatus(): Promise<boolean>;
+  
+  }
+}

package/harmony/audio/src/main/ets/generated/turboModules/ts.ts

@@ -0,0 +1,5 @@
+/**
+ * This code was generated by "react-native codegen-lib-harmony"
+ */
+
+export * from "./RTNAudio"

package/harmony/audio/src/main/module.json5

@@ -0,0 +1,19 @@
+{
+  module: {
+    name: 'audio',
+    type: 'har',
+    deviceTypes: ['default'],
+    mainElement: "AudioRecorder",
+    requestPermissions: [
+      {
+        name: 'ohos.permission.MICROPHONE',
+        reason: "$string:label_permission_microphone",
+        usedScene: {
+          abilities: [
+            "EntryAbility"
+          ],
+        },
+      }
+    ]
+  },
+}

package/harmony/audio/src/main/resources/base/element/string.json

@@ -0,0 +1,20 @@
+{
+  "string": [
+    {
+      "name": "page_show",
+      "value": "page from npm package"
+    },
+    {
+      "name": "label_permission_write_media",
+      "value": "用于媒体文件写"
+    },
+    {
+      "name": "label_permission_read_media",
+      "value": "用于媒体文件读"
+    },
+    {
+      "name": "label_permission_microphone",
+      "value": "用于录制音频"
+    }
+  ]
+}

package/harmony/audio/src/main/resources/en_US/element/string.json

@@ -0,0 +1,8 @@
+{
+  "string": [
+    {
+      "name": "page_show",
+      "value": "page from npm package"
+    }
+  ]
+}

package/harmony/audio/src/main/resources/zh_CN/element/string.json

@@ -0,0 +1,8 @@
+{
+  "string": [
+    {
+      "name": "page_show",
+      "value": "page from npm package"
+    }
+  ]
+}

package/harmony/audio/ts.ts

@@ -0,0 +1,7 @@
+/*
+ * Copyright (c) 2024 Huawei Device Co., Ltd. All rights reserved
+ * Use of this source code is governed by a MIT license that can be
+ * found in the LICENSE file.
+ */
+export * from "./src/main/ets/AudioPackage";
+export * from "./src/main/ets/AudioModule";

package/index.js

@@ -0,0 +1,169 @@
+'use strict';
+
+import React from "react";
+
+import ReactNative, {
+  NativeModules,
+  DeviceEventEmitter,
+  PermissionsAndroid,
+  Platform
+} from "react-native";
+
+// @ts-ignore We want to check whether __turboModuleProxy exitst, it may not
+const isTurboModuleEnabled = global.__turboModuleProxy != null;
+
+const nativeRecorderManager = isTurboModuleEnabled ?
+  require("./NativeAudio").default :
+  NativeModules.AudioRecorderManager;
+
+const AudioRecorder = {
+  prepareRecordingAtPath: function (path, options) {
+    if (this.progressSubscription) this.progressSubscription.remove();
+    this.progressSubscription = DeviceEventEmitter.addListener('recordingProgress',
+      (data) => {
+        if (this.onProgress) {
+          this.onProgress(data);
+        }
+      }
+    );
+
+    if (this.finishedSubscription) this.finishedSubscription.remove();
+    this.finishedSubscription = DeviceEventEmitter.addListener('recordingFinished',
+      (data) => {
+        if (this.onFinished) {
+          this.onFinished(data);
+        }
+      }
+    );
+
+    const defaultOptions = {
+      SampleRate: 48000,
+      Channels: 2,
+      AudioQuality: 'High',
+      AudioEncoding: 'ima4',
+      OutputFormat: 'mpeg_4',
+      MeteringEnabled: false,
+      MeasurementMode: false,
+      AudioEncodingBitRate: 100000,
+      IncludeBase64: false,
+      AudioSource: 0
+    };
+
+    const recordingOptions = { ...defaultOptions, ...options };
+
+    if (Platform.OS === 'ios') {
+      nativeRecorderManager.prepareRecordingAtPath(
+        path,
+        recordingOptions.SampleRate,
+        recordingOptions.Channels,
+        recordingOptions.AudioQuality,
+        recordingOptions.AudioEncoding,
+        recordingOptions.MeteringEnabled,
+        recordingOptions.MeasurementMode,
+        recordingOptions.IncludeBase64
+      );
+    } else {
+      return nativeRecorderManager.prepareRecordingAtPath(path, recordingOptions);
+    }
+  },
+  startRecording: function () {
+    return nativeRecorderManager.startRecording();
+  },
+  pauseRecording: function () {
+    return nativeRecorderManager.pauseRecording();
+  },
+  resumeRecording: function () {
+    return nativeRecorderManager.resumeRecording();
+  },
+  stopRecording: async function () {
+    await nativeRecorderManager.stopRecording();
+    const timer = setTimeout( ()=>{
+      this.removeListeners();
+      this.clearCallback();
+      clearTimeout(timer);
+    }, 200 );
+  },
+  checkAuthorizationStatus: nativeRecorderManager.checkAuthorizationStatus,
+  requestAuthorization: async () => {
+    if (Platform.OS === 'harmony') {
+      const res = await nativeRecorderManager.requestAuthorization();
+      return res;
+    } else {
+      return new Promise((resolve, reject) => {
+        PermissionsAndroid.request(
+          PermissionsAndroid.PERMISSIONS.RECORD_AUDIO
+        ).then(result => {
+          if (result === PermissionsAndroid.RESULTS.GRANTED || result === true) {
+            resolve(true);
+          }
+          else {
+            resolve(false);
+          }
+        });
+      });
+    }
+  },
+  getAllPath: function () {
+    const res = nativeRecorderManager.getAllPath();
+    return res;
+  },
+  removeListeners: function () {
+    if (this.progressSubscription) this.progressSubscription.remove();
+    if (this.finishedSubscription) this.finishedSubscription.remove();
+  },
+  clearCallback: function () {
+    if (this.onProgress) {
+        this.onProgress = null;
+      }
+    if (this.onFinished) {
+      this.onFinished = null;
+    }
+  }
+};
+
+let AudioUtils = {};
+let AudioSource = {};
+
+if (Platform.OS === 'ios') {
+  AudioUtils = {
+    MainBundlePath: nativeRecorderManager.MainBundlePath,
+    CachesDirectoryPath: nativeRecorderManager.NSCachesDirectoryPath,
+    DocumentDirectoryPath: nativeRecorderManager.NSDocumentDirectoryPath,
+    LibraryDirectoryPath: nativeRecorderManager.NSLibraryDirectoryPath,
+  };
+} else if (Platform.OS === 'harmony') {
+  const { FilesDirectoryPath, CacheDirectoryPath, TempsDirectoryPath } = AudioRecorder.getAllPath();
+  AudioUtils = {
+    FilesDirectoryPath,
+    CacheDirectoryPath,
+    TempsDirectoryPath
+  };
+  AudioSource = {
+    DEFAULT: 0,
+    MIC: 1,
+  };
+} else if (Platform.OS === 'android') {
+  AudioUtils = {
+    MainBundlePath: nativeRecorderManager.MainBundlePath,
+    CachesDirectoryPath: nativeRecorderManager.CachesDirectoryPath,
+    DocumentDirectoryPath: nativeRecorderManager.DocumentDirectoryPath,
+    LibraryDirectoryPath: nativeRecorderManager.LibraryDirectoryPath,
+    PicturesDirectoryPath: nativeRecorderManager.PicturesDirectoryPath,
+    MusicDirectoryPath: nativeRecorderManager.MusicDirectoryPath,
+    DownloadsDirectoryPath: nativeRecorderManager.DownloadsDirectoryPath
+  };
+  AudioSource = {
+    DEFAULT: 0,
+    MIC: 1,
+    VOICE_UPLINK: 2,
+    VOICE_DOWNLINK: 3,
+    VOICE_CALL: 4,
+    CAMCORDER: 5,
+    VOICE_RECOGNITION: 6,
+    VOICE_COMMUNICATION: 7,
+    REMOTE_SUBMIX: 8, // added in API 19
+    UNPROCESSED: 9, // added in API 24
+  };
+}
+
+module.exports = { AudioRecorder, AudioUtils, AudioSource };

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "@react-native-ohos/react-native-audio",
+  "version": "4.2.3-rc.1",
+  "description": "React Native extension for recording audio",
+  "main": "index.js",
+  "author": "Joshua Sierles <joshua@diluvia.net> (https://github.com/jsierles)",
+  "harmony": {
+    "alias": "react-native-audio"
+  },
+  "files": [
+    "/harmony",
+    "README.md",
+    "LICENSE",
+    "index.js",
+    "NativeAudio.ts"
+  ],
+  "keywords": [
+    "react-native",
+    "audio",
+    "record"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://gitee.com/openharmony-sig/rntpc_react-native-audio"
+  },
+  "scripts": {
+    "codegen-lib": "react-native codegen-lib-harmony --no-safety-check --npm-package-name react-native-audio --cpp-output-path ./harmony/audio/src/main/cpp/generated --ets-output-path ./harmony/audio/src/main/ets/generated --turbo-modules-spec-paths ./NativeAudio.ts "
+  },
+  "devDependencies": {
+    "@rnoh/react-native-harmony-cli": "npm:@react-native-oh/react-native-harmony-cli@^0.0.27"
+  },
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  },
+  "nativePackage": true
+}