Práctica de desarrollo de Flutter: MethodChannel realiza una comunicación bidireccional entre flutter y Android nativo

Práctica de desarrollo de Flutter: MethodChannel realiza una comunicación bidireccional entre flutter y Android nativo

En el desarrollo reciente, Android nativo y flutter necesitan comunicarse, y el MethodChannel utilizado aquí

1. Canal de método

MethodChannel: se utiliza para pasar llamadas a métodos (invocación de método).
Los extremos del cliente y del host de un canal están conectados a través del nombre del canal pasado al constructor del canal.

Todos los nombres de canales utilizados en una aplicación deben ser
nombres de canales de prefijo únicos con un prefijo de dominio único, por ejemplo: samples.flutter.dev/battery

Sitio web oficial https://flutter.cn/docs/development/platform-integration/platform-channels

https://blog.csdn.net/gloryFlow/article/details/132218837

2. Implementar MethodChannel en el lado del aleteo

Necesitamos crear un canal llamado "samples.flutter.dev/test".
Realizado por invokeNativeMethod y setMethodCallHandler

• invokeNativeMethod: llama al código en el lado de Android
• setMethodCallHandler: configura la devolución de llamada del método para recibir parámetros en el lado de Android

El código se muestra a continuación.

import 'package:flutter/services.dart';

//MethodChannel
const methodChannel = const MethodChannel('samples.flutter.dev/test');

class FlutterMethodChannel {
    
    
  /*
 * MethodChannel
 * 在方法通道上调用方法invokeMethod
 * methodName 方法名称
 * params 发送给原生的参数
 * return数据 原生发给Flutter的参数
 */
  static Future<Map> invokeNativeMethod(String methodName,
      [Map? params]) async {
    
    
    var res;
    try {
    
    
      if (params == null) {
    
    
        res = await methodChannel.invokeMethod('$methodName');
      } else {
    
    
        res = await methodChannel.invokeMethod('$methodName', params);
      }
    } catch (e) {
    
    
      res = {
    
    'Failed': e.toString()};
    }
    return res;
  }

  /*
 * MethodChannel
 * 接收methodHandler
 * methodName 方法名称
 * params 发送给原生的参数
 * return数据 原生发给Flutter的参数
 */
  static void methodHandlerListener(Future<dynamic> Function(MethodCall call)? handler) {
    
    
    methodChannel.setMethodCallHandler(handler);
  }
}

使用该MethodChannel，我们需要使用MethodChannel
使用代码如下

  @override
  void initState() {
    
    
    // TODO: implement initState
    super.initState();

    setMethodHandle();
  }

  void setMethodHandle() {
    
    
    FlutterMethodChannel.methodHandlerListener((call) {
    
    
      print("methodHandlerListener call:${
      
      call.toString()}");
      if ("methodToFlutter" == call.method) {
    
    
        print("methodToFlutter arg:${
      
      call.arguments}");
      }
      return Future.value("message from flutter");
    });
  }

  Future<void> invokeNativeMethod() async {
    
    
    var result = await FlutterMethodChannel.invokeNativeMethod("methodTest", {
    
    "param":"params from flutter"});
    print("invokeNativeMethod result:${
      
      result.toString()}");
  }

  void testButtonTouched() {
    
    
    invokeNativeMethod();
  }

  @override
  void dispose() {
    
    
    // TODO: implement dispose
    super.dispose();
  }

Aquí hemos procesado el método métodoToFlutter para recibir la llamada de paso de parámetros desde el lado de Android y, después del procesamiento, devolveremos el resultado "mensaje de flutter" al lado de Android.
Llamamos al método MethodTest en el lado de Android y pasamos parámetros para obtener los resultados devueltos por el lado de Android.

3. MainActivity en el lado de Android

En MainActivity de Android, también implementamos el
método MethodChannel para configurar setMethodCallHandler y llamar a Flutter.

El código se muestra a continuación.

import android.util.Log;

import android.text.TextUtils;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;

import io.flutter.embedding.android.FlutterActivity;
import io.flutter.plugin.common.MethodChannel;

import java.util.Timer;
import java.util.TimerTask;

public class MainActivity extends FlutterActivity {
    
    
    private MethodChannel methodChannel;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
    
    
        super.onCreate(savedInstanceState);
        getMethodChannel().setMethodCallHandler((call, result) -> {
    
    
            if (TextUtils.equals(call.method, "methodTest")) {
    
    
                result.success("message from Android");
            } else {
    
    
                result.error("1", "Illegal Argument Exception", "Unsupported Method - " + call.method);
            }
        });

        new Timer().schedule(new TimerTask() {
    
    
            @Override
            public void run() {
    
    
                runOnUiThread(() -> {
    
    
                    getMethodChannel().invokeMethod("methodToFlutter", "Params from Android");
                });
            }
        }, 10 * 1000);
    }

    private MethodChannel getMethodChannel() {
    
    
        if (methodChannel == null) {
    
    
            methodChannel = new MethodChannel(getFlutterEngine().getDartExecutor(), "samples.flutter.dev/test");
        }
        return methodChannel;
    }
}

Pasamos los parámetros al lado de Flutter llamando al método métodoToFlutter en MainActivity de Android. Configure setMethodCallHandler para procesar y recibir parámetros de flutter de acuerdo con el método métodoTest y devolver el resultado a flutter después del procesamiento.

Nota: La llamada al temporizador en MainActivity debe realizarse en el hilo principal, que puede ser manejado por runOnUiThread.

Cuatro Resumen

Práctica de desarrollo de Flutter: MethodChannel realiza una comunicación bidireccional entre Flutter y Android nativo. Implemente la función de comunicación mutua entre MethodChannel en el lado de flutter y MainActivity en el lado de Android.

Registros de aprendizaje, sigue mejorando cada día.