Flutter特效--給控件鑽石般的微光詳情 - flutter,Android,java,ide,Html,CSS,前端開發代碼匠人之心博客

在許多應用場景中，手電筒功能不僅需要開關燈，還希望可以調節亮度。Flutter 本身沒有提供直接操作手電筒的 API，但我們可以通過 Platform Channel 調用 Android/iOS 原生接口，實現開關燈和亮度控制。

本文我們將詳細講解實現思路和方法，讓讀者可以自己寫出一個類似的插件

功能需求

開/關手電筒
調節亮度（0~1 的百分比）
獲取當前亮度和手電狀態
獲取最大亮度等級（Android 13+ 有真實等級，iOS 默認 100）
自動開關燈邏輯：亮度 > 0 自動開燈，亮度 = 0 自動關燈
跨平台支持：Android 13+ 支持亮度，舊版本 Android 僅開燈；iOS 支持 0~1 小數亮度

實現原理

Android 原理實現

Android 使用 Camera2 API 控制手電筒：

開關手電筒

cameraManager.setTorchMode(cameraId, true); // 開燈
cameraManager.setTorchMode(cameraId, false); // 關燈

調節亮度（Android 13+）

cameraManager.turnOnTorchWithStrengthLevel(cameraId, torchLevel);

iOS原理實現

iOS 使用 AVCaptureDevice 控制攝像頭 LED：

開關手電筒

FlashlightBrightness.instance.flashOn();          // 開燈
FlashlightBrightness.instance.flashOff();         // 關燈

調節亮度

FlashlightBrightness.instance.setBrightness(0.5); // 50%亮度

實現步驟

創建一個Flutter 插件

flutter create --template=plugin --platforms=android,ios -a java flashlight_brightness

Flutter插件lib配置

1.文件預覽

lib/
├─ flashlight_brightness.dart              # 插件主入口，提供給用户的 API
├─ flashlight_brightness_method_channel.dart  # MethodChannel 平台實現（Android/iOS 調用）
└─ flashlight_brightness_platform_interface.dart # 抽象平台接口，定義公共方法

作用：

flashlight_brightness.dart：Flutter 層調用統一接口，無需關心平台差異。
flashlight_brightness_platform_interface.dart：定義接口，支持未來可能增加其他平台（web、macOS 等）。
flashlight_brightness_method_channel.dart：通過 MethodChannel 調用 Android/iOS 原生代碼，實現接口。

2.創建平台接口

在 lib/flashlight_brightness_platform_interface.dart：

import 'package:plugin_platform_interface/plugin_platform_interface.dart';
 
import 'flashlight_brightness_method_channel.dart';
 
/// @class FlashlightBrightnessPlatform
/// @description 定義插件接口，支持多平台實現
abstract class FlashlightBrightnessPlatform extends PlatformInterface {
  FlashlightBrightnessPlatform() : super(token: _token);
 
  static final Object _token = Object();
 
  static FlashlightBrightnessPlatform _instance =
      MethodChannelFlashlightBrightness();
 
  /// 默認實例，MethodChannel 實現
  static FlashlightBrightnessPlatform get instance => _instance;
 
  static set instance(FlashlightBrightnessPlatform instance) {
    PlatformInterface.verifyToken(instance, _token);
    _instance = instance;
  }
 
  /// 獲取 Android/iOS 版本（字符串）
  Future<String?> getPlatformVersion() {
    throw UnimplementedError('getPlatformVersion() has not been implemented.');
  }
 
  /// 初始化插件
  Future<void> init() {
    throw UnimplementedError('init() has not been implemented.');
  }
 
  /// 查詢手電筒是否點亮
  Future<bool?> isTorched() {
    throw UnimplementedError('isTorched() has not been implemented.');
  }
 
  /// 打開手電筒
  Future<void> flashOn() {
    throw UnimplementedError('flashOn() has not been implemented.');
  }
 
  /// 關閉手電筒
  Future<void> flashOff() {
    throw UnimplementedError('flashOff() has not been implemented.');
  }
 
  /// 獲取亮度百分比 0~1
  Future<double?> getBrightness() {
    throw UnimplementedError('getBrightness() has not been implemented.');
  }
 
  /// 設置亮度百分比 0~1
  Future<void> setBrightness(double value) {
    throw UnimplementedError('setBrightness() has not been implemented.');
  }
 
  /// 獲取設備最大等級
  Future<int?> getMaxLevel() {
    throw UnimplementedError('getMaxLevel() has not been implemented.');
  }
 
