Flutter混编工程之通讯之路

import 'package:flutter/services.dart';

/// This class includes implementation of two platform methods [increment],
/// and [decrement] which are used to increment and decrement value
/// of count respectively.
class Counter {
  /// Creates a [MethodChannel] with the specified name to invoke platform method.
  /// In order to communicate across platforms, the name of MethodChannel
  /// should be same on native and dart side.
  static MethodChannel methodChannel = const MethodChannel('methodChannelDemo');

  /// This method is responsible to increment and return the value of count.
  static Future<int> increment({required int counterValue}) async {
    final result = await methodChannel.invokeMethod<int>('increment', {'count': counterValue});
    return result!;
  }

  /// This method is responsible to decrement and return the value of count.
  static Future<int> decrement({required int counterValue}) async {
    final result = await methodChannel.invokeMethod<int>('decrement', {'count': counterValue});
    return result!;
  }
}

onPressed: () async {
  try {
    final value = await Counter.increment(counterValue: count);
    setState(() => count = value);
  } catch (error) {
  }
},

MethodChannel(flutterEngine.dartExecutor, "methodChannelDemo")
        .setMethodCallHandler { call, result ->
            val count: Int? = call.argument<Int>("count")

            if (count == null) {
                result.error("INVALID ARGUMENT", "Value of count cannot be null", null)
            } else {
                when (call.method) {
                    "increment" -> result.success(count + 1)
                    "decrement" -> result.success(count - 1)
                    else -> result.notImplemented()
                }
            }
        }

import 'package:flutter/services.dart';

/// This class includes the implementation for [EventChannel] to listen to value
/// changes from the Accelerometer sensor from native side. It has a [readings]
/// getter to provide a stream of [AccelerometerReadings].
class Accelerometer {
  static const _eventChannel = EventChannel('eventChannelDemo');

  /// Method responsible for providing a stream of [AccelerometerReadings] to listen
  /// to value changes from the Accelerometer sensor.
  static Stream<AccelerometerReadings> get readings {
    return _eventChannel.receiveBroadcastStream().map(
          (dynamic event) => AccelerometerReadings(
            event[0] as double,
            event[1] as double,
            event[2] as double,
          ),
        );
  }
}

class AccelerometerReadings {
  /// Acceleration force along the x-axis.
  final double x;

  /// Acceleration force along the y-axis.
  final double y;

  /// Acceleration force along the z-axis.
  final double z;

  AccelerometerReadings(this.x, this.y, this.z);
}

