Issue with recording audio

[mkhoussid]

Please provide the following:

1. SDK Version: 35
2. Platforms(Android/iOS/web/all): Tested on Android

Edit: Here is the Snack, however this is a different error that I am running into on my physical device. Although, they could be the same error, considering on my machine, the error is not very indicative – it just says “[Error: Start encountered an error: recording not started]”

Hello,

I am trying to record audio, but it doesn’t seem to work. It just prints the below endlessly:

Object {
  "canRecord": false,
  "durationMillis": 0,
  "isDoneRecording": false,
  "isRecording": false,
}
Object {
  "canRecord": true,
  "durationMillis": 0,
  "isRecording": false,
}
Object {
  "canRecord": true,
  "durationMillis": 0,
  "isRecording": false,
}
Object {
  "canRecord": true,
  "durationMillis": 0,
  "isRecording": false,
}

My code:

import React, { useEffect, useState } from "react";
import {  TouchableOpacity } from "react-native";

import { Icon } from "react-native-elements";

import { Audio } from "expo-av";

import * as Permissions from "expo-permissions";

const AudioRecording = () => {
  const [permissions, setPermissions] = useState(null);

  let recording = null;

  useEffect(() => {
    getStatus();
  }, []);

  const getStatus = async () => {
    const { status } = await Permissions.askAsync(Permissions.AUDIO_RECORDING);

    if (status === "granted") {
      setPermissions(true);
      await Audio.setAudioModeAsync({
        allowsRecordingIOS: true,
        interruptionModeIOS: Audio.INTERRUPTION_MODE_IOS_DO_NOT_MIX,
        playsInSilentModeIOS: true,
        shouldDuckAndroid: true,
        staysActiveInBackground: false,
        playThroughEarpieceAndroid: true,
        interruptionModeAndroid: Audio.INTERRUPTION_MODE_ANDROID_DO_NOT_MIX
      });
    }
  };

  const handleRecordAudio = async () => {
    try {
      if (permissions) {
        recording = new Audio.Recording();
        await recording.prepareToRecordAsync(
          Audio.RECORDING_OPTIONS_PRESET_HIGH_QUALITY
        );

        recording.setOnRecordingStatusUpdate(e => console.log(e));
        recording.setProgressUpdateInterval(500);

        await recording.startAsync();
      } else {
        alert("This function requires microphone permissions");
      }
    } catch (err) {
      console.log("err caught with recording video", err);
    }
  };

  const handleStopRecordingAudio = async () => {
    try {
      const data = await recording.stopAndUnloadAsync();
      console.log("data", data);
    } catch (err) {
      console.log("Error caught stopping recording", err);
    }
  };

  return (
    <TouchableOpacity
      onPressIn={() => handleRecordAudio()}
      onPressOut={() => handleStopRecordingAudio()}
    >
      <Icon
        name="md-microphone"
        type="ionicon"
        color="#9f24b5"
      />
    </TouchableOpacity>
  );
};

export default AudioRecording;

Relevant SO question.

Also, I’ve tried this doing simply,

const AudioRecording = () => {
  const r = new Audio.Recording();
  const recordOptions = Audio.RECORDING_OPTIONS_PRESET_HIGH_QUALITY;
  recordOptions.ios.outputFormat =
    Audio.RECORDING_OPTION_IOS_OUTPUT_FORMAT_MPEG4AAC;

  Audio.setAudioModeAsync({
    allowsRecordingIOS: true,
    staysActiveInBackground: false,
    interruptionModeIOS: Audio.INTERRUPTION_MODE_IOS_DO_NOT_MIX,
    playsInSilentModeIOS: true,
    shouldDuckAndroid: true,
    interruptionModeAndroid: Audio.INTERRUPTION_MODE_ANDROID_DO_NOT_MIX,
    playThroughEarpieceAndroid: true
  });

  const handleRecordAudio = async () => {
    r.prepareToRecordAsync(recordOptions);
    r.setOnRecordingStatusUpdate(e => console.log(e));
    await r.startAsync();
  };

  const handleStopRecordingAudio = async () => {
    await r.stopAndUnloadAsync();
  };

  return (
    <TouchableOpacity
      onPressIn={() => handleRecordAudio()}
      onPressOut={() => handleStopRecordingAudio()}
    >
    </TouchableOpacity>
  );
};

export default AudioRecording;

And this produces the same results. I’ve ejected to ExpoKit if it matters.