Skip to content

Commit 3742a4e

Browse files
authored
[pigeon] Allow event channel unregistration (#13438)
Adds a new class for each event channel API that wraps the underlying EventChannel and allows setting the stream handler, matching the underlying Flutter API. This allows clients that need to set a new handler later (notably, removing a handler to avoid an engine-lifetime reference to a handler for a transient channel) to do so, using the same API that non-Pigeon event channel code would use. The existing static `register` method is kept to avoid unnecessary breaking changes, but clients no longer need to use it if they want to create the channel directly. Fixes flutter/flutter#195049 ## Pre-Review Checklist [^1]: Regular contributors who have demonstrated familiarity with the repository guidelines only need to comment if the PR is not auto-exempted by repo tooling.
1 parent e830a53 commit 3742a4e

14 files changed

Lines changed: 408 additions & 130 deletions

File tree

‎packages/pigeon/CHANGELOG.md‎

Lines changed: 5 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1,3 +1,8 @@
1+
## 29.1.0
2+
3+
* [kotlin,swift] Adds support for removing event channel handler registration
4+
via a new event channel object returned from `register`.
5+
16
## 29.0.13
27

38
* [dart] Separates generated Dart native interop bindings into a conditionally imported companion file (`*.native_interop.g.dart`) so that the main generated Dart file can be imported on Web without pulling in `dart:ffi` or `dart:io`.

‎packages/pigeon/example/app/android/app/src/main/kotlin/dev/flutter/pigeon_example_app/EventChannelMessages.g.kt‎

Lines changed: 42 additions & 14 deletions
Original file line numberDiff line numberDiff line change
@@ -241,10 +241,10 @@ private open class EventChannelMessagesPigeonCodec : StandardMessageCodec() {
241241
override fun readValueOfType(type: Byte, buffer: ByteBuffer): Any? {
242242
return when (type) {
243243
129.toByte() -> {
244-
return (readValue(buffer) as? List<Any?>)?.let { IntEvent.fromList(it) }
244+
(readValue(buffer) as? List<Any?>)?.let { IntEvent.fromList(it) }
245245
}
246246
130.toByte() -> {
247-
return (readValue(buffer) as? List<Any?>)?.let { StringEvent.fromList(it) }
247+
(readValue(buffer) as? List<Any?>)?.let { StringEvent.fromList(it) }
248248
}
249249
else -> super.readValueOfType(type, buffer)
250250
}
@@ -284,9 +284,9 @@ private class EventChannelMessagesPigeonStreamHandler<T>(
284284
}
285285

286286
interface EventChannelMessagesPigeonEventChannelWrapper<T> {
287-
open fun onListen(p0: Any?, sink: PigeonEventSink<T>) {}
287+
fun onListen(p0: Any?, sink: PigeonEventSink<T>) {}
288288

289-
open fun onCancel(p0: Any?) {}
289+
fun onCancel(p0: Any?) {}
290290
}
291291

292292
class PigeonEventSink<T>(private val sink: EventChannel.EventSink) {
@@ -303,25 +303,53 @@ class PigeonEventSink<T>(private val sink: EventChannel.EventSink) {
303303
}
304304
}
305305

306+
/**
307+
* A typed channel for communicating with the Flutter application using asynchronous event streams.
308+
*/
309+
class StreamEventsEventChannel(messenger: BinaryMessenger, instanceName: String = "") {
310+
private val channel: EventChannel
311+
312+
init {
313+
var channelName = "dev.flutter.pigeon.pigeon_example_package.EventChannelMethods.streamEvents"
314+
if (instanceName.isNotEmpty()) {
315+
channelName += ".$instanceName"
316+
}
317+
channel = EventChannel(messenger, channelName, EventChannelMessagesPigeonMethodCodec)
318+
}
319+
320+
/**
321+
* Sets the stream handler for this channel, replacing any previous handler.
322+
*
323+
* Pass `null` to remove the event channel registration.
324+
*/
325+
fun setStreamHandler(streamHandler: StreamEventsStreamHandler?) {
326+
val internalHandler =
327+
streamHandler?.let { EventChannelMessagesPigeonStreamHandler<PlatformEvent>(it) }
328+
channel.setStreamHandler(internalHandler)
329+
}
330+
}
331+
306332
abstract class StreamEventsStreamHandler :
307333
EventChannelMessagesPigeonEventChannelWrapper<PlatformEvent> {
308334
companion object {
335+
/**
336+
* Creates and returns a new event channel that calls the provided stream handler.
337+
*
338+
* The returned channel can be stored to allow changing or removing the stream handler. If the
339+
* handler will not be changed for the lifetime of the engine associated with the messenger, the
340+
* return value can be ignored.
341+
*/
309342
fun register(
310343
messenger: BinaryMessenger,
311344
streamHandler: StreamEventsStreamHandler,
312345
instanceName: String = ""
313-
) {
314-
var channelName: String =
315-
"dev.flutter.pigeon.pigeon_example_package.EventChannelMethods.streamEvents"
316-
if (instanceName.isNotEmpty()) {
317-
channelName += ".$instanceName"
318-
}
319-
val internalStreamHandler =
320-
EventChannelMessagesPigeonStreamHandler<PlatformEvent>(streamHandler)
321-
EventChannel(messenger, channelName, EventChannelMessagesPigeonMethodCodec)
322-
.setStreamHandler(internalStreamHandler)
346+
): StreamEventsEventChannel {
347+
val channel = StreamEventsEventChannel(messenger, instanceName)
348+
channel.setStreamHandler(streamHandler)
349+
return channel
323350
}
324351
}
352+
325353
// Implement methods from EventChannelMessagesPigeonEventChannelWrapper
326354
override fun onListen(p0: Any?, sink: PigeonEventSink<PlatformEvent>) {}
327355

‎packages/pigeon/example/app/android/app/src/main/kotlin/dev/flutter/pigeon_example_app/Messages.g.kt‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -273,10 +273,10 @@ private open class MessagesPigeonCodec : StandardMessageCodec() {
273273
override fun readValueOfType(type: Byte, buffer: ByteBuffer): Any? {
274274
return when (type) {
275275
129.toByte() -> {
276-
return (readValue(buffer) as Long?)?.let { Code.ofRaw(it.toInt()) }
276+
(readValue(buffer) as Long?)?.let { Code.ofRaw(it.toInt()) }
277277
}
278278
130.toByte() -> {
279-
return (readValue(buffer) as? List<Any?>)?.let { MessageData.fromList(it) }
279+
(readValue(buffer) as? List<Any?>)?.let { MessageData.fromList(it) }
280280
}
281281
else -> super.readValueOfType(type, buffer)
282282
}

‎packages/pigeon/example/app/ios/Runner/EventChannelMessages.g.swift‎

Lines changed: 31 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -310,19 +310,41 @@ class PigeonEventSink<ReturnType> {
310310

311311
}
312312

313-
class StreamEventsStreamHandler: PigeonEventChannelWrapper<PlatformEvent> {
314-
static func register(
315-
with messenger: FlutterBinaryMessenger,
316-
instanceName: String = "",
317-
streamHandler: StreamEventsStreamHandler
318-
) {
313+
/// A typed channel for communicating with the Flutter application using asynchronous event streams.
314+
class StreamEventsEventChannel {
315+
private let channel: FlutterEventChannel
316+
317+
init(messenger: FlutterBinaryMessenger, instanceName: String = "") {
319318
var channelName = "dev.flutter.pigeon.pigeon_example_package.EventChannelMethods.streamEvents"
320319
if !instanceName.isEmpty {
321320
channelName += ".\(instanceName)"
322321
}
323-
let internalStreamHandler = PigeonStreamHandler<PlatformEvent>(wrapper: streamHandler)
324-
let channel = FlutterEventChannel(
322+
channel = FlutterEventChannel(
325323
name: channelName, binaryMessenger: messenger, codec: eventChannelMessagesPigeonMethodCodec)
326-
channel.setStreamHandler(internalStreamHandler)
324+
}
325+
326+
/// Sets the stream handler for this channel, replacing any previous handler.
327+
///
328+
/// Pass `nil` to remove the event channel registration.
329+
func setStreamHandler(_ streamHandler: StreamEventsStreamHandler?) {
330+
let internalHandler = streamHandler.map({ PigeonStreamHandler<PlatformEvent>(wrapper: $0) })
331+
channel.setStreamHandler(internalHandler)
332+
}
333+
}
334+
335+
class StreamEventsStreamHandler: PigeonEventChannelWrapper<PlatformEvent> {
336+
/// Creates and returns a new event channel that calls the provided stream handler.
337+
///
338+
/// The returned channel can be stored to allow changing or removing the stream handler.
339+
/// If the handler will not be changed for the lifetime of the engine associated with the messenger,
340+
/// the return value can be ignored.
341+
@discardableResult static func register(
342+
with messenger: FlutterBinaryMessenger,
343+
instanceName: String = "",
344+
streamHandler: StreamEventsStreamHandler
345+
) -> StreamEventsEventChannel {
346+
let channel = StreamEventsEventChannel(messenger: messenger, instanceName: instanceName)
347+
channel.setStreamHandler(streamHandler)
348+
return channel
327349
}
328350
}

‎packages/pigeon/lib/src/generator_tools.dart‎

Lines changed: 1 addition & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -16,7 +16,7 @@ import 'generator.dart';
1616
/// The current version of pigeon.
1717
///
1818
/// This must match the version in pubspec.yaml.
19-
const String pigeonVersion = '29.0.13';
19+
const String pigeonVersion = '29.1.0';
2020

2121
/// Default plugin package name.
2222
const String defaultPluginPackageName = 'dev.flutter.pigeon';

‎packages/pigeon/lib/src/kotlin/kotlin_generator.dart‎

Lines changed: 45 additions & 15 deletions
Original file line numberDiff line numberDiff line change
@@ -662,12 +662,12 @@ class KotlinGenerator extends StructuredGenerator<InternalKotlinOptions> {
662662
indent.write('${customType.enumeration}.toByte() -> ');
663663
indent.addScoped('{', '}', () {
664664
if (customType.type == CustomTypes.customClass) {
665-
indent.write('return (readValue(buffer) as? List<Any?>)?.let ');
665+
indent.write('(readValue(buffer) as? List<Any?>)?.let ');
666666
indent.addScoped('{', '}', () {
667667
indent.writeln('${customType.name}.fromList(it)');
668668
});
669669
} else if (customType.type == CustomTypes.customEnum) {
670-
indent.write('return (readValue(buffer) as Long?)?.let ');
670+
indent.write('(readValue(buffer) as Long?)?.let ');
671671
indent.addScoped('{', '}', () {
672672
indent.writeln('${customType.name}.ofRaw(it.toInt())');
673673
});
@@ -1445,9 +1445,9 @@ class ${api.name}Registrar() {
14451445
}
14461446
14471447
interface ${generatorOptions.fileSpecificClassNameComponent}PigeonEventChannelWrapper<T> {
1448-
open fun onListen(p0: Any?, sink: PigeonEventSink<T>) {}
1448+
fun onListen(p0: Any?, sink: PigeonEventSink<T>) {}
14491449
1450-
open fun onCancel(p0: Any?) {}
1450+
fun onCancel(p0: Any?) {}
14511451
}
14521452
''');
14531453

@@ -1471,22 +1471,52 @@ class ${api.name}Registrar() {
14711471
}
14721472
addDocumentationComments(indent, api.documentationComments, _docCommentSpec);
14731473
for (final Method func in api.methods) {
1474+
final channelClassName = '${toUpperCamelCase(func.name)}EventChannel';
1475+
final streamHandlerClassName = '${toUpperCamelCase(func.name)}StreamHandler';
14741476
indent.format('''
1475-
abstract class ${toUpperCamelCase(func.name)}StreamHandler : ${generatorOptions.fileSpecificClassNameComponent}PigeonEventChannelWrapper<${_kotlinTypeForDartType(func.returnType)}> {
1477+
/** A typed channel for communicating with the Flutter application using asynchronous event streams. */
1478+
class $channelClassName(messenger: BinaryMessenger, instanceName: String = "") {
1479+
private val channel: EventChannel
1480+
1481+
init {
1482+
var channelName = "${makeChannelName(api, func, dartPackageName)}"
1483+
if (instanceName.isNotEmpty()) {
1484+
channelName += ".\$instanceName"
1485+
}
1486+
channel = EventChannel(messenger, channelName, ${generatorOptions.fileSpecificClassNameComponent}$_pigeonMethodCodec)
1487+
}
1488+
1489+
/**
1490+
* Sets the stream handler for this channel, replacing any previous handler.
1491+
*
1492+
* Pass `null` to remove the event channel registration.
1493+
*/
1494+
fun setStreamHandler(streamHandler: $streamHandlerClassName?) {
1495+
val internalHandler = streamHandler?.let { ${generatorOptions.fileSpecificClassNameComponent}PigeonStreamHandler<${_kotlinTypeForDartType(func.returnType)}>(it) }
1496+
channel.setStreamHandler(internalHandler)
1497+
}
1498+
}
1499+
1500+
abstract class $streamHandlerClassName : ${generatorOptions.fileSpecificClassNameComponent}PigeonEventChannelWrapper<${_kotlinTypeForDartType(func.returnType)}> {
14761501
companion object {
1477-
fun register(messenger: BinaryMessenger, streamHandler: ${toUpperCamelCase(func.name)}StreamHandler, instanceName: String = "") {
1478-
var channelName: String = "${makeChannelName(api, func, dartPackageName)}"
1479-
if (instanceName.isNotEmpty()) {
1480-
channelName += ".\$instanceName"
1481-
}
1482-
val internalStreamHandler = ${generatorOptions.fileSpecificClassNameComponent}PigeonStreamHandler<${_kotlinTypeForDartType(func.returnType)}>(streamHandler)
1483-
EventChannel(messenger, channelName, ${generatorOptions.fileSpecificClassNameComponent}$_pigeonMethodCodec).setStreamHandler(internalStreamHandler)
1502+
/**
1503+
* Creates and returns a new event channel that calls the provided stream handler.
1504+
*
1505+
* The returned channel can be stored to allow changing or removing the stream handler.
1506+
* If the handler will not be changed for the lifetime of the engine associated with the messenger,
1507+
* the return value can be ignored.
1508+
*/
1509+
fun register(messenger: BinaryMessenger, streamHandler: $streamHandlerClassName, instanceName: String = ""): $channelClassName {
1510+
val channel = $channelClassName(messenger, instanceName)
1511+
channel.setStreamHandler(streamHandler)
1512+
return channel
14841513
}
14851514
}
1486-
// Implement methods from ${generatorOptions.fileSpecificClassNameComponent}PigeonEventChannelWrapper
1487-
override fun onListen(p0: Any?, sink: PigeonEventSink<${_kotlinTypeForDartType(func.returnType)}>) {}
14881515
1489-
override fun onCancel(p0: Any?) {}
1516+
// Implement methods from ${generatorOptions.fileSpecificClassNameComponent}PigeonEventChannelWrapper
1517+
override fun onListen(p0: Any?, sink: PigeonEventSink<${_kotlinTypeForDartType(func.returnType)}>) {}
1518+
1519+
override fun onCancel(p0: Any?) {}
14901520
}
14911521
''');
14921522
}

‎packages/pigeon/lib/src/swift/swift_generator.dart‎

Lines changed: 33 additions & 7 deletions
Original file line numberDiff line numberDiff line change
@@ -2670,18 +2670,44 @@ enum ${_classNamePrefix}PigeonInternalNumberType: Int {
26702670
}
26712671
addDocumentationComments(indent, api.documentationComments, _docCommentSpec);
26722672
for (final Method func in api.methods) {
2673+
final channelClassName = '${toUpperCamelCase(func.name)}EventChannel';
2674+
final streamHandlerClassName = '${toUpperCamelCase(func.name)}StreamHandler';
26732675
indent.format('''
2674-
class ${toUpperCamelCase(func.name)}StreamHandler: PigeonEventChannelWrapper<${_swiftTypeForDartType(func.returnType)}> {
2675-
static func register(with messenger: FlutterBinaryMessenger,
2676-
instanceName: String = "",
2677-
streamHandler: ${toUpperCamelCase(func.name)}StreamHandler) {
2676+
/// A typed channel for communicating with the Flutter application using asynchronous event streams.
2677+
class $channelClassName {
2678+
private let channel: FlutterEventChannel
2679+
2680+
init(messenger: FlutterBinaryMessenger, instanceName: String = "") {
26782681
var channelName = "${makeChannelName(api, func, dartPackageName)}"
26792682
if !instanceName.isEmpty {
26802683
channelName += ".\\(instanceName)"
26812684
}
2682-
let internalStreamHandler = PigeonStreamHandler<${_swiftTypeForDartType(func.returnType)}>(wrapper: streamHandler)
2683-
let channel = FlutterEventChannel(name: channelName, binaryMessenger: messenger, codec: ${_getMethodCodecVarName(generatorOptions)})
2684-
channel.setStreamHandler(internalStreamHandler)
2685+
channel = FlutterEventChannel(name: channelName, binaryMessenger: messenger, codec: ${_getMethodCodecVarName(generatorOptions)})
2686+
}
2687+
2688+
/// Sets the stream handler for this channel, replacing any previous handler.
2689+
///
2690+
/// Pass `nil` to remove the event channel registration.
2691+
func setStreamHandler(_ streamHandler: $streamHandlerClassName?) {
2692+
let internalHandler = streamHandler.map({ PigeonStreamHandler<${_swiftTypeForDartType(func.returnType)}>(wrapper: \$0) })
2693+
channel.setStreamHandler(internalHandler)
2694+
}
2695+
}
2696+
2697+
class $streamHandlerClassName: PigeonEventChannelWrapper<${_swiftTypeForDartType(func.returnType)}> {
2698+
/// Creates and returns a new event channel that calls the provided stream handler.
2699+
///
2700+
/// The returned channel can be stored to allow changing or removing the stream handler.
2701+
/// If the handler will not be changed for the lifetime of the engine associated with the messenger,
2702+
/// the return value can be ignored.
2703+
@discardableResult static func register(
2704+
with messenger: FlutterBinaryMessenger,
2705+
instanceName: String = "",
2706+
streamHandler: $streamHandlerClassName
2707+
) -> $channelClassName {
2708+
let channel = $channelClassName(messenger: messenger, instanceName: instanceName)
2709+
channel.setStreamHandler(streamHandler)
2710+
return channel
26852711
}
26862712
}
26872713
''');

‎packages/pigeon/platform_tests/test_plugin/android/src/main/kotlin/com/example/test_plugin/CoreTests.gen.kt‎

Lines changed: 9 additions & 11 deletions
Original file line numberDiff line numberDiff line change
@@ -1078,33 +1078,31 @@ private open class CoreTestsPigeonCodec : StandardMessageCodec() {
10781078
override fun readValueOfType(type: Byte, buffer: ByteBuffer): Any? {
10791079
return when (type) {
10801080
129.toByte() -> {
1081-
return (readValue(buffer) as Long?)?.let { AnEnum.ofRaw(it.toInt()) }
1081+
(readValue(buffer) as Long?)?.let { AnEnum.ofRaw(it.toInt()) }
10821082
}
10831083
130.toByte() -> {
1084-
return (readValue(buffer) as Long?)?.let { AnotherEnum.ofRaw(it.toInt()) }
1084+
(readValue(buffer) as Long?)?.let { AnotherEnum.ofRaw(it.toInt()) }
10851085
}
10861086
131.toByte() -> {
1087-
return (readValue(buffer) as? List<Any?>)?.let { UnusedClass.fromList(it) }
1087+
(readValue(buffer) as? List<Any?>)?.let { UnusedClass.fromList(it) }
10881088
}
10891089
132.toByte() -> {
1090-
return (readValue(buffer) as? List<Any?>)?.let { AllTypes.fromList(it) }
1090+
(readValue(buffer) as? List<Any?>)?.let { AllTypes.fromList(it) }
10911091
}
10921092
133.toByte() -> {
1093-
return (readValue(buffer) as? List<Any?>)?.let { AllNullableTypes.fromList(it) }
1093+
(readValue(buffer) as? List<Any?>)?.let { AllNullableTypes.fromList(it) }
10941094
}
10951095
134.toByte() -> {
1096-
return (readValue(buffer) as? List<Any?>)?.let {
1097-
AllNullableTypesWithoutRecursion.fromList(it)
1098-
}
1096+
(readValue(buffer) as? List<Any?>)?.let { AllNullableTypesWithoutRecursion.fromList(it) }
10991097
}
11001098
135.toByte() -> {
1101-
return (readValue(buffer) as? List<Any?>)?.let { AnEmptyClass.fromList(it) }
1099+
(readValue(buffer) as? List<Any?>)?.let { AnEmptyClass.fromList(it) }
11021100
}
11031101
136.toByte() -> {
1104-
return (readValue(buffer) as? List<Any?>)?.let { AllClassesWrapper.fromList(it) }
1102+
(readValue(buffer) as? List<Any?>)?.let { AllClassesWrapper.fromList(it) }
11051103
}
11061104
137.toByte() -> {
1107-
return (readValue(buffer) as? List<Any?>)?.let { TestMessage.fromList(it) }
1105+
(readValue(buffer) as? List<Any?>)?.let { TestMessage.fromList(it) }
11081106
}
11091107
else -> super.readValueOfType(type, buffer)
11101108
}

0 commit comments

Comments
 (0)