import bundleManager from '@ohos.bundle.bundleManager';
import abilityAccessCtrl, { Permissions } from '@ohos.abilityAccessCtrl';

async function checkAccessToken(permission: Permissions): Promise<abilityAccessCtrl.GrantStatus> {
  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 (err) {
    console.error(`getBundleInfoForSelf failed, code is ${err.code}, message is ${err.message}`);
  }

  // Убедитесь, что заявка удовлетворена.
  try {
    grantStatus = await atManager.checkAccessToken(tokenId, permission);
  } catch (err) {
    console.error(`checkAccessToken failed, code is ${err.code}, message is ${err.message}`);
  }

  return grantStatus;
}

export async function checkPermissions(permission: Permissions): Promise<boolean> {
  let grantStatus: abilityAccessCtrl.GrantStatus = await checkAccessToken(permission);

  if (grantStatus === abilityAccessCtrl.GrantStatus.PERMISSION_GRANTED) {
    return true
  } else {
    return false
  }
}

import media from '@ohos.multimedia.media';
import fs from '@ohos.file.fs';
import promptAction from '@ohos.promptAction';
import audio from '@ohos.multimedia.audio';

export default class AudioRecorder {
  private audioFile = null
  private avRecorder: media.AVRecorder | undefined = undefined;
  private avProfile: media.AVRecorderProfile = {
    audioBitrate: 48000, // Битрейт аудио
    audioChannels: audio.AudioChannel.CHANNEL_1, // Количество каналов в Аудио
    audioCodec: media.CodecMimeType.AUDIO_AAC, // Формат кодирования аудио, в настоящее время поддерживает только aac.
    audioSampleRate: audio.AudioSamplingRate.SAMPLE_RATE_16000, // Частота дискретизации аудио
    fileFormat: media.ContainerFormatType.CFT_MPEG_4A, // Формат упаковки, на данный момент поддерживает только m4a.
  };
  private avConfig: media.AVRecorderConfig = {
    audioSourceType: media.AudioSourceType.AUDIO_SOURCE_TYPE_MIC, // Источник аудиовхода, здесь установлен микрофон
    profile: this.avProfile,
    url: '', // URL-адрес файла записи
  };

  // Зарегистрировать функцию обратного вызова audioRecorder
  setAudioRecorderCallback() {
    if (this.avRecorder != undefined) {
      // Функция обратного вызова для сообщения об ошибках
      this.avRecorder.on('error', (err) => {
        console.error(`В регистраторе произошла ошибка, код ошибки: ${err.code}, Сообщение об ошибке: ${err.message}`);
      })
    }
  }

  // Начать запись
  async startRecord(audioPath: string) {
    // 1. Создайте экземпляр записи.
    this.avRecorder = await media.createAVRecorder();
    this.setAudioRecorderCallback();
    // Создание и открытие файлов записи
    this.audioFile = fs.openSync(audioPath, fs.OpenMode.READ_WRITE | fs.OpenMode.CREATE);
    // 2. Получите URL-адрес в avConfig, назначенный файлом записи fd.
    this.avConfig.url = `fd://${this.audioFile.fd}`
    // 3. Настройте параметры записи для завершения подготовки.
    await this.avRecorder.prepare(this.avConfig);
    // 4.Начать запись
    await this.avRecorder.start();
    console.info('Запись...')
  }

  // Пауза записи
  async pauseRecord() {
    // Вызовите паузу только в запущенном состоянии, чтобы переключиться в разумное состояние.
    if (this.avRecorder != undefined && this.avRecorder.state === 'started') {
      await this.avRecorder.pause();
    }
  }

  // Возобновить запись
  async resumeRecord() {
    // Вызывайте возобновление только в состоянии паузы, чтобы переключиться в разумное состояние.
    if (this.avRecorder != undefined && this.avRecorder.state === 'paused') {
      await this.avRecorder.resume();
    }
  }

  // Остановить запись
  async stopRecord() {
    if (this.avRecorder != undefined) {
      // 1. Остановить запись
      // Останавливайте вызов только в запущенном или приостановленном состоянии для разумного переключения состояний.
      if (this.avRecorder.state === 'started'
        || this.avRecorder.state === 'paused') {
        await this.avRecorder.stop();
      }
      // 2. Сброс
      await this.avRecorder.reset();
      // 3. Освободите экземпляр записи.
      await this.avRecorder.release();
      // 4. Закройте файл записи fd.
      fs.closeSync(this.audioFile);

      promptAction.showToast({ message: «Запись успешна!» })
    }
  }
}

    "requestPermissions": [
      {
        "name": "ohos.permission.MICROPHONE",
        "reason": "$string:record_reason",
        "usedScene": {
          "abilities": [
            "EntryAbility"
          ],
          "when": "always"
        }
      }
    ]

import { checkPermissions } from '../utils/Permission';
import abilityAccessCtrl, { Permissions } from '@ohos.abilityAccessCtrl';
import common from '@ohos.app.ability.common';
import AudioCapturer from '../utils/Recorder';
import AudioRecorder from '../utils/Recorder';
import promptAction from '@ohos.promptAction';
import media from '@ohos.multimedia.media';
import fs from '@ohos.file.fs';


// Разрешения, требующие динамического применения
const permissions: Array<Permissions> = ['ohos.permission.MICROPHONE'];
// Получить контекст программы
const context = getContext(this) as common.UIAbilityContext;
// Получить каталог файлов проекта
const filesDir = context.filesDir;
// Создайте папку, если она не существует
fs.access(filesDir, (err, res: boolean) => {
  if (!res) {
    fs.mkdirSync(filesDir)
  }
});

// Путь к файлу записи
let audioPath = filesDir + "/audio.m4a";

