diff --git a/CODEOWNERS b/CODEOWNERS
index 68e4cb7..16bf98b 100644
--- a/CODEOWNERS
+++ b/CODEOWNERS
@@ -26,7 +26,7 @@
 packages/**/*_web/**                                     @ditman
 
 # - Android
-packages/camera/camera/android/**                        @camsim99
+packages/camera/camera_android/**                        @camsim99
 packages/espresso/**                                     @blasten
 packages/flutter_plugin_android_lifecycle/**             @blasten
 packages/google_maps_flutter/google_maps_flutter/android/**  @GaryQian
@@ -40,7 +40,7 @@
 packages/video_player/video_player_android/**            @blasten
 
 # - iOS
-packages/camera/camera/ios/**                            @hellohuanlin
+packages/camera/camera_avfoundation/**                   @hellohuanlin
 packages/google_maps_flutter/google_maps_flutter/ios/**  @cyanglaz
 packages/google_sign_in/google_sign_in_ios/**            @jmagman
 packages/image_picker/image_picker_ios/**                @cyanglaz
diff --git a/packages/camera/camera_android/CHANGELOG.md b/packages/camera/camera_android/CHANGELOG.md
index c57f301..5bc7c8a 100644
--- a/packages/camera/camera_android/CHANGELOG.md
+++ b/packages/camera/camera_android/CHANGELOG.md
@@ -1,3 +1,7 @@
+## 0.9.8
+
+* Switches to internal method channel implementation.
+
 ## 0.9.7+1
 
 * Splits from `camera` as a federated implementation.
diff --git a/packages/camera/camera_android/android/src/main/java/io/flutter/plugins/camera/DartMessenger.java b/packages/camera/camera_android/android/src/main/java/io/flutter/plugins/camera/DartMessenger.java
index dc62fce..e15078e 100644
--- a/packages/camera/camera_android/android/src/main/java/io/flutter/plugins/camera/DartMessenger.java
+++ b/packages/camera/camera_android/android/src/main/java/io/flutter/plugins/camera/DartMessenger.java
@@ -64,8 +64,9 @@
    *     the main thread. The handler is mainly supplied so it will be easier test this class.
    */
   DartMessenger(BinaryMessenger messenger, long cameraId, @NonNull Handler handler) {
-    cameraChannel = new MethodChannel(messenger, "flutter.io/cameraPlugin/camera" + cameraId);
-    deviceChannel = new MethodChannel(messenger, "flutter.io/cameraPlugin/device");
+    cameraChannel =
+        new MethodChannel(messenger, "plugins.flutter.io/camera_android/camera" + cameraId);
+    deviceChannel = new MethodChannel(messenger, "plugins.flutter.io/camera_android/fromPlatform");
     this.handler = handler;
   }
 
diff --git a/packages/camera/camera_android/android/src/main/java/io/flutter/plugins/camera/MethodCallHandlerImpl.java b/packages/camera/camera_android/android/src/main/java/io/flutter/plugins/camera/MethodCallHandlerImpl.java
index 35cc2b0..38201e1 100644
--- a/packages/camera/camera_android/android/src/main/java/io/flutter/plugins/camera/MethodCallHandlerImpl.java
+++ b/packages/camera/camera_android/android/src/main/java/io/flutter/plugins/camera/MethodCallHandlerImpl.java
@@ -49,8 +49,9 @@
     this.permissionsRegistry = permissionsAdder;
     this.textureRegistry = textureRegistry;
 
-    methodChannel = new MethodChannel(messenger, "plugins.flutter.io/camera");
-    imageStreamChannel = new EventChannel(messenger, "plugins.flutter.io/camera/imageStream");
+    methodChannel = new MethodChannel(messenger, "plugins.flutter.io/camera_android");
+    imageStreamChannel =
+        new EventChannel(messenger, "plugins.flutter.io/camera_android/imageStream");
     methodChannel.setMethodCallHandler(this);
   }
 
diff --git a/packages/camera/camera_android/example/integration_test/camera_test.dart b/packages/camera/camera_android/example/integration_test/camera_test.dart
index 05c6693..99029fc 100644
--- a/packages/camera/camera_android/example/integration_test/camera_test.dart
+++ b/packages/camera/camera_android/example/integration_test/camera_test.dart
@@ -5,6 +5,7 @@
 import 'dart:io';
 import 'dart:ui';
 
+import 'package:camera_android/camera_android.dart';
 import 'package:camera_example/camera_controller.dart';
 import 'package:camera_platform_interface/camera_platform_interface.dart';
 import 'package:flutter/painting.dart';
@@ -19,6 +20,7 @@
   IntegrationTestWidgetsFlutterBinding.ensureInitialized();
 
   setUpAll(() async {
+    CameraPlatform.instance = AndroidCamera();
     final Directory extDir = await getTemporaryDirectory();
     testDir = await Directory('${extDir.path}/test').create(recursive: true);
   });
diff --git a/packages/camera/camera_android/lib/camera_android.dart b/packages/camera/camera_android/lib/camera_android.dart
new file mode 100644
index 0000000..93e3e17
--- /dev/null
+++ b/packages/camera/camera_android/lib/camera_android.dart
@@ -0,0 +1,5 @@
+// Copyright 2013 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+export 'src/android_camera.dart';
diff --git a/packages/camera/camera_android/lib/src/android_camera.dart b/packages/camera/camera_android/lib/src/android_camera.dart
new file mode 100644
index 0000000..5fb3443
--- /dev/null
+++ b/packages/camera/camera_android/lib/src/android_camera.dart
@@ -0,0 +1,587 @@
+// Copyright 2013 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import 'dart:async';
+import 'dart:math';
+
+import 'package:camera_platform_interface/camera_platform_interface.dart';
+import 'package:flutter/foundation.dart';
+import 'package:flutter/services.dart';
+import 'package:flutter/widgets.dart';
+import 'package:stream_transform/stream_transform.dart';
+
+import 'type_conversion.dart';
+import 'utils.dart';
+
+const MethodChannel _channel =
+    MethodChannel('plugins.flutter.io/camera_android');
+
+/// The Android implementation of [CameraPlatform] that uses method channels.
+class AndroidCamera extends CameraPlatform {
+  /// Construct a new method channel camera instance.
+  AndroidCamera() {
+    const MethodChannel channel =
+        MethodChannel('plugins.flutter.io/camera_android/fromPlatform');
+    channel.setMethodCallHandler(
+        (MethodCall call) => handleDeviceMethodCall(call));
+  }
+
+  /// Registers this class as the default instance of [CameraPlatform].
+  static void registerWith() {
+    CameraPlatform.instance = AndroidCamera();
+  }
+
+  final Map<int, MethodChannel> _channels = <int, MethodChannel>{};
+
+  /// The controller we need to broadcast the different events coming
+  /// from handleMethodCall, specific to camera events.
+  ///
+  /// It is a `broadcast` because multiple controllers will connect to
+  /// different stream views of this Controller.
+  /// This is only exposed for test purposes. It shouldn't be used by clients of
+  /// the plugin as it may break or change at any time.
+  @visibleForTesting
+  final StreamController<CameraEvent> cameraEventStreamController =
+      StreamController<CameraEvent>.broadcast();
+
+  /// The controller we need to broadcast the different events coming
+  /// from handleMethodCall, specific to general device events.
+  ///
+  /// It is a `broadcast` because multiple controllers will connect to
+  /// different stream views of this Controller.
+  /// This is only exposed for test purposes. It shouldn't be used by clients of
+  /// the plugin as it may break or change at any time.
+  @visibleForTesting
+  final StreamController<DeviceEvent> deviceEventStreamController =
+      StreamController<DeviceEvent>.broadcast();
+
+  // The stream to receive frames from the native code.
+  StreamSubscription<dynamic>? _platformImageStreamSubscription;
+
+  // The stream for vending frames to platform interface clients.
+  StreamController<CameraImageData>? _frameStreamController;
+
+  Stream<CameraEvent> _cameraEvents(int cameraId) =>
+      cameraEventStreamController.stream
+          .where((CameraEvent event) => event.cameraId == cameraId);
+
+  @override
+  Future<List<CameraDescription>> availableCameras() async {
+    try {
+      final List<Map<dynamic, dynamic>>? cameras = await _channel
+          .invokeListMethod<Map<dynamic, dynamic>>('availableCameras');
+
+      if (cameras == null) {
+        return <CameraDescription>[];
+      }
+
+      return cameras.map((Map<dynamic, dynamic> camera) {
+        return CameraDescription(
+          name: camera['name']! as String,
+          lensDirection:
+              parseCameraLensDirection(camera['lensFacing']! as String),
+          sensorOrientation: camera['sensorOrientation']! as int,
+        );
+      }).toList();
+    } on PlatformException catch (e) {
+      throw CameraException(e.code, e.message);
+    }
+  }
+
+  @override
+  Future<int> createCamera(
+    CameraDescription cameraDescription,
+    ResolutionPreset? resolutionPreset, {
+    bool enableAudio = false,
+  }) async {
+    try {
+      final Map<String, dynamic>? reply = await _channel
+          .invokeMapMethod<String, dynamic>('create', <String, dynamic>{
+        'cameraName': cameraDescription.name,
+        'resolutionPreset': resolutionPreset != null
+            ? _serializeResolutionPreset(resolutionPreset)
+            : null,
+        'enableAudio': enableAudio,
+      });
+
+      return reply!['cameraId']! as int;
+    } on PlatformException catch (e) {
+      throw CameraException(e.code, e.message);
+    }
+  }
+
+  @override
+  Future<void> initializeCamera(
+    int cameraId, {
+    ImageFormatGroup imageFormatGroup = ImageFormatGroup.unknown,
+  }) {
+    _channels.putIfAbsent(cameraId, () {
+      final MethodChannel channel =
+          MethodChannel('plugins.flutter.io/camera_android/camera$cameraId');
+      channel.setMethodCallHandler(
+          (MethodCall call) => handleCameraMethodCall(call, cameraId));
+      return channel;
+    });
+
+    final Completer<void> _completer = Completer<void>();
+
+    onCameraInitialized(cameraId).first.then((CameraInitializedEvent value) {
+      _completer.complete();
+    });
+
+    _channel.invokeMapMethod<String, dynamic>(
+      'initialize',
+      <String, dynamic>{
+        'cameraId': cameraId,
+        'imageFormatGroup': imageFormatGroup.name(),
+      },
+    ).catchError(
+      (Object error, StackTrace stackTrace) {
+        if (error is! PlatformException) {
+          throw error;
+        }
+        _completer.completeError(
+          CameraException(error.code, error.message),
+          stackTrace,
+        );
+      },
+    );
+
+    return _completer.future;
+  }
+
+  @override
+  Future<void> dispose(int cameraId) async {
+    if (_channels.containsKey(cameraId)) {
+      final MethodChannel? cameraChannel = _channels[cameraId];
+      cameraChannel?.setMethodCallHandler(null);
+      _channels.remove(cameraId);
+    }
+
+    await _channel.invokeMethod<void>(
+      'dispose',
+      <String, dynamic>{'cameraId': cameraId},
+    );
+  }
+
+  @override
+  Stream<CameraInitializedEvent> onCameraInitialized(int cameraId) {
+    return _cameraEvents(cameraId).whereType<CameraInitializedEvent>();
+  }
+
+  @override
+  Stream<CameraResolutionChangedEvent> onCameraResolutionChanged(int cameraId) {
+    return _cameraEvents(cameraId).whereType<CameraResolutionChangedEvent>();
+  }
+
+  @override
+  Stream<CameraClosingEvent> onCameraClosing(int cameraId) {
+    return _cameraEvents(cameraId).whereType<CameraClosingEvent>();
+  }
+
+  @override
+  Stream<CameraErrorEvent> onCameraError(int cameraId) {
+    return _cameraEvents(cameraId).whereType<CameraErrorEvent>();
+  }
+
+  @override
+  Stream<VideoRecordedEvent> onVideoRecordedEvent(int cameraId) {
+    return _cameraEvents(cameraId).whereType<VideoRecordedEvent>();
+  }
+
+  @override
+  Stream<DeviceOrientationChangedEvent> onDeviceOrientationChanged() {
+    return deviceEventStreamController.stream
+        .whereType<DeviceOrientationChangedEvent>();
+  }
+
+  @override
+  Future<void> lockCaptureOrientation(
+    int cameraId,
+    DeviceOrientation orientation,
+  ) async {
+    await _channel.invokeMethod<String>(
+      'lockCaptureOrientation',
+      <String, dynamic>{
+        'cameraId': cameraId,
+        'orientation': serializeDeviceOrientation(orientation)
+      },
+    );
+  }
+
+  @override
+  Future<void> unlockCaptureOrientation(int cameraId) async {
+    await _channel.invokeMethod<String>(
+      'unlockCaptureOrientation',
+      <String, dynamic>{'cameraId': cameraId},
+    );
+  }
+
+  @override
+  Future<XFile> takePicture(int cameraId) async {
+    final String? path = await _channel.invokeMethod<String>(
+      'takePicture',
+      <String, dynamic>{'cameraId': cameraId},
+    );
+
+    if (path == null) {
+      throw CameraException(
+        'INVALID_PATH',
+        'The platform "$defaultTargetPlatform" did not return a path while reporting success. The platform should always return a valid path or report an error.',
+      );
+    }
+
+    return XFile(path);
+  }
+
+  @override
+  Future<void> prepareForVideoRecording() =>
+      _channel.invokeMethod<void>('prepareForVideoRecording');
+
+  @override
+  Future<void> startVideoRecording(int cameraId,
+      {Duration? maxVideoDuration}) async {
+    await _channel.invokeMethod<void>(
+      'startVideoRecording',
+      <String, dynamic>{
+        'cameraId': cameraId,
+        'maxVideoDuration': maxVideoDuration?.inMilliseconds,
+      },
+    );
+  }
+
+  @override
+  Future<XFile> stopVideoRecording(int cameraId) async {
+    final String? path = await _channel.invokeMethod<String>(
+      'stopVideoRecording',
+      <String, dynamic>{'cameraId': cameraId},
+    );
+
+    if (path == null) {
+      throw CameraException(
+        'INVALID_PATH',
+        'The platform "$defaultTargetPlatform" did not return a path while reporting success. The platform should always return a valid path or report an error.',
+      );
+    }
+
+    return XFile(path);
+  }
+
+  @override
+  Future<void> pauseVideoRecording(int cameraId) => _channel.invokeMethod<void>(
+        'pauseVideoRecording',
+        <String, dynamic>{'cameraId': cameraId},
+      );
+
+  @override
+  Future<void> resumeVideoRecording(int cameraId) =>
+      _channel.invokeMethod<void>(
+        'resumeVideoRecording',
+        <String, dynamic>{'cameraId': cameraId},
+      );
+
+  @override
+  Stream<CameraImageData> onStreamedFrameAvailable(int cameraId,
+      {CameraImageStreamOptions? options}) {
+    _frameStreamController = StreamController<CameraImageData>(
+      onListen: _onFrameStreamListen,
+      onPause: _onFrameStreamPauseResume,
+      onResume: _onFrameStreamPauseResume,
+      onCancel: _onFrameStreamCancel,
+    );
+    return _frameStreamController!.stream;
+  }
+
+  void _onFrameStreamListen() {
+    _startPlatformStream();
+  }
+
+  Future<void> _startPlatformStream() async {
+    await _channel.invokeMethod<void>('startImageStream');
+    const EventChannel cameraEventChannel =
+        EventChannel('plugins.flutter.io/camera_android/imageStream');
+    _platformImageStreamSubscription =
+        cameraEventChannel.receiveBroadcastStream().listen((dynamic imageData) {
+      _frameStreamController!
+          .add(cameraImageFromPlatformData(imageData as Map<dynamic, dynamic>));
+    });
+  }
+
+  FutureOr<void> _onFrameStreamCancel() async {
+    await _channel.invokeMethod<void>('stopImageStream');
+    await _platformImageStreamSubscription?.cancel();
+    _platformImageStreamSubscription = null;
+    _frameStreamController = null;
+  }
+
+  void _onFrameStreamPauseResume() {
+    throw CameraException('InvalidCall',
+        'Pause and resume are not supported for onStreamedFrameAvailable');
+  }
+
+  @override
+  Future<void> setFlashMode(int cameraId, FlashMode mode) =>
+      _channel.invokeMethod<void>(
+        'setFlashMode',
+        <String, dynamic>{
+          'cameraId': cameraId,
+          'mode': _serializeFlashMode(mode),
+        },
+      );
+
+  @override
+  Future<void> setExposureMode(int cameraId, ExposureMode mode) =>
+      _channel.invokeMethod<void>(
+        'setExposureMode',
+        <String, dynamic>{
+          'cameraId': cameraId,
+          'mode': serializeExposureMode(mode),
+        },
+      );
+
+  @override
+  Future<void> setExposurePoint(int cameraId, Point<double>? point) {
+    assert(point == null || point.x >= 0 && point.x <= 1);
+    assert(point == null || point.y >= 0 && point.y <= 1);
+
+    return _channel.invokeMethod<void>(
+      'setExposurePoint',
+      <String, dynamic>{
+        'cameraId': cameraId,
+        'reset': point == null,
+        'x': point?.x,
+        'y': point?.y,
+      },
+    );
+  }
+
+  @override
+  Future<double> getMinExposureOffset(int cameraId) async {
+    final double? minExposureOffset = await _channel.invokeMethod<double>(
+      'getMinExposureOffset',
+      <String, dynamic>{'cameraId': cameraId},
+    );
+
+    return minExposureOffset!;
+  }
+
+  @override
+  Future<double> getMaxExposureOffset(int cameraId) async {
+    final double? maxExposureOffset = await _channel.invokeMethod<double>(
+      'getMaxExposureOffset',
+      <String, dynamic>{'cameraId': cameraId},
+    );
+
+    return maxExposureOffset!;
+  }
+
+  @override
+  Future<double> getExposureOffsetStepSize(int cameraId) async {
+    final double? stepSize = await _channel.invokeMethod<double>(
+      'getExposureOffsetStepSize',
+      <String, dynamic>{'cameraId': cameraId},
+    );
+
+    return stepSize!;
+  }
+
+  @override
+  Future<double> setExposureOffset(int cameraId, double offset) async {
+    final double? appliedOffset = await _channel.invokeMethod<double>(
+      'setExposureOffset',
+      <String, dynamic>{
+        'cameraId': cameraId,
+        'offset': offset,
+      },
+    );
+
+    return appliedOffset!;
+  }
+
+  @override
+  Future<void> setFocusMode(int cameraId, FocusMode mode) =>
+      _channel.invokeMethod<void>(
+        'setFocusMode',
+        <String, dynamic>{
+          'cameraId': cameraId,
+          'mode': serializeFocusMode(mode),
+        },
+      );
+
+  @override
+  Future<void> setFocusPoint(int cameraId, Point<double>? point) {
+    assert(point == null || point.x >= 0 && point.x <= 1);
+    assert(point == null || point.y >= 0 && point.y <= 1);
+
+    return _channel.invokeMethod<void>(
+      'setFocusPoint',
+      <String, dynamic>{
+        'cameraId': cameraId,
+        'reset': point == null,
+        'x': point?.x,
+        'y': point?.y,
+      },
+    );
+  }
+
+  @override
+  Future<double> getMaxZoomLevel(int cameraId) async {
+    final double? maxZoomLevel = await _channel.invokeMethod<double>(
+      'getMaxZoomLevel',
+      <String, dynamic>{'cameraId': cameraId},
+    );
+
+    return maxZoomLevel!;
+  }
+
+  @override
+  Future<double> getMinZoomLevel(int cameraId) async {
+    final double? minZoomLevel = await _channel.invokeMethod<double>(
+      'getMinZoomLevel',
+      <String, dynamic>{'cameraId': cameraId},
+    );
+
+    return minZoomLevel!;
+  }
+
+  @override
+  Future<void> setZoomLevel(int cameraId, double zoom) async {
+    try {
+      await _channel.invokeMethod<double>(
+        'setZoomLevel',
+        <String, dynamic>{
+          'cameraId': cameraId,
+          'zoom': zoom,
+        },
+      );
+    } on PlatformException catch (e) {
+      throw CameraException(e.code, e.message);
+    }
+  }
+
+  @override
+  Future<void> pausePreview(int cameraId) async {
+    await _channel.invokeMethod<double>(
+      'pausePreview',
+      <String, dynamic>{'cameraId': cameraId},
+    );
+  }
+
+  @override
+  Future<void> resumePreview(int cameraId) async {
+    await _channel.invokeMethod<double>(
+      'resumePreview',
+      <String, dynamic>{'cameraId': cameraId},
+    );
+  }
+
+  @override
+  Widget buildPreview(int cameraId) {
+    return Texture(textureId: cameraId);
+  }
+
+  /// Returns the flash mode as a String.
+  String _serializeFlashMode(FlashMode flashMode) {
+    switch (flashMode) {
+      case FlashMode.off:
+        return 'off';
+      case FlashMode.auto:
+        return 'auto';
+      case FlashMode.always:
+        return 'always';
+      case FlashMode.torch:
+        return 'torch';
+      default:
+        throw ArgumentError('Unknown FlashMode value');
+    }
+  }
+
+  /// Returns the resolution preset as a String.
+  String _serializeResolutionPreset(ResolutionPreset resolutionPreset) {
+    switch (resolutionPreset) {
+      case ResolutionPreset.max:
+        return 'max';
+      case ResolutionPreset.ultraHigh:
+        return 'ultraHigh';
+      case ResolutionPreset.veryHigh:
+        return 'veryHigh';
+      case ResolutionPreset.high:
+        return 'high';
+      case ResolutionPreset.medium:
+        return 'medium';
+      case ResolutionPreset.low:
+        return 'low';
+      default:
+        throw ArgumentError('Unknown ResolutionPreset value');
+    }
+  }
+
+  /// Converts messages received from the native platform into device events.
+  ///
+  /// This is only exposed for test purposes. It shouldn't be used by clients of
+  /// the plugin as it may break or change at any time.
+  @visibleForTesting
+  Future<dynamic> handleDeviceMethodCall(MethodCall call) async {
+    switch (call.method) {
+      case 'orientation_changed':
+        deviceEventStreamController.add(DeviceOrientationChangedEvent(
+            deserializeDeviceOrientation(
+                call.arguments['orientation']! as String)));
+        break;
+      default:
+        throw MissingPluginException();
+    }
+  }
+
+  /// Converts messages received from the native platform into camera events.
+  ///
+  /// This is only exposed for test purposes. It shouldn't be used by clients of
+  /// the plugin as it may break or change at any time.
+  @visibleForTesting
+  Future<dynamic> handleCameraMethodCall(MethodCall call, int cameraId) async {
+    switch (call.method) {
+      case 'initialized':
+        cameraEventStreamController.add(CameraInitializedEvent(
+          cameraId,
+          call.arguments['previewWidth']! as double,
+          call.arguments['previewHeight']! as double,
+          deserializeExposureMode(call.arguments['exposureMode']! as String),
+          call.arguments['exposurePointSupported']! as bool,
+          deserializeFocusMode(call.arguments['focusMode']! as String),
+          call.arguments['focusPointSupported']! as bool,
+        ));
+        break;
+      case 'resolution_changed':
+        cameraEventStreamController.add(CameraResolutionChangedEvent(
+          cameraId,
+          call.arguments['captureWidth']! as double,
+          call.arguments['captureHeight']! as double,
+        ));
+        break;
+      case 'camera_closing':
+        cameraEventStreamController.add(CameraClosingEvent(
+          cameraId,
+        ));
+        break;
+      case 'video_recorded':
+        cameraEventStreamController.add(VideoRecordedEvent(
+          cameraId,
+          XFile(call.arguments['path']! as String),
+          call.arguments['maxVideoDuration'] != null
+              ? Duration(
+                  milliseconds: call.arguments['maxVideoDuration']! as int)
+              : null,
+        ));
+        break;
+      case 'error':
+        cameraEventStreamController.add(CameraErrorEvent(
+          cameraId,
+          call.arguments['description']! as String,
+        ));
+        break;
+      default:
+        throw MissingPluginException();
+    }
+  }
+}
diff --git a/packages/camera/camera_android/lib/src/type_conversion.dart b/packages/camera/camera_android/lib/src/type_conversion.dart
new file mode 100644
index 0000000..754a5a0
--- /dev/null
+++ b/packages/camera/camera_android/lib/src/type_conversion.dart
@@ -0,0 +1,49 @@
+// Copyright 2013 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// TODO(a14n): remove this import once Flutter 3.1 or later reaches stable (including flutter/flutter#104231)
+// ignore: unnecessary_import
+import 'dart:typed_data';
+
+import 'package:camera_platform_interface/camera_platform_interface.dart';
+
+/// Converts method channel call [data] for `receivedImageStreamData` to a
+/// [CameraImageData].
+CameraImageData cameraImageFromPlatformData(Map<dynamic, dynamic> data) {
+  return CameraImageData(
+      format: _cameraImageFormatFromPlatformData(data['format']),
+      height: data['height'] as int,
+      width: data['width'] as int,
+      lensAperture: data['lensAperture'] as double?,
+      sensorExposureTime: data['sensorExposureTime'] as int?,
+      sensorSensitivity: data['sensorSensitivity'] as double?,
+      planes: List<CameraImagePlane>.unmodifiable(
+          (data['planes'] as List<dynamic>).map<CameraImagePlane>(
+              (dynamic planeData) => _cameraImagePlaneFromPlatformData(
+                  planeData as Map<dynamic, dynamic>))));
+}
+
+CameraImageFormat _cameraImageFormatFromPlatformData(dynamic data) {
+  return CameraImageFormat(_imageFormatGroupFromPlatformData(data), raw: data);
+}
+
+ImageFormatGroup _imageFormatGroupFromPlatformData(dynamic data) {
+  switch (data) {
+    case 35: // android.graphics.ImageFormat.YUV_420_888
+      return ImageFormatGroup.yuv420;
+    case 256: // android.graphics.ImageFormat.JPEG
+      return ImageFormatGroup.jpeg;
+  }
+
+  return ImageFormatGroup.unknown;
+}
+
+CameraImagePlane _cameraImagePlaneFromPlatformData(Map<dynamic, dynamic> data) {
+  return CameraImagePlane(
+      bytes: data['bytes'] as Uint8List,
+      bytesPerPixel: data['bytesPerPixel'] as int?,
+      bytesPerRow: data['bytesPerRow'] as int,
+      height: data['height'] as int?,
+      width: data['width'] as int?);
+}
diff --git a/packages/camera/camera_android/lib/src/utils.dart b/packages/camera/camera_android/lib/src/utils.dart
new file mode 100644
index 0000000..663ec6d
--- /dev/null
+++ b/packages/camera/camera_android/lib/src/utils.dart
@@ -0,0 +1,51 @@
+// Copyright 2013 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import 'package:camera_platform_interface/camera_platform_interface.dart';
+import 'package:flutter/services.dart';
+
+/// Parses a string into a corresponding CameraLensDirection.
+CameraLensDirection parseCameraLensDirection(String string) {
+  switch (string) {
+    case 'front':
+      return CameraLensDirection.front;
+    case 'back':
+      return CameraLensDirection.back;
+    case 'external':
+      return CameraLensDirection.external;
+  }
+  throw ArgumentError('Unknown CameraLensDirection value');
+}
+
+/// Returns the device orientation as a String.
+String serializeDeviceOrientation(DeviceOrientation orientation) {
+  switch (orientation) {
+    case DeviceOrientation.portraitUp:
+      return 'portraitUp';
+    case DeviceOrientation.portraitDown:
+      return 'portraitDown';
+    case DeviceOrientation.landscapeRight:
+      return 'landscapeRight';
+    case DeviceOrientation.landscapeLeft:
+      return 'landscapeLeft';
+    default:
+      throw ArgumentError('Unknown DeviceOrientation value');
+  }
+}
+
+/// Returns the device orientation for a given String.
+DeviceOrientation deserializeDeviceOrientation(String str) {
+  switch (str) {
+    case 'portraitUp':
+      return DeviceOrientation.portraitUp;
+    case 'portraitDown':
+      return DeviceOrientation.portraitDown;
+    case 'landscapeRight':
+      return DeviceOrientation.landscapeRight;
+    case 'landscapeLeft':
+      return DeviceOrientation.landscapeLeft;
+    default:
+      throw ArgumentError('"$str" is not a valid DeviceOrientation value');
+  }
+}
diff --git a/packages/camera/camera_android/pubspec.yaml b/packages/camera/camera_android/pubspec.yaml
index 908d55f..73eeaa7 100644
--- a/packages/camera/camera_android/pubspec.yaml
+++ b/packages/camera/camera_android/pubspec.yaml
@@ -2,7 +2,7 @@
 description: Android implementation of the camera plugin.
 repository: https://github.com/flutter/plugins/tree/main/packages/camera/camera_android
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+camera%22
-version: 0.9.7+1
+version: 0.9.8
 
 environment:
   sdk: ">=2.14.0 <3.0.0"