  /// 銷燬插件
  Future<void> dispose() {
    throw UnimplementedError('dispose() has not been implemented.');
  }
}

説明：

所有方法都是抽象的，必須由具體平台實現。
_instance 默認指向 MethodChannel 實現。

3.創建 MethodChannel 實現

在 lib/flashlight_brightness_method_channel.dart：

import 'package:flutter/services.dart';
import 'flashlight_brightness_platform_interface.dart';
 
/// @class MethodChannelFlashlightBrightness
/// @description 通過 MethodChannel 與原生通信實現 FlashlightBrightnessPlatform
class MethodChannelFlashlightBrightness extends FlashlightBrightnessPlatform {
  final MethodChannel _channel = const MethodChannel('flashlight_brightness');
 
  @override
  Future<String?> getPlatformVersion() async {
    return await _channel.invokeMethod('getPlatformVersion');
  }
 
  @override
  Future<void> init() async {
    await _channel.invokeMethod('init');
  }
 
  @override
  Future<bool?> isTorched() async {
    return await _channel.invokeMethod('isTorched');
  }
 
  @override
  Future<void> flashOn() async {
    await _channel.invokeMethod('flashOn');
  }
 
  @override
  Future<void> flashOff() async {
    await _channel.invokeMethod('flashOff');
  }
 
  @override
  Future<double?> getBrightness() async {
    return await _channel.invokeMethod('getPercent');
  }
 
  @override
  Future<void> setBrightness(double value) async {
    if (value < 0) value = 0;
    if (value > 1) value = 1;
    await _channel.invokeMethod('setPercent', value);
  }
 
  @override
  Future<int?> getMaxLevel() async {
    return await _channel.invokeMethod('maxLevel');
  }
 
  @override
  Future<void> dispose() async {
    await _channel.invokeMethod('dispose');
  }
}

説明：

使用 MethodChannel 調用原生 Android/iOS 方法。
參數和返回值都做了簡單映射（比如亮度百分比 0~1）。

4.創建插件主入口

在 lib/flashlight_brightness.dart：

import 'flashlight_brightness_platform_interface.dart';
 
/// @class FlashlightBrightness
/// @description Flutter 端插件封裝，提供統一方法給業務層調用
class FlashlightBrightness {
  FlashlightBrightness._privateConstructor() {
    _platform.init(); // 自動初始化
  }
 
  static final FlashlightBrightness instance =
      FlashlightBrightness._privateConstructor(); // 單例模式
 
  final FlashlightBrightnessPlatform _platform =
      FlashlightBrightnessPlatform.instance;
 
  /// 獲取系統版本
  Future<String?> getPlatformVersion() => _platform.getPlatformVersion();
 
  /// 初始化插件
  Future<void> init() => _platform.init();
 
  /// 手電筒是否點亮
  Future<bool?> isTorched() => _platform.isTorched();
 
  /// 打開手電筒
  Future<void> flashOn() => _platform.flashOn();
 
  /// 關閉手電筒
  Future<void> flashOff() => _platform.flashOff();
 
  /// 獲取亮度百分比 0~1
  Future<double?> getBrightness() => _platform.getBrightness();
 
  /// 設置亮度百分比 0~1
  Future<void> setBrightness(double value) => _platform.setBrightness(value);
 
  /// 獲取設備最大等級
  Future<int?> getMaxLevel() => _platform.getMaxLevel();
 
  /// 銷燬插件
  Future<void> dispose() => _platform.dispose();
}

説明：

提供統一的 Flutter API，隱藏平台差異。
用户只需要導入 flashlight_brightness.dart 即可使用插件功能。
使用單例模式 instance，確保全局只有一個插件實例。

Android 手電筒亮度控制實現方式

1.文件預覽

android/src/main/java/com/example/flashlight_brightness/
├─ FlashlightBrightnessConstants.java     # 方法名與關鍵常量
├─ FlashlightBrightnessController.java    # 具體的手電筒實現邏輯
└─ FlashlightBrightnessPlugin.java        # Flutter 插件入口，MethodChannel 分發

作用：

FlashlightBrightnessConstants.java：規範接口，集中管理 MethodChannel 的方法名
FlashlightBrightnessController.java：手電筒控制邏輯，不影響 MethodChannel
FlashlightBrightnessPlugin.java：MethodChannel 入口，收 Flutter 調用 → 分發給 Controller → 返回結果給 Flutter

2.定義方法變量