child: StreamBuilder<AccelerometerReadings>(
  stream: Accelerometer.readings,
  builder: (context, snapshot) {
    if (snapshot.hasError) {
      return Text((snapshot.error as PlatformException).message!);
    } else if (snapshot.hasData) {
      return Column(
        mainAxisAlignment: MainAxisAlignment.center,
        children: [
          Text(
            'x axis: ' + snapshot.data!.x.toStringAsFixed(3),
            style: textStyle,
          ),
          Text(
            'y axis: ' + snapshot.data!.y.toStringAsFixed(3),
            style: textStyle,
          ),
          Text(
            'z axis: ' + snapshot.data!.z.toStringAsFixed(3),
            style: textStyle,
          )
        ],
      );
    }

class AccelerometerStreamHandler(sManager: SensorManager, s: Sensor) : EventChannel.StreamHandler, SensorEventListener {
    private val sensorManager: SensorManager = sManager
    private val accelerometerSensor: Sensor = s
    private lateinit var eventSink: EventChannel.EventSink

    override fun onListen(arguments: Any?, events: EventChannel.EventSink?) {
        if (events != null) {
            eventSink = events
            sensorManager.registerListener(this, accelerometerSensor, SensorManager.SENSOR_DELAY_UI)
        }
    }

    override fun onCancel(arguments: Any?) {
        sensorManager.unregisterListener(this)
    }

    override fun onAccuracyChanged(sensor: Sensor?, accuracy: Int) {}

    override fun onSensorChanged(sensorEvent: SensorEvent?) {
        if (sensorEvent != null) {
            val axisValues = listOf(sensorEvent.values[0], sensorEvent.values[1], sensorEvent.values[2])
            eventSink.success(axisValues)
        } else {
            eventSink.error("DATA_UNAVAILABLE", "Cannot get accelerometer data", null)
        }
    }
}

val sensorManger: SensorManager = getSystemService(Context.SENSOR_SERVICE) as SensorManager
val accelerometerSensor: Sensor = sensorManger.getDefaultSensor(Sensor.TYPE_ACCELEROMETER)
EventChannel(flutterEngine.dartExecutor, "eventChannelDemo")
        .setStreamHandler(AccelerometerStreamHandler(sensorManger, accelerometerSensor))

/// This class manages a [BasicMessageChannel] that can return an image loaded
/// from a native asset. The [BasicMessageChannel] uses [StandardMessageCodec]
/// since it supports [Uint8List], which is used to transport the image data.
class PlatformImageFetcher {
  static const _basicMessageChannel = BasicMessageChannel<dynamic>('platformImageDemo', StandardMessageCodec());

  /// Method responsible for providing the platform image.
  static Future<Uint8List> getImage() async {
    final reply = await _basicMessageChannel.send('getImage') as Uint8List?;
    if (reply == null) {
      throw PlatformException(
        code: 'Error',
        message: 'Failed to load Platform Image',
        details: null,
      );
    }
    return reply;
  }
}

child: FutureBuilder<Uint8List>(
  future: imageData,
  builder: (context, snapshot) {
    if (snapshot.connectionState == ConnectionState.none) {
      return const Placeholder();
    } else if (snapshot.hasError) {
      return Center(
        child: Text(
          (snapshot.error as PlatformException).message!,
        ),
      );
    } else if (snapshot.connectionState ==
        ConnectionState.done) {
      return Image.memory(
        snapshot.data!,
        fit: BoxFit.fill,
      );
    }
    return const CircularProgressIndicator();
  },

// Registers a MessageHandler for BasicMessageChannel to receive a message from Dart and send
// image data in reply.
BasicMessageChannel(flutterEngine.dartExecutor, "platformImageDemo", StandardMessageCodec())
        .setMessageHandler { message, reply ->
            if (message == "getImage") {
                val inputStream: InputStream = assets.open("eat_new_orleans.jpg")
                reply.reply(inputStream.readBytes())
            }
        }

@override
void initState() {
  super.initState();
  // Receives a string of json object from the platform and converts it to PetModel.
  const BasicMessageChannel<String?>('stringCodecDemo', StringCodec()).setMessageHandler((message) async {
    if (message == null) {
      showSnackBar('An error occurred while adding pet details.', context);
    } else {
      setState(() {
        petListModel = PetListModel.fromJson(message);
      });
    }
    return null;
  });
}

class PetListMessageChannel {
  static const _jsonMessageCodecChannel = BasicMessageChannel<dynamic>('jsonMessageCodecDemo', JSONMessageCodec());

  /// Method to add a new pet to the list.
  ///
  /// Demonstrates how to use [BasicMessageChannel] and [JSONMessageCodec] to
  /// send more structured data to platform like a [Map] in this case.
  static void addPetDetails(PetDetails petDetails) {
    _jsonMessageCodecChannel.send(petDetails.toJson());
  }

class PetListMessageChannel {

  static const _binaryCodecChannel = BasicMessageChannel('binaryCodecDemo', BinaryCodec());

  /// Method to remove a pet from the list.
  ///
  /// Demonstrates how to use [BasicMessageChannel] and [BinaryCodec] to
  /// send [ByteData] to platform. If the reply received is null, then
  /// we will throw a [PlatformException].
  static Future<void> removePet(int index) async {
    final uInt8List = utf8.encoder.convert(index.toString());
    final reply = await _binaryCodecChannel.send(uInt8List.buffer.asByteData());
    if (reply == null) {
      throw PlatformException(
        code: 'INVALID INDEX',
        message: 'Failed to delete pet details',
        details: null,
      );
    }
  }
}

// Registers a MessageHandler for BasicMessageChannel to receive pet details to be
// added in petList and send the it back to Dart using stringCodecChannel.
BasicMessageChannel(flutterEngine.dartExecutor, "jsonMessageCodecDemo", JSONMessageCodec.INSTANCE)
        .setMessageHandler { message, reply ->
            petList.add(0, gson.fromJson(message.toString(), object : TypeToken<Map<String, String>>() {}.type))
            stringCodecChannel.send(gson.toJson(mapOf("petList" to petList)))
        }

val petList = mutableListOf<Map<String, String>>()
val gson = Gson()

// A BasicMessageChannel for sending petList to Dart.
val stringCodecChannel = BasicMessageChannel(flutterEngine.dartExecutor, "stringCodecDemo", StringCodec.INSTANCE)

// Registers a MessageHandler for BasicMessageChannel to receive the index of pet
// details to be removed from the petList and send the petList back to Dart using
// stringCodecChannel. If the index is not in the range of petList, we send null
// back to Dart.
BasicMessageChannel(flutterEngine.dartExecutor, "binaryCodecDemo", BinaryCodec.INSTANCE)
        .setMessageHandler { message, reply ->
            val index = String(message!!.array()).toInt()
            if (index >= 0 && index < petList.size) {
                petList.removeAt(index)
                val replyMessage = "Removed Successfully"
                reply.reply(ByteBuffer.allocateDirect(replyMessage.toByteArray().size)
                    .put(replyMessage.toByteArray()))
                stringCodecChannel.send(gson.toJson(mapOf("petList" to petList)))
            } else {
                reply.reply(null)
            }
        }