🐛 Front Camera not loading in s23 ultra

[victorkvarghese]

What's happening?

@mrousavy I tried the latest v3 example code. By default front camera is loading in s23 ultra.

Then i removed everything and made it

const devices = useCameraDevices();
now back camera loads, but switching to front crashes the app.

now if i use

const device = useCameraDevice(cameraPosition, {
physicalDevices: [
'ultra-wide-angle-camera',
'telephoto-camera',
'wide-angle-camera',
],
});

i can see front camera. but unable to switch back to Back Camera

now if i go back to the old code and refresh the app. Then both cameras work.
But if i close the app open it again, back camera will work, but front camera will fail

Reproduceable Code

CameraPage.tsx

import * as React from 'react';
import {useRef, useState, useCallback, useMemo} from 'react';
import {StyleSheet, Text, View} from 'react-native';
import {
  PinchGestureHandler,
  PinchGestureHandlerGestureEvent,
  TapGestureHandler,
} from 'react-native-gesture-handler';
import {
  CameraRuntimeError,
  PhotoFile,
  useCameraDevice,
  //useCameraDevices,
  useCameraFormat,
  // useFrameProcessor,
  VideoFile,
} from 'react-native-vision-camera';
import {Camera} from 'react-native-vision-camera';
import {
  CONTENT_SPACING,
  MAX_ZOOM_FACTOR,
  SAFE_AREA_PADDING,
  SCREEN_HEIGHT,
  SCREEN_WIDTH,
} from './Constants';
import Reanimated, {
  Extrapolate,
  interpolate,
  useAnimatedGestureHandler,
  useAnimatedProps,
  useSharedValue,
} from 'react-native-reanimated';
import {useEffect} from 'react';
import {useIsForeground} from './hooks/useIsForeground';
import {StatusBarBlurBackground} from './views/StatusBarBlurBackground';
import {CaptureButton} from './views/CaptureButton';
import {PressableOpacity} from 'react-native-pressable-opacity';
import MaterialIcon from 'react-native-vector-icons/MaterialCommunityIcons';
import IonIcon from 'react-native-vector-icons/Ionicons';
import type {Routes} from './Routes';
import type {NativeStackScreenProps} from '@react-navigation/native-stack';
import {useIsFocused} from '@react-navigation/core';
// import {examplePlugin} from './frame-processors/ExamplePlugin';

const ReanimatedCamera = Reanimated.createAnimatedComponent(Camera);
Reanimated.addWhitelistedNativeProps({
  zoom: true,
});

const SCALE_FULL_ZOOM = 3;
const BUTTON_SIZE = 40;