在android/src/main/java/com/example/flashlight_brightness/FlashlightBrightnessConstants.java:

package com.example.flashlight_brightness;
 
/**
 * @class FlashlightBrightnessConstants
 * @description 定義插件中使用的所有方法名常量，統一管理 Flutter 與 Android 端通信的 key
 * @features
 *   - 提供插件方法常量
 *   - 避免字符串硬編碼
 *   - 提供亮度控制相關常量
 */
public final class FlashlightBrightnessConstants {
 
  private FlashlightBrightnessConstants() {} // 私有構造，防止實例化
 
  // 獲取 Android 系統版本
  public static final String VERSION = "getPlatformVersion";
 
  // 初始化 FlashlightBrightnessController
  public static final String INIT = "init";
 
  // 開燈 / 關燈
  public static final String FLASH_ON = "flashOn";
  public static final String FLASH_OFF = "flashOff";
 
  // 獲取 / 設置亮度百分比（0~1）
  public static final String SET_PERCENT = "setPercent";
  public static final String GET_PERCENT = "getPercent";
 
  // 獲取設備支持的最大 torch level
  public static final String MAX_LEVEL = "maxLevel";
 
  // 查詢手電筒是否已點亮
  public static final String IS_TORCHED = "isTorched";
 
  // 銷燬 FlashlightBrightnessController
  public static final String DISPOSE = "dispose";
}

3.配置手電筒配置邏輯

在android/src/main/java/com/example/flashlight_brightness/FlashlightBrightnessController.java:

主要功能

獲取亮度等級

Android 13+：獲取真實最大等級
Android 6~12：等級為1

獲取手電筒亮度

當前的亮度等級/最大亮度等級

設置手電筒亮度

設置值範圍0~1。

0：關閉手電筒

亮度值*最大亮度等級並取整

package com.example.flashlight_brightness;
 
import android.annotation.TargetApi;
import android.content.Context;
import android.hardware.camera2.CameraCharacteristics;
import android.hardware.camera2.CameraManager;
import android.os.Build;
import android.util.Log;
 
/**
 * @class FlashlightBrightnessController
 * @description Android 手電筒控制類，支持亮度控制
 * @features
 *           - 獲取 / 設置亮度（百分比 0~1）
 *           - 打開 / 關閉手電筒
 *           - 獲取最大亮度等級
 *           - Android 13+ 支持多級亮度控制
 *           - Android 6~12 基礎開關手電筒兼容
 */
@TargetApi(Build.VERSION_CODES.LOLLIPOP)
public class FlashlightBrightnessController {
 
  private final CameraManager cameraManager;
  private String cameraId;
 
  private boolean isTorched = false; // 當前是否點亮
  private int torchLevel = 1; // 當前亮度等級（整數）
  private int maxLevel = 1; // 設備支持的最大亮度等級
 
  /**
   * Torch 回調監聽器
   * 用於監聽亮度和狀態變化
   */
  private final CameraManager.TorchCallback torchCallback = new CameraManager.TorchCallback() {
    @Override
    public void onTorchStrengthLevelChanged(String id, int newStrengthLevel) {
      torchLevel = newStrengthLevel;
    }
 
    @Override
    public void onTorchModeChanged(String id, boolean enabled) {
      isTorched = enabled;
    }
  };
 