@@ -15,14 +15,17 @@
       android:
         package: io.flutter.plugins.camera
         pluginClass: CameraPlugin
+        dartPluginClass: AndroidCamera
 
 dependencies:
   camera_platform_interface: ^2.2.0
   flutter:
     sdk: flutter
   flutter_plugin_android_lifecycle: ^2.0.2
+  stream_transform: ^2.0.0
 
 dev_dependencies:
+  async: ^2.5.0
   flutter_driver:
     sdk: flutter
   flutter_test:
diff --git a/packages/camera/camera_android/test/android_camera_test.dart b/packages/camera/camera_android/test/android_camera_test.dart
new file mode 100644
index 0000000..9674b0c
--- /dev/null
+++ b/packages/camera/camera_android/test/android_camera_test.dart
@@ -0,0 +1,1075 @@
+// Copyright 2013 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import 'dart:async';
+import 'dart:math';
+
+import 'package:async/async.dart';
+import 'package:camera_android/src/android_camera.dart';
+import 'package:camera_android/src/utils.dart';
+import 'package:camera_platform_interface/camera_platform_interface.dart';
+import 'package:flutter/services.dart';
+import 'package:flutter/widgets.dart';
+import 'package:flutter_test/flutter_test.dart';
+
+import 'method_channel_mock.dart';
+
+const String _channelName = 'plugins.flutter.io/camera_android';
+
+void main() {
+  TestWidgetsFlutterBinding.ensureInitialized();
+
+  test('registers instance', () async {
+    AndroidCamera.registerWith();
+    expect(CameraPlatform.instance, isA<AndroidCamera>());
+  });
+
+  group('Creation, Initialization & Disposal Tests', () {
+    test('Should send creation data and receive back a camera id', () async {
+      // Arrange
+      final MethodChannelMock cameraMockChannel = MethodChannelMock(
+          channelName: _channelName,
+          methods: <String, dynamic>{
+            'create': <String, dynamic>{
+              'cameraId': 1,
+              'imageFormatGroup': 'unknown',
+            }
+          });
+      final AndroidCamera camera = AndroidCamera();
+
+      // Act
+      final int cameraId = await camera.createCamera(
+        const CameraDescription(
+            name: 'Test',
+            lensDirection: CameraLensDirection.back,
+            sensorOrientation: 0),
+        ResolutionPreset.high,
+      );
+
+      // Assert
+      expect(cameraMockChannel.log, <Matcher>[
+        isMethodCall(
+          'create',
+          arguments: <String, Object?>{
+            'cameraName': 'Test',
+            'resolutionPreset': 'high',
+            'enableAudio': false
+          },
+        ),
+      ]);
+      expect(cameraId, 1);
+    });
+
+    test('Should throw CameraException when create throws a PlatformException',
+        () {
+      // Arrange
+      MethodChannelMock(channelName: _channelName, methods: <String, dynamic>{
+        'create': PlatformException(
+          code: 'TESTING_ERROR_CODE',
+          message: 'Mock error message used during testing.',
+        )
+      });
+      final AndroidCamera camera = AndroidCamera();
+
+      // Act
+      expect(
+        () => camera.createCamera(
+          const CameraDescription(
+            name: 'Test',
+            lensDirection: CameraLensDirection.back,
+            sensorOrientation: 0,
+          ),
+          ResolutionPreset.high,
+        ),
+        throwsA(
+          isA<CameraException>()
+              .having(
+                  (CameraException e) => e.code, 'code', 'TESTING_ERROR_CODE')
+              .having((CameraException e) => e.description, 'description',
+                  'Mock error message used during testing.'),
+        ),
+      );
+    });
+
+    test('Should throw CameraException when create throws a PlatformException',
+        () {
+      // Arrange
+      MethodChannelMock(channelName: _channelName, methods: <String, dynamic>{
+        'create': PlatformException(
+          code: 'TESTING_ERROR_CODE',
+          message: 'Mock error message used during testing.',
+        )
+      });
+      final AndroidCamera camera = AndroidCamera();
+
+      // Act
+      expect(
+        () => camera.createCamera(
+          const CameraDescription(
+            name: 'Test',
+            lensDirection: CameraLensDirection.back,
+            sensorOrientation: 0,
+          ),
+          ResolutionPreset.high,
+        ),
+        throwsA(
+          isA<CameraException>()
+              .having(
+                  (CameraException e) => e.code, 'code', 'TESTING_ERROR_CODE')
+              .having((CameraException e) => e.description, 'description',
+                  'Mock error message used during testing.'),
+        ),
+      );
+    });
+
+    test(
+      'Should throw CameraException when initialize throws a PlatformException',
+      () {
+        // Arrange
+        MethodChannelMock(
+          channelName: _channelName,
+          methods: <String, dynamic>{
+            'initialize': PlatformException(
+              code: 'TESTING_ERROR_CODE',
+              message: 'Mock error message used during testing.',
+            )
+          },
+        );
+        final AndroidCamera camera = AndroidCamera();
+
+        // Act
+        expect(
+          () => camera.initializeCamera(0),
+          throwsA(
+            isA<CameraException>()
+                .having(
+                    (CameraException e) => e.code, 'code', 'TESTING_ERROR_CODE')
+                .having(
+                  (CameraException e) => e.description,
+                  'description',
+                  'Mock error message used during testing.',
+                ),
+          ),
+        );
+      },
+    );
+
+    test('Should send initialization data', () async {
+      // Arrange
+      final MethodChannelMock cameraMockChannel = MethodChannelMock(
+          channelName: _channelName,
+          methods: <String, dynamic>{
+            'create': <String, dynamic>{
+              'cameraId': 1,
+              'imageFormatGroup': 'unknown',
+            },
+            'initialize': null
+          });
+      final AndroidCamera camera = AndroidCamera();
+      final int cameraId = await camera.createCamera(
+        const CameraDescription(
+          name: 'Test',
+          lensDirection: CameraLensDirection.back,
+          sensorOrientation: 0,
+        ),
+        ResolutionPreset.high,
+      );
+
+      // Act
+      final Future<void> initializeFuture = camera.initializeCamera(cameraId);
+      camera.cameraEventStreamController.add(CameraInitializedEvent(
+        cameraId,
+        1920,
+        1080,
+        ExposureMode.auto,
+        true,
+        FocusMode.auto,
+        true,
+      ));
+      await initializeFuture;
+
+      // Assert
+      expect(cameraId, 1);
+      expect(cameraMockChannel.log, <Matcher>[
+        anything,
+        isMethodCall(
+          'initialize',
+          arguments: <String, Object?>{
+            'cameraId': 1,
+            'imageFormatGroup': 'unknown',
+          },
+        ),
+      ]);
+    });
+
+    test('Should send a disposal call on dispose', () async {
+      // Arrange
+      final MethodChannelMock cameraMockChannel = MethodChannelMock(
+          channelName: _channelName,
+          methods: <String, dynamic>{
+            'create': <String, dynamic>{'cameraId': 1},
+            'initialize': null,
+            'dispose': <String, dynamic>{'cameraId': 1}
+          });
+
+      final AndroidCamera camera = AndroidCamera();
+      final int cameraId = await camera.createCamera(
+        const CameraDescription(
+          name: 'Test',
+          lensDirection: CameraLensDirection.back,
+          sensorOrientation: 0,
+        ),
+        ResolutionPreset.high,
+      );
+      final Future<void> initializeFuture = camera.initializeCamera(cameraId);
+      camera.cameraEventStreamController.add(CameraInitializedEvent(
+        cameraId,
+        1920,
+        1080,
+        ExposureMode.auto,
+        true,
+        FocusMode.auto,
+        true,
+      ));
+      await initializeFuture;
+
+      // Act
+      await camera.dispose(cameraId);
+
+      // Assert
+      expect(cameraId, 1);
+      expect(cameraMockChannel.log, <Matcher>[
+        anything,
+        anything,
+        isMethodCall(
+          'dispose',
+          arguments: <String, Object?>{'cameraId': 1},
+        ),
+      ]);
+    });
+  });
+
+  group('Event Tests', () {
+    late AndroidCamera camera;
+    late int cameraId;
+    setUp(() async {
+      MethodChannelMock(
+        channelName: _channelName,
+        methods: <String, dynamic>{
+          'create': <String, dynamic>{'cameraId': 1},
+          'initialize': null
+        },
+      );
+      camera = AndroidCamera();
+      cameraId = await camera.createCamera(
+        const CameraDescription(
+          name: 'Test',
+          lensDirection: CameraLensDirection.back,
+          sensorOrientation: 0,
+        ),
+        ResolutionPreset.high,
+      );
+      final Future<void> initializeFuture = camera.initializeCamera(cameraId);
+      camera.cameraEventStreamController.add(CameraInitializedEvent(
+        cameraId,
+        1920,
+        1080,
+        ExposureMode.auto,
+        true,
+        FocusMode.auto,
+        true,
+      ));
+      await initializeFuture;
+    });
+
+    test('Should receive initialized event', () async {
+      // Act
+      final Stream<CameraInitializedEvent> eventStream =
+          camera.onCameraInitialized(cameraId);
+      final StreamQueue<CameraInitializedEvent> streamQueue =
+          StreamQueue<CameraInitializedEvent>(eventStream);
+
+      // Emit test events
+      final CameraInitializedEvent event = CameraInitializedEvent(
+        cameraId,
+        3840,
+        2160,
+        ExposureMode.auto,
+        true,
+        FocusMode.auto,
+        true,
+      );
+      await camera.handleCameraMethodCall(
+          MethodCall('initialized', event.toJson()), cameraId);
+
+      // Assert
+      expect(await streamQueue.next, event);
+
+      // Clean up
+      await streamQueue.cancel();
+    });
+
+    test('Should receive resolution changes', () async {
+      // Act
+      final Stream<CameraResolutionChangedEvent> resolutionStream =
+          camera.onCameraResolutionChanged(cameraId);
+      final StreamQueue<CameraResolutionChangedEvent> streamQueue =
+          StreamQueue<CameraResolutionChangedEvent>(resolutionStream);
+
+      // Emit test events
+      final CameraResolutionChangedEvent fhdEvent =
+          CameraResolutionChangedEvent(cameraId, 1920, 1080);
+      final CameraResolutionChangedEvent uhdEvent =
+          CameraResolutionChangedEvent(cameraId, 3840, 2160);
+      await camera.handleCameraMethodCall(
+          MethodCall('resolution_changed', fhdEvent.toJson()), cameraId);
+      await camera.handleCameraMethodCall(
+          MethodCall('resolution_changed', uhdEvent.toJson()), cameraId);
+      await camera.handleCameraMethodCall(
+          MethodCall('resolution_changed', fhdEvent.toJson()), cameraId);
+      await camera.handleCameraMethodCall(
+          MethodCall('resolution_changed', uhdEvent.toJson()), cameraId);
+
+      // Assert
+      expect(await streamQueue.next, fhdEvent);
+      expect(await streamQueue.next, uhdEvent);
+      expect(await streamQueue.next, fhdEvent);
+      expect(await streamQueue.next, uhdEvent);
+
+      // Clean up
+      await streamQueue.cancel();
+    });
+
+    test('Should receive camera closing events', () async {
+      // Act
+      final Stream<CameraClosingEvent> eventStream =
+          camera.onCameraClosing(cameraId);
+      final StreamQueue<CameraClosingEvent> streamQueue =
+          StreamQueue<CameraClosingEvent>(eventStream);
+
+      // Emit test events
+      final CameraClosingEvent event = CameraClosingEvent(cameraId);
+      await camera.handleCameraMethodCall(
+          MethodCall('camera_closing', event.toJson()), cameraId);
+      await camera.handleCameraMethodCall(
+          MethodCall('camera_closing', event.toJson()), cameraId);
+      await camera.handleCameraMethodCall(
+          MethodCall('camera_closing', event.toJson()), cameraId);
+
+      // Assert
+      expect(await streamQueue.next, event);
+      expect(await streamQueue.next, event);
+      expect(await streamQueue.next, event);
+
+      // Clean up
+      await streamQueue.cancel();
+    });
+
+    test('Should receive camera error events', () async {
+      // Act
+      final Stream<CameraErrorEvent> errorStream =
+          camera.onCameraError(cameraId);
+      final StreamQueue<CameraErrorEvent> streamQueue =
+          StreamQueue<CameraErrorEvent>(errorStream);
+
+      // Emit test events
+      final CameraErrorEvent event =
+          CameraErrorEvent(cameraId, 'Error Description');
+      await camera.handleCameraMethodCall(
+          MethodCall('error', event.toJson()), cameraId);
+      await camera.handleCameraMethodCall(
+          MethodCall('error', event.toJson()), cameraId);
+      await camera.handleCameraMethodCall(
+          MethodCall('error', event.toJson()), cameraId);
+
+      // Assert
+      expect(await streamQueue.next, event);
+      expect(await streamQueue.next, event);
+      expect(await streamQueue.next, event);
+
+      // Clean up
+      await streamQueue.cancel();
+    });
+
+    test('Should receive device orientation change events', () async {
+      // Act
+      final Stream<DeviceOrientationChangedEvent> eventStream =
+          camera.onDeviceOrientationChanged();
+      final StreamQueue<DeviceOrientationChangedEvent> streamQueue =
+          StreamQueue<DeviceOrientationChangedEvent>(eventStream);
+
+      // Emit test events
+      const DeviceOrientationChangedEvent event =
+          DeviceOrientationChangedEvent(DeviceOrientation.portraitUp);
+      await camera.handleDeviceMethodCall(
+          MethodCall('orientation_changed', event.toJson()));
+      await camera.handleDeviceMethodCall(
+          MethodCall('orientation_changed', event.toJson()));
+      await camera.handleDeviceMethodCall(
+          MethodCall('orientation_changed', event.toJson()));
+
+      // Assert
+      expect(await streamQueue.next, event);
+      expect(await streamQueue.next, event);
+      expect(await streamQueue.next, event);
+
+      // Clean up
+      await streamQueue.cancel();
+    });
+  });
+
+  group('Function Tests', () {
+    late AndroidCamera camera;
+    late int cameraId;
+
+    setUp(() async {
+      MethodChannelMock(
+        channelName: _channelName,
+        methods: <String, dynamic>{
+          'create': <String, dynamic>{'cameraId': 1},
+          'initialize': null
+        },
+      );
+      camera = AndroidCamera();
+      cameraId = await camera.createCamera(
+        const CameraDescription(
+          name: 'Test',
+          lensDirection: CameraLensDirection.back,
+          sensorOrientation: 0,
+        ),
+        ResolutionPreset.high,
+      );
+      final Future<void> initializeFuture = camera.initializeCamera(cameraId);
+      camera.cameraEventStreamController.add(
+        CameraInitializedEvent(
+          cameraId,
+          1920,
+          1080,
+          ExposureMode.auto,
+          true,
+          FocusMode.auto,
+          true,
+        ),
+      );
+      await initializeFuture;
+    });
+
+    test('Should fetch CameraDescription instances for available cameras',
+        () async {
+      // Arrange
+      final List<dynamic> returnData = <dynamic>[
+        <String, dynamic>{
+          'name': 'Test 1',
+          'lensFacing': 'front',
+          'sensorOrientation': 1
+        },
+        <String, dynamic>{
+          'name': 'Test 2',
+          'lensFacing': 'back',
+          'sensorOrientation': 2
+        }
+      ];
+      final MethodChannelMock channel = MethodChannelMock(
+        channelName: _channelName,
+        methods: <String, dynamic>{'availableCameras': returnData},
+      );
+
+      // Act
+      final List<CameraDescription> cameras = await camera.availableCameras();
+
+      // Assert
+      expect(channel.log, <Matcher>[
+        isMethodCall('availableCameras', arguments: null),
+      ]);
+      expect(cameras.length, returnData.length);
+      for (int i = 0; i < returnData.length; i++) {
+        final CameraDescription cameraDescription = CameraDescription(
+          name: returnData[i]['name']! as String,
+          lensDirection:
+              parseCameraLensDirection(returnData[i]['lensFacing']! as String),
+          sensorOrientation: returnData[i]['sensorOrientation']! as int,
+        );
+        expect(cameras[i], cameraDescription);
+      }
+    });
+
+    test(
+        'Should throw CameraException when availableCameras throws a PlatformException',
+        () {
+      // Arrange
+      MethodChannelMock(channelName: _channelName, methods: <String, dynamic>{
+        'availableCameras': PlatformException(
+          code: 'TESTING_ERROR_CODE',
+          message: 'Mock error message used during testing.',
+        )
+      });
+
+      // Act
+      expect(
+        camera.availableCameras,
+        throwsA(
+          isA<CameraException>()
+              .having(
+                  (CameraException e) => e.code, 'code', 'TESTING_ERROR_CODE')
+              .having((CameraException e) => e.description, 'description',
+                  'Mock error message used during testing.'),
+        ),
+      );
+    });
+
+    test('Should take a picture and return an XFile instance', () async {
+      // Arrange
+      final MethodChannelMock channel = MethodChannelMock(
+          channelName: _channelName,
+          methods: <String, dynamic>{'takePicture': '/test/path.jpg'});
+
+      // Act
+      final XFile file = await camera.takePicture(cameraId);
+
+      // Assert
+      expect(channel.log, <Matcher>[
+        isMethodCall('takePicture', arguments: <String, Object?>{
+          'cameraId': cameraId,
+        }),
+      ]);
+      expect(file.path, '/test/path.jpg');
+    });
+
+    test('Should prepare for video recording', () async {
+      // Arrange
+      final MethodChannelMock channel = MethodChannelMock(
+        channelName: _channelName,
+        methods: <String, dynamic>{'prepareForVideoRecording': null},
+      );
+
+      // Act
+      await camera.prepareForVideoRecording();
+
+      // Assert
+      expect(channel.log, <Matcher>[
+        isMethodCall('prepareForVideoRecording', arguments: null),
+      ]);
+    });
+
+    test('Should start recording a video', () async {
+      // Arrange
+      final MethodChannelMock channel = MethodChannelMock(
+        channelName: _channelName,
+        methods: <String, dynamic>{'startVideoRecording': null},
+      );
+
+      // Act
+      await camera.startVideoRecording(cameraId);
+
+      // Assert
+      expect(channel.log, <Matcher>[
+        isMethodCall('startVideoRecording', arguments: <String, Object?>{
+          'cameraId': cameraId,
+          'maxVideoDuration': null,
+        }),
+      ]);
+    });
+
+    test('Should pass maxVideoDuration when starting recording a video',
+        () async {
+      // Arrange
+      final MethodChannelMock channel = MethodChannelMock(
+        channelName: _channelName,
+        methods: <String, dynamic>{'startVideoRecording': null},
+      );
+
+      // Act
+      await camera.startVideoRecording(
+        cameraId,
+        maxVideoDuration: const Duration(seconds: 10),
+      );
+
+      // Assert
+      expect(channel.log, <Matcher>[
+        isMethodCall('startVideoRecording', arguments: <String, Object?>{
+          'cameraId': cameraId,
+          'maxVideoDuration': 10000
+        }),
+      ]);
+    });
+
+    test('Should stop a video recording and return the file', () async {
+      // Arrange
+      final MethodChannelMock channel = MethodChannelMock(
+        channelName: _channelName,
+        methods: <String, dynamic>{'stopVideoRecording': '/test/path.mp4'},
+      );
+
+      // Act
+      final XFile file = await camera.stopVideoRecording(cameraId);
+
+      // Assert
+      expect(channel.log, <Matcher>[
+        isMethodCall('stopVideoRecording', arguments: <String, Object?>{
+          'cameraId': cameraId,
+        }),
+      ]);
+      expect(file.path, '/test/path.mp4');
+    });
+
+    test('Should pause a video recording', () async {
+      // Arrange
+      final MethodChannelMock channel = MethodChannelMock(
+        channelName: _channelName,
+        methods: <String, dynamic>{'pauseVideoRecording': null},
+      );
+
+      // Act
+      await camera.pauseVideoRecording(cameraId);
+
+      // Assert
+      expect(channel.log, <Matcher>[
+        isMethodCall('pauseVideoRecording', arguments: <String, Object?>{
+          'cameraId': cameraId,
+        }),
+      ]);
+    });
+
+    test('Should resume a video recording', () async {
+      // Arrange
+      final MethodChannelMock channel = MethodChannelMock(
+        channelName: _channelName,
+        methods: <String, dynamic>{'resumeVideoRecording': null},
+      );
+
+      // Act
+      await camera.resumeVideoRecording(cameraId);
+
+      // Assert
+      expect(channel.log, <Matcher>[
+        isMethodCall('resumeVideoRecording', arguments: <String, Object?>{
+          'cameraId': cameraId,
+        }),
+      ]);
+    });
+
+    test('Should set the flash mode', () async {
+      // Arrange
+      final MethodChannelMock channel = MethodChannelMock(
+        channelName: _channelName,
+        methods: <String, dynamic>{'setFlashMode': null},
+      );
+
+      // Act
+      await camera.setFlashMode(cameraId, FlashMode.torch);
+      await camera.setFlashMode(cameraId, FlashMode.always);
+      await camera.setFlashMode(cameraId, FlashMode.auto);
+      await camera.setFlashMode(cameraId, FlashMode.off);
+
+      // Assert
+      expect(channel.log, <Matcher>[
+        isMethodCall('setFlashMode', arguments: <String, Object?>{
+          'cameraId': cameraId,
+          'mode': 'torch'
+        }),
+        isMethodCall('setFlashMode', arguments: <String, Object?>{
+          'cameraId': cameraId,
+          'mode': 'always'
+        }),
+        isMethodCall('setFlashMode',
+            arguments: <String, Object?>{'cameraId': cameraId, 'mode': 'auto'}),
+        isMethodCall('setFlashMode',
+            arguments: <String, Object?>{'cameraId': cameraId, 'mode': 'off'}),
+      ]);
+    });
+
+    test('Should set the exposure mode', () async {
+      // Arrange
+      final MethodChannelMock channel = MethodChannelMock(
+        channelName: _channelName,
+        methods: <String, dynamic>{'setExposureMode': null},
+      );
+
+      // Act
+      await camera.setExposureMode(cameraId, ExposureMode.auto);
+      await camera.setExposureMode(cameraId, ExposureMode.locked);
+
+      // Assert
+      expect(channel.log, <Matcher>[
+        isMethodCall('setExposureMode',
+            arguments: <String, Object?>{'cameraId': cameraId, 'mode': 'auto'}),
+        isMethodCall('setExposureMode', arguments: <String, Object?>{
+          'cameraId': cameraId,
+          'mode': 'locked'
+        }),
+      ]);
+    });
+
+    test('Should set the exposure point', () async {
+      // Arrange
+      final MethodChannelMock channel = MethodChannelMock(
+        channelName: _channelName,
+        methods: <String, dynamic>{'setExposurePoint': null},
+      );
+
+      // Act
+      await camera.setExposurePoint(cameraId, const Point<double>(0.5, 0.5));
+      await camera.setExposurePoint(cameraId, null);
+
+      // Assert
+      expect(channel.log, <Matcher>[
+        isMethodCall('setExposurePoint', arguments: <String, Object?>{
+          'cameraId': cameraId,
+          'x': 0.5,
+          'y': 0.5,
+          'reset': false
+        }),
+        isMethodCall('setExposurePoint', arguments: <String, Object?>{
+          'cameraId': cameraId,
+          'x': null,
+          'y': null,
+          'reset': true
+        }),
+      ]);
+    });
+
+    test('Should get the min exposure offset', () async {
+      // Arrange
+      final MethodChannelMock channel = MethodChannelMock(
+        channelName: _channelName,
+        methods: <String, dynamic>{'getMinExposureOffset': 2.0},
+      );
+
+      // Act
+      final double minExposureOffset =
+          await camera.getMinExposureOffset(cameraId);
+
+      // Assert
+      expect(minExposureOffset, 2.0);
+      expect(channel.log, <Matcher>[
+        isMethodCall('getMinExposureOffset', arguments: <String, Object?>{
+          'cameraId': cameraId,
+        }),
+      ]);
+    });
+
+    test('Should get the max exposure offset', () async {
+      // Arrange
+      final MethodChannelMock channel = MethodChannelMock(
+        channelName: _channelName,
+        methods: <String, dynamic>{'getMaxExposureOffset': 2.0},
+      );
+
+      // Act
+      final double maxExposureOffset =
+          await camera.getMaxExposureOffset(cameraId);
+
+      // Assert
+      expect(maxExposureOffset, 2.0);
+      expect(channel.log, <Matcher>[
+        isMethodCall('getMaxExposureOffset', arguments: <String, Object?>{
+          'cameraId': cameraId,
+        }),
+      ]);
+    });
+
+    test('Should get the exposure offset step size', () async {
+      // Arrange
+      final MethodChannelMock channel = MethodChannelMock(
+        channelName: _channelName,
+        methods: <String, dynamic>{'getExposureOffsetStepSize': 0.25},
+      );
+
+      // Act
+      final double stepSize = await camera.getExposureOffsetStepSize(cameraId);
+
+      // Assert
+      expect(stepSize, 0.25);
+      expect(channel.log, <Matcher>[
+        isMethodCall('getExposureOffsetStepSize', arguments: <String, Object?>{
+          'cameraId': cameraId,
+        }),
+      ]);
+    });
+
+    test('Should set the exposure offset', () async {
+      // Arrange
+      final MethodChannelMock channel = MethodChannelMock(
+        channelName: _channelName,
+        methods: <String, dynamic>{'setExposureOffset': 0.6},
+      );
+
+      // Act
+      final double actualOffset = await camera.setExposureOffset(cameraId, 0.5);
+
+      // Assert
+      expect(actualOffset, 0.6);
+      expect(channel.log, <Matcher>[
+        isMethodCall('setExposureOffset', arguments: <String, Object?>{
+          'cameraId': cameraId,
+          'offset': 0.5,
+        }),
+      ]);
+    });
+
+    test('Should set the focus mode', () async {
+      // Arrange
+      final MethodChannelMock channel = MethodChannelMock(
+        channelName: _channelName,
+        methods: <String, dynamic>{'setFocusMode': null},
+      );
+
+      // Act
+      await camera.setFocusMode(cameraId, FocusMode.auto);
+      await camera.setFocusMode(cameraId, FocusMode.locked);
+
+      // Assert
+      expect(channel.log, <Matcher>[
+        isMethodCall('setFocusMode',
+            arguments: <String, Object?>{'cameraId': cameraId, 'mode': 'auto'}),
+        isMethodCall('setFocusMode', arguments: <String, Object?>{
+          'cameraId': cameraId,
+          'mode': 'locked'
+        }),
+      ]);
+    });
+
+    test('Should set the exposure point', () async {
+      // Arrange
+      final MethodChannelMock channel = MethodChannelMock(
+        channelName: _channelName,
+        methods: <String, dynamic>{'setFocusPoint': null},
+      );
+
+      // Act
+      await camera.setFocusPoint(cameraId, const Point<double>(0.5, 0.5));
+      await camera.setFocusPoint(cameraId, null);
+
+      // Assert
+      expect(channel.log, <Matcher>[
+        isMethodCall('setFocusPoint', arguments: <String, Object?>{
+          'cameraId': cameraId,
+          'x': 0.5,
+          'y': 0.5,
+          'reset': false
+        }),
+        isMethodCall('setFocusPoint', arguments: <String, Object?>{
+          'cameraId': cameraId,
+          'x': null,
+          'y': null,
+          'reset': true
+        }),
+      ]);
+    });
+
+    test('Should build a texture widget as preview widget', () async {
+      // Act
+      final Widget widget = camera.buildPreview(cameraId);
+
+      // Act
+      expect(widget is Texture, isTrue);
+      expect((widget as Texture).textureId, cameraId);
+    });
+
+    test('Should throw MissingPluginException when handling unknown method',
+        () {
+      final AndroidCamera camera = AndroidCamera();
+
+      expect(
+          () => camera.handleCameraMethodCall(
+              const MethodCall('unknown_method'), 1),
+          throwsA(isA<MissingPluginException>()));
+    });
+
+    test('Should get the max zoom level', () async {
+      // Arrange
+      final MethodChannelMock channel = MethodChannelMock(
+        channelName: _channelName,
+        methods: <String, dynamic>{'getMaxZoomLevel': 10.0},
+      );
+
+      // Act
+      final double maxZoomLevel = await camera.getMaxZoomLevel(cameraId);
+
+      // Assert
+      expect(maxZoomLevel, 10.0);
+      expect(channel.log, <Matcher>[
+        isMethodCall('getMaxZoomLevel', arguments: <String, Object?>{
+          'cameraId': cameraId,
+        }),
+      ]);
+    });
+
+    test('Should get the min zoom level', () async {
+      // Arrange
+      final MethodChannelMock channel = MethodChannelMock(
+        channelName: _channelName,
+        methods: <String, dynamic>{'getMinZoomLevel': 1.0},
+      );
+
+      // Act
+      final double maxZoomLevel = await camera.getMinZoomLevel(cameraId);
+
+      // Assert
+      expect(maxZoomLevel, 1.0);
+      expect(channel.log, <Matcher>[
+        isMethodCall('getMinZoomLevel', arguments: <String, Object?>{
+          'cameraId': cameraId,
+        }),
+      ]);
+    });
+
+    test('Should set the zoom level', () async {
+      // Arrange
+      final MethodChannelMock channel = MethodChannelMock(
+        channelName: _channelName,
+        methods: <String, dynamic>{'setZoomLevel': null},
+      );
+
+      // Act
+      await camera.setZoomLevel(cameraId, 2.0);
+
+      // Assert
+      expect(channel.log, <Matcher>[
+        isMethodCall('setZoomLevel',
+            arguments: <String, Object?>{'cameraId': cameraId, 'zoom': 2.0}),
+      ]);
+    });
+
+    test('Should throw CameraException when illegal zoom level is supplied',
+        () async {
+      // Arrange
+      MethodChannelMock(
+        channelName: _channelName,
+        methods: <String, dynamic>{
+          'setZoomLevel': PlatformException(
+            code: 'ZOOM_ERROR',
+            message: 'Illegal zoom error',
+            details: null,
+          )
+        },
+      );
+
+      // Act & assert
+      expect(
+          () => camera.setZoomLevel(cameraId, -1.0),
+          throwsA(isA<CameraException>()
+              .having((CameraException e) => e.code, 'code', 'ZOOM_ERROR')
+              .having((CameraException e) => e.description, 'description',
+                  'Illegal zoom error')));
+    });
+
+    test('Should lock the capture orientation', () async {
+      // Arrange
+      final MethodChannelMock channel = MethodChannelMock(
+        channelName: _channelName,
+        methods: <String, dynamic>{'lockCaptureOrientation': null},
+      );
+
+      // Act
+      await camera.lockCaptureOrientation(
+          cameraId, DeviceOrientation.portraitUp);
+
+      // Assert
+      expect(channel.log, <Matcher>[
+        isMethodCall('lockCaptureOrientation', arguments: <String, Object?>{
+          'cameraId': cameraId,
+          'orientation': 'portraitUp'
+        }),
+      ]);
+    });
+
+    test('Should unlock the capture orientation', () async {
+      // Arrange
+      final MethodChannelMock channel = MethodChannelMock(
+        channelName: _channelName,
+        methods: <String, dynamic>{'unlockCaptureOrientation': null},
+      );
+
+      // Act
+      await camera.unlockCaptureOrientation(cameraId);
+
+      // Assert
+      expect(channel.log, <Matcher>[
+        isMethodCall('unlockCaptureOrientation',
+            arguments: <String, Object?>{'cameraId': cameraId}),
+      ]);
+    });
+
+    test('Should pause the camera preview', () async {
+      // Arrange
+      final MethodChannelMock channel = MethodChannelMock(
+        channelName: _channelName,
+        methods: <String, dynamic>{'pausePreview': null},
+      );
+
+      // Act
+      await camera.pausePreview(cameraId);
+
+      // Assert
+      expect(channel.log, <Matcher>[
+        isMethodCall('pausePreview',
+            arguments: <String, Object?>{'cameraId': cameraId}),
+      ]);
+    });
+
+    test('Should resume the camera preview', () async {
+      // Arrange
+      final MethodChannelMock channel = MethodChannelMock(
+        channelName: _channelName,
+        methods: <String, dynamic>{'resumePreview': null},
+      );
+
+      // Act
+      await camera.resumePreview(cameraId);
+
+      // Assert
+      expect(channel.log, <Matcher>[
+        isMethodCall('resumePreview',
+            arguments: <String, Object?>{'cameraId': cameraId}),
+      ]);
+    });
+
+    test('Should start streaming', () async {
+      // Arrange
+      final MethodChannelMock channel = MethodChannelMock(
+        channelName: _channelName,
+        methods: <String, dynamic>{
+          'startImageStream': null,
+          'stopImageStream': null,
+        },
+      );
+
+      // Act
+      final StreamSubscription<CameraImageData> subscription = camera
+          .onStreamedFrameAvailable(cameraId)
+          .listen((CameraImageData imageData) {});
+
+      // Assert
+      expect(channel.log, <Matcher>[
+        isMethodCall('startImageStream', arguments: null),
+      ]);
+
+      subscription.cancel();
+    });
+
+    test('Should stop streaming', () async {
+      // Arrange
+      final MethodChannelMock channel = MethodChannelMock(
+        channelName: _channelName,
+        methods: <String, dynamic>{
+          'startImageStream': null,
+          'stopImageStream': null,
+        },
+      );
+
+      // Act
+      final StreamSubscription<CameraImageData> subscription = camera
+          .onStreamedFrameAvailable(cameraId)
+          .listen((CameraImageData imageData) {});
+      subscription.cancel();
+
+      // Assert
+      expect(channel.log, <Matcher>[
+        isMethodCall('startImageStream', arguments: null),
+        isMethodCall('stopImageStream', arguments: null),
+      ]);
+    });
+  });
+}
diff --git a/packages/camera/camera_android/test/method_channel_mock.dart b/packages/camera/camera_android/test/method_channel_mock.dart
new file mode 100644
index 0000000..413c106
--- /dev/null
+++ b/packages/camera/camera_android/test/method_channel_mock.dart
@@ -0,0 +1,39 @@
+// Copyright 2013 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import 'package:flutter/services.dart';
+import 'package:flutter_test/flutter_test.dart';
+
+class MethodChannelMock {
+  MethodChannelMock({
+    required String channelName,
+    this.delay,
+    required this.methods,
+  }) : methodChannel = MethodChannel(channelName) {
+    methodChannel.setMockMethodCallHandler(_handler);
+  }
+
+  final Duration? delay;
+  final MethodChannel methodChannel;
+  final Map<String, dynamic> methods;
+  final List<MethodCall> log = <MethodCall>[];
+
+  Future<dynamic> _handler(MethodCall methodCall) async {
+    log.add(methodCall);
+
+    if (!methods.containsKey(methodCall.method)) {
+      throw MissingPluginException('No implementation found for method '
+          '${methodCall.method} on channel ${methodChannel.name}');
+    }
+
+    return Future<dynamic>.delayed(delay ?? Duration.zero, () {
+      final dynamic result = methods[methodCall.method];
+      if (result is Exception) {
+        throw result;
+      }
+
+      return Future<dynamic>.value(result);
+    });
+  }
+}
diff --git a/packages/camera/camera_android/test/type_conversion_test.dart b/packages/camera/camera_android/test/type_conversion_test.dart
new file mode 100644
index 0000000..b07466d
--- /dev/null
+++ b/packages/camera/camera_android/test/type_conversion_test.dart
@@ -0,0 +1,60 @@
+// Copyright 2013 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// TODO(a14n): remove this import once Flutter 3.1 or later reaches stable (including flutter/flutter#104231)
+// ignore: unnecessary_import
+import 'dart:typed_data';
+
+import 'package:camera_android/src/type_conversion.dart';
+import 'package:camera_platform_interface/camera_platform_interface.dart';
+import 'package:flutter_test/flutter_test.dart';
+
+void main() {
+  test('CameraImageData can be created', () {
+    final CameraImageData cameraImage =
+        cameraImageFromPlatformData(<dynamic, dynamic>{
+      'format': 1,
+      'height': 1,
+      'width': 4,
+      'lensAperture': 1.8,
+      'sensorExposureTime': 9991324,
+      'sensorSensitivity': 92.0,
+      'planes': <dynamic>[
+        <dynamic, dynamic>{
+          'bytes': Uint8List.fromList(<int>[1, 2, 3, 4]),
+          'bytesPerPixel': 1,
+          'bytesPerRow': 4,
+          'height': 1,
+          'width': 4
+        }
+      ]
+    });
+    expect(cameraImage.height, 1);
+    expect(cameraImage.width, 4);
+    expect(cameraImage.format.group, ImageFormatGroup.unknown);
+    expect(cameraImage.planes.length, 1);
+  });
+
+  test('CameraImageData has ImageFormatGroup.yuv420', () {
+    final CameraImageData cameraImage =
+        cameraImageFromPlatformData(<dynamic, dynamic>{
+      'format': 35,
+      'height': 1,
+      'width': 4,
+      'lensAperture': 1.8,
+      'sensorExposureTime': 9991324,
+      'sensorSensitivity': 92.0,
+      'planes': <dynamic>[
+        <dynamic, dynamic>{
+          'bytes': Uint8List.fromList(<int>[1, 2, 3, 4]),
+          'bytesPerPixel': 1,
+          'bytesPerRow': 4,
+          'height': 1,
+          'width': 4
+        }
+      ]
+    });
+    expect(cameraImage.format.group, ImageFormatGroup.yuv420);
+  });
+}
diff --git a/packages/camera/camera_android/test/utils_test.dart b/packages/camera/camera_android/test/utils_test.dart
new file mode 100644
index 0000000..6f426bc
--- /dev/null
+++ b/packages/camera/camera_android/test/utils_test.dart
@@ -0,0 +1,60 @@
+// Copyright 2013 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import 'package:camera_android/src/utils.dart';
+import 'package:camera_platform_interface/camera_platform_interface.dart';
+import 'package:flutter/services.dart';
+import 'package:flutter_test/flutter_test.dart';
+
+void main() {
+  group('Utility methods', () {
+    test(
+        'Should return CameraLensDirection when valid value is supplied when parsing camera lens direction',
+        () {
+      expect(
+        parseCameraLensDirection('back'),
+        CameraLensDirection.back,
+      );
+      expect(
+        parseCameraLensDirection('front'),
+        CameraLensDirection.front,
+      );
+      expect(
+        parseCameraLensDirection('external'),
+        CameraLensDirection.external,
+      );
+    });
+
+    test(
+        'Should throw ArgumentException when invalid value is supplied when parsing camera lens direction',
+        () {
+      expect(
+        () => parseCameraLensDirection('test'),
+        throwsA(isArgumentError),
+      );
+    });
+
+    test('serializeDeviceOrientation() should serialize correctly', () {
+      expect(serializeDeviceOrientation(DeviceOrientation.portraitUp),
+          'portraitUp');
+      expect(serializeDeviceOrientation(DeviceOrientation.portraitDown),
+          'portraitDown');
+      expect(serializeDeviceOrientation(DeviceOrientation.landscapeRight),
+          'landscapeRight');
+      expect(serializeDeviceOrientation(DeviceOrientation.landscapeLeft),
+          'landscapeLeft');
+    });
+
+    test('deserializeDeviceOrientation() should deserialize correctly', () {
+      expect(deserializeDeviceOrientation('portraitUp'),
+          DeviceOrientation.portraitUp);
+      expect(deserializeDeviceOrientation('portraitDown'),
+          DeviceOrientation.portraitDown);
+      expect(deserializeDeviceOrientation('landscapeRight'),
+          DeviceOrientation.landscapeRight);
+      expect(deserializeDeviceOrientation('landscapeLeft'),
+          DeviceOrientation.landscapeLeft);
+    });
+  });
+}
diff --git a/packages/camera/camera_avfoundation/CHANGELOG.md b/packages/camera/camera_avfoundation/CHANGELOG.md
index c57f301..5bc7c8a 100644
--- a/packages/camera/camera_avfoundation/CHANGELOG.md
+++ b/packages/camera/camera_avfoundation/CHANGELOG.md
@@ -1,3 +1,7 @@
+## 0.9.8
+
+* Switches to internal method channel implementation.
+
 ## 0.9.7+1
 
 * Splits from `camera` as a federated implementation.