type Props = NativeStackScreenProps<Routes, 'CameraPage'>;
export function CameraPage({navigation}: Props): React.ReactElement {
  const camera = useRef<Camera>(null);
  const [isCameraInitialized, setIsCameraInitialized] = useState(false);
  const [hasMicrophonePermission, setHasMicrophonePermission] = useState(false);
  const zoom = useSharedValue(0);
  const isPressingButton = useSharedValue(false);

  // check if camera page is active
  const isFocussed = useIsFocused();
  const isForeground = useIsForeground();
  const isActive = isFocussed && isForeground;

  const [cameraPosition, setCameraPosition] = useState<'front' | 'back'>(
    'back',
  );
  const [enableHdr, setEnableHdr] = useState(false);
  const [flash, setFlash] = useState<'off' | 'on'>('off');
  const [enableNightMode, setEnableNightMode] = useState(false);

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

  const getDevices = async () => {
    const devicesDetected = await Camera.getAvailableCameraDevices();
    // console.log('devicesDetected', devicesDetected);
    return devicesDetected;
  };

  // const devices = useCameraDevices();

  // console.log('devicesXXSD', devices);

  // const device = devices[1];

  // camera format settings
  const device = useCameraDevice(cameraPosition, {
    physicalDevices: [],
  });

  console.log(
    'cameraPosition',
    cameraPosition,
    device?.name,
    device?.maxZoom,
    device?.formats.some(f => f.maxFps >= 60),
  );

  const [targetFps, setTargetFps] = useState(60);

  const screenAspectRatio = SCREEN_HEIGHT / SCREEN_WIDTH;
  const format = useCameraFormat(device, [
    {fps: targetFps},
    {videoAspectRatio: screenAspectRatio},
    {videoResolution: 'max'},
    {photoAspectRatio: screenAspectRatio},
    {photoResolution: 'max'},
    {photoHDR: enableHdr},
    {videoHDR: enableHdr},
  ]);

  const fps = Math.min(format?.maxFps ?? 1, targetFps);

  const supportsFlash = device?.hasFlash ?? false;
  const supportsHdr = format?.supportsPhotoHDR && format.supportsVideoHDR;
  const supports60Fps = useMemo(
    () => device?.formats.some(f => f.maxFps >= 60),
    [device?.formats],
  );

  const canToggleNightMode = device?.supportsLowLightBoost ?? false;

  //#region Animated Zoom
  // This just maps the zoom factor to a percentage value.
  // so e.g. for [min, neutr., max] values [1, 2, 128] this would result in [0, 0.0081, 1]
  const minZoom = device?.minZoom ?? 1;
  const maxZoom = Math.min(device?.maxZoom ?? 1, MAX_ZOOM_FACTOR);

  const cameraAnimatedProps = useAnimatedProps(() => {
    const z = Math.max(Math.min(zoom.value, maxZoom), minZoom);
    return {
      zoom: z,
    };
  }, [maxZoom, minZoom, zoom]);
  //#endregion

  //#region Callbacks
  const setIsPressingButton = useCallback(
    (_isPressingButton: boolean) => {
      isPressingButton.value = _isPressingButton;
    },
    [isPressingButton],
  );
  // Camera callbacks
  const onError = useCallback((error: CameraRuntimeError) => {
    console.error(error);
  }, []);
  const onInitialized = useCallback(() => {
    console.log('Camera initialized!');
    setIsCameraInitialized(true);
  }, []);
  const onMediaCaptured = useCallback(
    (media: PhotoFile | VideoFile, type: 'photo' | 'video') => {
      console.log(`Media captured! ${JSON.stringify(media)}`);
      navigation.navigate('MediaPage', {
        path: media.path,
        type: type,
      });
    },
    [navigation],
  );
  const onFlipCameraPressed = useCallback(() => {
    setCameraPosition(p => (p === 'back' ? 'front' : 'back'));
  }, []);
  const onFlashPressed = useCallback(() => {
    setFlash(f => (f === 'off' ? 'on' : 'off'));
  }, []);
  //#endregion

  //#region Tap Gesture
  const onDoubleTap = useCallback(() => {
    onFlipCameraPressed();
  }, [onFlipCameraPressed]);
  //#endregion

  //#region Effects
  const neutralZoom = device?.neutralZoom ?? 1;
  useEffect(() => {
    // Run everytime the neutralZoomScaled value changes. (reset zoom when device changes)
    zoom.value = neutralZoom;
  }, [neutralZoom, zoom]);

  useEffect(() => {
    Camera.getMicrophonePermissionStatus().then(status =>
      setHasMicrophonePermission(status === 'granted'),
    );
  }, []);
  //#endregion

  //#region Pinch to Zoom Gesture
  // The gesture handler maps the linear pinch gesture (0 - 1) to an exponential curve since a camera's zoom
  // function does not appear linear to the user. (aka zoom 0.1 -> 0.2 does not look equal in difference as 0.8 -> 0.9)
  const onPinchGesture = useAnimatedGestureHandler<
    PinchGestureHandlerGestureEvent,
    {startZoom?: number}
  >({
    onStart: (_, context) => {
      context.startZoom = zoom.value;
    },
    onActive: (event, context) => {
      // we're trying to map the scale gesture to a linear zoom here
      const startZoom = context.startZoom ?? 0;
      const scale = interpolate(
        event.scale,
        [1 - 1 / SCALE_FULL_ZOOM, 1, SCALE_FULL_ZOOM],
        [-1, 0, 1],
        Extrapolate.CLAMP,
      );
      zoom.value = interpolate(
        scale,
        [-1, 0, 1],
        [minZoom, startZoom, maxZoom],
        Extrapolate.CLAMP,
      );
    },
  });
  //#endregion

  if (device != null && format != null) {
    console.log(
      `Re-rendering camera page with ${
        isActive ? 'active' : 'inactive'
      } camera. ` +
        `Device: "${device.name}" (${format.photoWidth}x${format.photoHeight} photo / ${format.videoWidth}x${format.videoHeight} video @ ${fps}fps)`,
    );
  } else {
    console.log('re-rendering camera page without active camera');
  }

  // const frameProcessor = useFrameProcessor((frame) => {
  //   'worklet';

  //   console.log(`${frame.timestamp}: ${frame.width}x${frame.height} ${frame.pixelFormat} Frame (${frame.orientation})`);
  //   examplePlugin(frame);
  // }, []);

  return (
    <View style={styles.container}>
      {device != null && (
        <PinchGestureHandler onGestureEvent={onPinchGesture} enabled={isActive}>
          <Reanimated.View style={StyleSheet.absoluteFill}>
            <TapGestureHandler onEnded={onDoubleTap} numberOfTaps={2}>
              <ReanimatedCamera
                ref={camera}
                style={StyleSheet.absoluteFill}
                device={device}
                format={format}
                fps={fps}
                key={device.id}
                hdr={enableHdr}
                lowLightBoost={device.supportsLowLightBoost && enableNightMode}
                isActive={isActive}
                onInitialized={onInitialized}
                onError={onError}
                enableZoomGesture={false}
                animatedProps={cameraAnimatedProps}
                enableFpsGraph={true}
                orientation="portrait"
                photo={true}
                video={true}
                audio={hasMicrophonePermission}
                // frameProcessor={frameProcessor}
              />
            </TapGestureHandler>
          </Reanimated.View>
        </PinchGestureHandler>
      )}

      <CaptureButton
        style={styles.captureButton}
        camera={camera}
        onMediaCaptured={onMediaCaptured}
        cameraZoom={zoom}
        minZoom={minZoom}
        maxZoom={maxZoom}
        flash={supportsFlash ? flash : 'off'}
        enabled={isCameraInitialized && isActive}
        setIsPressingButton={setIsPressingButton}
      />

      <StatusBarBlurBackground />

      <View style={styles.rightButtonRow}>
        <PressableOpacity
          style={styles.button}
          onPress={onFlipCameraPressed}
          disabledOpacity={0.4}>
          <IonIcon name="camera-reverse" color="white" size={24} />
        </PressableOpacity>
        {supportsFlash && (
          <PressableOpacity
            style={styles.button}
            onPress={onFlashPressed}
            disabledOpacity={0.4}>
            <IonIcon
              name={flash === 'on' ? 'flash' : 'flash-off'}
              color="white"
              size={24}
            />
          </PressableOpacity>
        )}
        {supports60Fps && (
          <PressableOpacity
            style={styles.button}
            onPress={() => setTargetFps(t => (t === 30 ? 60 : 30))}>
            <Text style={styles.text}>{`${targetFps}\nFPS`}</Text>
          </PressableOpacity>
        )}
        {supportsHdr && (
          <PressableOpacity
            style={styles.button}
            onPress={() => setEnableHdr(h => !h)}>
            <MaterialIcon
              name={enableHdr ? 'hdr' : 'hdr-off'}
              color="white"
              size={24}
            />
          </PressableOpacity>
        )}
        {canToggleNightMode && (
          <PressableOpacity
            style={styles.button}
            onPress={() => setEnableNightMode(!enableNightMode)}
            disabledOpacity={0.4}>
            <IonIcon
              name={enableNightMode ? 'moon' : 'moon-outline'}
              color="white"
              size={24}
            />
          </PressableOpacity>
        )}
      </View>
    </View>
  );
}

