🐛 Domain=AVFoundationErrorDomain Code=-11800 | The operation could not be completed | Error Domain=NSOSStatusErrorDo- main Code=-10868

[renishmithani]

What's happening?

When recording a short video, facing this error, and the audio is not coming in the video.

Reproduceable Code

// Parent component function for video recording
 const onLongPressIn = async () => {
    try {
      if (!cameraPermission || !microphonePermission) {
        return;
      }
      if (ref.current) {
        onToogleVideo();
        ref.current.recordVideo({
          fileType: 'mp4',
          flash: 'off',
          videoCodec: 'h265',
          onRecordingError: () => {
            setIsVideo(false);
          },
          onRecordingFinished: async video => {
            if (video.duration >= 1) {
              const thumbnail = await generaeThumbail({
                url: `file://${video.path}`,
                format: 'jpeg',
              });
              console.log(thumbnail.path, ' videoThumbnail');
              console.log(JSON.stringify(video), null, 2, ' video');
              dispatch({
                thumbnail: `${thumbnail.path}`,
                path: `file://${video.path}`,
                is_camera: false,
                type: getFileType(video.path).type,
                format: getFileType(video.path).format,
              });
              setIsVideo(false);
            } else {
              SnackBar({
                type: 'success',
                text1: 'video is too short for post',
              });
              setIsVideo(false);
            }
          },
        });
      }
    } catch (error) {}
  };

  const onPressOut = () => {
    if (isvideo && !isCameraError) {
      onFinishVideo();
    } else {
      setIsVideo(false);
      setIsCameraError(false);
      // if (isCameraError) {
      //   SnackBar({
      //     type: 'error',
      //     text1: 'Camera session have some issue',
      //   });
      // }
      onFinishVideo();
    }
  };

  const onFinishVideo = useCallback(async () => {
    if (ref.current) {
      await ref.current.stopRecording();
    }
  }, []);



// Child Component 
import {
  AppState,
  StyleSheet,
  Text,
  useWindowDimensions,
  View,
  Alert,
} from 'react-native';
import React, {
  useCallback,
  useEffect,
  useRef,
  useImperativeHandle,
  useState,
  memo,
} from 'react';
import {
  Camera as VisionCamera,
  PhotoFile,
  useCameraDevice,
  CameraPosition,
  RecordVideoOptions,
  TakePhotoOptions,
  CameraRuntimeError,
  useCameraPermission,
  CameraProps,
  useMicrophonePermission,
  FormatFilter,
  DeviceFilter,
  CameraDevice,
  useCameraFormat,
  getCameraFormat,
} from 'react-native-vision-camera';
import {
  requestCameraPermission,
  requestVideoAndAudioPermission,
} from 'utils/Permissions';
import {Heading} from './Text';
import {
  IS_IOS,
  UniStyleSheet,
  WINDOW_HEIGHT,
  WINDOW_WIDTH,
  hp,
} from 'styles/Dimensions';
import {useStyles} from 'react-native-unistyles';
import {ButtonCompact} from './Button';
import ImageResizer from '@bam.tech/react-native-image-resizer';
import {ASPECT_RATIO, ASPECT_RATIO_CAMERA_POST} from 'constants/AppConstant';
import SnackBar from './Snakbar';

export type TZoomLevel = 1 | 2 | 0.5;

interface Props extends Partial<CameraProps> {
  onClick?: () => void;
  children?: React.ReactNode;
  zoom?: number;
  onError: (error: CameraRuntimeError | any) => void;
  isActive?: boolean;
  deviceFormat?: FormatFilter[];
  getAvailableZoomLevel?: (v: number[], l: any) => void;
  dafaultCameraSide?: 'front' | 'back';
  useFormate: boolean;
  cameraPostStyle: boolean;
}

export type cameraRefType = {
  takePhoto: (
    options?: TakePhotoOptions,
  ) => Promise<Partial<TCameraResult> | undefined>;
  toogleTourch: (mode?: TTourchMode) => void;
  toogleCamera: () => void;
  recordVideo: (options: RecordVideoOptions) => void;
  stopRecording: () => Promise<void>;
  pauseRecord: () => Promise<void>;
  cancelRecording: () => Promise<void>;
  setZoomLevel: (zoomLevel: TZoomLevel) => void;
};