diff --git a/packages/camera/camera_avfoundation/example/integration_test/camera_test.dart b/packages/camera/camera_avfoundation/example/integration_test/camera_test.dart
index 6ac7a68..51eab63 100644
--- a/packages/camera/camera_avfoundation/example/integration_test/camera_test.dart
+++ b/packages/camera/camera_avfoundation/example/integration_test/camera_test.dart
@@ -6,6 +6,7 @@
 import 'dart:io';
 import 'dart:ui';
 
+import 'package:camera_avfoundation/camera_avfoundation.dart';
 import 'package:camera_example/camera_controller.dart';
 import 'package:camera_platform_interface/camera_platform_interface.dart';
 import 'package:flutter/painting.dart';
@@ -20,6 +21,7 @@
   IntegrationTestWidgetsFlutterBinding.ensureInitialized();
 
   setUpAll(() async {
+    CameraPlatform.instance = AVFoundationCamera();
     final Directory extDir = await getTemporaryDirectory();
     testDir = await Directory('${extDir.path}/test').create(recursive: true);
   });
diff --git a/packages/camera/camera_avfoundation/example/test_driver/integration_test.dart b/packages/camera/camera_avfoundation/example/test_driver/integration_test.dart
index 4ec97e6..4f10f2a 100644
--- a/packages/camera/camera_avfoundation/example/test_driver/integration_test.dart
+++ b/packages/camera/camera_avfoundation/example/test_driver/integration_test.dart
@@ -2,63 +2,6 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
-import 'dart:async';
-import 'dart:convert';
-import 'dart:io';
+import 'package:integration_test/integration_test_driver.dart';
 
