Let's break down how to resolve this permission error and get your video feed working properly.

1. First, Ensure Camera Permissions Are Requested & Granted #

The most common cause of this error is missing camera permissions. In Expo, you can't access the camera without explicitly requesting user permission first.

Step 1: Add Permission Config to app.json #

First, update your app.json to declare the required permissions for both iOS and Android:

{
  "expo": {
    "ios": {
      "infoPlist": {
        "NSCameraUsageDescription": "We need access to your camera for video calls"
      }
    },
    "android": {
      "permissions": ["CAMERA"]
    }
  }
}

Step 2: Request Permissions Before Accessing the Camera #

Use Expo's expo-camera module to request camera permissions before you join the call or attempt to enable the camera. Here's how to integrate this:

import { Camera, Alert } from 'expo-camera';
import * as Linking from 'expo-linking';

// Add this function to check/request permissions
const requestCameraPermission = async () => {
  const { status } = await Camera.requestCameraPermissionsAsync();
  if (status === 'denied') {
    await Alert.alert(
      'Camera Access Required',
      'We need your camera to make video calls. Would you like to open settings to enable it?',
      [
        { text: 'Cancel', style: 'cancel' },
        { text: 'Open Settings', onPress: () => Linking.openSettings() }
      ]
    );
    return false;
  }
  return status === 'granted';
};

2. Adjust Call Flow: Permissions First, Then Join/Enable Camera #

Your current code might be trying to enable the camera or join the call before permissions are granted. Update your flow to:

1. Request camera permission
2. Only proceed if permission is granted
3. Create/join the call
4. Enable the camera (if needed)

Modify your call initialization code like this:

// Request permissions first
const hasCameraPermission = await requestCameraPermission();
if (!hasCameraPermission) return;

// Now create the call
const myCall = client.call("default", cast(callId));
await myCall.getOrCreate({
  data: {
    members: [
      { user_id: String(user.user?.id), role: "call_member" },
      { user_id: String(recipientId), role: "call_member" },
    ],
    settings_override: {
      video: {
        camera_default_on: isVideoCall,
        target_resolution: {
          bitrate: 400000,
          height: 640,
          width: 360,
        },
      },
    },
  },
});

// Join the call AFTER permissions are confirmed
await joinWithRetry(call, { 
  create: initiate === "true", 
  videoEnabled: isVideoCall // Explicitly enable video here
});

// If you still need to manually enable the camera (only if camera_default_on is false)
if (isVideoCall) {
  try {
    await call?.camera.enable();
  } catch (error) {
    console.error('Failed to enable camera:', error);
  }
}

3. Wait for Call Connection Before Enabling Camera #

Sometimes the call might not be fully connected when you try to enable the camera. Wrap the enable call in a listener for the call's connected state:

// Wait for the call to connect before enabling camera
call.on('connected', async () => {
  if (isVideoCall) {
    await call?.camera.enable();
  }
});

4. Verify Join Call Options #

Ensure your joinWithRetry function passes video-related options correctly. The videoEnabled flag tells the call client you intend to publish video, which pairs with your permission setup.

内容的提问来源于stack exchange，提问作者Victor Ezekiel