Prática de desenvolvimento de Flutter - MethodChannel realiza comunicação bidirecional entre flutter e Android nativo

Prática de desenvolvimento de Flutter - MethodChannel realiza comunicação bidirecional entre flutter e Android nativo

No desenvolvimento recente, o Android nativo e o flutter precisam se comunicar, e o MethodChannel usado aqui

1. MétodoCanal

MethodChannel: usado para passar chamadas de método (invocação de método).
As extremidades cliente e host de um canal são conectadas através do nome do canal passado ao construtor do canal

Todos os nomes de canais usados ​​em um aplicativo devem ser
nomes de canais prefixados exclusivos com um prefixo de domínio exclusivo, por exemplo: samples.flutter.dev/battery

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

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

2. Implemente MethodChannel no lado do flutter

Precisamos criar um canal chamado "samples.flutter.dev/test".
Realizado por InvokeNativeMethod e setMethodCallHandler

• invocaNativeMethod: chama o código no lado do Android
• setMethodCallHandler: Defina o retorno de chamada do método para receber parâmetros no lado Android

código mostrado abaixo

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();
  }

Aqui processamos o método methodToFlutter para receber a chamada de passagem de parâmetro do lado Android e, após o processamento, retornaremos o resultado "message from flutter" para o lado Android.
Chamamos o método methodTest no lado Android e passamos parâmetros para obter os resultados retornados pelo lado Android.

3. MainActivity no lado Android

Na MainActivity do Android, também implementamos o
método MethodChannel para definir setMethodCallHandler e chamar Flutter

código mostrado abaixo

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;
    }
}

Passamos os parâmetros para o lado do Flutter chamando o método methodToFlutter na MainActivity do Android. Defina setMethodCallHandler para processar e receber parâmetros de flutter de acordo com o método methodTest e retornar o resultado para flutter após o processamento.

Nota: A chamada do Timer em MainActivity precisa ser chamada no thread principal, que pode ser tratado por runOnUiThread.

Quatro. Resumo

Prática de desenvolvimento de Flutter - MethodChannel realiza comunicação bidirecional entre flutter e Android nativo. Realize a função de comunicação mútua entre MethodChannel no lado flutter e MainActivity no lado Android.

Registros de aprendizagem, continue melhorando a cada dia.