-import 'package:flutter_driver/flutter_driver.dart';
-
-const String _examplePackage = 'io.flutter.plugins.cameraexample';
-
-Future<void> main() async {
-  if (!(Platform.isLinux || Platform.isMacOS)) {
-    print('This test must be run on a POSIX host. Skipping...');
-    exit(0);
-  }
-  final bool adbExists =
-      Process.runSync('which', <String>['adb']).exitCode == 0;
-  if (!adbExists) {
-    print(r'This test needs ADB to exist on the $PATH. Skipping...');
-    exit(0);
-  }
-  print('Granting camera permissions...');
-  Process.runSync('adb', <String>[
-    'shell',
-    'pm',
-    'grant',
-    _examplePackage,
-    'android.permission.CAMERA'
-  ]);
-  Process.runSync('adb', <String>[
-    'shell',
-    'pm',
-    'grant',
-    _examplePackage,
-    'android.permission.RECORD_AUDIO'
-  ]);
-  print('Starting test.');
-  final FlutterDriver driver = await FlutterDriver.connect();
-  final String data = await driver.requestData(
-    null,
-    timeout: const Duration(minutes: 1),
-  );
-  await driver.close();
-  print('Test finished. Revoking camera permissions...');
-  Process.runSync('adb', <String>[
-    'shell',
-    'pm',
-    'revoke',
-    _examplePackage,
-    'android.permission.CAMERA'
-  ]);
-  Process.runSync('adb', <String>[
-    'shell',
-    'pm',
-    'revoke',
-    _examplePackage,
-    'android.permission.RECORD_AUDIO'
-  ]);
-
-  final Map<String, dynamic> result = jsonDecode(data) as Map<String, dynamic>;
-  exit(result['result'] == 'true' ? 0 : 1);
-}
+Future<void> main() => integrationDriver();
diff --git a/packages/camera/camera_avfoundation/ios/Classes/CameraPlugin.m b/packages/camera/camera_avfoundation/ios/Classes/CameraPlugin.m
index 90327e3..cb19c09 100644
--- a/packages/camera/camera_avfoundation/ios/Classes/CameraPlugin.m
+++ b/packages/camera/camera_avfoundation/ios/Classes/CameraPlugin.m
@@ -26,7 +26,7 @@
 
 + (void)registerWithRegistrar:(NSObject<FlutterPluginRegistrar> *)registrar {
   FlutterMethodChannel *channel =
-      [FlutterMethodChannel methodChannelWithName:@"plugins.flutter.io/camera"
+      [FlutterMethodChannel methodChannelWithName:@"plugins.flutter.io/camera_avfoundation"
                                   binaryMessenger:[registrar messenger]];
   CameraPlugin *instance = [[CameraPlugin alloc] initWithRegistry:[registrar textures]
                                                         messenger:[registrar messenger]];
@@ -49,9 +49,9 @@
 }
 
 - (void)initDeviceEventMethodChannel {
-  FlutterMethodChannel *methodChannel =
-      [FlutterMethodChannel methodChannelWithName:@"flutter.io/cameraPlugin/device"
-                                  binaryMessenger:_messenger];
+  FlutterMethodChannel *methodChannel = [FlutterMethodChannel
+      methodChannelWithName:@"plugins.flutter.io/camera_avfoundation/fromPlatform"
+            binaryMessenger:_messenger];
   _deviceEventMethodChannel =
       [[FLTThreadSafeMethodChannel alloc] initWithMethodChannel:methodChannel];
 }
@@ -162,8 +162,9 @@
         }
       };
       FlutterMethodChannel *methodChannel = [FlutterMethodChannel
-          methodChannelWithName:[NSString stringWithFormat:@"flutter.io/cameraPlugin/camera%lu",
-                                                           (unsigned long)cameraId]
+          methodChannelWithName:
+              [NSString stringWithFormat:@"plugins.flutter.io/camera_avfoundation/camera%lu",
+                                         (unsigned long)cameraId]
                 binaryMessenger:_messenger];
       FLTThreadSafeMethodChannel *threadSafeMethodChannel =
           [[FLTThreadSafeMethodChannel alloc] initWithMethodChannel:methodChannel];