export type TFileType = 'image' | 'video';
export interface TCameraResult extends Pick<PhotoFile, 'path'> {
  type: TFileType;
  format?: 'mp4' | 'jpg' | 'png' | 'jpeg';
  thumbnail: string;
}
export const getFileType = (
  uri: string,
): Pick<TCameraResult, 'format' | 'type'> => {
  if (uri.includes('.jpeg')) {
    return {
      type: 'image',
      format: 'jpeg',
    };
  }
  if (uri.includes('.png')) {
    return {
      type: 'image',
      format: 'png',
    };
  }
  if (uri.includes('.jpg')) {
    return {
      type: 'image',
      format: 'jpg',
    };
  }
  return {
    type: 'video',
    format: 'mp4',
  };
};

const handleRotation = async (image: PhotoFile, quality: number = 60) => {
  try {
    let rotationAngle = 0;

    const rotatedImage = await ImageResizer.createResizedImage(
      `file://${image.path}`,
      image.width,
      image.height, 
      'JPEG',
      quality, 
      rotationAngle,
    );

    return rotatedImage;
  } catch (error) {
    console.error('Failed to rotate image:', error);
  }
};

const changeImageQuality = async (image: PhotoFile, quality: number = 10) => {
  const rotatedImage = await ImageResizer.createResizedImage(
    `file://${image.path}`,
    image.width,
    image.height, 
    'JPEG',
    quality, 
    undefined, 
  );
  return rotatedImage;
};

export type TTourchMode = 'on' | 'off' | 'auto';

