Código específico de plataforma Flutter

Esta sección explica cómo usar los canales de plataforma (Platform Channels) para llamar código de plataforma nativa en Flutter.


Descripción general de los canales de plataforma

Los canales de plataforma permiten que el código Dart se comunique con la plataforma nativa (iOS/Android).

TipoDescripción
MethodChannelCanal de métodos, utilizado para llamar métodos de plataforma
EventChannelCanal de eventos, utilizado para datos en streaming

Llamada desde el lado Dart

Ejemplo: uso de MethodChannel

import 'package:flutter/services.dart';

// Definir el canal
class PlatformChannel {
  static const MethodChannel _channel = MethodChannel('my_app/channel');

  // Llamar al método nativo - obtener el nivel de batería
  static Future<int> getBatteryLevel() async {
    try {
      final int batteryLevel = await _channel.invokeMethod('getBatteryLevel');
      return batteryLevel;
    } on PlatformException catch (e) {
      print('Error al obtener el nivel de batería: ${e.message}');
      return -1;
    }
  }

  // Llamar al método nativo - mostrar Toast
  static Future<void> showToast(String message) async {
    try {
      await _channel.invokeMethod('showToast', {'message': message});
    } on PlatformException catch (e) {
      print('Error al mostrar Toast: ${e.message}');
    }
  }

  // Llamar al método nativo - obtener información del dispositivo
  static Future<Map<String, dynamic>> getDeviceInfo() async {
    try {
      final result = await _channel.invokeMapMethod('getDeviceInfo');
      return result ?? {};
    } on PlatformException catch (e) {
      print('Error al obtener la información del dispositivo: ${e.message}');
      return {};
    }
  }
}

// Ejemplo de uso
class MyWidget extends StatelessWidget {
  const MyWidget({super.key});

  @override
  Widget build(BuildContext context) {
    return ElevatedButton(
      onPressed: () async {
        final battery = await PlatformChannel.getBatteryLevel();
        print('Nivel de batería: $battery%');
      },
      child: const Text('Obtener nivel de batería'),
    );
  }
}

Implementación en Android (Kotlin)

Ejemplo: código de Android

// MainActivity.kt
package com.example.my_app

import android.os.Bundle
import io.flutter.embedding.android.FlutterActivity
import io.flutter.embedding.engine.FlutterEngine
import io.flutter.plugin.common.MethodChannel

class MainActivity : FlutterActivity() {
    private val CHANNEL = "my_app/channel"

    override fun configureFlutterEngine(flutterEngine: FlutterEngine) {
        super.configureFlutterEngine(flutterEngine)

        MethodChannel(flutterEngine.dartExecutor.binaryMessenger, CHANNEL)
            .setMethodCallHandler { call, result ->
                when (call.method) {
                    "getBatteryLevel" -> {
                        val batteryLevel = getBatteryLevel()
                        if (batteryLevel != -1) {
                            result.success(batteryLevel)
                        } else {
result.error("UNAVAILABLE", "No se pudo obtener el nivel de batería", null)
                        }
                    }
                    "showToast" -> {
                        val message = call.argument<String>("message")
                        showToast(message!!)
                        result.success(null)
                    }
                    else -> {
                        result.notImplemented()
                    }
                }
            }
    }

    private fun getBatteryLevel(): Int {
        return try {
            val batteryManager = getSystemService(BATTERY_SERVICE) as BatteryManager
            batteryManager.getIntProperty(BatteryManager.BATTERY_PROPERTY_CAPACITY)
        } catch (e: Exception) {
            -1
        }
    }

    private fun showToast(message: String) {
        android.widget.Toast.makeText(this, message, android.widget.Toast.LENGTH_SHORT).show()
    }
}

Implementación en iOS (Swift)

Ejemplo: código de iOS

// AppDelegate.swift
import Flutter
import UIKit

@UIApplicationMain
@objc class AppDelegate: FlutterAppDelegate {
    private let CHANNEL = "my_app/channel"

    override func application(
        _ application: UIApplication,
        didFinishLaunchingWithOptions launchOptions: [UIApplication.LaunchOptionsKey: Any]?
    ) -> Bool {
        let controller = window?.rootViewController as! FlutterViewController

        let channel = FlutterMethodChannel(
            name: CHANNEL,
            binaryMessenger: controller.binaryMessenger
        )

        channel.setMethodCallHandler { (call: FlutterMethodCall, result: @escaping FlutterResult) in
            switch call.method {
            case "getBatteryLevel":
                self.getBatteryLevel(result: result)
            case "showToast":
                if let args = call.arguments as? [String: Any],
                   let message = args["message"] as? String {
                    self.showToast(message: message)
                    result(nil)
                }
            default:
                result(FlutterMethodNotImplemented)
            }
        }

        return super.application(application, didFinishLaunchingWithOptions: launchOptions)
    }

    private func getBatteryLevel(result: @escaping FlutterResult) {
        UIDevice.current.isBatteryMonitoringEnabled = true
        let batteryLevel = UIDevice.current.batteryLevel

        if batteryLevel < 0 {
result(FlutterError(code: "UNAVAILABLE", message: "No se pudo obtener el nivel de batería", details: nil))
        } else {
            result(Int(batteryLevel * 100))
        }
    }

    private func showToast(message: String) {
        let alert = UIAlertController(title: nil, message: message, preferredStyle: .alert)
        present(alert, animated: true)
        DispatchQueue.main.asyncAfter(deadline: .now() + 1.5) {
            alert.dismiss(animated: true)
        }
    }
}

Los canales de plataforma son el método principal de comunicación entre Flutter y el código nativo, comúnmente utilizados para llamar APIs del sistema, funciones de hardware o usar SDK nativos de terceros.

Otras extensiones