  /**
   * 構造函數
   *
   * @param context 應用上下文
   * @description 初始化 CameraManager 和 TorchCallback，獲取後置攝像頭 ID 和最大亮度
   */
  public FlashlightBrightnessController(Context context) {
    cameraManager = (CameraManager) context.getSystemService(Context.CAMERA_SERVICE);
 
    try {
      for (String id : cameraManager.getCameraIdList()) {
        CameraCharacteristics cs = cameraManager.getCameraCharacteristics(id);
        Integer lens = cs.get(CameraCharacteristics.LENS_FACING);
        if (lens != null && lens == CameraCharacteristics.LENS_FACING_BACK) {
          cameraId = id;
 
          // Android 13+ 獲取真實最大等級
          if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
            maxLevel = cameraManager.getTorchStrengthLevel(cameraId);
          } else {
            maxLevel = 1; // Android 6~12 無多級亮度
          }
          break;
        }
      }
 
      // 註冊回調監聽
      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
        cameraManager.registerTorchCallback(torchCallback, null);
      }
 
    } catch (Exception e) {
      Log.e("FlashlightBrightnessController", "Init failed", e);
    }
  }
 
  /**
   * @return 當前手電筒是否點亮
   */
  public boolean isTorched() {
    return isTorched;
  }
 
  /**
   * @return 設備最大亮度等級
   */
  public int getMaxTorchLevel() {
    return maxLevel;
  }
 
  /**
   * @return 當前亮度百分比（0~1）
   */
  public double getTorchLevelPercent() {
    if (maxLevel <= 1)
      return isTorched ? 1.0 : 0.0;
    return torchLevel / (double) maxLevel;
  }
 
  /**
   * 設置亮度百分比並自動開燈
   *
   * @param percent 亮度百分比，範圍 0~1
   */
  public void setTorchLevelPercent(double percent) {
    // if (percent < 0.0) percent = 0.0;
    // if (percent > 1.0) percent = 1.0;
    percent = Math.max(0, Math.min(percent, 1)); // 限制在 0~1
    if (percent == 0) {
      // 如果亮度為 0，直接關燈
      flashOff();
      torchLevel = 0;
      return;
    }
 
    int level = (int) Math.round(percent * maxLevel);
    if (level < 1)
      level = 1;
 
    torchLevel = level;
 
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
      try {
        cameraManager.turnOnTorchWithStrengthLevel(cameraId, torchLevel);
        isTorched = true;
      } catch (Exception e) {
        Log.e("FlashlightBrightnessController", "setTorchLevelPercent failed", e);
      }
    } else {
      flashOn(); // Android 6~12 只能開燈，不支持亮度
    }
  }
 
  /**
   * 開燈
   */
  public void flashOn() {
    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M)
      return;
 
    if (!isTorched) {
      try {
        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU && maxLevel > 1) {
          cameraManager.turnOnTorchWithStrengthLevel(cameraId, torchLevel);
        } else {
          cameraManager.setTorchMode(cameraId, true);
        }
        isTorched = true;
      } catch (Exception e) {
        Log.e("FlashlightBrightnessController", "flashOn failed", e);
      }
    }
  }
 
  /**
   * 關燈
   */
  public void flashOff() {
    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M && isTorched) {
      try {
        cameraManager.setTorchMode(cameraId, false);
        isTorched = false;
      } catch (Exception e) {
        Log.e("FlashlightBrightnessController", "flashOff failed", e);
      }
    }
  }
 
  /**
   * 註銷回調並關閉手電筒
   */
  public void dispose() {
    try {
      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
        cameraManager.unregisterTorchCallback(torchCallback);
      }
    } catch (Exception ignored) {
    }
    flashOff();
  }
}

4.Flutter ↔ Android 通信橋樑配置

在android/src/main/java/com/example/flashlight_brightness/FlashlightBrightnessPlugin.java:

主要作用：

Flutter ↔ Android 通信橋樑
分發方法到 Controller

package com.example.flashlight_brightness;
 
import android.content.Context;
import android.os.Build;
 
import androidx.annotation.NonNull;
 
import io.flutter.embedding.engine.plugins.FlutterPlugin;
import io.flutter.plugin.common.MethodCall;
import io.flutter.plugin.common.MethodChannel;
 
/**
 * @class FlashlightBrightnessPlugin
 * @description Flutter 插件入口，實現 MethodChannel 與 Android 原生通信
 * @features
 *           - 註冊 MethodChannel
 *           - 分發 Flutter 調用到 FlashlightBrightnessController
 *           - 提供百分比亮度接口
 *           - 提供最大亮度等級查詢
 *           - 管理生命週期（初始化、銷燬）
 */
public class FlashlightBrightnessPlugin implements FlutterPlugin, MethodChannel.MethodCallHandler {
 
  private MethodChannel channel;
  private Context context;
  private FlashlightBrightnessController flashlightController;
 
  @Override
  public void onAttachedToEngine(@NonNull FlutterPluginBinding binding) {
    channel = new MethodChannel(binding.getBinaryMessenger(), "flashlight_brightness");
    channel.setMethodCallHandler(this);
    context = binding.getApplicationContext();
    // 自動初始化
    ensureController();
  }
 