diff --git a/packages/camera/camera_avfoundation/ios/Classes/FLTCam.m b/packages/camera/camera_avfoundation/ios/Classes/FLTCam.m
index 7af505b..f267604 100644
--- a/packages/camera/camera_avfoundation/ios/Classes/FLTCam.m
+++ b/packages/camera/camera_avfoundation/ios/Classes/FLTCam.m
@@ -910,9 +910,9 @@
 - (void)startImageStreamWithMessenger:(NSObject<FlutterBinaryMessenger> *)messenger
                    imageStreamHandler:(FLTImageStreamHandler *)imageStreamHandler {
   if (!_isStreamingImages) {
-    FlutterEventChannel *eventChannel =
-        [FlutterEventChannel eventChannelWithName:@"plugins.flutter.io/camera/imageStream"
-                                  binaryMessenger:messenger];
+    FlutterEventChannel *eventChannel = [FlutterEventChannel
+        eventChannelWithName:@"plugins.flutter.io/camera_avfoundation/imageStream"
+             binaryMessenger:messenger];
     FLTThreadSafeEventChannel *threadSafeEventChannel =
         [[FLTThreadSafeEventChannel alloc] initWithEventChannel:eventChannel];
 
diff --git a/packages/camera/camera_avfoundation/lib/camera_avfoundation.dart b/packages/camera/camera_avfoundation/lib/camera_avfoundation.dart
new file mode 100644
index 0000000..e07a440
--- /dev/null
+++ b/packages/camera/camera_avfoundation/lib/camera_avfoundation.dart
@@ -0,0 +1,5 @@
+// Copyright 2013 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+export 'src/avfoundation_camera.dart';
diff --git a/packages/camera/camera_avfoundation/lib/src/avfoundation_camera.dart b/packages/camera/camera_avfoundation/lib/src/avfoundation_camera.dart
new file mode 100644
index 0000000..1bff901
--- /dev/null
+++ b/packages/camera/camera_avfoundation/lib/src/avfoundation_camera.dart
@@ -0,0 +1,592 @@
+// Copyright 2013 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import 'dart:async';
+import 'dart:math';
+
+import 'package:camera_platform_interface/camera_platform_interface.dart';
+import 'package:flutter/foundation.dart';
+import 'package:flutter/services.dart';
+import 'package:flutter/widgets.dart';
+import 'package:stream_transform/stream_transform.dart';
+
+import 'type_conversion.dart';
+import 'utils.dart';
+
+const MethodChannel _channel =
+    MethodChannel('plugins.flutter.io/camera_avfoundation');
+
+/// An iOS implementation of [CameraPlatform] based on AVFoundation.
+class AVFoundationCamera extends CameraPlatform {
+  /// Construct a new method channel camera instance.
+  AVFoundationCamera() {
+    const MethodChannel channel =
+        MethodChannel('plugins.flutter.io/camera_avfoundation/fromPlatform');
+    channel.setMethodCallHandler(
+        (MethodCall call) => handleDeviceMethodCall(call));
+  }
+
+  /// Registers this class as the default instance of [CameraPlatform].
+  static void registerWith() {
+    CameraPlatform.instance = AVFoundationCamera();
+  }
+
+  final Map<int, MethodChannel> _channels = <int, MethodChannel>{};
+
+  /// The controller we need to broadcast the different events coming
+  /// from handleMethodCall, specific to camera events.
+  ///
+  /// It is a `broadcast` because multiple controllers will connect to
+  /// different stream views of this Controller.
+  /// This is only exposed for test purposes. It shouldn't be used by clients of
+  /// the plugin as it may break or change at any time.
+  @visibleForTesting
+  final StreamController<CameraEvent> cameraEventStreamController =
+      StreamController<CameraEvent>.broadcast();
+
+  /// The controller we need to broadcast the different events coming
+  /// from handleMethodCall, specific to general device events.
+  ///
+  /// It is a `broadcast` because multiple controllers will connect to
+  /// different stream views of this Controller.
+  /// This is only exposed for test purposes. It shouldn't be used by clients of
+  /// the plugin as it may break or change at any time.
+  @visibleForTesting
+  final StreamController<DeviceEvent> deviceEventStreamController =
+      StreamController<DeviceEvent>.broadcast();
+
+  // The stream to receive frames from the native code.
+  StreamSubscription<dynamic>? _platformImageStreamSubscription;
+
+  // The stream for vending frames to platform interface clients.
+  StreamController<CameraImageData>? _frameStreamController;
+
+  Stream<CameraEvent> _cameraEvents(int cameraId) =>
+      cameraEventStreamController.stream
+          .where((CameraEvent event) => event.cameraId == cameraId);
+
+  @override
+  Future<List<CameraDescription>> availableCameras() async {
+    try {
+      final List<Map<dynamic, dynamic>>? cameras = await _channel
+          .invokeListMethod<Map<dynamic, dynamic>>('availableCameras');
+
+      if (cameras == null) {
+        return <CameraDescription>[];
+      }
+
+      return cameras.map((Map<dynamic, dynamic> camera) {
+        return CameraDescription(
+          name: camera['name']! as String,
+          lensDirection:
+              parseCameraLensDirection(camera['lensFacing']! as String),
+          sensorOrientation: camera['sensorOrientation']! as int,
+        );
+      }).toList();
+    } on PlatformException catch (e) {
+      throw CameraException(e.code, e.message);
+    }
+  }
+
+  @override
+  Future<int> createCamera(
+    CameraDescription cameraDescription,
+    ResolutionPreset? resolutionPreset, {
+    bool enableAudio = false,
+  }) async {
+    try {
+      final Map<String, dynamic>? reply = await _channel
+          .invokeMapMethod<String, dynamic>('create', <String, dynamic>{
+        'cameraName': cameraDescription.name,
+        'resolutionPreset': resolutionPreset != null
+            ? _serializeResolutionPreset(resolutionPreset)
+            : null,
+        'enableAudio': enableAudio,
+      });
+
+      return reply!['cameraId']! as int;
+    } on PlatformException catch (e) {
+      throw CameraException(e.code, e.message);
+    }
+  }
+
+  @override
+  Future<void> initializeCamera(
+    int cameraId, {
+    ImageFormatGroup imageFormatGroup = ImageFormatGroup.unknown,
+  }) {
+    _channels.putIfAbsent(cameraId, () {
+      final MethodChannel channel = MethodChannel(
+          'plugins.flutter.io/camera_avfoundation/camera$cameraId');
+      channel.setMethodCallHandler(
+          (MethodCall call) => handleCameraMethodCall(call, cameraId));
+      return channel;
+    });
+
+    final Completer<void> _completer = Completer<void>();
+
+    onCameraInitialized(cameraId).first.then((CameraInitializedEvent value) {
+      _completer.complete();
+    });
+
+    _channel.invokeMapMethod<String, dynamic>(
+      'initialize',
+      <String, dynamic>{
+        'cameraId': cameraId,
+        'imageFormatGroup': imageFormatGroup.name(),
+      },
+    ).catchError(
+      (Object error, StackTrace stackTrace) {
+        if (error is! PlatformException) {
+          throw error;
+        }
+        _completer.completeError(
+          CameraException(error.code, error.message),
+          stackTrace,
+        );
+      },
+    );
+
+    return _completer.future;
+  }
+
+  @override
+  Future<void> dispose(int cameraId) async {
+    if (_channels.containsKey(cameraId)) {
+      final MethodChannel? cameraChannel = _channels[cameraId];
+      cameraChannel?.setMethodCallHandler(null);
+      _channels.remove(cameraId);
+    }
+
+    await _channel.invokeMethod<void>(
+      'dispose',
+      <String, dynamic>{'cameraId': cameraId},
+    );
+  }
+
+  @override
+  Stream<CameraInitializedEvent> onCameraInitialized(int cameraId) {
+    return _cameraEvents(cameraId).whereType<CameraInitializedEvent>();
+  }
+
+  @override
+  Stream<CameraResolutionChangedEvent> onCameraResolutionChanged(int cameraId) {
+    return _cameraEvents(cameraId).whereType<CameraResolutionChangedEvent>();
+  }
+
+  @override
+  Stream<CameraClosingEvent> onCameraClosing(int cameraId) {
+    return _cameraEvents(cameraId).whereType<CameraClosingEvent>();
+  }
+
+  @override
+  Stream<CameraErrorEvent> onCameraError(int cameraId) {
+    return _cameraEvents(cameraId).whereType<CameraErrorEvent>();
+  }
+
+  @override
+  Stream<VideoRecordedEvent> onVideoRecordedEvent(int cameraId) {
+    return _cameraEvents(cameraId).whereType<VideoRecordedEvent>();
+  }
+
+  @override
+  Stream<DeviceOrientationChangedEvent> onDeviceOrientationChanged() {
+    return deviceEventStreamController.stream
+        .whereType<DeviceOrientationChangedEvent>();
+  }
+
+  @override
+  Future<void> lockCaptureOrientation(
+    int cameraId,
+    DeviceOrientation orientation,
+  ) async {
+    await _channel.invokeMethod<String>(
+      'lockCaptureOrientation',
+      <String, dynamic>{
+        'cameraId': cameraId,
+        'orientation': serializeDeviceOrientation(orientation)
+      },
+    );
+  }
+
+  @override
+  Future<void> unlockCaptureOrientation(int cameraId) async {
+    await _channel.invokeMethod<String>(
+      'unlockCaptureOrientation',
+      <String, dynamic>{'cameraId': cameraId},
+    );
+  }
+
+  @override
+  Future<XFile> takePicture(int cameraId) async {
+    final String? path = await _channel.invokeMethod<String>(
+      'takePicture',
+      <String, dynamic>{'cameraId': cameraId},
+    );
+
+    if (path == null) {
+      throw CameraException(
+        'INVALID_PATH',
+        'The platform "$defaultTargetPlatform" did not return a path while reporting success. The platform should always return a valid path or report an error.',
+      );
+    }
+
+    return XFile(path);
+  }
+
+  @override
+  Future<void> prepareForVideoRecording() =>
+      _channel.invokeMethod<void>('prepareForVideoRecording');
+
+  @override
+  Future<void> startVideoRecording(int cameraId,
+      {Duration? maxVideoDuration}) async {
+    await _channel.invokeMethod<void>(
+      'startVideoRecording',
+      <String, dynamic>{
+        'cameraId': cameraId,
+        'maxVideoDuration': maxVideoDuration?.inMilliseconds,
+      },
+    );
+  }
+
+  @override
+  Future<XFile> stopVideoRecording(int cameraId) async {
+    final String? path = await _channel.invokeMethod<String>(
+      'stopVideoRecording',
+      <String, dynamic>{'cameraId': cameraId},
+    );
+
+    if (path == null) {
+      throw CameraException(
+        'INVALID_PATH',
+        'The platform "$defaultTargetPlatform" did not return a path while reporting success. The platform should always return a valid path or report an error.',
+      );
+    }
+
+    return XFile(path);
+  }
+
+  @override
+  Future<void> pauseVideoRecording(int cameraId) => _channel.invokeMethod<void>(
+        'pauseVideoRecording',
+        <String, dynamic>{'cameraId': cameraId},
+      );
+
+  @override
+  Future<void> resumeVideoRecording(int cameraId) =>
+      _channel.invokeMethod<void>(
+        'resumeVideoRecording',
+        <String, dynamic>{'cameraId': cameraId},
+      );
+
+  @override
+  Stream<CameraImageData> onStreamedFrameAvailable(int cameraId,
+      {CameraImageStreamOptions? options}) {
+    _frameStreamController = StreamController<CameraImageData>(
+      onListen: _onFrameStreamListen,
+      onPause: _onFrameStreamPauseResume,
+      onResume: _onFrameStreamPauseResume,
+      onCancel: _onFrameStreamCancel,
+    );
+    return _frameStreamController!.stream;
+  }
+
+  void _onFrameStreamListen() {
+    _startPlatformStream();
+  }
+
+  Future<void> _startPlatformStream() async {
+    await _channel.invokeMethod<void>('startImageStream');
+    const EventChannel cameraEventChannel =
+        EventChannel('plugins.flutter.io/camera_avfoundation/imageStream');
+    _platformImageStreamSubscription =
+        cameraEventChannel.receiveBroadcastStream().listen((dynamic imageData) {
+      try {
+        _channel.invokeMethod<void>('receivedImageStreamData');
+      } on PlatformException catch (e) {
+        throw CameraException(e.code, e.message);
+      }
+      _frameStreamController!
+          .add(cameraImageFromPlatformData(imageData as Map<dynamic, dynamic>));
+    });
+  }
+
+  FutureOr<void> _onFrameStreamCancel() async {
+    await _channel.invokeMethod<void>('stopImageStream');
+    await _platformImageStreamSubscription?.cancel();
+    _platformImageStreamSubscription = null;
+    _frameStreamController = null;
+  }
+
+  void _onFrameStreamPauseResume() {
+    throw CameraException('InvalidCall',
+        'Pause and resume are not supported for onStreamedFrameAvailable');
+  }
+
+  @override
+  Future<void> setFlashMode(int cameraId, FlashMode mode) =>
+      _channel.invokeMethod<void>(
+        'setFlashMode',
+        <String, dynamic>{
+          'cameraId': cameraId,
+          'mode': _serializeFlashMode(mode),
+        },
+      );
+
+  @override
+  Future<void> setExposureMode(int cameraId, ExposureMode mode) =>
+      _channel.invokeMethod<void>(
+        'setExposureMode',
+        <String, dynamic>{
+          'cameraId': cameraId,
+          'mode': serializeExposureMode(mode),
+        },
+      );
+
+  @override
+  Future<void> setExposurePoint(int cameraId, Point<double>? point) {
+    assert(point == null || point.x >= 0 && point.x <= 1);
+    assert(point == null || point.y >= 0 && point.y <= 1);
+
+    return _channel.invokeMethod<void>(
+      'setExposurePoint',
+      <String, dynamic>{
+        'cameraId': cameraId,
+        'reset': point == null,
+        'x': point?.x,
+        'y': point?.y,
+      },
+    );
+  }
+
+  @override
+  Future<double> getMinExposureOffset(int cameraId) async {
+    final double? minExposureOffset = await _channel.invokeMethod<double>(
+      'getMinExposureOffset',
+      <String, dynamic>{'cameraId': cameraId},
+    );
+
+    return minExposureOffset!;
+  }
+
+  @override
+  Future<double> getMaxExposureOffset(int cameraId) async {
+    final double? maxExposureOffset = await _channel.invokeMethod<double>(
+      'getMaxExposureOffset',
+      <String, dynamic>{'cameraId': cameraId},
+    );
+
+    return maxExposureOffset!;
+  }
+
+  @override
+  Future<double> getExposureOffsetStepSize(int cameraId) async {
+    final double? stepSize = await _channel.invokeMethod<double>(
+      'getExposureOffsetStepSize',
+      <String, dynamic>{'cameraId': cameraId},
+    );
+
+    return stepSize!;
+  }
+
+  @override
+  Future<double> setExposureOffset(int cameraId, double offset) async {
+    final double? appliedOffset = await _channel.invokeMethod<double>(
+      'setExposureOffset',
+      <String, dynamic>{
+        'cameraId': cameraId,
+        'offset': offset,
+      },
+    );
+
+    return appliedOffset!;
+  }
+
+  @override
+  Future<void> setFocusMode(int cameraId, FocusMode mode) =>
+      _channel.invokeMethod<void>(
+        'setFocusMode',
+        <String, dynamic>{
+          'cameraId': cameraId,
+          'mode': serializeFocusMode(mode),
+        },
+      );
+
+  @override
+  Future<void> setFocusPoint(int cameraId, Point<double>? point) {
+    assert(point == null || point.x >= 0 && point.x <= 1);
+    assert(point == null || point.y >= 0 && point.y <= 1);
+
+    return _channel.invokeMethod<void>(
+      'setFocusPoint',
+      <String, dynamic>{
+        'cameraId': cameraId,
+        'reset': point == null,
+        'x': point?.x,
+        'y': point?.y,
+      },
+    );
+  }
+
+  @override
+  Future<double> getMaxZoomLevel(int cameraId) async {
+    final double? maxZoomLevel = await _channel.invokeMethod<double>(
+      'getMaxZoomLevel',
+      <String, dynamic>{'cameraId': cameraId},
+    );
+
+    return maxZoomLevel!;
+  }
+
+  @override
+  Future<double> getMinZoomLevel(int cameraId) async {
+    final double? minZoomLevel = await _channel.invokeMethod<double>(
+      'getMinZoomLevel',
+      <String, dynamic>{'cameraId': cameraId},
+    );
+
+    return minZoomLevel!;
+  }
+
+  @override
+  Future<void> setZoomLevel(int cameraId, double zoom) async {
+    try {
+      await _channel.invokeMethod<double>(
+        'setZoomLevel',
+        <String, dynamic>{
+          'cameraId': cameraId,
+          'zoom': zoom,
+        },
+      );
+    } on PlatformException catch (e) {
+      throw CameraException(e.code, e.message);
+    }
+  }
+
+  @override
+  Future<void> pausePreview(int cameraId) async {
+    await _channel.invokeMethod<double>(
+      'pausePreview',
+      <String, dynamic>{'cameraId': cameraId},
+    );
+  }
+
+  @override
+  Future<void> resumePreview(int cameraId) async {
+    await _channel.invokeMethod<double>(
+      'resumePreview',
+      <String, dynamic>{'cameraId': cameraId},
+    );
+  }
+
+  @override
+  Widget buildPreview(int cameraId) {
+    return Texture(textureId: cameraId);
+  }
+
+  /// Returns the flash mode as a String.
+  String _serializeFlashMode(FlashMode flashMode) {
+    switch (flashMode) {
+      case FlashMode.off:
+        return 'off';
+      case FlashMode.auto:
+        return 'auto';
+      case FlashMode.always:
+        return 'always';
+      case FlashMode.torch:
+        return 'torch';
+      default:
+        throw ArgumentError('Unknown FlashMode value');
+    }
+  }
+
+  /// Returns the resolution preset as a String.
+  String _serializeResolutionPreset(ResolutionPreset resolutionPreset) {
+    switch (resolutionPreset) {
+      case ResolutionPreset.max:
+        return 'max';
+      case ResolutionPreset.ultraHigh:
+        return 'ultraHigh';
+      case ResolutionPreset.veryHigh:
+        return 'veryHigh';
+      case ResolutionPreset.high:
+        return 'high';
+      case ResolutionPreset.medium:
+        return 'medium';
+      case ResolutionPreset.low:
+        return 'low';
+      default:
+        throw ArgumentError('Unknown ResolutionPreset value');
+    }
+  }
+
+  /// Converts messages received from the native platform into device events.
+  ///
+  /// This is only exposed for test purposes. It shouldn't be used by clients of
+  /// the plugin as it may break or change at any time.
+  @visibleForTesting
+  Future<dynamic> handleDeviceMethodCall(MethodCall call) async {
+    switch (call.method) {
+      case 'orientation_changed':
+        deviceEventStreamController.add(DeviceOrientationChangedEvent(
+            deserializeDeviceOrientation(
+                call.arguments['orientation']! as String)));
+        break;
+      default:
+        throw MissingPluginException();
+    }
+  }
+
+  /// Converts messages received from the native platform into camera events.
+  ///
+  /// This is only exposed for test purposes. It shouldn't be used by clients of
+  /// the plugin as it may break or change at any time.
+  @visibleForTesting
+  Future<dynamic> handleCameraMethodCall(MethodCall call, int cameraId) async {
+    switch (call.method) {
+      case 'initialized':
+        cameraEventStreamController.add(CameraInitializedEvent(
+          cameraId,
+          call.arguments['previewWidth']! as double,
+          call.arguments['previewHeight']! as double,
+          deserializeExposureMode(call.arguments['exposureMode']! as String),
+          call.arguments['exposurePointSupported']! as bool,
+          deserializeFocusMode(call.arguments['focusMode']! as String),
+          call.arguments['focusPointSupported']! as bool,
+        ));
+        break;
+      case 'resolution_changed':
+        cameraEventStreamController.add(CameraResolutionChangedEvent(
+          cameraId,
+          call.arguments['captureWidth']! as double,
+          call.arguments['captureHeight']! as double,
+        ));
+        break;
+      case 'camera_closing':
+        cameraEventStreamController.add(CameraClosingEvent(
+          cameraId,
+        ));
+        break;
+      case 'video_recorded':
+        cameraEventStreamController.add(VideoRecordedEvent(
+          cameraId,
+          XFile(call.arguments['path']! as String),
+          call.arguments['maxVideoDuration'] != null
+              ? Duration(
+                  milliseconds: call.arguments['maxVideoDuration']! as int)
+              : null,
+        ));
+        break;
+      case 'error':
+        cameraEventStreamController.add(CameraErrorEvent(
+          cameraId,
+          call.arguments['description']! as String,
+        ));
+        break;
+      default:
+        throw MissingPluginException();
+    }
+  }
+}
diff --git a/packages/camera/camera_avfoundation/lib/src/type_conversion.dart b/packages/camera/camera_avfoundation/lib/src/type_conversion.dart
new file mode 100644
index 0000000..c2a539a
--- /dev/null
+++ b/packages/camera/camera_avfoundation/lib/src/type_conversion.dart
@@ -0,0 +1,50 @@
+// Copyright 2013 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// TODO(a14n): remove this import once Flutter 3.1 or later reaches stable (including flutter/flutter#104231)
+// ignore: unnecessary_import
+import 'dart:typed_data';
+
+import 'package:camera_platform_interface/camera_platform_interface.dart';
+
+/// Converts method channel call [data] for `receivedImageStreamData` to a
+/// [CameraImageData].
+CameraImageData cameraImageFromPlatformData(Map<dynamic, dynamic> data) {
+  return CameraImageData(
+      format: _cameraImageFormatFromPlatformData(data['format']),
+      height: data['height'] as int,
+      width: data['width'] as int,
+      lensAperture: data['lensAperture'] as double?,
+      sensorExposureTime: data['sensorExposureTime'] as int?,
+      sensorSensitivity: data['sensorSensitivity'] as double?,
+      planes: List<CameraImagePlane>.unmodifiable(
+          (data['planes'] as List<dynamic>).map<CameraImagePlane>(
+              (dynamic planeData) => _cameraImagePlaneFromPlatformData(
+                  planeData as Map<dynamic, dynamic>))));
+}
+
+CameraImageFormat _cameraImageFormatFromPlatformData(dynamic data) {
+  return CameraImageFormat(_imageFormatGroupFromPlatformData(data), raw: data);
+}
+
+ImageFormatGroup _imageFormatGroupFromPlatformData(dynamic data) {
+  switch (data) {
+    case 875704438: // kCVPixelFormatType_420YpCbCr8BiPlanarVideoRange
+      return ImageFormatGroup.yuv420;
+
+    case 1111970369: // kCVPixelFormatType_32BGRA
+      return ImageFormatGroup.bgra8888;
+  }
+
+  return ImageFormatGroup.unknown;
+}
+
+CameraImagePlane _cameraImagePlaneFromPlatformData(Map<dynamic, dynamic> data) {
+  return CameraImagePlane(
+      bytes: data['bytes'] as Uint8List,
+      bytesPerPixel: data['bytesPerPixel'] as int?,
+      bytesPerRow: data['bytesPerRow'] as int,
+      height: data['height'] as int?,
+      width: data['width'] as int?);
+}
diff --git a/packages/camera/camera_avfoundation/lib/src/utils.dart b/packages/camera/camera_avfoundation/lib/src/utils.dart
new file mode 100644
index 0000000..663ec6d
--- /dev/null
+++ b/packages/camera/camera_avfoundation/lib/src/utils.dart
@@ -0,0 +1,51 @@
+// Copyright 2013 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import 'package:camera_platform_interface/camera_platform_interface.dart';
+import 'package:flutter/services.dart';
+
+/// Parses a string into a corresponding CameraLensDirection.
+CameraLensDirection parseCameraLensDirection(String string) {
+  switch (string) {
+    case 'front':
+      return CameraLensDirection.front;
+    case 'back':
+      return CameraLensDirection.back;
+    case 'external':
+      return CameraLensDirection.external;
+  }
+  throw ArgumentError('Unknown CameraLensDirection value');
+}
+
+/// Returns the device orientation as a String.
+String serializeDeviceOrientation(DeviceOrientation orientation) {
+  switch (orientation) {
+    case DeviceOrientation.portraitUp:
+      return 'portraitUp';
+    case DeviceOrientation.portraitDown:
+      return 'portraitDown';
+    case DeviceOrientation.landscapeRight:
+      return 'landscapeRight';
+    case DeviceOrientation.landscapeLeft:
+      return 'landscapeLeft';
+    default:
+      throw ArgumentError('Unknown DeviceOrientation value');
+  }
+}
+
+/// Returns the device orientation for a given String.
+DeviceOrientation deserializeDeviceOrientation(String str) {
+  switch (str) {
+    case 'portraitUp':
+      return DeviceOrientation.portraitUp;
+    case 'portraitDown':
+      return DeviceOrientation.portraitDown;
+    case 'landscapeRight':
+      return DeviceOrientation.landscapeRight;
+    case 'landscapeLeft':
+      return DeviceOrientation.landscapeLeft;
+    default:
+      throw ArgumentError('"$str" is not a valid DeviceOrientation value');
+  }
+}
diff --git a/packages/camera/camera_avfoundation/pubspec.yaml b/packages/camera/camera_avfoundation/pubspec.yaml
index 237f5ad..231ce26 100644
--- a/packages/camera/camera_avfoundation/pubspec.yaml
+++ b/packages/camera/camera_avfoundation/pubspec.yaml
@@ -2,7 +2,7 @@
 description: iOS implementation of the camera plugin.
 repository: https://github.com/flutter/plugins/tree/main/packages/camera/camera_avfoundation
 issue_tracker: https://github.com/flutter/flutter/issues?q=is%3Aissue+is%3Aopen+label%3A%22p%3A+camera%22
-version: 0.9.7+1
+version: 0.9.8
 
 environment:
   sdk: ">=2.14.0 <3.0.0"
@@ -14,13 +14,16 @@
     platforms:
       ios:
         pluginClass: CameraPlugin
+        dartPluginClass: AVFoundationCamera
 
 dependencies:
   camera_platform_interface: ^2.2.0
   flutter:
     sdk: flutter
+  stream_transform: ^2.0.0
 
 dev_dependencies:
+  async: ^2.5.0
   flutter_driver:
     sdk: flutter
   flutter_test:
diff --git a/packages/camera/camera_avfoundation/test/avfoundation_camera_test.dart b/packages/camera/camera_avfoundation/test/avfoundation_camera_test.dart
new file mode 100644
index 0000000..4b32d2e
--- /dev/null
+++ b/packages/camera/camera_avfoundation/test/avfoundation_camera_test.dart
@@ -0,0 +1,1075 @@
+// Copyright 2013 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import 'dart:async';
+import 'dart:math';
+
+import 'package:async/async.dart';
+import 'package:camera_avfoundation/src/avfoundation_camera.dart';
+import 'package:camera_avfoundation/src/utils.dart';
+import 'package:camera_platform_interface/camera_platform_interface.dart';
+import 'package:flutter/services.dart';
+import 'package:flutter/widgets.dart';
+import 'package:flutter_test/flutter_test.dart';
+
+import 'method_channel_mock.dart';
+
+const String _channelName = 'plugins.flutter.io/camera_avfoundation';
+
+void main() {
+  TestWidgetsFlutterBinding.ensureInitialized();
+
+  test('registers instance', () async {
+    AVFoundationCamera.registerWith();
+    expect(CameraPlatform.instance, isA<AVFoundationCamera>());
+  });
+
+  group('Creation, Initialization & Disposal Tests', () {
+    test('Should send creation data and receive back a camera id', () async {
+      // Arrange
+      final MethodChannelMock cameraMockChannel = MethodChannelMock(
+          channelName: _channelName,
+          methods: <String, dynamic>{
+            'create': <String, dynamic>{
+              'cameraId': 1,
+              'imageFormatGroup': 'unknown',
+            }
+          });
+      final AVFoundationCamera camera = AVFoundationCamera();
+
+      // Act
+      final int cameraId = await camera.createCamera(
+        const CameraDescription(
+            name: 'Test',
+            lensDirection: CameraLensDirection.back,
+            sensorOrientation: 0),
+        ResolutionPreset.high,
+      );
+
+      // Assert
+      expect(cameraMockChannel.log, <Matcher>[
+        isMethodCall(
+          'create',
+          arguments: <String, Object?>{
+            'cameraName': 'Test',
+            'resolutionPreset': 'high',
+            'enableAudio': false
+          },
+        ),
+      ]);
+      expect(cameraId, 1);
+    });
+
+    test('Should throw CameraException when create throws a PlatformException',
+        () {
+      // Arrange
+      MethodChannelMock(channelName: _channelName, methods: <String, dynamic>{
+        'create': PlatformException(
+          code: 'TESTING_ERROR_CODE',
+          message: 'Mock error message used during testing.',
+        )
+      });
+      final AVFoundationCamera camera = AVFoundationCamera();
+
+      // Act
+      expect(
+        () => camera.createCamera(
+          const CameraDescription(
+            name: 'Test',
+            lensDirection: CameraLensDirection.back,
+            sensorOrientation: 0,
+          ),
+          ResolutionPreset.high,
+        ),
+        throwsA(
+          isA<CameraException>()
+              .having(
+                  (CameraException e) => e.code, 'code', 'TESTING_ERROR_CODE')
+              .having((CameraException e) => e.description, 'description',
+                  'Mock error message used during testing.'),
+        ),
+      );
+    });
+
+    test('Should throw CameraException when create throws a PlatformException',
+        () {
+      // Arrange
+      MethodChannelMock(channelName: _channelName, methods: <String, dynamic>{
+        'create': PlatformException(
+          code: 'TESTING_ERROR_CODE',
+          message: 'Mock error message used during testing.',
+        )
+      });
+      final AVFoundationCamera camera = AVFoundationCamera();
+
+      // Act
+      expect(
+        () => camera.createCamera(
+          const CameraDescription(
+            name: 'Test',
+            lensDirection: CameraLensDirection.back,
+            sensorOrientation: 0,
+          ),
+          ResolutionPreset.high,
+        ),
+        throwsA(
+          isA<CameraException>()
+              .having(
+                  (CameraException e) => e.code, 'code', 'TESTING_ERROR_CODE')
+              .having((CameraException e) => e.description, 'description',
+                  'Mock error message used during testing.'),
+        ),
+      );
+    });
+
+    test(
+      'Should throw CameraException when initialize throws a PlatformException',
+      () {
+        // Arrange
+        MethodChannelMock(
+          channelName: _channelName,
+          methods: <String, dynamic>{
+            'initialize': PlatformException(
+              code: 'TESTING_ERROR_CODE',
+              message: 'Mock error message used during testing.',
+            )
+          },
+        );
+        final AVFoundationCamera camera = AVFoundationCamera();
+
+        // Act
+        expect(
+          () => camera.initializeCamera(0),
+          throwsA(
+            isA<CameraException>()
+                .having(
+                    (CameraException e) => e.code, 'code', 'TESTING_ERROR_CODE')
+                .having(
+                  (CameraException e) => e.description,
+                  'description',
+                  'Mock error message used during testing.',
+                ),
+          ),
+        );
+      },
+    );
+
+    test('Should send initialization data', () async {
+      // Arrange
+      final MethodChannelMock cameraMockChannel = MethodChannelMock(
+          channelName: _channelName,
+          methods: <String, dynamic>{
+            'create': <String, dynamic>{
+              'cameraId': 1,
+              'imageFormatGroup': 'unknown',
+            },
+            'initialize': null
+          });
+      final AVFoundationCamera camera = AVFoundationCamera();
+      final int cameraId = await camera.createCamera(
+        const CameraDescription(
+          name: 'Test',
+          lensDirection: CameraLensDirection.back,
+          sensorOrientation: 0,
+        ),
+        ResolutionPreset.high,
+      );
+
+      // Act
+      final Future<void> initializeFuture = camera.initializeCamera(cameraId);
+      camera.cameraEventStreamController.add(CameraInitializedEvent(
+        cameraId,
+        1920,
+        1080,
+        ExposureMode.auto,
+        true,
+        FocusMode.auto,
+        true,
+      ));
+      await initializeFuture;
+
+      // Assert
+      expect(cameraId, 1);
+      expect(cameraMockChannel.log, <Matcher>[
+        anything,
+        isMethodCall(
+          'initialize',
+          arguments: <String, Object?>{
+            'cameraId': 1,
+            'imageFormatGroup': 'unknown',
+          },
+        ),
+      ]);
+    });
+
+    test('Should send a disposal call on dispose', () async {
+      // Arrange
+      final MethodChannelMock cameraMockChannel = MethodChannelMock(
+          channelName: _channelName,
+          methods: <String, dynamic>{
+            'create': <String, dynamic>{'cameraId': 1},
+            'initialize': null,
+            'dispose': <String, dynamic>{'cameraId': 1}
+          });
+
+      final AVFoundationCamera camera = AVFoundationCamera();
+      final int cameraId = await camera.createCamera(
+        const CameraDescription(
+          name: 'Test',
+          lensDirection: CameraLensDirection.back,
+          sensorOrientation: 0,
+        ),
+        ResolutionPreset.high,
+      );
+      final Future<void> initializeFuture = camera.initializeCamera(cameraId);
+      camera.cameraEventStreamController.add(CameraInitializedEvent(
+        cameraId,
+        1920,
+        1080,
+        ExposureMode.auto,
+        true,
+        FocusMode.auto,
+        true,
+      ));
+      await initializeFuture;
+
+      // Act
+      await camera.dispose(cameraId);
+
+      // Assert
+      expect(cameraId, 1);
+      expect(cameraMockChannel.log, <Matcher>[
+        anything,
+        anything,
+        isMethodCall(
+          'dispose',
+          arguments: <String, Object?>{'cameraId': 1},
+        ),
+      ]);
+    });
+  });
+
+  group('Event Tests', () {
+    late AVFoundationCamera camera;
+    late int cameraId;
+    setUp(() async {
+      MethodChannelMock(
+        channelName: _channelName,
+        methods: <String, dynamic>{
+          'create': <String, dynamic>{'cameraId': 1},
+          'initialize': null
+        },
+      );
+      camera = AVFoundationCamera();
+      cameraId = await camera.createCamera(
+        const CameraDescription(
+          name: 'Test',
+          lensDirection: CameraLensDirection.back,
+          sensorOrientation: 0,
+        ),
+        ResolutionPreset.high,
+      );
+      final Future<void> initializeFuture = camera.initializeCamera(cameraId);
+      camera.cameraEventStreamController.add(CameraInitializedEvent(
+        cameraId,
+        1920,
+        1080,
+        ExposureMode.auto,
+        true,
+        FocusMode.auto,
+        true,
+      ));
+      await initializeFuture;
+    });
+
+    test('Should receive initialized event', () async {
+      // Act
+      final Stream<CameraInitializedEvent> eventStream =
+          camera.onCameraInitialized(cameraId);
+      final StreamQueue<CameraInitializedEvent> streamQueue =
+          StreamQueue<CameraInitializedEvent>(eventStream);
+
+      // Emit test events
+      final CameraInitializedEvent event = CameraInitializedEvent(
+        cameraId,
+        3840,
+        2160,
+        ExposureMode.auto,
+        true,
+        FocusMode.auto,
+        true,
+      );
+      await camera.handleCameraMethodCall(
+          MethodCall('initialized', event.toJson()), cameraId);
+
+      // Assert
+      expect(await streamQueue.next, event);
+
+      // Clean up
+      await streamQueue.cancel();
+    });
+
+    test('Should receive resolution changes', () async {
+      // Act
+      final Stream<CameraResolutionChangedEvent> resolutionStream =
+          camera.onCameraResolutionChanged(cameraId);
+      final StreamQueue<CameraResolutionChangedEvent> streamQueue =
+          StreamQueue<CameraResolutionChangedEvent>(resolutionStream);
+
+      // Emit test events
+      final CameraResolutionChangedEvent fhdEvent =
+          CameraResolutionChangedEvent(cameraId, 1920, 1080);
+      final CameraResolutionChangedEvent uhdEvent =
+          CameraResolutionChangedEvent(cameraId, 3840, 2160);
+      await camera.handleCameraMethodCall(
+          MethodCall('resolution_changed', fhdEvent.toJson()), cameraId);
+      await camera.handleCameraMethodCall(
+          MethodCall('resolution_changed', uhdEvent.toJson()), cameraId);
+      await camera.handleCameraMethodCall(
+          MethodCall('resolution_changed', fhdEvent.toJson()), cameraId);
+      await camera.handleCameraMethodCall(
+          MethodCall('resolution_changed', uhdEvent.toJson()), cameraId);
+
+      // Assert
+      expect(await streamQueue.next, fhdEvent);
+      expect(await streamQueue.next, uhdEvent);
+      expect(await streamQueue.next, fhdEvent);
+      expect(await streamQueue.next, uhdEvent);
+
+      // Clean up
+      await streamQueue.cancel();
+    });
+
+    test('Should receive camera closing events', () async {
+      // Act
+      final Stream<CameraClosingEvent> eventStream =
+          camera.onCameraClosing(cameraId);
+      final StreamQueue<CameraClosingEvent> streamQueue =
+          StreamQueue<CameraClosingEvent>(eventStream);
+
+      // Emit test events
+      final CameraClosingEvent event = CameraClosingEvent(cameraId);
+      await camera.handleCameraMethodCall(
+          MethodCall('camera_closing', event.toJson()), cameraId);
+      await camera.handleCameraMethodCall(
+          MethodCall('camera_closing', event.toJson()), cameraId);
+      await camera.handleCameraMethodCall(
+          MethodCall('camera_closing', event.toJson()), cameraId);
+
+      // Assert
+      expect(await streamQueue.next, event);
+      expect(await streamQueue.next, event);
+      expect(await streamQueue.next, event);
+
+      // Clean up
+      await streamQueue.cancel();
+    });
+
+    test('Should receive camera error events', () async {
+      // Act
+      final Stream<CameraErrorEvent> errorStream =
+          camera.onCameraError(cameraId);
+      final StreamQueue<CameraErrorEvent> streamQueue =
+          StreamQueue<CameraErrorEvent>(errorStream);
+
+      // Emit test events
+      final CameraErrorEvent event =
+          CameraErrorEvent(cameraId, 'Error Description');
+      await camera.handleCameraMethodCall(
+          MethodCall('error', event.toJson()), cameraId);
+      await camera.handleCameraMethodCall(
+          MethodCall('error', event.toJson()), cameraId);
+      await camera.handleCameraMethodCall(
+          MethodCall('error', event.toJson()), cameraId);
+
+      // Assert
+      expect(await streamQueue.next, event);
+      expect(await streamQueue.next, event);
+      expect(await streamQueue.next, event);
+
+      // Clean up
+      await streamQueue.cancel();
+    });
+
+    test('Should receive device orientation change events', () async {
+      // Act
+      final Stream<DeviceOrientationChangedEvent> eventStream =
+          camera.onDeviceOrientationChanged();
+      final StreamQueue<DeviceOrientationChangedEvent> streamQueue =
+          StreamQueue<DeviceOrientationChangedEvent>(eventStream);
+
+      // Emit test events
+      const DeviceOrientationChangedEvent event =
+          DeviceOrientationChangedEvent(DeviceOrientation.portraitUp);
+      await camera.handleDeviceMethodCall(
+          MethodCall('orientation_changed', event.toJson()));
+      await camera.handleDeviceMethodCall(
+          MethodCall('orientation_changed', event.toJson()));
+      await camera.handleDeviceMethodCall(
+          MethodCall('orientation_changed', event.toJson()));
+
+      // Assert
+      expect(await streamQueue.next, event);
+      expect(await streamQueue.next, event);
+      expect(await streamQueue.next, event);
+
+      // Clean up
+      await streamQueue.cancel();
+    });
+  });
+
+  group('Function Tests', () {
+    late AVFoundationCamera camera;
+    late int cameraId;
+
+    setUp(() async {
+      MethodChannelMock(
+        channelName: _channelName,
+        methods: <String, dynamic>{
+          'create': <String, dynamic>{'cameraId': 1},
+          'initialize': null
+        },
+      );
+      camera = AVFoundationCamera();
+      cameraId = await camera.createCamera(
+        const CameraDescription(
+          name: 'Test',
+          lensDirection: CameraLensDirection.back,
+          sensorOrientation: 0,
+        ),
+        ResolutionPreset.high,
+      );
+      final Future<void> initializeFuture = camera.initializeCamera(cameraId);
+      camera.cameraEventStreamController.add(
+        CameraInitializedEvent(
+          cameraId,
+          1920,
+          1080,
+          ExposureMode.auto,
+          true,
+          FocusMode.auto,
+          true,
+        ),
+      );
+      await initializeFuture;
+    });
+
+    test('Should fetch CameraDescription instances for available cameras',
+        () async {
+      // Arrange
+      final List<dynamic> returnData = <dynamic>[
+        <String, dynamic>{
+          'name': 'Test 1',
+          'lensFacing': 'front',
+          'sensorOrientation': 1
+        },
+        <String, dynamic>{
+          'name': 'Test 2',
+          'lensFacing': 'back',
+          'sensorOrientation': 2
+        }
+      ];
+      final MethodChannelMock channel = MethodChannelMock(
+        channelName: _channelName,
+        methods: <String, dynamic>{'availableCameras': returnData},
+      );
+
+      // Act
+      final List<CameraDescription> cameras = await camera.availableCameras();
+
+      // Assert
+      expect(channel.log, <Matcher>[
+        isMethodCall('availableCameras', arguments: null),
+      ]);
+      expect(cameras.length, returnData.length);
+      for (int i = 0; i < returnData.length; i++) {
+        final CameraDescription cameraDescription = CameraDescription(
+          name: returnData[i]['name']! as String,
+          lensDirection:
+              parseCameraLensDirection(returnData[i]['lensFacing']! as String),
+          sensorOrientation: returnData[i]['sensorOrientation']! as int,
+        );
+        expect(cameras[i], cameraDescription);
+      }
+    });
+
+    test(
+        'Should throw CameraException when availableCameras throws a PlatformException',
+        () {
+      // Arrange
+      MethodChannelMock(channelName: _channelName, methods: <String, dynamic>{
+        'availableCameras': PlatformException(
+          code: 'TESTING_ERROR_CODE',
+          message: 'Mock error message used during testing.',
+        )
+      });
+
+      // Act
+      expect(
+        camera.availableCameras,
+        throwsA(
+          isA<CameraException>()
+              .having(
+                  (CameraException e) => e.code, 'code', 'TESTING_ERROR_CODE')
+              .having((CameraException e) => e.description, 'description',
+                  'Mock error message used during testing.'),
+        ),
+      );
+    });
+
+    test('Should take a picture and return an XFile instance', () async {
+      // Arrange
+      final MethodChannelMock channel = MethodChannelMock(
+          channelName: _channelName,
+          methods: <String, dynamic>{'takePicture': '/test/path.jpg'});
+
+      // Act
+      final XFile file = await camera.takePicture(cameraId);
+
+      // Assert
+      expect(channel.log, <Matcher>[
+        isMethodCall('takePicture', arguments: <String, Object?>{
+          'cameraId': cameraId,
+        }),
+      ]);
+      expect(file.path, '/test/path.jpg');
+    });
+
+    test('Should prepare for video recording', () async {
+      // Arrange
+      final MethodChannelMock channel = MethodChannelMock(
+        channelName: _channelName,
+        methods: <String, dynamic>{'prepareForVideoRecording': null},
+      );
+
+      // Act
+      await camera.prepareForVideoRecording();
+
+      // Assert
+      expect(channel.log, <Matcher>[
+        isMethodCall('prepareForVideoRecording', arguments: null),
+      ]);
+    });
+
+    test('Should start recording a video', () async {
+      // Arrange
+      final MethodChannelMock channel = MethodChannelMock(
+        channelName: _channelName,
+        methods: <String, dynamic>{'startVideoRecording': null},
+      );
+
+      // Act
+      await camera.startVideoRecording(cameraId);
+
+      // Assert
+      expect(channel.log, <Matcher>[
+        isMethodCall('startVideoRecording', arguments: <String, Object?>{
+          'cameraId': cameraId,
+          'maxVideoDuration': null,
+        }),
+      ]);
+    });
+
+    test('Should pass maxVideoDuration when starting recording a video',
+        () async {
+      // Arrange
+      final MethodChannelMock channel = MethodChannelMock(
+        channelName: _channelName,
+        methods: <String, dynamic>{'startVideoRecording': null},
+      );
+
+      // Act
+      await camera.startVideoRecording(
+        cameraId,
+        maxVideoDuration: const Duration(seconds: 10),
+      );
+
+      // Assert
+      expect(channel.log, <Matcher>[
+        isMethodCall('startVideoRecording', arguments: <String, Object?>{
+          'cameraId': cameraId,
+          'maxVideoDuration': 10000
+        }),
+      ]);
+    });
+
+    test('Should stop a video recording and return the file', () async {
+      // Arrange
+      final MethodChannelMock channel = MethodChannelMock(
+        channelName: _channelName,
+        methods: <String, dynamic>{'stopVideoRecording': '/test/path.mp4'},
+      );
+
+      // Act
+      final XFile file = await camera.stopVideoRecording(cameraId);
+
+      // Assert
+      expect(channel.log, <Matcher>[
+        isMethodCall('stopVideoRecording', arguments: <String, Object?>{
+          'cameraId': cameraId,
+        }),
+      ]);
+      expect(file.path, '/test/path.mp4');
+    });
+
+    test('Should pause a video recording', () async {
+      // Arrange
+      final MethodChannelMock channel = MethodChannelMock(
+        channelName: _channelName,
+        methods: <String, dynamic>{'pauseVideoRecording': null},
+      );
+
+      // Act
+      await camera.pauseVideoRecording(cameraId);
+
+      // Assert
+      expect(channel.log, <Matcher>[
+        isMethodCall('pauseVideoRecording', arguments: <String, Object?>{
+          'cameraId': cameraId,
+        }),
+      ]);
+    });
+
+    test('Should resume a video recording', () async {
+      // Arrange
+      final MethodChannelMock channel = MethodChannelMock(
+        channelName: _channelName,
+        methods: <String, dynamic>{'resumeVideoRecording': null},
+      );
+
+      // Act
+      await camera.resumeVideoRecording(cameraId);
+
+      // Assert
+      expect(channel.log, <Matcher>[
+        isMethodCall('resumeVideoRecording', arguments: <String, Object?>{
+          'cameraId': cameraId,
+        }),
+      ]);
+    });
+
+    test('Should set the flash mode', () async {
+      // Arrange
+      final MethodChannelMock channel = MethodChannelMock(
+        channelName: _channelName,
+        methods: <String, dynamic>{'setFlashMode': null},
+      );
+
+      // Act
+      await camera.setFlashMode(cameraId, FlashMode.torch);
+      await camera.setFlashMode(cameraId, FlashMode.always);
+      await camera.setFlashMode(cameraId, FlashMode.auto);
+      await camera.setFlashMode(cameraId, FlashMode.off);
+
+      // Assert
+      expect(channel.log, <Matcher>[
+        isMethodCall('setFlashMode', arguments: <String, Object?>{
+          'cameraId': cameraId,
+          'mode': 'torch'
+        }),
+        isMethodCall('setFlashMode', arguments: <String, Object?>{
+          'cameraId': cameraId,
+          'mode': 'always'
+        }),
+        isMethodCall('setFlashMode',
+            arguments: <String, Object?>{'cameraId': cameraId, 'mode': 'auto'}),
+        isMethodCall('setFlashMode',
+            arguments: <String, Object?>{'cameraId': cameraId, 'mode': 'off'}),
+      ]);
+    });
+
+    test('Should set the exposure mode', () async {
+      // Arrange
+      final MethodChannelMock channel = MethodChannelMock(
+        channelName: _channelName,
+        methods: <String, dynamic>{'setExposureMode': null},
+      );
+
+      // Act
+      await camera.setExposureMode(cameraId, ExposureMode.auto);
+      await camera.setExposureMode(cameraId, ExposureMode.locked);
+
+      // Assert
+      expect(channel.log, <Matcher>[
+        isMethodCall('setExposureMode',
+            arguments: <String, Object?>{'cameraId': cameraId, 'mode': 'auto'}),
+        isMethodCall('setExposureMode', arguments: <String, Object?>{
+          'cameraId': cameraId,
+          'mode': 'locked'
+        }),
+      ]);
+    });
+
+    test('Should set the exposure point', () async {
+      // Arrange
+      final MethodChannelMock channel = MethodChannelMock(
+        channelName: _channelName,
+        methods: <String, dynamic>{'setExposurePoint': null},
+      );
+
+      // Act
+      await camera.setExposurePoint(cameraId, const Point<double>(0.5, 0.5));
+      await camera.setExposurePoint(cameraId, null);
+
+      // Assert
+      expect(channel.log, <Matcher>[
+        isMethodCall('setExposurePoint', arguments: <String, Object?>{
+          'cameraId': cameraId,
+          'x': 0.5,
+          'y': 0.5,
+          'reset': false
+        }),
+        isMethodCall('setExposurePoint', arguments: <String, Object?>{
+          'cameraId': cameraId,
+          'x': null,
+          'y': null,
+          'reset': true
+        }),
+      ]);
+    });
+
+    test('Should get the min exposure offset', () async {
+      // Arrange
+      final MethodChannelMock channel = MethodChannelMock(
+        channelName: _channelName,
+        methods: <String, dynamic>{'getMinExposureOffset': 2.0},
+      );
+
+      // Act
+      final double minExposureOffset =
+          await camera.getMinExposureOffset(cameraId);
+
+      // Assert
+      expect(minExposureOffset, 2.0);
+      expect(channel.log, <Matcher>[
+        isMethodCall('getMinExposureOffset', arguments: <String, Object?>{
+          'cameraId': cameraId,
+        }),
+      ]);
+    });
+
+    test('Should get the max exposure offset', () async {
+      // Arrange
+      final MethodChannelMock channel = MethodChannelMock(
+        channelName: _channelName,
+        methods: <String, dynamic>{'getMaxExposureOffset': 2.0},
+      );
+
+      // Act
+      final double maxExposureOffset =
+          await camera.getMaxExposureOffset(cameraId);
+
+      // Assert
+      expect(maxExposureOffset, 2.0);
+      expect(channel.log, <Matcher>[
+        isMethodCall('getMaxExposureOffset', arguments: <String, Object?>{
+          'cameraId': cameraId,
+        }),
+      ]);
+    });
+
+    test('Should get the exposure offset step size', () async {
+      // Arrange
+      final MethodChannelMock channel = MethodChannelMock(
+        channelName: _channelName,
+        methods: <String, dynamic>{'getExposureOffsetStepSize': 0.25},
+      );
+
+      // Act
+      final double stepSize = await camera.getExposureOffsetStepSize(cameraId);
+
+      // Assert
+      expect(stepSize, 0.25);
+      expect(channel.log, <Matcher>[
+        isMethodCall('getExposureOffsetStepSize', arguments: <String, Object?>{
+          'cameraId': cameraId,
+        }),
+      ]);
+    });
+
+    test('Should set the exposure offset', () async {
+      // Arrange
+      final MethodChannelMock channel = MethodChannelMock(
+        channelName: _channelName,
+        methods: <String, dynamic>{'setExposureOffset': 0.6},
+      );
+
+      // Act
+      final double actualOffset = await camera.setExposureOffset(cameraId, 0.5);
+
+      // Assert
+      expect(actualOffset, 0.6);
+      expect(channel.log, <Matcher>[
+        isMethodCall('setExposureOffset', arguments: <String, Object?>{
+          'cameraId': cameraId,
+          'offset': 0.5,
+        }),
+      ]);
+    });
+
+    test('Should set the focus mode', () async {
+      // Arrange
+      final MethodChannelMock channel = MethodChannelMock(
+        channelName: _channelName,
+        methods: <String, dynamic>{'setFocusMode': null},
+      );
+
+      // Act
+      await camera.setFocusMode(cameraId, FocusMode.auto);
+      await camera.setFocusMode(cameraId, FocusMode.locked);
+
+      // Assert
+      expect(channel.log, <Matcher>[
+        isMethodCall('setFocusMode',
+            arguments: <String, Object?>{'cameraId': cameraId, 'mode': 'auto'}),
+        isMethodCall('setFocusMode', arguments: <String, Object?>{
+          'cameraId': cameraId,
+          'mode': 'locked'
+        }),
+      ]);
+    });
+
+    test('Should set the exposure point', () async {
+      // Arrange
+      final MethodChannelMock channel = MethodChannelMock(
+        channelName: _channelName,
+        methods: <String, dynamic>{'setFocusPoint': null},
+      );
+
+      // Act
+      await camera.setFocusPoint(cameraId, const Point<double>(0.5, 0.5));
+      await camera.setFocusPoint(cameraId, null);
+
+      // Assert
+      expect(channel.log, <Matcher>[
+        isMethodCall('setFocusPoint', arguments: <String, Object?>{
+          'cameraId': cameraId,
+          'x': 0.5,
+          'y': 0.5,
+          'reset': false
+        }),
+        isMethodCall('setFocusPoint', arguments: <String, Object?>{
+          'cameraId': cameraId,
+          'x': null,
+          'y': null,
+          'reset': true
+        }),
+      ]);
+    });
+
+    test('Should build a texture widget as preview widget', () async {
+      // Act
+      final Widget widget = camera.buildPreview(cameraId);
+
+      // Act
+      expect(widget is Texture, isTrue);
+      expect((widget as Texture).textureId, cameraId);
+    });
+
+    test('Should throw MissingPluginException when handling unknown method',
+        () {
+      final AVFoundationCamera camera = AVFoundationCamera();
+
+      expect(
+          () => camera.handleCameraMethodCall(
+              const MethodCall('unknown_method'), 1),
+          throwsA(isA<MissingPluginException>()));
+    });
+
+    test('Should get the max zoom level', () async {
+      // Arrange
+      final MethodChannelMock channel = MethodChannelMock(
+        channelName: _channelName,
+        methods: <String, dynamic>{'getMaxZoomLevel': 10.0},
+      );
+
+      // Act
+      final double maxZoomLevel = await camera.getMaxZoomLevel(cameraId);
+
+      // Assert
+      expect(maxZoomLevel, 10.0);
+      expect(channel.log, <Matcher>[
+        isMethodCall('getMaxZoomLevel', arguments: <String, Object?>{
+          'cameraId': cameraId,
+        }),
+      ]);
+    });
+
+    test('Should get the min zoom level', () async {
+      // Arrange
+      final MethodChannelMock channel = MethodChannelMock(
+        channelName: _channelName,
+        methods: <String, dynamic>{'getMinZoomLevel': 1.0},
+      );
+
+      // Act
+      final double maxZoomLevel = await camera.getMinZoomLevel(cameraId);
+
+      // Assert
+      expect(maxZoomLevel, 1.0);
+      expect(channel.log, <Matcher>[
+        isMethodCall('getMinZoomLevel', arguments: <String, Object?>{
+          'cameraId': cameraId,
+        }),
+      ]);
+    });
+
+    test('Should set the zoom level', () async {
+      // Arrange
+      final MethodChannelMock channel = MethodChannelMock(
+        channelName: _channelName,
+        methods: <String, dynamic>{'setZoomLevel': null},
+      );
+
+      // Act
+      await camera.setZoomLevel(cameraId, 2.0);
+
+      // Assert
+      expect(channel.log, <Matcher>[
+        isMethodCall('setZoomLevel',
+            arguments: <String, Object?>{'cameraId': cameraId, 'zoom': 2.0}),
+      ]);
+    });
+
+    test('Should throw CameraException when illegal zoom level is supplied',
+        () async {
+      // Arrange
+      MethodChannelMock(
+        channelName: _channelName,
+        methods: <String, dynamic>{
+          'setZoomLevel': PlatformException(
+            code: 'ZOOM_ERROR',
+            message: 'Illegal zoom error',
+            details: null,
+          )
+        },
+      );
+
+      // Act & assert
+      expect(
+          () => camera.setZoomLevel(cameraId, -1.0),
+          throwsA(isA<CameraException>()
+              .having((CameraException e) => e.code, 'code', 'ZOOM_ERROR')
+              .having((CameraException e) => e.description, 'description',
+                  'Illegal zoom error')));
+    });
+
+    test('Should lock the capture orientation', () async {
+      // Arrange
+      final MethodChannelMock channel = MethodChannelMock(
+        channelName: _channelName,
+        methods: <String, dynamic>{'lockCaptureOrientation': null},
+      );
+
+      // Act
+      await camera.lockCaptureOrientation(
+          cameraId, DeviceOrientation.portraitUp);
+
+      // Assert
+      expect(channel.log, <Matcher>[
+        isMethodCall('lockCaptureOrientation', arguments: <String, Object?>{
+          'cameraId': cameraId,
+          'orientation': 'portraitUp'
+        }),
+      ]);
+    });
+
+    test('Should unlock the capture orientation', () async {
+      // Arrange
+      final MethodChannelMock channel = MethodChannelMock(
+        channelName: _channelName,
+        methods: <String, dynamic>{'unlockCaptureOrientation': null},
+      );
+
+      // Act
+      await camera.unlockCaptureOrientation(cameraId);
+
+      // Assert
+      expect(channel.log, <Matcher>[
+        isMethodCall('unlockCaptureOrientation',
+            arguments: <String, Object?>{'cameraId': cameraId}),
+      ]);
+    });
+
+    test('Should pause the camera preview', () async {
+      // Arrange
+      final MethodChannelMock channel = MethodChannelMock(
+        channelName: _channelName,
+        methods: <String, dynamic>{'pausePreview': null},
+      );
+
+      // Act
+      await camera.pausePreview(cameraId);
+
+      // Assert
+      expect(channel.log, <Matcher>[
+        isMethodCall('pausePreview',
+            arguments: <String, Object?>{'cameraId': cameraId}),
+      ]);
+    });
+
+    test('Should resume the camera preview', () async {
+      // Arrange
+      final MethodChannelMock channel = MethodChannelMock(
+        channelName: _channelName,
+        methods: <String, dynamic>{'resumePreview': null},
+      );
+
+      // Act
+      await camera.resumePreview(cameraId);
+
+      // Assert
+      expect(channel.log, <Matcher>[
+        isMethodCall('resumePreview',
+            arguments: <String, Object?>{'cameraId': cameraId}),
+      ]);
+    });
+
+    test('Should start streaming', () async {
+      // Arrange
+      final MethodChannelMock channel = MethodChannelMock(
+        channelName: _channelName,
+        methods: <String, dynamic>{
+          'startImageStream': null,
+          'stopImageStream': null,
+        },
+      );
+
+      // Act
+      final StreamSubscription<CameraImageData> subscription = camera
+          .onStreamedFrameAvailable(cameraId)
+          .listen((CameraImageData imageData) {});
+
+      // Assert
+      expect(channel.log, <Matcher>[
+        isMethodCall('startImageStream', arguments: null),
+      ]);
+
+      subscription.cancel();
+    });
+
+    test('Should stop streaming', () async {
+      // Arrange
+      final MethodChannelMock channel = MethodChannelMock(
+        channelName: _channelName,
+        methods: <String, dynamic>{
+          'startImageStream': null,
+          'stopImageStream': null,
+        },
+      );
+
+      // Act
+      final StreamSubscription<CameraImageData> subscription = camera
+          .onStreamedFrameAvailable(cameraId)
+          .listen((CameraImageData imageData) {});
+      subscription.cancel();
+
+      // Assert
+      expect(channel.log, <Matcher>[
+        isMethodCall('startImageStream', arguments: null),
+        isMethodCall('stopImageStream', arguments: null),
+      ]);
+    });
+  });
+}
diff --git a/packages/camera/camera_avfoundation/test/method_channel_mock.dart b/packages/camera/camera_avfoundation/test/method_channel_mock.dart
new file mode 100644
index 0000000..413c106
--- /dev/null
+++ b/packages/camera/camera_avfoundation/test/method_channel_mock.dart
@@ -0,0 +1,39 @@
+// Copyright 2013 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import 'package:flutter/services.dart';
+import 'package:flutter_test/flutter_test.dart';
+
+class MethodChannelMock {
+  MethodChannelMock({
+    required String channelName,
+    this.delay,
+    required this.methods,
+  }) : methodChannel = MethodChannel(channelName) {
+    methodChannel.setMockMethodCallHandler(_handler);
+  }
+
+  final Duration? delay;
+  final MethodChannel methodChannel;
+  final Map<String, dynamic> methods;
+  final List<MethodCall> log = <MethodCall>[];
+
+  Future<dynamic> _handler(MethodCall methodCall) async {
+    log.add(methodCall);
+
+    if (!methods.containsKey(methodCall.method)) {
+      throw MissingPluginException('No implementation found for method '
+          '${methodCall.method} on channel ${methodChannel.name}');
+    }
+
+    return Future<dynamic>.delayed(delay ?? Duration.zero, () {
+      final dynamic result = methods[methodCall.method];
+      if (result is Exception) {
+        throw result;
+      }
+
+      return Future<dynamic>.value(result);
+    });
+  }
+}
diff --git a/packages/camera/camera_avfoundation/test/type_conversion_test.dart b/packages/camera/camera_avfoundation/test/type_conversion_test.dart
new file mode 100644
index 0000000..282f4ae
--- /dev/null
+++ b/packages/camera/camera_avfoundation/test/type_conversion_test.dart
@@ -0,0 +1,60 @@
+// Copyright 2013 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+// TODO(a14n): remove this import once Flutter 3.1 or later reaches stable (including flutter/flutter#104231)
+// ignore: unnecessary_import
+import 'dart:typed_data';
+
+import 'package:camera_avfoundation/src/type_conversion.dart';
+import 'package:camera_platform_interface/camera_platform_interface.dart';
+import 'package:flutter_test/flutter_test.dart';
+
+void main() {
+  test('CameraImageData can be created', () {
+    final CameraImageData cameraImage =
+        cameraImageFromPlatformData(<dynamic, dynamic>{
+      'format': 1,
+      'height': 1,
+      'width': 4,
+      'lensAperture': 1.8,
+      'sensorExposureTime': 9991324,
+      'sensorSensitivity': 92.0,
+      'planes': <dynamic>[
+        <dynamic, dynamic>{
+          'bytes': Uint8List.fromList(<int>[1, 2, 3, 4]),
+          'bytesPerPixel': 1,
+          'bytesPerRow': 4,
+          'height': 1,
+          'width': 4
+        }
+      ]
+    });
+    expect(cameraImage.height, 1);
+    expect(cameraImage.width, 4);
+    expect(cameraImage.format.group, ImageFormatGroup.unknown);
+    expect(cameraImage.planes.length, 1);
+  });
+
+  test('CameraImageData has ImageFormatGroup.yuv420', () {
+    final CameraImageData cameraImage =
+        cameraImageFromPlatformData(<dynamic, dynamic>{
+      'format': 875704438,
+      'height': 1,
+      'width': 4,
+      'lensAperture': 1.8,
+      'sensorExposureTime': 9991324,
+      'sensorSensitivity': 92.0,
+      'planes': <dynamic>[
+        <dynamic, dynamic>{
+          'bytes': Uint8List.fromList(<int>[1, 2, 3, 4]),
+          'bytesPerPixel': 1,
+          'bytesPerRow': 4,
+          'height': 1,
+          'width': 4
+        }
+      ]
+    });
+    expect(cameraImage.format.group, ImageFormatGroup.yuv420);
+  });
+}
diff --git a/packages/camera/camera_avfoundation/test/utils_test.dart b/packages/camera/camera_avfoundation/test/utils_test.dart
new file mode 100644
index 0000000..bd28abb
--- /dev/null
+++ b/packages/camera/camera_avfoundation/test/utils_test.dart
@@ -0,0 +1,60 @@
+// Copyright 2013 The Flutter Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+import 'package:camera_avfoundation/src/utils.dart';
+import 'package:camera_platform_interface/camera_platform_interface.dart';
+import 'package:flutter/services.dart';
+import 'package:flutter_test/flutter_test.dart';
+
+void main() {
+  group('Utility methods', () {
+    test(
+        'Should return CameraLensDirection when valid value is supplied when parsing camera lens direction',
+        () {
+      expect(
+        parseCameraLensDirection('back'),
+        CameraLensDirection.back,
+      );
+      expect(
+        parseCameraLensDirection('front'),
+        CameraLensDirection.front,
+      );
+      expect(
+        parseCameraLensDirection('external'),
+        CameraLensDirection.external,
+      );
+    });
+
+    test(
+        'Should throw ArgumentException when invalid value is supplied when parsing camera lens direction',
+        () {
+      expect(
+        () => parseCameraLensDirection('test'),
+        throwsA(isArgumentError),
+      );
+    });
+
+    test('serializeDeviceOrientation() should serialize correctly', () {
+      expect(serializeDeviceOrientation(DeviceOrientation.portraitUp),
+          'portraitUp');
+      expect(serializeDeviceOrientation(DeviceOrientation.portraitDown),
+          'portraitDown');
+      expect(serializeDeviceOrientation(DeviceOrientation.landscapeRight),
+          'landscapeRight');
+      expect(serializeDeviceOrientation(DeviceOrientation.landscapeLeft),
+          'landscapeLeft');
+    });
+
+    test('deserializeDeviceOrientation() should deserialize correctly', () {
+      expect(deserializeDeviceOrientation('portraitUp'),
+          DeviceOrientation.portraitUp);
+      expect(deserializeDeviceOrientation('portraitDown'),
+          DeviceOrientation.portraitDown);
+      expect(deserializeDeviceOrientation('landscapeRight'),
+          DeviceOrientation.landscapeRight);
+      expect(deserializeDeviceOrientation('landscapeLeft'),
+          DeviceOrientation.landscapeLeft);
+    });
+  });
+}