@Entry
@Component
struct Index {
  @State recordBtnText: string = «Нажмите запись»
  @State playBtnText: string = «Включить аудио»
  // диктофон
  private audioRecorder?: AudioRecorder;
  // игрок
  private avPlayer
  private playIng: boolean = false

  // Когда страница отображается
  async onPageShow() {
    // Определить, было ли получено разрешение
    let promise = checkPermissions(permissions[0])
    promise.then((result) => {
      if (result) {
        // Инициализировать диктофон
        if (this.audioRecorder == null) {
          this.audioRecorder = new AudioRecorder()
        }
      } else {
        this.reqPermissionsAndRecord(permissions)
      }
    })
    // Создать объект экземпляра avPlayer
    this.avPlayer = await media.createAVPlayer();
    // создаватьгосударственная Функция обратного вызова изменения машины
    this.setAVPlayerCallback();
    console.info('игрок готов')
  }

  build() {
    Row() {
      RelativeContainer() {
        // кнопка записи
        Button(this.recordBtnText)
          .id('btn1')
          .width('90%')
          .margin({ bottom: 10 })
          .alignRules({
            bottom: { anchor: '__container__', align: VerticalAlign.Bottom },
            middle: { anchor: '__container__', align: HorizontalAlign.Center }
          })
          .onTouch((event) => {
            switch (event.type) {
              case TouchType.Down:
                console.info('нажмите кнопку')
              // Определить, есть ли Разрешения
                let promise = checkPermissions(permissions[0])
                promise.then((result) => {
                  if (result) {
                    // Начать запись
                    this.audioRecorder.startRecord(audioPath)
                    this.recordBtnText = «Запись...»
                  } else {
                    // Применять Разрешения                    this.reqPermissionsAndRecord(permissions)
                  }
                })
                break
              case TouchType.Up:
                console.info('Отпустите кнопку')
                if (this.audioRecorder != null) {
                  // Остановить запись
                  this.audioRecorder.stopRecord()
                }
                this.recordBtnText = «Нажмите запись»
                break
            }
          })

        // кнопка записи
        Button(this.playBtnText)
          .id('btn2')
          .width('90%')
          .margin({ bottom: 10 })
          .alignRules({
            bottom: { anchor: 'btn1', align: VerticalAlign.Top },
            middle: { anchor: '__container__', align: HorizontalAlign.Center }
          })
          .onClick(() => {
            if (!this.playIng) {
              this.playBtnText = «Играю...»
              // Воспроизвести аудио
              this.playAudio(audioPath)
            }else {
              // Хватит играть
              this.stopPlay()
            }
          })
      }
      .width('100%')
      .height('100%')
    }
    .width('100%')
    .height('100%')
  }

  // Воспроизвести аудио
  async playAudio(path: string) {
    this.playIng = true
    let fdPath = 'fd://';
    let res = fs.accessSync(path);
    if (!res) {
      console.error(`Аудиофайл не существует: ${path}`);
      this.playIng = false
      return
    }
    console.info(`Воспроизвести аудиофайл: ${path}`)
    // Откройте соответствующий адрес файла ресурсов, чтобы получить fd.
    let file = await fs.open(path);
    fdPath = fdPath + '' + file.fd;
    // назначение URL-адреса запускает инициализированнуюгосударственную машина Отчет    this.avPlayer.url = fdPath;
  }

  // Хватит играть
  stopPlay() {
    this.avPlayer.reset();
  }

  // Зарегистрировать функцию обратного вызова avplayer
  setAVPlayerCallback() {
    this.avPlayer.on('error', (err) => {
      this.playIng = false
      this.playBtnText = «Включить аудио»
      console.error(`игрок Произошла ошибка,код ошибки：${err.code}, Сообщение об ошибке: ${err.message}`);
      // Вызов сброса для сброса ресурсов и перехода в состояние ожидания.
      this.avPlayer.reset();
    })
    // государственная Функция обратного вызова изменения машины
    this.avPlayer.on('stateChange', async (state) => {
      switch (state) {
        case 'initialized':
        // Инициализация ресурса завершена и начинается подготовка файла.
          this.avPlayer.prepare();
          break;
        case 'prepared':
        // Подготовка ресурса завершена, приступаем к подготовке файлов
          this.avPlayer.play();
          break;
        case 'completed':
        // Вызовите функцию сброса() для сброса ресурса, AVPlayer снова перейдет в состояние ожидания, позволяя изменить URL-адрес ресурса.
          this.avPlayer.reset();
          break;
        case 'idle':
          this.playIng = false
          this.playBtnText = «Включить аудио»
          break;
      }
    })
  }

  // Применять Разрешения  reqPermissionsAndRecord(permissions: Array<Permissions>): void {
    let atManager = abilityAccessCtrl.createAtManager();
    // requestPermissionsFromUser определит статус авторизации Разрешения, чтобы решить, вызывать ли всплывающее окно.
    atManager.requestPermissionsFromUser(context, permissions).then((data) => {
      let grantStatus: Array<number> = data.authResults;
      let length: number = grantStatus.length;
      for (let i = 0; i < length; i++) {
        if (grantStatus[i] === 0) {
          // Пользователь имеет право продолжать доступ к целевой операции.
          console.info('Авторизация прошла успешно')
          if (this.audioRecorder == null) {
            this.audioRecorder = new AudioCapturer()
          }
        } else {
          promptAction.showToast({ message: «Ошибка авторизации, для записи необходима авторизация» })
          return;
        }
      }
    }).catch((err) => {
      console.error(`requestPermissionsFromUser failed, code is ${err.code}, message is ${err.message}`);
    })
  }
}