  @Override
  public void onMethodCall(@NonNull MethodCall call, @NonNull MethodChannel.Result result) {
 
    switch (call.method) {
 
      case FlashlightBrightnessConstants.VERSION:
        result.success("Android " + Build.VERSION.RELEASE);
        break;
 
      case FlashlightBrightnessConstants.INIT:
        if (flashlightController == null) {
          flashlightController = new FlashlightBrightnessController(context);
        }
        result.success(true);
        break;
 
      case FlashlightBrightnessConstants.IS_TORCHED:
        // 自動初始化
        ensureController();
        result.success(flashlightController.isTorched());
        break;
 
      case FlashlightBrightnessConstants.FLASH_ON:
        ensureController();
        flashlightController.flashOn();
        result.success(true);
        break;
 
      case FlashlightBrightnessConstants.FLASH_OFF:
        ensureController();
        flashlightController.flashOff();
        result.success(true);
        break;
 
      case FlashlightBrightnessConstants.GET_PERCENT:
        ensureController();
        result.success(flashlightController.getTorchLevelPercent());
        break;
 
      case FlashlightBrightnessConstants.SET_PERCENT:
        ensureController();
        Object arg = call.arguments;
        double percent = 1.0;
        if (arg instanceof Number) {
          percent = ((Number) arg).doubleValue();
        }
        flashlightController.setTorchLevelPercent(percent);
        result.success(true);
        break;
 
      case FlashlightBrightnessConstants.MAX_LEVEL:
        ensureController();
        result.success(flashlightController.getMaxTorchLevel());
        break;
 
      case FlashlightBrightnessConstants.DISPOSE:
        if (flashlightController != null) {
          flashlightController.dispose();
          flashlightController = null;
        }
        result.success(true);
        break;
 
      default:
        result.notImplemented();
    }
  }
 
  /**
   * 確保 flashlightController 已初始化
   */
  private void ensureController() {
    if (flashlightController == null) {
      flashlightController = new FlashlightBrightnessController(context);
    }
  }
 
  @Override
  public void onDetachedFromEngine(@NonNull FlutterPluginBinding binding) {
    channel.setMethodCallHandler(null);
  }
}

至此，Android配置就完成了

iOS 手電筒亮度控制實現方式

1.文件預覽

flashlight_brightness/
 └─ ios/
     └─ Classes/
         ├─ FlashlightBrightnessPlugin.swift        // Flutter 插件入口
         ├─ FlashlightBrightnessController.swift     // 手電筒控制核心邏輯
         └─ FlashlightBrightnessConstants.swift      // 方法名常量（與 Android 對應）

作用：

FlashlightBrightnessConstants.swift ：負責統一 iOS MethodChannel 方法名
FlashlightBrightnessController.swift：控制 iOS 手電筒亮度核心邏輯
FlashlightBrightnessPlugin.swift：插件入口：接收 Flutter 調用 → 分發給 Controller

2.定義方法變量

在ios/Classes/FlashlightBrightnessConstants.swift

//
//  FlashlightBrightnessConstants.swift
//  flashlight_brightness
//
//  定義 Flutter 與 iOS 通信的常量方法名
//
 
import Foundation
 
enum FlashlightBrightnessConstants {
    static let version = "getPlatformVersion"
    static let initPlugin = "init"
     
    static let flashOn = "flashOn"
    static let flashOff = "flashOff"
     
    static let setPercent = "setPercent"
    static let getPercent = "getPercent"
     
    static let maxLevel = "maxLevel"
    static let isTorched = "isTorched"
     
    static let dispose = "dispose"
}

3.配置手電筒配置邏輯

在ios/Classes/FlashlightBrightnessController.swift

//
//  FlashlightBrightnessController.swift
//  flashlight_brightness
//
//  封裝手電筒控制邏輯，支持開關和亮度控制
//
 
import AVFoundation
import UIKit
 
class FlashlightBrightnessController {
     
    private let device = AVCaptureDevice.default(for: .video)
    private var currentBrightness: Float = 1.0
     
    /// 判斷設備是否有手電筒
    var hasTorch: Bool {
        return device?.hasTorch ?? false
    }
     
    /// 當前是否點亮
    var isTorched: Bool {
        guard let device = device else { return false }
        return device.isTorchActive
    }
     
    /// 最大亮度等級（iOS 恆定為 1.0）
    var maxLevel: Int {
        return 100
    }
     
    /// 獲取當前亮度百分比 0~1
    var brightness: Float {
        return currentBrightness
    }
     
    /// 設置亮度百分比 0~1 並自動開燈
    func setBrightness(_ percent: Float) {
        guard hasTorch, let device = device else { return }
        let level = min(max(percent, 0.0), 1.0)
        if level == 0 {
            // 亮度為0，自動關燈
            flashOff()
            currentBrightness = 0
            return
        }
        currentBrightness = level
         
        do {
            try device.lockForConfiguration()
            try device.setTorchModeOn(level: level)
            device.unlockForConfiguration()
        } catch {
            print("Failed to set torch brightness: \(error)")
        }
    }
     