const Camera = React.forwardRef<cameraRefType, Props>(
  (
    {
      onError,
      style,
      deviceFormat = [],
      dafaultCameraSide = 'front',
      useFormate = false,
      cameraPostStyle = false,
      getAvailableZoomLevel = () => null,
      ...props
    },
    ref,
  ) => {
    const {styles} = useStyles(CameraStyle);
    const {hasPermission: camerPermission} = useCameraPermission();
    const {hasPermission: microphonePermission} = useMicrophonePermission();
    const CameraRef = useRef<VisionCamera>(null);
    const [cameraFormat, setCameraFormat] =
      useState<FormatFilter[]>(deviceFormat);
    const [device, setDevice] = useState<CameraPosition>(dafaultCameraSide);
    const [torchMode, setTorchMode] = useState<TTourchMode>('off');

    const [appState, setAppState] = useState(AppState.currentState);
    const [isCameraActive, setIsCameraActive] = useState(true);

    const deviceFilter: DeviceFilter = {
      physicalDevices: [
        'ultra-wide-angle-camera',
        'wide-angle-camera',
        'telephoto-camera',
      ],
    };
    const cameraDevice: CameraDevice | undefined = useCameraDevice(
      device,
      deviceFilter,
    );

    const availableZoomLevels = [
      cameraDevice?.minZoom || 1,
      cameraDevice?.neutralZoom || 1,
      (cameraDevice?.neutralZoom || 1) * 2, 
    ].filter(
      zoom =>
        zoom >= (cameraDevice?.minZoom || 1) &&
        zoom <= (cameraDevice?.maxZoom || 2),
    );

    const [deviceZoom, setDeviceZoom] = useState(cameraDevice?.neutralZoom);

    const requestCaptureVideoAndAudio = useCallback(async () => {
      try {
        if (props?.audio) {
          await requestVideoAndAudioPermission();
        } else {
          await requestCameraPermission();
        }
      } catch (error) {
        console.log(error);
      }
    }, [props.audio]);

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

    useImperativeHandle(
      ref,
      () => {
        return {
          changeCameraFormat: (changeformat: FormatFilter[]) => {
            if (CameraRef.current) {
              // setCameraFormat(changeformat);
            }
          },
          takePhoto: async (
            options?: TakePhotoOptions,
          ): Promise<Partial<TCameraResult> | undefined> => {
            try {
              if (CameraRef.current) {
                const result = await CameraRef.current.takePhoto(options);
                const resizedImage = await handleRotation(result);
                const thumbnailImage = await changeImageQuality(result, 10);
                const type = getFileType(result.path);

                return {
                  ...result,
                  path: `file://${resizedImage?.path}`,
                  type: type.type,
                  format: type.format,
                  thumbnail: `file://${thumbnailImage.path}`,
                };
              }
            } catch (error) {
              onError(error);
            }
          },
          recordVideo: async (options: RecordVideoOptions) => {
            try {
              if (CameraRef.current) {
                CameraRef.current.startRecording(options);
              }
            } catch (error) {
              onError(error);
            }
          },
          cancelRecording: async () => {
            try {
              if (CameraRef.current) {
                await CameraRef.current.cancelRecording();
              }
            } catch (error) {
              onError(error);
            }
          },
          stopRecording: async () => {
            try {
              if (CameraRef.current) {
                await CameraRef.current.stopRecording();
              }
            } catch (error) {
              onError(error);
            }
          },
          pauseRecord: async () => {
            try {
              if (CameraRef.current) {
                await CameraRef.current.pauseRecording();
              }
            } catch (error) {
              onError(error);
            }
          },
          toogleTourch: () => {
            try {
              if (torchMode === 'on') {
                setTorchMode('off');
              } else {
                setTorchMode('on');
              }
            } catch (error) {
              onError(error);
            }
          },

          toogleCamera: () => {
            try {
              if (device === 'back') {
                setDeviceZoom(1);
                setDevice('front');
              } else {
                setDeviceZoom(cameraDevice?.neutralZoom);
                setDevice('back');
              }
            } catch (error) {
              onError(error);
            }
          },
          setZoomLevel: (zoomLevel: number) => {
            if (device === 'front') {
              setDeviceZoom(zoomLevel);
            } else if (device === 'back') {
              if (zoomLevel === 0.5) {
                setDeviceZoom(0.5);
              } else if (zoomLevel === 2) {
                setDeviceZoom(2);
              } else {
                setDeviceZoom(zoomLevel);
              }
            }
          },
        };
      },
      [onError, torchMode, cameraDevice?.neutralZoom, device],
    );

    useEffect(() => {
      if (availableZoomLevels) {
        const zoomL = [...new Set(availableZoomLevels || [])].reverse();
        const lenses = {
          minZoom: cameraDevice?.minZoom,
          maxZoom: cameraDevice?.maxZoom,
          neutralZoom: cameraDevice?.neutralZoom,
        };
        getAvailableZoomLevel(zoomL, lenses);
      }
    }, []);

    useEffect(() => {
      const subscription = AppState.addEventListener('change', nextAppState => {
        setAppState(nextAppState);
        if (nextAppState === 'active') {
          setIsCameraActive(true);
        } else {
          setIsCameraActive(false);
        }
      });

      return () => {
        subscription.remove();
      };
    }, []);

    if (!cameraDevice) {
      return (
        <View style={styles.container}>
          <Heading color="white" size="large" weight="bold">
            No Device Found
          </Heading>
        </View>
      );
    }

    if (!camerPermission || (props?.audio && !microphonePermission)) {
      return (
        <View style={[styles.container]}>
          <Heading color="white" size="large" weight="bold">
            {props.audio
              ? 'Camera and Microphone Permission Required!'
              : 'Camera Permission Required!'}
          </Heading>
          <ButtonCompact
            buttonStyle={{
              position: 'relative',
              zIndex: 1000,
            }}
            variants="white"
            onPress={requestCaptureVideoAndAudio}
            label="Allow now"
          />
        </View>
      );
    }
    return <VisionCamera
        photo
        onError={onError}
        enableZoomGesture={false}
        zoom={deviceZoom}
        ref={CameraRef}
        style={[style, StyleSheet.absoluteFill]}
        device={cameraDevice}
        isActive={isCameraActive}
        outputOrientation="preview"
        {...props}
      />
  },
);

const CameraStyle = UniStyleSheet({
  container: {
    gap: hp(1),
    flex: 1,
    position: 'absolute',
    top: 0,
    left: 0,
    right: 0,
    bottom: 0,
    height: WINDOW_HEIGHT,
    width: WINDOW_WIDTH,
    justifyContent: 'center',
    alignItems: 'center',
  },
});
export default memo(Camera);

Relevant log output

