@react-native-ohos/audio-toolkit 2.0.4-rc.1

package/harmony/audio_toolkit/src/main/ets/RNCAudioRecorderTurboModule.ts

@@ -0,0 +1,261 @@
+/**
+ * MIT License
+ *
+ * Copyright (C) 2024 Huawei Device Co., Ltd.
+ *
+ * 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.
+ */
+
+import { TurboModule, type TurboModuleContext } from '@rnoh/react-native-openharmony/ts';
+import { type TM } from '@rnoh/react-native-openharmony/generated/ts';
+import { type BusinessError } from '@ohos.base';
+import media from '@ohos.multimedia.media';
+import fs from '@ohos.file.fs';
+import abilityAccessCtrl, { type Permissions } from '@ohos.abilityAccessCtrl';
+import picker from '@ohos.file.picker';
+import logger from './Logger';
+
+const TAG = 'RCTAudioRecorderTurboModule';
+
+const PERMISSIONS: Array<Permissions> = [
+  'ohos.permission.MICROPHONE',
+];
+
+enum FormatType {
+  CFT_MPEG_4 = 'mp4',
+  CFT_MPEG_4A = 'm4a'
+}
+
+export class RCTAudioRecorderTurboModule extends TurboModule {
+  private _file: fs.File;
+  // 音频参数
+  private avRecorder: media.AVRecorder | undefined = undefined;
+  private avProfile: media.AVRecorderProfile;
+  private avConfig: media.AVRecorderConfig;
+  private readonly AUDIOBITRATE_DEFAULT = 48000;
+  private readonly AUDIOCHANNELS_DEFAULT = 2;
+  private readonly AUDIOSAMPLERATE = 48000;
+  private readonly FD_PATH = 'fd://';
+
+  constructor(protected ctx: TurboModuleContext) {
+    super(ctx);
+    this.ctx = ctx;
+  }
+
+  // 注册audioRecorder回调函数
+  setAudioRecorderCallback(recorderId: number): void {
+    if (this.avRecorder !== undefined) {
+      // 状态机变化回调函数
+      this.avRecorder.on('stateChange', (state: media.AVRecorderState, reason: media.StateChangeReason) => {
+        this.toEmit(recorderId, 'info', {
+          event: 'info',
+          data: {
+            info: {
+              what: state,
+              extra: reason,
+            },
+          },
+        });
+      });
+      // 错误上报回调函数
+      this.avRecorder.on('error', (err: BusinessError) => {
+        this.toEmit(recorderId, 'error', {
+          event: 'err',
+          message: 'harmony MediaRecorder error',
+        });
+      });
+    }
+  }
+
+  emit(name: string, data: object): void {
+    this.ctx.rnInstance.emitDeviceEvent(name, data);
+  }
+
+  toEmit(recorderId: number, name: string, data: object): void {
+    this.emit(`RCTAudioRecorderEvent:${recorderId}`, { event: name, data });
+  }
+
+  // 开始录制对应的流程
+  async startRecordingProcess(path: string, next: (object?, fsPath?: string) => void,
+    preparingCall?: (object?) => void): Promise<void> {
+    try {
+      let audioSaveOptions = new picker.AudioSaveOptions();
+      audioSaveOptions.newFileNames = [path];
+      let audioPicker = new picker.AudioViewPicker();
+
+      audioPicker.save(audioSaveOptions, async (err: BusinessError, audioSaveResult: Array<string>) => {
+        if (err || !audioSaveResult || audioSaveResult.length === 0) {
+          next(null);
+          return;
+        }
+        preparingCall(null);
+        this._file = fs.openSync(audioSaveResult[0], fs.OpenMode.READ_WRITE);
+        this.avConfig.url = this.FD_PATH + this._file.fd;
+        this.requestPermission().then(async res => {
+          if (res) {
+            await this.avRecorder.prepare(this.avConfig);
+            await this.avRecorder.start();
+            next(null, audioSaveResult[0]);
+          } else {
+            next(null);
+          }
+        });
+      });
+    } catch (error) {
+      next(null);
+    }
+  }
+
+  // 以下demo为使用fs文件系统打开沙箱地址获取媒体文件地址并通过url属性进行播放示例
+  async prepare(recorderId: number, path: string, option: TM.RCTAudioRecorder.RecorderOptions
+    , next: (object?, fsPath?: string) => void, preparingCall?: (object?) => void): Promise<void> {
+    if (path === null || path === undefined) {
+      next({
+        err: 'invalidpath',
+        stackTrace: 'Exception occurred while parsing stack trace',
+        message: 'Provided path was empty',
+      });
+      return;
+    }
+    if (this.avRecorder !== undefined) {
+      await this.avRecorder.release();
+      this.avRecorder = undefined;
+    }
+    // 1.创建录制实例
+    this.avRecorder = await media.createAVRecorder();
+    this.setAudioRecorderCallback(recorderId);
+    this.avProfile = {
+      audioBitrate: option.bitrate ?? this.AUDIOBITRATE_DEFAULT, // 音频比特率
+      audioChannels: option.channels ?? this.AUDIOCHANNELS_DEFAULT, // 音频声道数
+      audioCodec: media.CodecMimeType.AUDIO_AAC, // 音频编码格式，当前只支持aac
+      audioSampleRate: option.sampleRate ?? this.AUDIOSAMPLERATE, // 音频采样率
+      fileFormat: this.getFileFormat(option.format, path), // 封装格式，当前只支持m4a、mp4
+    };
+    logger.debug(`avProfile = ${JSON.stringify(this.avProfile)}}`);
+    this.avConfig = {
+      audioSourceType: media.AudioSourceType.AUDIO_SOURCE_TYPE_MIC, // 音频输入源，这里设置为麦克风
+      profile: this.avProfile,
+      url: '', // 参考应用文件访问与管理开发示例新建并读写一个文件
+    };
+    await this.startRecordingProcess(path, next, preparingCall);
+  }
+
+  private formatFromPath(path: String): media.ContainerFormatType {
+    if (!path) {
+      return media.ContainerFormatType.CFT_MPEG_4A;
+    }
+    let ext = path.substring(path.lastIndexOf('.') + 1);
+    if (!ext) {
+      return media.ContainerFormatType.CFT_MPEG_4A;
+    }
+    return this.getFileFormat(ext);
+  }
+
+  getFileFormat(format: string, path?: string): media.ContainerFormatType {
+    if (!format) {
+      return this.formatFromPath(path);
+    }
+    switch (format) {
+      case FormatType.CFT_MPEG_4:
+        return media.ContainerFormatType.CFT_MPEG_4;
+      default:
+        return media.ContainerFormatType.CFT_MPEG_4A
+    }
+  }
+
+  async record(recorderId: number, next: (object?) => void): Promise<void> {
+    if (this.avRecorder !== undefined) {
+      this.avRecorder.resume();
+      next();
+    } else {
+      next({ code: 'notfound', recorderId: `${recorderId}not found.` });
+    }
+  }
+
+  async pause(recorderId: number, next: () => void): Promise<void> {
+    if (this.avRecorder !== undefined) {
+      // 1. 停止录制
+      if (this.avRecorder.state === 'started') { // 仅在started状态下调用started为合理状态切换
+        await this.avRecorder.pause();
+      }
+    }
+    next();
+  }
+
+  /**
+   * Get clipboard image as JPG in base64, this method returns a `Promise`, so you can use following code to get clipboard content
+   * ```javascript
+   * async _getContent() {
+   *   var content = await Clipboard.getImageJPG();
+   * }
+   * ```
+   */
+
+  // 停止录制对应的流程
+  async stop(recorderId: number, next: (object?) => void): Promise<void> {
+    if (this.avRecorder !== undefined) {
+      // 1. 停止录制
+      if (this.avRecorder.state === 'started' ||
+        this.avRecorder.state === 'paused') { // 仅在started或者paused状态下调用stop为合理状态切换
+        await this.avRecorder.stop();
+      }
+      next();
+    } else {
+      next({ code: 'notfound', recorderId: `${recorderId}not found.` });
+    }
+  }
+
+  /**
+   * recorder destroy
+   * @param recorderId
+   * @param next
+   * @returns void
+   */
+  async destroy(recorderId: number, next: (object?) => void): Promise<void> {
+    if (this.avRecorder) {
+      //重置
+      await this.avRecorder.reset();
+      //释放录制实例
+      await this.avRecorder.release();
+      //关闭录制文件fd
+      fs.close(this._file);
+      this.toEmit(recorderId, 'info', {
+        message: 'Destroyed recorder',
+      });
+    }
+    logger.debug(TAG, 'RCTAudioRecorderTurboModule destroy');
+  }
+
+  requestPermission(): Promise<boolean> {
+    return new Promise<boolean>((resolve) => {
+      abilityAccessCtrl.createAtManager()
+        .requestPermissionsFromUser(this.ctx.uiAbilityContext, PERMISSIONS).then(result => {
+        if (result.authResults[0] === 0) {
+          resolve(true);
+        } else {
+          logger.debug(`getString,text out:用户拒绝授权`);
+          resolve(false);
+        }
+      }).catch(() => {
+        logger.debug(`getString,text out:用户拒绝授权`);
+        resolve(false);
+      });
+    });
+  }
+}

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