const styles = StyleSheet.create({
  container: {
    flex: 1,
    backgroundColor: 'black',
  },
  captureButton: {
    position: 'absolute',
    alignSelf: 'center',
    bottom: SAFE_AREA_PADDING.paddingBottom,
  },
  button: {
    marginBottom: CONTENT_SPACING,
    width: BUTTON_SIZE,
    height: BUTTON_SIZE,
    borderRadius: BUTTON_SIZE / 2,
    backgroundColor: 'rgba(140, 140, 140, 0.3)',
    justifyContent: 'center',
    alignItems: 'center',
  },
  rightButtonRow: {
    position: 'absolute',
    right: SAFE_AREA_PADDING.paddingRight,
    top: SAFE_AREA_PADDING.paddingTop,
  },
  text: {
    color: 'white',
    fontSize: 11,
    fontWeight: 'bold',
    textAlign: 'center',
  },
});

Relevant log output

Some logs i got

{ [session/camera-has-been-disconnected: [session/camera-has-been-disconnected] The given Camera device (id: 1) has been disconnected! Error: UNKNOWN_CAMERA_DEVICE_ERROR]
name: 'session/camera-has-been-disconnected',

`device/invalid-device: No Camera Device could be found!
`

Process: com.visioncamera, PID: 27069
java.lang.IllegalArgumentException: getCameraCharacteristics:1043: Unable to retrieve camera characteristics for unknown device 1: No such file or directory (-2)
                                      

### Camera Device

```json
[ { pixelFormats: [ 'rgb', 'native', 'yuv', 'unknown' ],
                                                                                                        videoStabilizationModes: [ 'off', 'standard', 'cinematic', 'off', 'cinematic-extended' ],
                                                                                                        autoFocusSystem: 'contrast-detection',
                                                                                                        supportsPhotoHDR: true,
                                                                                                        photoHeight: 3060,
                                                                                                        supportsVideoHDR: true,
                                                                                                        supportsDepthCapture: false,
                                                                                                        maxISO: 3200,
                                                                                                        minISO: 50,
                                                                                                        minFps: 1,
                                                                                                        videoWidth: 3840,
                                                                                                        videoHeight: 2160,
                                                                                                        photoWidth: 4080,
                                                                                                        fieldOfView: 75.70461464712741,
                                                                                                        maxFps: 30 },
                                                                                                      { pixelFormats: [ 'rgb', 'native', 'yuv', 'unknown' ],
                                                                                                        videoStabilizationModes: [ 'off', 'standard', 'cinematic', 'off', 'cinematic-extended' ],
                                                                                                        autoFocusSystem: 'contrast-detection',
                                                                                                        supportsPhotoHDR: true,
                                                                                                        photoHeight: 3000,
                                                                                                        supportsVideoHDR: true,
                                                                                                        supportsDepthCapture: false,
                                                                                                        maxISO: 3200,
                                                                                                        minISO: 50,
                                                                                                        minFps: 1,
                                                                                                        videoWidth: 3840,
                                                                                                        videoHeight: 2160,
                                                                                                        photoWidth: 4000,
                                                                                                        fieldOfView: 75.70461464712741,
                                                                                                        maxFps: 30 },
                                                                                                      { pixelFormats: [ 'rgb', 'native', 'yuv', 'unknown' ],
                                                                                                        videoStabilizationModes: [ 'off', 'standard', 'cinematic', 'off', 'cinematic-extended' ],
                                                                                                        autoFocusSystem: 'contrast-detection',
                                                                                                        supportsPhotoHDR: true,
                                                                                                        photoHeight: 2252,
                                                                                                        supportsVideoHDR: true,
                                                                                                        supportsDepthCapture: false,
                                                                                                        maxISO: 3200,
                                                                                                        minISO: 50,
                                                                                                        minFps: 1,
                                                                                                        videoWidth: 3840,
                                                                                                        videoHeight: 2160,
                                                                                                        photoWidth: 4000,
                                                                                                        fieldOfView: 75.70461464712741,
                                                                                                        maxFps: 30 },
                                                                                                      { pixelFormats: [ 'rgb', 'native', 'yuv', 'unknown' ],
                                                                                                        videoStabilizationModes: [ 'off', 'standard', 'cinematic', 'off', 'cinematic-extended' ],
                                                                                                        autoFocusSystem: 'contrast-detection',
                                                                                                        supportsPhotoHDR: true,
                                                                                                        photoHeight: 1868,
                                                                                                        supportsVideoHDR: true,
                                                                                                        supportsDepthCapture: false,
                                                                                                        maxISO: 3200,
                                                                                                        minISO: 50,
                                                                                                        minFps: 1,
                                                                                                        videoWidth: 3840,
                                                                                                        videoHeight: 2160,
                                                                                                        photoWidth: 4000,
                                                                                                        fieldOfView: 75.70461464712741,
                                                                                                        maxFps: 30 },
                                                                                                      { pixelFormats: [ 'rgb', 'native', 'yuv', 'unknown' ],
                                                                                                        videoStabilizationModes: [ 'off', 'standard', 'cinematic', 'off', 'cinematic-extended' ],
                                                                                                        autoFocusSystem: 'contrast-detection',
                                                                                                        supportsPhotoHDR: true,
                                                                                                        photoHeight: 1716,
                                                                                                        supportsVideoHDR: true,
                                                                                                        supportsDepthCapture: false,
                                                                                                        maxISO: 3200,
                                                                                                        minISO: 50,
                                                                                                        minFps: 1,
                                                                                                        videoWidth: 3840,
                                                                                                        videoHeight: 2160,
                                                                                                        photoWidth: 4000,
                                                                                                        fieldOfView: 75.70461464712741,
                                                                                                        maxFps: 30 },
                                                                                                      { pixelFormats: [ 'rgb', 'native', 'yuv', 'unknown' ],
                                                                                                        videoStabilizationModes: [ 'off', 'standard', 'cinematic', 'off', 'cinematic-extended' ],
                                                                                                        autoFocusSystem: 'contrast-detection',
                                                                                                        supportsPhotoHDR: true,
                                                                                                        photoHeight: 2160,
                                                                                                        supportsVideoHDR: true,
                                                                                                        supportsDepthCapture: false,
                                                                                                        maxISO: 3200,
                                                                                                        minISO: 50,
                                                                                                        minFps: 1,
                                                                                                        videoWidth: 3840,
                                                                                                        videoHeight: 2160,
                                                                                                        photoWidth: 3840,
                                                                                                        fieldOfView: 75.70461464712741,
                                                                                                        maxFps: 30 },
                                                                                                      { pixelFormats: [ 'rgb', 'native', 'yuv', 'unknown' ],
                                                                                                        videoStabilizationModes: [ 'off', 'standard', 'cinematic', 'off', 'cinematic-extended' ],
                                                                                                        autoFocusSystem: 'contrast-detection',
                                                                                                        supportsPhotoHDR: true,
                                                                                                        photoHeight: 2736,
                                                                                                        supportsVideoHDR: true,
                                                                                                        supportsDepthCapture: false,
                                                                                                        maxISO: 3200,
                                                                                                        minISO: 50,
                                                                                                        minFps: 1,
                                                                                                        videoWidth: 3840,
                                                                                                        videoHeight: 2160,
                                                                                                        photoWidth: 3648,
                                                                                                        fieldOfView: 75.70461464712741,
                                                                                                        maxFps: 30 },
                                                                                                      { pixelFormats: [ 'rgb', 'native', 'yuv', 'unknown' ],
                                                                                                        videoStabilizationModes: [ 'off', 'standard', 'cinematic', 'off', 'cinematic-extended' ],
                                                                                                        autoFocusSystem: 'contrast-detection',
                                                                                                        supportsPhotoHDR: true,
                                                                                                        photoHeight: 2052,
                                                                                                        supportsVideoHDR: true,
                                                                                                        supportsDepthCapture: false,
                                                                                                        maxISO: 3200,
                                                                                                        minISO: 50,
                                                                                                        minFps: 1,
                                                                                                        videoWidth: 3840,
                                                                                                        videoHeight: 2160,
                                                                                                        photoWidth: 3648,
                                                                                                        fieldOfView: 75.70461464712741,
                                                                                                        maxFps: [TOO BIG formatValueCalls 201 exceeded limit of 200] },

Device

S23 Ultra Android

VisionCamera Version

3.1.0

Can you reproduce this issue in the VisionCamera Example app?

Yes I can

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.

[victorkvarghese]

@mrousavy

I think this is related to s23 ultra. I was able to run this properly in an Oppo v27 pro. I ran the example project disabling frame processors.

• Flash not working in S23 ultra
• HDR click crashes the App.
• 60 FPS was not listed in the camera module.
• Max Zoom is limited to 10

Not sure if this will help. Adding for clarity

[victorkvarghese]

Might be related: #1801 (comment)

I will check removing lines

[victorkvarghese]

@mrousavy hope this helps

Thing are working after removing those lines of code. I tried adding them one by one.

Device: S23 Ultra
Android Version: 13

Switching from back camera to front camera crashed when i added zoom related piece of code.

react-native-vision-camera/package/android/src/main/java/com/mrousavy/camera/core/CameraSession.kt

  // Zoom
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
      captureRequest.set(CaptureRequest.CONTROL_ZOOM_RATIO, zoom)
    } else {
      val cameraCharacteristics = cameraManager.getCameraCharacteristics(cameraId!!)
      val size = cameraCharacteristics.get(CameraCharacteristics.SENSOR_INFO_ACTIVE_ARRAY_SIZE)!!
      captureRequest.set(CaptureRequest.SCALER_CROP_REGION, size.zoomed(zoom))
    }

One of the errors i got was

java.lang.IllegalArgumentException: getCameraCharacteristics:1043: Unable to retrieve camera characteristics for unknown device 1: No such file or directory (-2)

[mrousavy]

1. Please stop tagging me.
2. I even explained how you can get the native (adb) logs, and even put a placeholder in there of how those should look like - yet you still ignored that and didn't paste them in there. How do you expect me to help you?

Thanks for trying the other approach though, I think we can pinpoint this to the zoom here - maybe Samsung can't handle non-clamped zoom values? What if you pass something like 0.5 or 1 here in that prop?

[victorkvarghese]

Sorry for the multiple number of messages/tags.

I have attached what i could salvage from android studio. (Not able to get the entire logcat)

not sure, I will check and get back. Im using same code as the example folder. App crashes when switching the camera, not when zooming happens.

will pass the prop and get back

[victorkvarghese]

Hi,

i tried to log the zoom.value.

• Intially back camera is opened and zoom value is 1
• Then if i switch to front camera it crashes
• Open app again
• Zoom out the back camera after loaded, value becomes 0.6
• Now if i switch to front camera , it works.

neutral zoom value is 1 for both back and front camera

I trying to see if there is a way to reset zoom to preferred value when camera position changes. Not sure if this is a reanimated issue that's causing the camera to have an unsupported value

[victorkvarghese]

Update

Fix 1 with reanimated zoom

I passed zoom={1} as a prop. And i think issues got fixed. App is not breaking when user zooms in/out. I think without zoom prop app crashes when cameras are switched

PS: Max zoom/min zoom is not proper. Think max zoom is 10 but it should be 100

Fix 2:

Remove reanimated zoom gesture and use enableZoomGesture={true}

Zoom gesture is not great, but u can zoom 100x

[mrousavy]

Okay so we need to clamp zoom

[victorkvarghese]

Do we need to add any permissions for flash. I tried 3 different devices , flash is not working on any of them.

HDR is also crashing for me.

[mrousavy]

Flash is not yet implemented in V3. there is a feature request for that.

HDR is crashing; please create a separate bug report and share the logs.

[xts-bit]

i also get this issue in Samsung devices, just a black screen on Camera view

[victorkvarghese]

i also get this issue in Samsung devices, just a black screen on Camera view

@xts-bit try const devices = useCameraDevices() and check if any cameras are detected.

[xts-bit]

@victorkvarghese It didn't work black screen on V3.1

[muhammedjailam]

Same issue... any fixes?

[mrousavy]

Hey!

Quick update: I think there could be four problems here:

1. You are using a limited/legacy device, and use Preview (always on), photo and video/frameProcessor outputs (3 outputs) which are by default at maximum resolution. LIMITED/LEGACY devices might not support full-resolution streaming, see the Android capture session documentation on supported configuration maps.
   We need PRIV PREVIEW + YUV/PRIV RECORD + JPEG MAXIMUM. anything lower, needs to be explicitly handled by me, but I can easily add that no problemo. I just need the device to test it on.
   
   What you can do: Try disabling photo, video and frameProcessor and check if that works. If only PREVIEW is attached, everything should work.
2. We are using some setting in the Capture Request that is not supported (e.g. FPS, HDR, Zoom, ...) but we don't previously check if those settings are supported on the device. I can easily add some checks here, so that the Camera doesn't just swallow any errors and fails silently, but instead throws and says something like "60 FPS is not supported on this device".

   react-native-vision-camera/package/android/src/main/java/com/mrousavy/camera/core/CameraSession.kt

   Lines 461 to 492 in fb6ebd9

   	// FPS
   	val fpsRange = if (fps != null && CAN_SET_FPS) Range(fps, fps) else Range(30, 30)
   	captureRequest.set(CaptureRequest.CONTROL_AE_TARGET_FPS_RANGE, fpsRange)
   	// Video Stabilization
   	captureRequest.set(CaptureRequest.CONTROL_VIDEO_STABILIZATION_MODE, videoStabilizationMode?.toDigitalStabilizationMode())
   	captureRequest.set(CaptureRequest.LENS_OPTICAL_STABILIZATION_MODE, videoStabilizationMode?.toOpticalStabilizationMode())
   	// Night/HDR Mode
   	val sceneMode = if (hdr ==
   	true
   	) {
   	CaptureRequest.CONTROL_SCENE_MODE_HDR
   	} else if (lowLightBoost == true) CaptureRequest.CONTROL_SCENE_MODE_NIGHT else null
   	captureRequest.set(CaptureRequest.CONTROL_SCENE_MODE, sceneMode)
   	captureRequest.set(
   	CaptureRequest.CONTROL_MODE,
   	if (sceneMode != null) CaptureRequest.CONTROL_MODE_USE_SCENE_MODE else CaptureRequest.CONTROL_MODE_AUTO
   	)
   	// Zoom
   	if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R) {
   	captureRequest.set(CaptureRequest.CONTROL_ZOOM_RATIO, zoom)
   	} else {
   	val cameraCharacteristics = cameraManager.getCameraCharacteristics(cameraId!!)
   	val size = cameraCharacteristics.get(CameraCharacteristics.SENSOR_INFO_ACTIVE_ARRAY_SIZE)!!
   	captureRequest.set(CaptureRequest.SCALER_CROP_REGION, size.zoomed(zoom))
   	}
   	// Torch Mode
   	val torchMode = if (torch == true) CaptureRequest.FLASH_MODE_TORCH else CaptureRequest.FLASH_MODE_OFF
   	captureRequest.set(CaptureRequest.FLASH_MODE, torchMode)

   
   What you can do: Try disabling each line in getPreviewCaptureRequest and see what happens. I've heard zoom is often the cause.
3. Some manufacturers (cough* cough Samsung) explicitly say they support something (e.g. 60 FPS), but then don't support it and just swallow errors and show blackscreens when trying to use it. This is the most ridiculous sh*t I've ever seen, but yea, that's how it is.
   What you can do: Also try other steps here and remove code by code to see what it is. Maybe also browse similar issues in the CameraX issue tracker or StackOverflow to see if someone had similar issues, explicitly by searching for your device.
4. There could be some synchronization issue. I can try to make everything fully atomic so nothing ever goes out of sync with mutexes. This is pretty tricky, but I'll do it

[xts-bit]

@mrousavy Make sense I am using "fps={60}" prop in my Camera. However, V2 works fine.

[mrousavy]

Hey! Can anyone try with VisionCamera 3.4.1. and see if the issue still persists? Thanks!

[mrousavy]

@xts-bit does it work if you remove those lines in CameraSession.kt?

[victorkvarghese]

@mrousavy

I just checked in S23 Ultra. v3.4.1

1. Camera switching is working fine without issues.
2. HDR Fails ( CamerXXError [unknown/unknown: [unknown/unknown] CaptureRequest contains unconfigured Input/Output Surface!])
3. Night mode is not crashing, but i am not sure if that mode is indeed functional.

[mrousavy]

1. Nice!
2. Okay, will try to fix that.
3. Night mode is just an Android Camera2 scene mode - it will probably not do a lot but that's how it works on Android.

[mrousavy]

Hey! Did #2049 (released in 3.6.0) fix the HDR issue? Thanks!

[victorkvarghese]

Hi @mrousavy
i tested the latest code with S23 ultra.

front camera is kind of stretched out , weird aspect ratio. I tried commenting all aspect ratio related code, but same results

I had same issue with back camera. But it got resolved when i commented everything in format

Camera hangs up when HDR is turned on with the exception
com.mrousavy.camera.core.CameraSessionCannotBeConfiguredError: [session/cannot-create-session] Failed to create a Camera Session for Camera 0!

  // const screenAspectRatio = SCREEN_HEIGHT / SCREEN_WIDTH;
  const format = useCameraFormat(device, [
    // { fps: targetFps },
    // { videoAspectRatio: screenAspectRatio },
    // { videoResolution: 'max' },
    // { photoAspectRatio: screenAspectRatio },
    // { photoResolution: 'max' },
  ]);

I tested with another vivo device. Front and back camera is working alright without providing aspect ratio

[victorkvarghese]

Update: things are fine if i downgrade to 3.4.1 , Front camera is not stretched out

[mrousavy]

Okay so there is some wrong stretching going on in the preview? cc @blancham is that something you noticed as well?

[victorkvarghese]

I think this is also related: #2123

Have the same issue. front camera photos are horizontal oriented, while back camera is working okay.

[bglgwyng]

I'm still facing the same issue. I opened the example app and repeated flipping the direction.
My device is a Galaxy S10, Android 12.

logs: https://gist.github.com/bglgwyng/4b287419ff61a02d7c09efb9a53e8cad

[mrousavy]

Unable to retrieve camera characteristics for unknown device 1: No such file or directory (-2)

Lol that is a weird error.

This has been reported by a few people on the internet and seems to be a device manifacturer error, e.g.: https://www.reddit.com/r/Xiaomi/comments/wtytkp/my_camera_keeps_on_crashing/

[ben-qiu]

I had an issue with com.mrousavy.camera.core.CameraSessionCannotBeConfiguredError: [session/cannot-create-session] Failed to create a Camera Session for Camera 0!
This only happens to the users who are using Samsung S23

I tried to replicate the issue and got the log

02-02 15:38:13.056 10536 11563 W CameraDevice-JV-0: Stream configuration failed due to: createSurfaceFromGbp:482: Camera 0: No 10-bit supported stream configurations with format 0x21 defined and profile 2, failed to create output stream
02-02 15:38:13.058 10536 11563 E CameraCaptureSession: Session 0: Failed to create capture session; configuration failed
02-02 15:38:13.058 10536 11563 E CreateCaptureSession: Camera #0: Failed to create CameraCaptureSession #1!
02-02 15:38:13.058 10536 11563 E CameraSession: Failed to configure CameraSession! Error: [session/cannot-create-session] Failed to create a Camera Session for Camera #0!, isRunning: false, Config-Diff: Difference(deviceChanged=true, outputsChanged=true, sidePropsChanged=true, isActiveChanged=true)
02-02 15:38:13.058 10536 11563 E CameraSession: pl.k: [session/cannot-create-session] Failed to create a Camera Session for Camera #0!

So the problem is CameraDevice-JV-0: Stream configuration failed due to: createSurfaceFromGbp:482: Camera 0: No 10-bit supported stream configurations with format 0x21 defined and profile 2, failed to create output stream

I can fix the problem by setting the photoHdr={false}

[mrousavy]

@ben-qiu does your format even have supportsPhotoHdr?

[ben-qiu]

@ben-qiu does your format even have supportsPhotoHdr?

Hi @mrousavy , I didn't log the value, but I believe it is true, because the original code was photoHdr={format.supportsPhotoHdr}

[mrousavy]

Okay yea makes sense.

[bglgwyng]

I've occasionally observed this behavior with VisionCamera 3.8.2 on Galaxy S21.
However, after upgrading to version 3.9.0, now I consistently experience this behavior.

[mrousavy]

@bglgwyng wow - weird. Can you show me how you're using the <Camera> component, and also the adb logcat logs?

[mrousavy]

If you are using a Frame Processor, maybe it's this change? v3.8.2...v3.9.0-beta.0#diff-2335891be153a7966add00cea63f840e8c3c5597af11fb9f7156dac0d1fb57b1R84-R87

Could you try to disable a Frame Processor and see if that works? Also, maybe try explicitly passing a different format? Either native or yuv