{"name": "unknown/
unknown","_code":"unknown/ unknown", "_message":"Error
Domain=AVFoundationErrorDomain
Code=-11800 |"The operation could not be completed\"
UserInfo={NSLocalizedFailureReason=
An unknown error occurred (-10868), NSLocalizedDescription=The operation could not be completed,
NSUnderlyingError=0x300b74060
{Error Domain=NSOSStatusErrorDo-
main Code=-10868 \"(null)
("""_cause": "code": -11800,"details":
{"NSLocalizedFailureReason": "An unknown error occurred
(-10868)","NSUnderlyingError":null,"N
SLocalizedDescription":"The operation could not be
completed"), "domain":"AVFoundation-ErrorDomain", "message": "Error Domain=AVFoundationErrorDomain Code=-11800 \"The operation could not be completed\"
UserInfo={NSLocalizedFailureReason=
An unknown error occurred (-10868), NSLocalizedDescription=The operation could not be completed,
NSUnderlyingError=0x300b74060
{Error Domain=NSOSStatusErrorDo-main Code=-10868 \"(null) \"}"}}

Camera Device

{
  "maxZoom": 16,
  "id": "com.apple.avfoundation.avcapturedevice.built-in_video:3",
  "position": "back",
  "formats": [],
  "minFocusDistance": 12,
  "name": "Back Dual Camera",
  "hasFlash": true,
  "minExposure": -8,
  "isMultiCam": true,
  "maxExposure": 8,
  "supportsLowLightBoost": false,
  "sensorOrientation": "portrait",
  "supportsRawCapture": false,
  "neutralZoom": 1,
  "physicalDevices": [
    "wide-angle-camera",
    "telephoto-camera"
  ],
  "supportsFocus": true,
  "minZoom": 1,
  "hasTorch": true,
  "hardwareLevel": "full"
}

Device

iPhone 16 pro max (iOS 18), iPhone Xs (iOS 18)

VisionCamera Version

4.5.1

Can you reproduce this issue in the VisionCamera Example app?

Yes, I can reproduce the same issue in the Example app here

Additional information

• I am using Expo
• I have enabled Frame Processors (react-native-worklets-core)
• I have read the Troubleshooting Guide
• I agree to follow this project's Code of Conduct
• I searched for similar issues in this repository and found none.

[maintenance-hans]

Guten Tag, Hans here! 🍻

Thanks for reporting your issue. The information you provided is quite detailed, which is helpful for diagnosing the problem. However, it seems a crucial part is missing – that is the relevant logs from Xcode or adb logcat for your recording issue.

Please provide those logs so mrousavy can better understand what’s going wrong. You can gather logs in Xcode by checking the "Debug" console or in Android Studio using adb logcat. This information is vital for troubleshooting.

Looking forward to your update!

Note: If you think I made a mistake, please ping @mrousavy to take a look.

[renishmithani]

@mrousavy Here are the logs from Xcode while recording video. JFYI this issue is occurring in only iOS device and audio is not coming in video

{
"isMultiCam": true,
"maxZoom": 16,
"hasTorch": true,
"minFocusDistance": 12,
"position": "back",
"name": "Back Dual Camera",
"minExposure": -8,
"hasFlash": true,
"minZoom": 1,
"supportsLowLightBoost": false,
"maxExposure": 8,
"id": "com.apple.avfoundation.avcapturedevice.built-in_video:3",
"sensorOrientation": "portrait",
"neutralZoom": 1,
"physicalDevices": [
"wide-angle-camera",
"telephoto-camera"
],
"supportsFocus": true,
"supportsRawCapture": false,
"formats": [],
"hardwareLevel": "full"
}
10:24:29.164: [info] 📸 VisionCamera.didSetProps(:): Updating 30 props: [onInitialized, cameraId, position, enableBufferCompression, preview, onOutputOrientationChanged, onStarted, onCodeScanned, top, right, isActive, video, onViewReady, onError, onStopped, isMirrored, onPreviewOrientationChanged, onPreviewStopped, enableFrameProcessor, onPreviewStarted, enableZoomGesture, left, audio, bottom, outputOrientation, height, width, zoom, onShutter, photo]
10:24:29.168: [info] 📸 VisionCamera.configurePreviewOrientation(:): Updating Preview rotation: portrait...
10:24:29.168: [info] 📸 VisionCamera.configureOutputOrientation(:): Updating Outputs rotation: portrait...
10:24:29.168: [info] 📸 VisionCamera.configure(:): configure { ... }: Waiting for lock...
10:24:29.173: [info] 📸 VisionCamera.configure(:): configure { ... }: Updating CameraSession Configuration... Difference(inputChanged: true, outputsChanged: true, videoStabilizationChanged: true, orientationChanged: true, formatChanged: true, sidePropsChanged: true, torchChanged: true, zoomChanged: true, exposureChanged: true, audioSessionChanged: true, locationChanged: true)
10:24:29.173: [info] 📸 VisionCamera.configureDevice(configuration:): Configuring Input Device...
10:24:29.173: [info] 📸 VisionCamera.configureDevice(configuration:): Configuring Camera com.apple.avfoundation.avcapturedevice.built-in_video:3...
10:24:29.174: [info] 📸 VisionCamera.configureDevice(configuration:): Successfully configured Input Device!
10:24:29.174: [info] 📸 VisionCamera.configureOutputs(configuration:): Configuring Outputs...
10:24:29.174: [info] 📸 VisionCamera.configureOutputs(configuration:): Adding Photo output...
10:24:29.176: [info] 📸 VisionCamera.configureOutputs(configuration:): Adding Video Data output...
10:24:29.177: [info] 📸 VisionCamera.configurePreviewOrientation(:): Updating Preview rotation: portrait...
10:24:29.177: [info] 📸 VisionCamera.configureOutputOrientation(:): Updating Outputs rotation: portrait...
10:24:29.177: [info] 📸 VisionCamera.configureOutputs(configuration:): Successfully configured all outputs!
10:24:29.180: [info] 📸 VisionCamera.setTargetOutputOrientation(:): Setting target output orientation from device to preview...
10:24:29.183: [info] 📸 VisionCamera.getPixelFormat(for:): Available Pixel Formats: ["420v", "420f", "BGRA"], finding best match... (pixelFormat="yuv", enableHdr={false}, enableBufferCompression={true})
10:24:29.183: [info] 📸 VisionCamera.getPixelFormat(for:): Using PixelFormat: 420f...
10:24:29.541: [info] 📸 VisionCamera.init(frame:session:): Preview Layer started previewing.
10:24:29.542: [info] 📸 VisionCamera.configure(:): Beginning AudioSession configuration...
10:24:29.542: [info] 📸 VisionCamera.configureAudioSession(configuration:): Configuring Audio Session...
10:24:29.542: [info] 📸 VisionCamera.configureAudioSession(configuration:): Adding Audio input...
10:24:29.543: [info] 📸 VisionCamera.configureAudioSession(configuration:): Adding Audio Data output...
10:24:29.543: [info] 📸 VisionCamera.configure(:): Beginning Location Output configuration...
10:24:29.543: [info] 📸 VisionCamera.configure(:): Committed AudioSession configuration!
10:24:29.544: [info] 📸 VisionCamera.configure(:): Finished Location Output configuration!
{
"isMultiCam": true,
"maxZoom": 16,
"hasTorch": true,
"minFocusDistance": 12,
"position": "back",
"name": "Back Dual Camera",
"minExposure": -8,
"hasFlash": true,
"minZoom": 1,
"supportsLowLightBoost": false,
"maxExposure": 8,
"id": "com.apple.avfoundation.avcapturedevice.built-in_video:3",
"sensorOrientation": "portrait",
"neutralZoom": 1,
"physicalDevices": [
"wide-angle-camera",
"telephoto-camera"
],
"supportsFocus": true,
"supportsRawCapture": false,
"formats": [],
"hardwareLevel": "full"
}
10:24:31.245: [info] 📸 VisionCamera.startRecording(options:onVideoRecorded:onError:): Starting Video recording...
10:24:31.245: [info] 📸 VisionCamera.startRecording(options:onVideoRecorded:onError:): Starting recording into file: file:///private/var/mobile/Containers/Data/Application/D52A2389-7057-46E9-BB7F-FDD55F791B35/tmp/411941C4-71EC-4ADB-BD81-371489E695C5.mp4
10:24:31.245: [info] 📸 VisionCamera.init(url:fileType:metadataProvider:clock:orientation:completion:): Creating RecordingSession... (orientation: landscapeLeft)
10:24:31.245: [info] 📸 VisionCamera.startRecording(options:onVideoRecorded:onError:): Enabling Audio for Recording...
10:24:31.246: [info] 📸 VisionCamera.activateAudioSession(): Activating Audio Session...
10:24:31.246: [info] 📸 VisionCamera.initializeAudioTrack(withSettings:format:): Initializing Audio AssetWriter with settings: ["AVEncoderBitRateStrategyKey": AVAudioBitRateStrategy_Variable, "AVEncoderQualityForVBRKey": 91, "AVSampleRateKey": 44100, "AVEncoderBitRatePerChannelKey": 96000, "AVNumberOfChannelsKey": 1, "AVFormatIDKey": 1633772320]
10:24:31.247: [info] 📸 VisionCamera.updateCategory(:mode:options:): Changing AVAudioSession category from AVAudioSessionCategoryPlayback -> AVAudioSessionCategoryPlayAndRecord
10:24:31.248: [info] 📸 VisionCamera.initializeAudioTrack(withSettings:format:): Initialized Audio AssetWriter.
10:24:31.248: [info] 📸 VisionCamera.recommendedVideoSettings(forOptions:): Getting recommended video settings for AVFileType(rawValue: public.mpeg-4) file...
10:24:31.253: [info] 📸 VisionCamera.initializeVideoTrack(withSettings:): Initializing Video AssetWriter with settings: ["AVVideoCompressionPropertiesKey": {
AllowFrameReordering = 1;
AllowOpenGOP = 1;
AverageBitRate = 7651584;
ExpectedFrameRate = 30;
MaxAllowedFrameQP = 41;
MaxKeyFrameIntervalDuration = 1;
MaximumRealTimeFrameRate = 30;
MinAllowedFrameQP = 15;
Priority = 80;
ProfileLevel = "HEVC_Main_AutoLevel";
RealTime = 1;
RelaxAverageBitRateTarget = 1;
}, "AVVideoHeightKey": 1080, "AVVideoWidthKey": 1920, "AVVideoCodecKey": hvc1]
10:24:31.257: [info] 📸 VisionCamera.initializeVideoTrack(withSettings:): Initialized Video AssetWriter.
10:24:31.257: [info] 📸 VisionCamera.start(): Starting Asset Writer...
10:24:31.417: [info] 📸 VisionCamera.start(): Asset Writer started!
10:24:31.418: [info] 📸 VisionCamera.start(): Asset Writer session started at 117639.5445335.
10:24:31.418: [info] 📸 VisionCamera.start(): Requesting video timeline start at 117639.546218875...
10:24:31.418: [info] 📸 VisionCamera.start(): Requesting audio timeline start at 117639.546244458...
10:24:31.418: [info] 📸 VisionCamera.startRecording(options:onVideoRecorded:onError:): RecordingSesssion started in 173.775791ms!
10:24:31.422: [info] 📸 VisionCamera.isTimestampWithinTimeline(timestamp:): video Timeline: First timestamp: 117639.507732125
10:24:31.488: [info] 📸 VisionCamera.updateCategory(:mode:options:): AVAudioSession category changed!
<0x160c1dcc0> Gesture: System gesture gate timed out.
<<<< FigSharedMemPool >>>> Fig assert: "blkHdr->useCount > 0" at (FigSharedMemPool.c:591) - (err=0)
10:24:31.531: [error] 📸 VisionCamera.sessionRuntimeError(notification:): Unexpected Camera Runtime Error occured!
10:24:31.531: [info] 📸 VisionCamera.activateAudioSession(): Audio Session activated!
10:24:31.532: [error] 📸 VisionCamera.onError(:): Invoking onError(): Error Domain=AVFoundationErrorDomain Code=-11800 "The operation could not be completed" UserInfo={NSLocalizedFailureReason=An unknown error occurred (-10868), NSLocalizedDescription=The operation could not be completed, NSUnderlyingError=0x16384cdb0 {Error Domain=NSOSStatusErrorDomain Code=-10868 "(null)"}}
{ [unknown/unknown: Error Domain=AVFoundationErrorDomain Code=-11800 "The operation could not be completed" UserInfo={NSLocalizedFailureReason=An unknown error occurred (-10868), NSLocalizedDescription=The operation could not be completed, NSUnderlyingError=0x16384cdb0 {Error Domain=NSOSStatusErrorDomain Code=-10868 "(null)"}}]
name: 'unknown/unknown',
_code: 'unknown/unknown',
_message: 'Error Domain=AVFoundationErrorDomain Code=-11800 "The operation could not be completed" UserInfo={NSLocalizedFailureReason=An unknown error occurred (-10868), NSLocalizedDescription=The operation could not be completed, NSUnderlyingError=0x16384cdb0 {Error Domain=NSOSStatusErrorDomain Code=-10868 "(null)"}}',
_cause:
{ details:
{ NSLocalizedDescription: 'The operation could not be completed',
NSUnderlyingError: null,
NSLocalizedFailureReason: 'An unknown error occurred (-10868)' },
code: -11800,
domain: 'AVFoundationErrorDomain',
message: 'Error Domain=AVFoundationErrorDomain Code=-11800 "The operation could not be completed" UserInfo={NSLocalizedFailureReason=An unknown error occurred (-10868), NSLocalizedDescription=The operation could not be completed, NSUnderlyingError=0x16384cdb0 {Error Domain=NSOSStatusErrorDomain Code=-10868 "(null)"}}' } }
{
"isMultiCam": true,
"maxZoom": 16,
"hasTorch": true,
"minFocusDistance": 12,
"position": "back",
"name": "Back Dual Camera",
"minExposure": -8,
"hasFlash": true,
"minZoom": 1,
"supportsLowLightBoost": false,
"maxExposure": 8,
"id": "com.apple.avfoundation.avcapturedevice.built-in_video:3",
"sensorOrientation": "portrait",
"neutralZoom": 1,
"physicalDevices": [
"wide-angle-camera",
"telephoto-camera"
],
"supportsFocus": true,
"supportsRawCapture": false,
"formats": [],
"hardwareLevel": "full"
}
{
"isMultiCam": true,
"maxZoom": 16,
"hasTorch": true,
"minFocusDistance": 12,
"position": "back",
"name": "Back Dual Camera",
"minExposure": -8,
"hasFlash": true,
"minZoom": 1,
"supportsLowLightBoost": false,
"maxExposure": 8,
"id": "com.apple.avfoundation.avcapturedevice.built-in_video:3",
"sensorOrientation": "portrait",
"neutralZoom": 1,
"physicalDevices": [
"wide-angle-camera",
"telephoto-camera"
],
"supportsFocus": true,
"supportsRawCapture": false,
"formats": [],
"hardwareLevel": "full"
}

[qper228]

having the same issue, it works only once I launch the app first time another time same error

[RohitDianApps]

Having the same issue, it works only once I launch the app first time another time same error

[somibuon]

Do you use react-native-video?
Try to add disableAudioSessionManagement={true} to the Video component
If that doesn't work, try to downgrade the react-native-video version to 6.10.2 which is the latest version doesn't have audioSessionManager.

[therveux]

@somibuon I can confirm that after downgrading react-native-video to version 6.10.2, the error disappeared. I had recently upgraded to version 6.14, so when I saw your message, I immediately thought of that. Do we have to wait for a fix on the react-native-video side before being able to upgrade?

[renishmithani]

Do you use react-native-video? Try to add disableAudioSessionManagement={true} to the Video component If that doesn't work, try to downgrade the react-native-video version to 6.10.2 which is the latest version doesn't have audioSessionManager.

That worked perfectly!
Thank you!

[RohitDianApps]

That worked perfectly!
Thank you!

[rfontes-scene]

For other people encountering this issue, these are the issue reports on react-native-video:
TheWidlarzGroup/react-native-video#4535
TheWidlarzGroup/react-native-video#4484

[Bhavesh091]

I think issue will be solved in iOS 18 add belove to info.plist

<key>NSAppTransportSecurity</key>
	<dict>
		<key>NSAllowsArbitraryLoadsForMedia</key>
		<true/>
    </dict>

[mihailShumilov]

Here is a fix for that issue

#3706