@@ -0,0 +1,7 @@
+{
+  "module": {
+    "name": "audio_toolkit",
+    "type": "har",
+    "deviceTypes": ['default'],
+  }
+}

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

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

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

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

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

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

package/harmony/audio_toolkit/ts.ts

@@ -0,0 +1,26 @@
+/**
+ * MIT License
+ *
+ * Copyright (C) 2023 Huawei Device Co., Ltd.
+ *
+ * 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.
+ */
+
+export * from './src/main/ets/AudioToolkitPackage'
+export * from './src/main/ets/RNCAudioPlayerTurboModule'

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "@react-native-ohos/audio-toolkit",
+  "version": "2.0.4-rc.1",
+  "description": "Cross-platform audio library for React Native",
+  "main": "./src/index.ts",
+  "types": "typings/index.d.ts",
+  "harmony": {
+    "alias": "@react-native-community/audio-toolkit",
+    "codegenConfig": {
+      "specPaths": [
+        "./src"
+      ]
+    }
+  },
+  "directories": {
+    "doc": "docs"
+  },
+  "scripts": {
+    "start": "react-native start"
+  },
+  "homepage": "https://github.com/react-native-community/react-native-audio-toolkit#readme",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/react-native-community/react-native-audio-toolkit.git"
+  },
+  "bugs": {
+    "url": "https://github.com/react-native-community/react-native-audio-toolkit/issues"
+  },
+  "dependencies": {
+    "async": "^2.6.3",
+    "eventemitter3": "^1.2.0",
+    "lodash": "^4.17.19",
+    "@react-native-community/audio-toolkit": "2.0.3"
+  },
+  "keywords": [
+    "react-native",
+    "react native",
+    "audio",
+    "audio toolkit",
+    "audio-toolkit"
+  ],
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org/",
+    "access": "public"
+  }
+}