    /// 打開手電筒（使用當前亮度）
    func flashOn() {
        guard hasTorch, let device = device else { return }
        do {
            try device.lockForConfiguration()
            if !device.isTorchActive {
                try device.setTorchModeOn(level: currentBrightness)
            }
            device.unlockForConfiguration()
        } catch {
            print("Failed to turn on torch: \(error)")
        }
    }
     
    /// 關閉手電筒
    func flashOff() {
        guard hasTorch, let device = device else { return }
        do {
            try device.lockForConfiguration()
            device.torchMode = .off
            device.unlockForConfiguration()
        } catch {
            print("Failed to turn off torch: \(error)")
        }
    }
     
    /// 銷燬控制器（iOS 不需要額外操作）
    func dispose() {
        flashOff()
    }

4.接收 Flutter 調用 → 分發給 Controller 配置

在ios/Classes/FlashlightBrightnessPlugin.swift

//
//  FlashlightBrightnessPlugin.swift
//  flashlight_brightness
//
//  Flutter 插件入口，註冊 MethodChannel 並分發方法
//
 
import Flutter
import UIKit
 
public class FlashlightBrightnessPlugin: NSObject, FlutterPlugin {
     
    /// 控制器實例，可變變量
    private var controller: FlashlightBrightnessController?
     
    public static func register(with registrar: FlutterPluginRegistrar) {
        let channel = FlutterMethodChannel(name: "flashlight_brightness", binaryMessenger: registrar.messenger())
        let instance = FlashlightBrightnessPlugin()
        registrar.addMethodCallDelegate(instance, channel: channel)
    }
     
    /// 獲取控制器，如果未創建則自動初始化
    private func getController() -> FlashlightBrightnessController {
        if controller == nil {
            controller = FlashlightBrightnessController() // 自動初始化
        }
        return controller!
    }
     
    public func handle(_ call: FlutterMethodCall, result: @escaping FlutterResult) {
        // 使用類屬性 controller，不再聲明 let
        switch call.method {
             
        case FlashlightBrightnessConstants.version:
            result("iOS \(UIDevice.current.systemVersion)")
             
        case FlashlightBrightnessConstants.initPlugin:
            // 已經自動初始化，無需重新賦值
            _ = getController()
            result(true)
             
        case FlashlightBrightnessConstants.isTorched:
            result(controller?.isTorched ?? false)
             
        case FlashlightBrightnessConstants.flashOn:
            getController().flashOn()
            result(true)
             
        case FlashlightBrightnessConstants.flashOff:
            getController().flashOff()
            result(true)
             
        case FlashlightBrightnessConstants.getPercent:
            result(getController().brightness)
             
        case FlashlightBrightnessConstants.setPercent:
            if let arg = call.arguments as? Double {
                getController().setBrightness(Float(arg)) // 自動開燈或關燈
            }
            result(true)
             
        case FlashlightBrightnessConstants.maxLevel:
            result(getController().maxLevel)
             
        case FlashlightBrightnessConstants.dispose:
            controller?.dispose()
            controller = nil
            result(true)
             
        default:
            result(FlutterMethodNotImplemented)
        }
    }
}

至此，iOS配置也就完成了

使用方法

創建單例實例

import 'package:flashlight_brightness/flashlight_brightness.dart';
final flashlight = FlashlightBrightness.instance;

開啓/關閉手電筒

await flashlight.flashOn();  // 開燈
await flashlight.flashOff(); // 關燈

設置亮度 (0.0 - 1.0)

// 設置亮度為50%，如果手電未開則會自動開燈
await flashlight.setBrightness(0.5);
 
// 設置亮度為0，會自動關閉手電筒
await flashlight.setBrightness(0.0);

獲取當前亮度

double? brightness = await flashlight.getBrightness(); // 返回0.0~1.0

判斷手電筒是否開啓

bool? isOn = await flashlight.isTorched();

獲取最大亮度等級

int? maxLevel = await flashlight.getMaxLevel(); // Android: 5，iOS: 100

釋放資源（可選）

await flashlight.dispose();

本文章為轉載內容，我們尊重原作者對文章享有的著作權。如有內容錯誤或侵權問題，歡迎原作者聯繫我們進行內容更正或刪除文章。

博客 / 詳情