如何在Flutter中获取相机内参？自研插件调用iOS/Android原生API是否可行？

Hey there! As a Flutter developer who’s tackled camera-related projects before, I can help clarify this for you. The short answer is yes, you can get camera intrinsic parameters in Flutter—but there’s no out-of-the-box official API for this. Let’s dive into how to do it, including building a custom plugin to bridge native code.

1. Why You Might Not Have Found a Direct Flutter Solution #

Flutter’s official camera package focuses on core camera controls and media capture, but it doesn’t expose low-level intrinsic parameters like focal length or principal points. Most third-party packages also stick to common camera features, so this specific need often requires bridging to native iOS/Android code.

2. Implementing a Custom Flutter Plugin #

Writing a custom plugin to call native APIs is absolutely feasible, and it’s the most reliable way to get these parameters. Here’s a step-by-step breakdown:

Step 1: Generate a Plugin Scaffold #

Start by creating a new plugin project with the Flutter CLI:

flutter create --template=plugin camera_intrinsics

Step 2: Android Native Implementation (Kotlin) #

In android/src/main/kotlin/com/yourcompany/camera_intrinsics/CameraIntrinsicsPlugin.kt, use the Camera2 API to access camera characteristics:

import android.hardware.camera2.CameraCharacteristics
import android.hardware.camera2.CameraManager
import io.flutter.embedding.engine.plugins.FlutterPlugin
import io.flutter.plugin.common.MethodCall
import io.flutter.plugin.common.MethodChannel
import io.flutter.plugin.common.MethodChannel.Result

class CameraIntrinsicsPlugin : FlutterPlugin, MethodChannel.MethodCallHandler {
    private lateinit var channel: MethodChannel
    private var cameraManager: CameraManager? = null

    override fun onAttachedToEngine(binding: FlutterPlugin.FlutterPluginBinding) {
        channel = MethodChannel(binding.binaryMessenger, "camera_intrinsics")
        channel.setMethodCallHandler(this)
        cameraManager = binding.applicationContext.getSystemService(CameraManager::class.java)
    }

    override fun onMethodCall(call: MethodCall, result: Result) {
        if (call.method == "getIntrinsics") {
            try {
                // Get the default back camera (adjust for front/multi-camera setups)
                val cameraId = cameraManager?.cameraIdList?.firstOrNull() ?: run {
                    result.error("NO_CAMERA", "No camera detected", null)
                    return
                }
                val characteristics = cameraManager?.getCameraCharacteristics(cameraId)
                
                // Extract key intrinsic parameters
                val focalLength = characteristics?.get(CameraCharacteristics.LENS_INFO_AVAILABLE_FOCAL_LENGTHS)?.firstOrNull() ?: 0.0f
                val principalPointX = characteristics?.get(CameraCharacteristics.SENSOR_INFO_PRINCIPAL_POINT_X) ?: 0.0f
                val principalPointY = characteristics?.get(CameraCharacteristics.SENSOR_INFO_PRINCIPAL_POINT_Y) ?: 0.0f

                val intrinsics = mapOf(
                    "focalLength" to focalLength,
                    "principalPointX" to principalPointX,
                    "principalPointY" to principalPointY
                )
                result.success(intrinsics)
            } catch (e: Exception) {
                result.error("FETCH_ERROR", "Failed to retrieve intrinsics: ${e.message}", null)
            }
        } else {
            result.notImplemented()
        }
    }

    override fun onDetachedFromEngine(binding: FlutterPlugin.FlutterPluginBinding) {
        channel.setMethodCallHandler(null)
    }
}

Step 3: iOS Native Implementation (Swift) #

In ios/Classes/SwiftCameraIntrinsicsPlugin.swift, use AVCaptureDevice to access camera intrinsics:

import Flutter
import AVFoundation

public class SwiftCameraIntrinsicsPlugin: NSObject, FlutterPlugin {
    public static func register(with registrar: FlutterPluginRegistrar) {
        let channel = FlutterMethodChannel(name: "camera_intrinsics", binaryMessenger: registrar.messenger())
        let instance = SwiftCameraIntrinsicsPlugin()
        registrar.addMethodCallDelegate(instance, channel: channel)
    }

    public func handle(_ call: FlutterMethodCall, result: @escaping FlutterResult) {
        if call.method == "getIntrinsics" {
            // Get default back camera
            guard let device = AVCaptureDevice.default(.builtInWideAngleCamera, for: .video, position: .back) else {
                result(FlutterError(code: "NO_CAMERA", message: "Back camera not available", details: nil))
                return
            }
            
            guard let format = device.activeFormat else {
                result(FlutterError(code: "NO_FORMAT", message: "No active camera format found", details: nil))
                return
            }
            
            let intrinsics = format.intrinsics
            let resultDict: [String: Any] = [
                "focalLength": intrinsics.focalLength,
                "principalPointX": intrinsics.principalPoint.x,
                "principalPointY": intrinsics.principalPoint.y
            ]
            result(resultDict)
        } else {
            result(FlutterMethodNotImplemented)
        }
    }
}

Step 4: Flutter Side Usage #

Call the plugin from your Flutter app to retrieve the parameters:

import 'package:flutter/services.dart';

class CameraIntrinsicsService {
  static const MethodChannel _channel = MethodChannel('camera_intrinsics');

  static Future<Map<String, dynamic>?> getIntrinsics() async {
    try {
      final result = await _channel.invokeMethod('getIntrinsics');
      return result?.cast<String, dynamic>();
    } on PlatformException catch (e) {
      print("Error fetching intrinsics: ${e.message}");
      return null;
    }
  }
}

// Example usage in a widget
Future<void> fetchCameraIntrinsics() async {
  final intrinsics = await CameraIntrinsicsService.getIntrinsics();
  if (intrinsics != null) {
    print("Focal Length: ${intrinsics['focalLength']}");
    print("Principal Point (X/Y): ${intrinsics['principalPointX']}/${intrinsics['principalPointY']}");
  }
}

3. Limitations to Consider #

• Permissions: You must request camera permissions first. Add NSCameraUsageDescription to iOS Info.plist and android.permission.CAMERA to Android AndroidManifest.xml.
• Camera Selection: The examples use the default back camera. To support multiple cameras (front, ultra-wide), modify the plugin to accept a camera position parameter from Flutter.
• API Compatibility: Android requires API level 21+ (Camera2 API), and iOS requires iOS 10+. Older devices won’t work with this implementation.
• Format Variability: Intrinsic parameters can change across camera resolutions/formats. The example uses the active format—adjust if your app supports multiple capture resolutions.

Final Notes #

If you prefer not to build a plugin from scratch, keep checking pub.dev—community packages may add this functionality over time. For now, a custom plugin is the most reliable way to access camera intrinsic parameters in Flutter.

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