package/src/Player.js

@@ -0,0 +1,329 @@
+import { DeviceEventEmitter, NativeAppEventEmitter, Platform } from 'react-native';
+import RCTAudioPlayer from './PlayerModule'
+import async from 'async';
+import EventEmitter from 'eventemitter3';
+import MediaStates from '@react-native-community/audio-toolkit/src/MediaStates';
+// Only import specific items from lodash to keep build size down
+import filter from 'lodash/filter';
+import identity from 'lodash/identity';
+import last from 'lodash/last';
+import noop from 'lodash/noop';
+
+let playerId = 0;
+
+export const PlaybackCategories = {
+  Playback: 1,
+  Ambient: 2,
+  SoloAmbient: 3,
+}
+
+const defaultPlayerOptions = {
+  autoDestroy: true,
+  continuesToPlayInBackground: false,
+  category: PlaybackCategories.Playback,
+  mixWithOthers: false,
+};
+
+/**
+ * Represents a media player
+ * @constructor
+ */
+class Player extends EventEmitter {
+  constructor(path, options = defaultPlayerOptions) {
+    super();
+
+    this._path = path;
+
+    if (options == null) {
+      this._options = defaultPlayerOptions;
+    } else {
+      // Make sure all required options have values
+      if (options.autoDestroy == null)
+        options.autoDestroy = defaultPlayerOptions.autoDestroy;
+      if (options.continuesToPlayInBackground == null)
+        options.continuesToPlayInBackground = defaultPlayerOptions.continuesToPlayInBackground;
+      if (options.category == null)
+        options.category = defaultPlayerOptions.category;
+      if (options.mixWithOthers == null)
+        options.mixWithOthers = defaultPlayerOptions.mixWithOthers;
+
+      this._options = options;
+    }
+
+    this._playerId = playerId++;
+    this._reset();
+
+    const appEventEmitter = Platform.OS === 'ios' ? NativeAppEventEmitter : DeviceEventEmitter;
+
+    appEventEmitter.addListener(`RCTAudioPlayerEvent:${this._playerId}`, (payload: Event) => {
+      this._handleEvent(payload.event, payload.data);
+    });
+  }
+
+  _reset() {
+    this._state = MediaStates.IDLE;
+    this._volume = 1.0;
+    this._pan = 0.0;
+    this._speed = 1.0;
+    this._wakeLock = false;
+    this._duration = -1;
+    this._position = -1;
+    this._lastSync = -1;
+    this._looping = false;
+  }
+
+  _storeInfo(info) {
+    if (!info) {
+      return;
+    }
+
+    this._duration = info.duration;
+    this._position = info.position;
+    this._lastSync = Date.now();
+  }
+
+  _updateState(err, state, results) {
+    this._state = err ? MediaStates.ERROR : state;
+
+    if (err || !results) {
+      return;
+    }
+
+    // Use last truthy value from results array as new media info
+    const info = last(filter(results, identity));
+    this._storeInfo(info);
+  }
+
+  _handleEvent(event, data) {
+    switch (event) {
+      case 'progress':
+        // TODO
+        break;
+      case 'ended':
+        this._updateState(null, MediaStates.PREPARED);
+        this._position = -1;
+        break;
+      case 'info':
+        // TODO
+        break;
+      case 'error':
+        this._state = MediaStates.ERROR;
+        break;
+      case 'pause':
+        this._state = MediaStates.PAUSED;
+        this._storeInfo(data.info);
+        break;
+      case 'forcePause':
+        this.pause();
+        break;
+      case 'looped':
+        this._position = 0;
+        this._lastSync = Date.now();
+        break;
+    }
+
+    this.emit(event, data);
+  }
+
+  prepare(callback = noop) {
+    this._updateState(null, MediaStates.PREPARING);
+
+    const tasks = [];
+
+    // Prepare player
+    tasks.push((next) => {
+      RCTAudioPlayer.prepare(this._playerId, this._path, this._options, next);
+    });
+
+    // Set initial values for player options
+    tasks.push((next) => {
+      RCTAudioPlayer.set(
+        this._playerId,
+        {
+          volume: this._volume,
+          pan: this._pan,
+          wakeLock: this._wakeLock,
+          looping: this._looping,
+          speed: this._speed,
+        },
+        next,
+      );
+    });
+
+    async.series(tasks, (err, results) => {
+      this._updateState(err, MediaStates.PREPARED, results);
+      callback(err);
+    });
+
+    return this;
+  }
+
+  play(callback = noop) {
+    const tasks = [];
+    // Make sure player is prepared
+    if (this._state === MediaStates.IDLE) {
+      tasks.push((next) => {
+        this.prepare(next);
+      });
+    }
+
+    // Start playback
+    tasks.push((next) => {
+      RCTAudioPlayer.play(this._playerId, next);
+    });
+    async.series(tasks, (err, results) => {
+      this._updateState(err, MediaStates.PLAYING, results);
+      callback(err);
+    });
+
+    return this;
+  }
+
+  pause(callback = noop) {
+    RCTAudioPlayer.pause(this._playerId, (err, results) => {
+      // Android emits a pause event on the native side
+      if (Platform.OS === 'ios' || Platform.OS === 'harmony') {
+        this._updateState(err, MediaStates.PAUSED, [results]);
+      }
+      callback(err);
+    });
+
+    return this;
+  }
+
+  playPause(callback = noop) {
+    if (this._state === MediaStates.PLAYING) {
+      this.pause((err) => {
+        callback(err, true);
+      });
+    } else {
+      this.play((err) => {
+        callback(err, false);
+      });
+    }
+
+    return this;
+  }
+
+  stop(callback = noop) {
+    RCTAudioPlayer.stop(this._playerId, (err, results) => {
+      this._updateState(err, MediaStates.PREPARED);
+      this._position = -1;
+      callback(err);
+    });
+
+    return this;
+  }
+
+  destroy(callback = noop) {
+    this._reset();
+    RCTAudioPlayer.destroy(this._playerId, callback);
+  }
+
+  seek(position = 0, callback = noop) {
+    // Store old state, but not if it was already SEEKING
+    if (this._state != MediaStates.SEEKING) {
+      this._preSeekState = this._state;
+    }
+
+    this._updateState(null, MediaStates.SEEKING);
+    RCTAudioPlayer.seek(this._playerId, position, (err, results) => {
+      if (err && err.err === 'seekfail') {
+        // Seek operation was cancelled; ignore
+        return;
+      }
+      this._updateState(err, this._preSeekState, [results]);
+      callback(err);
+    });
+  }
+
+  _setIfInitialized(options, callback = noop) {
+    if (this._state >= MediaStates.PREPARED) {
+      RCTAudioPlayer.set(this._playerId, options, callback);
+    }
+  }
+
+  set volume(value) {
+    this._volume = value;
+    this._setIfInitialized({ volume: value });
+  }
+
+  set currentTime(value) {
+    this.seek(value);
+  }
+
+  set wakeLock(value) {
+    this._wakeLock = value;
+    this._setIfInitialized({ wakeLock: value });
+  }
+
+  set looping(value) {
+    this._looping = value;
+    this._setIfInitialized({ looping: value });
+  }
+
+  set speed(value) {
+    this._speed = value;
+    this._setIfInitialized({ speed: value });
+  }
+
+  get currentTime() {
+    // Queue up an async call to get an accurate current time
+    RCTAudioPlayer.getCurrentTime(this._playerId, (err, results) => {
+      this._storeInfo(results);
+    });
+
+    if (this._position < 0) {
+      return -1;
+    }
+
+    if (this._state === MediaStates.PLAYING) {
+      // Estimate the current time based on the latest info we received
+      let pos = this._position + (Date.now() - this._lastSync) * this._speed;
+      pos = Math.min(pos, this._duration);
+      return pos;
+    }
+
+    return this._position;
+  }
+
+  get volume() {
+    return this._volume;
+  }
+  get looping() {
+    return this._looping;
+  }
+  get duration() {
+    return this._duration;
+  }
+  get speed() {
+    return this._speed;
+  }
+
+  get state() {
+    return this._state;
+  }
+  get canPlay() {
+    return this._state >= MediaStates.PREPARED;
+  }
+  get canStop() {
+    return this._state >= MediaStates.PLAYING;
+  }
+  get canPrepare() {
+    return this._state == MediaStates.IDLE;
+  }
+  get isPlaying() {
+    return this._state == MediaStates.PLAYING;
+  }
+  get isStopped() {
+    return this._state <= MediaStates.PREPARED;
+  }
+  get isPaused() {
+    return this._state == MediaStates.PAUSED;
+  }
+  get isPrepared() {
+    return this._state == MediaStates.PREPARED;
+  }
+}
+
+export default Player;