From 3c9b795d0908931cb45d9998f1ed7ceb8fd8a09c Mon Sep 17 00:00:00 2001 From: =?UTF-8?q?Piotr=20Szyde=C5=82ko?= Date: Wed, 31 May 2023 08:20:29 +0200 Subject: [PATCH] Add tizen_interop_callbacks (#19) Co-authored-by: Jakub Siewierski Co-authored-by: Swift Kim --- .clang-format | 1 + README.md | 9 + packages/tizen_interop_callbacks/.gitignore | 28 + packages/tizen_interop_callbacks/CHANGELOG.md | 3 + packages/tizen_interop_callbacks/LICENSE | 25 + packages/tizen_interop_callbacks/README.md | 58 + .../analysis_options.yaml | 1 + .../example/.gitignore | 42 + .../tizen_interop_callbacks/example/README.md | 34 + .../example/lib/battery.dart | 134 + .../example/lib/main.dart | 38 + .../example/lib/preview_resolutions.dart | 106 + .../example/pubspec.yaml | 20 + .../example/tizen/.gitignore | 5 + .../example/tizen/App.cs | 20 + .../example/tizen/Runner.csproj | 19 + .../example/tizen/shared/res/ic_launcher.png | Bin 0 -> 1443 bytes .../example/tizen/tizen-manifest.xml | 10 + .../lib/tizen_interop_callbacks.dart | 348 + packages/tizen_interop_callbacks/pubspec.yaml | 25 + .../tizen_interop_callbacks/tizen/.gitignore | 5 + .../inc/tizen_interop_callbacks_plugin.h | 53 + .../tizen/project_def.prop | 20 + .../tizen/src/generated_callbacks.cc | 5746 +++++++++++++++++ .../tizen_interop_callbacks/tizen/src/log.h | 31 + .../tizen/src/macros.h | 454 ++ .../src/tizen_interop_callbacks_plugin.cc | 179 + .../tizen_interop_callbacks/tizen/src/types.h | 39 + scripts/README.md | 7 + scripts/callbacks_generator/README.md | 44 + scripts/callbacks_generator/__init__.py | 0 scripts/callbacks_generator/gen_callbacks.py | 1002 +++ scripts/callbacks_generator/tests/__init__.py | 0 .../callbacks_generator/tests/run_tests.py | 9 + .../tests/test_callbacksdata.py | 17 + .../tests/test_tokenize.py | 422 ++ .../tests/test_typedef_reading.py | 760 +++ .../tests/test_typedef_recognition.py | 271 + scripts/generate_callbacks.sh | 90 + 39 files changed, 10075 insertions(+) create mode 100644 .clang-format create mode 100644 packages/tizen_interop_callbacks/.gitignore create mode 100644 packages/tizen_interop_callbacks/CHANGELOG.md create mode 100644 packages/tizen_interop_callbacks/LICENSE create mode 100644 packages/tizen_interop_callbacks/README.md create mode 100644 packages/tizen_interop_callbacks/analysis_options.yaml create mode 100644 packages/tizen_interop_callbacks/example/.gitignore create mode 100644 packages/tizen_interop_callbacks/example/README.md create mode 100644 packages/tizen_interop_callbacks/example/lib/battery.dart create mode 100644 packages/tizen_interop_callbacks/example/lib/main.dart create mode 100644 packages/tizen_interop_callbacks/example/lib/preview_resolutions.dart create mode 100644 packages/tizen_interop_callbacks/example/pubspec.yaml create mode 100644 packages/tizen_interop_callbacks/example/tizen/.gitignore create mode 100644 packages/tizen_interop_callbacks/example/tizen/App.cs create mode 100644 packages/tizen_interop_callbacks/example/tizen/Runner.csproj create mode 100644 packages/tizen_interop_callbacks/example/tizen/shared/res/ic_launcher.png create mode 100644 packages/tizen_interop_callbacks/example/tizen/tizen-manifest.xml create mode 100644 packages/tizen_interop_callbacks/lib/tizen_interop_callbacks.dart create mode 100644 packages/tizen_interop_callbacks/pubspec.yaml create mode 100644 packages/tizen_interop_callbacks/tizen/.gitignore create mode 100644 packages/tizen_interop_callbacks/tizen/inc/tizen_interop_callbacks_plugin.h create mode 100644 packages/tizen_interop_callbacks/tizen/project_def.prop create mode 100644 packages/tizen_interop_callbacks/tizen/src/generated_callbacks.cc create mode 100644 packages/tizen_interop_callbacks/tizen/src/log.h create mode 100644 packages/tizen_interop_callbacks/tizen/src/macros.h create mode 100644 packages/tizen_interop_callbacks/tizen/src/tizen_interop_callbacks_plugin.cc create mode 100644 packages/tizen_interop_callbacks/tizen/src/types.h create mode 100644 scripts/callbacks_generator/README.md create mode 100644 scripts/callbacks_generator/__init__.py create mode 100755 scripts/callbacks_generator/gen_callbacks.py create mode 100644 scripts/callbacks_generator/tests/__init__.py create mode 100755 scripts/callbacks_generator/tests/run_tests.py create mode 100644 scripts/callbacks_generator/tests/test_callbacksdata.py create mode 100644 scripts/callbacks_generator/tests/test_tokenize.py create mode 100644 scripts/callbacks_generator/tests/test_typedef_reading.py create mode 100644 scripts/callbacks_generator/tests/test_typedef_recognition.py create mode 100755 scripts/generate_callbacks.sh diff --git a/.clang-format b/.clang-format new file mode 100644 index 0000000..f6cb8ad --- /dev/null +++ b/.clang-format @@ -0,0 +1 @@ +BasedOnStyle: Google diff --git a/README.md b/README.md index 31481cc..203468e 100644 --- a/README.md +++ b/README.md @@ -66,6 +66,15 @@ int freeMemory = using((Arena arena) { } return 0; }); + +// Both sync and async callbacks are supported as long as they are called on +// the same thread. +tizen.storage_foreach_device_supported( + Pointer.fromFunction(_storageDevice, false), nullptr); + +// Callbacks that are called outside the current thread will cause the error: +// "Cannot invoke native callback outside an isolate". +// See the tizen_interop_callbacks package for a solution. ``` diff --git a/packages/tizen_interop_callbacks/.gitignore b/packages/tizen_interop_callbacks/.gitignore new file mode 100644 index 0000000..d87f6f0 --- /dev/null +++ b/packages/tizen_interop_callbacks/.gitignore @@ -0,0 +1,28 @@ +# Miscellaneous +*.class +*.log +*.pyc +*.swp +.DS_Store +.atom/ +.buildlog/ +.history +.svn/ +migrate_working_dir/ + +# IntelliJ related +*.iml +*.ipr +*.iws +.idea/ + +# VS Code related +.vscode/ + +# Flutter/Dart/Pub related +# Libraries should not include pubspec.lock, per https://dart.dev/guides/libraries/private-files#pubspeclock. +/pubspec.lock +**/doc/api/ +.dart_tool/ +.packages +build/ diff --git a/packages/tizen_interop_callbacks/CHANGELOG.md b/packages/tizen_interop_callbacks/CHANGELOG.md new file mode 100644 index 0000000..6073234 --- /dev/null +++ b/packages/tizen_interop_callbacks/CHANGELOG.md @@ -0,0 +1,3 @@ +## 0.1.0 + +* Initial release. diff --git a/packages/tizen_interop_callbacks/LICENSE b/packages/tizen_interop_callbacks/LICENSE new file mode 100644 index 0000000..a476ad0 --- /dev/null +++ b/packages/tizen_interop_callbacks/LICENSE @@ -0,0 +1,25 @@ +Copyright (c) 2023 Samsung Electronics Co., Ltd. All rights reserved. + +Redistribution and use in source and binary forms, with or without modification, +are permitted provided that the following conditions are met: + + * Redistributions of source code must retain the above copyright + notice, this list of conditions and the following disclaimer. + * Redistributions in binary form must reproduce the above + copyright notice, this list of conditions and the following + disclaimer in the documentation and/or other materials provided + with the distribution. + * Neither the name of the copyright holder nor the names of the + contributors may be used to endorse or promote products derived + from this software without specific prior written permission. + +THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND +ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED +WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE +DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR +ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES +(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; +LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON +ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT +(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS +SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. diff --git a/packages/tizen_interop_callbacks/README.md b/packages/tizen_interop_callbacks/README.md new file mode 100644 index 0000000..2e012be --- /dev/null +++ b/packages/tizen_interop_callbacks/README.md @@ -0,0 +1,58 @@ +# tizen_interop_callbacks + +A Flutter plugin to resolve issues related to the error message: `Cannot invoke native callback outside an isolate`. + +This package is designed to be used with the [`tizen_interop`](https://pub.dev/packages/tizen_interop) package. +Similarly to `tizen_interop`, this package has no build time dependency on a specific Tizen profile or version. + +## Usage + +1. Add this package and `tizen_interop` as dependencies in your `pubspec.yaml` file. + + ```yaml + dependencies: + ffi: ^2.0.1 + tizen_interop: ^0.2.6 + tizen_interop_callbacks: ^0.1.0 + ``` + +2. In your Dart code, import the packages: + + ```dart + import 'dart:ffi'; + import 'package:tizen_interop/4.0/tizen.dart'; + import 'package:tizen_interop_callbacks/tizen_interop_callbacks.dart'; + ``` + +3. Instantiate the `TizenInteropCallbacks` class. This should be done in the root isolate - the thread where your `main()` is called. + + ```dart + final callbacks = TizenInteropCallbacks(); + ``` + +4. Implement your callback in Dart and register it with `TizenInteropCallbacks`: + + ```dart + final callback = _callbacks.register, Pointer)>( + 'device_changed_cb', + Pointer.fromFunction(_batteryChanged), + ); + ``` + + The native function type to be used in `register<>()` can be obtained by checking + the definition of the related callback type - the `device_changed_cb` in this case. + +5. Pass the obtained callback pointer and user_data to the Native API function: + + > **Warning** + > + > Both `interopCallback` and `interopUserData` must be passed. The callback handling implementation relies on the `interopUserData`. + > The only exceptions are a few callbacks that do not accept `user_data` parameters. + + ```dart + final ret = tizen.device_add_callback( + device_callback_e.DEVICE_CALLBACK_BATTERY_CAPACITY, + callback.interopCallback, + callback.interopUserData, + ); + ``` diff --git a/packages/tizen_interop_callbacks/analysis_options.yaml b/packages/tizen_interop_callbacks/analysis_options.yaml new file mode 100644 index 0000000..f9b3034 --- /dev/null +++ b/packages/tizen_interop_callbacks/analysis_options.yaml @@ -0,0 +1 @@ +include: package:flutter_lints/flutter.yaml diff --git a/packages/tizen_interop_callbacks/example/.gitignore b/packages/tizen_interop_callbacks/example/.gitignore new file mode 100644 index 0000000..ad3c2ca --- /dev/null +++ b/packages/tizen_interop_callbacks/example/.gitignore @@ -0,0 +1,42 @@ +# Miscellaneous +*.class +*.log +*.pyc +*.swp +.DS_Store +.atom/ +.buildlog/ +.history +.svn/ +migrate_working_dir/ + +# IntelliJ related +*.iml +*.ipr +*.iws +.idea/ + +# VS Code related +.vscode/ + +# Flutter/Dart/Pub related +**/doc/api/ +**/ios/Flutter/.last_build_id +.dart_tool/ +.flutter-plugins +.flutter-plugins-dependencies +.packages +.pub-cache/ +.pub/ +/build/ + +# Symbolication related +app.*.symbols + +# Obfuscation related +app.*.map.json + +# Android Studio will place build artifacts here +/android/app/debug +/android/app/profile +/android/app/release diff --git a/packages/tizen_interop_callbacks/example/README.md b/packages/tizen_interop_callbacks/example/README.md new file mode 100644 index 0000000..f6bb47b --- /dev/null +++ b/packages/tizen_interop_callbacks/example/README.md @@ -0,0 +1,34 @@ +# tizen_interop_callbacks_example + +Demonstrates how to use the tizen_interop_callbacks plugin. + +## Introduction + +This application consists of 2 tabs showing: + +### Battery status + +Here, a typical scenario is shown. We need to receive callbacks, but the Tizen Native API +invokes the callback from another thread. Trying to pass a function pointer obtained +by [`Pointer.fromFunction()`](https://api.flutter.dev/flutter/dart-ffi/Pointer/fromFunction.html) +to [`device_add_callback()`](https://docs.tizen.org/application/native/api/mobile/4.0/group__CAPI__SYSTEM__DEVICE__CALLBACK__MODULE.html#ga89a756a9c46fb670f603d79b66af6cf0) +will cause an error when the callback is called. +Therefore, `TizenInteropCallbacks` is used to obtain a native proxy callback that can be run in any thread. + +You can run the example on a Tizen emulator and use the Control Panel to simulate +changes to the battery level and status. + +### Camera preview resolutions + +Here, a workaround for a locking issue is presented. Usually, a foreach API function would call the callback synchronously. +Thus, `TizenInteropCallbacks` would not be needed at all. + +However, [`camera_foreach_supported_preview_resolution()`](https://docs.tizen.org/application/native/api/mobile/4.0/group__CAPI__MEDIA__CAMERA__CAPABILITY__MODULE.html#gaccca0251a0432ca8752be09b400b9b3b) +locks the calling thread and invokes the given callback in another thread. +Therefore, we need to use `TizenInteropCallbacks` and call the API in a different isolate. +This isolate will be blocked while our root isolate is processing the callbacks. + +Notice that `TizenInteropCallbacks` is only accessed in the root isolate and +the `RegisteredCallback` is passed to the spawned isolate. +Our Dart callback runs in the root isolate, so we have full and safe access +to all its objects. diff --git a/packages/tizen_interop_callbacks/example/lib/battery.dart b/packages/tizen_interop_callbacks/example/lib/battery.dart new file mode 100644 index 0000000..2e466b5 --- /dev/null +++ b/packages/tizen_interop_callbacks/example/lib/battery.dart @@ -0,0 +1,134 @@ +// Copyright 2023 Samsung Electronics Co., Ltd. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// ignore_for_file: public_member_api_docs, avoid_print + +import 'dart:ffi'; + +import 'package:ffi/ffi.dart'; +import 'package:flutter/material.dart'; +import 'package:tizen_interop/4.0/tizen.dart'; +import 'package:tizen_interop_callbacks/tizen_interop_callbacks.dart'; + +class BatteryTab extends StatefulWidget { + const BatteryTab({super.key}); + + @override + State createState() => _BatteryTabState(); +} + +class _BatteryTabState extends State { + final TizenInteropCallbacks _callbacks = TizenInteropCallbacks(); + + late final RegisteredCallback< + Void Function(Int32, Pointer, Pointer)> _chargingCallback; + late final RegisteredCallback< + Void Function(Int32, Pointer, Pointer)> _levelCallback; + + bool? _batteryCharging; + int _batteryLevel = 0; + + static void _batteryChanged( + int type, + Pointer value, + Pointer userData, + ) { + final state = + TizenInteropCallbacks.getUserObject<_BatteryTabState>(userData)!; + if (type == device_callback_e.DEVICE_CALLBACK_BATTERY_CHARGING) { + state._batteryCharging = value.address != 0; + } else if (type == device_callback_e.DEVICE_CALLBACK_BATTERY_CAPACITY) { + state._batteryLevel = value.address; + } + state.setState(() {}); + } + + @override + void initState() { + super.initState(); + + _chargingCallback = _callbacks.register( + 'device_changed_cb', + Pointer.fromFunction(_batteryChanged), + userObject: this, + blocking: true, + ); + int ret = tizen.device_add_callback( + device_callback_e.DEVICE_CALLBACK_BATTERY_CHARGING, + _chargingCallback.interopCallback, + _chargingCallback.interopUserData, + ); + if (ret != 0) { + final error = tizen.get_error_message(ret).toDartString(); + print('Failed to add battery charging callback: $error'); + } + + _levelCallback = _callbacks.register( + 'device_changed_cb', + Pointer.fromFunction(_batteryChanged), + userObject: this, + ); + ret = tizen.device_add_callback( + device_callback_e.DEVICE_CALLBACK_BATTERY_CAPACITY, + _levelCallback.interopCallback, + _levelCallback.interopUserData, + ); + if (ret != 0) { + final error = tizen.get_error_message(ret).toDartString(); + print('Failed to add battery level callback: $error'); + } + + using((Arena arena) { + Pointer percent = arena(); + int ret = tizen.device_battery_get_percent(percent); + if (ret == 0) { + _batteryLevel = percent.value; + } else { + final error = tizen.get_error_message(ret).toDartString(); + print('Failed to read battery level: $error'); + } + + Pointer charging = arena(); + ret = tizen.device_battery_is_charging(charging); + if (ret == 0) { + _batteryCharging = charging.value; + } else { + final error = tizen.get_error_message(ret).toDartString(); + print('Failed to read battery charging status: $error'); + } + setState(() {}); + }); + } + + @override + void dispose() { + tizen.device_remove_callback( + device_callback_e.DEVICE_CALLBACK_BATTERY_CAPACITY, + _levelCallback.interopCallback, + ); + tizen.device_remove_callback( + device_callback_e.DEVICE_CALLBACK_BATTERY_CHARGING, + _chargingCallback.interopCallback, + ); + _callbacks.unregister(_levelCallback); + _callbacks.unregister(_chargingCallback); + + super.dispose(); + } + + @override + Widget build(BuildContext context) { + String status = 'Unknown'; + if (_batteryCharging != null) { + status = _batteryCharging! ? 'Charging' : 'Discharging'; + } + return Column( + mainAxisAlignment: MainAxisAlignment.center, + children: [ + Text('Battery status: $status'), + if (_batteryCharging != null) Text('Battery level: $_batteryLevel%') + ], + ); + } +} diff --git a/packages/tizen_interop_callbacks/example/lib/main.dart b/packages/tizen_interop_callbacks/example/lib/main.dart new file mode 100644 index 0000000..6d53251 --- /dev/null +++ b/packages/tizen_interop_callbacks/example/lib/main.dart @@ -0,0 +1,38 @@ +// Copyright 2023 Samsung Electronics Co., Ltd. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +import 'package:flutter/material.dart'; + +import 'battery.dart'; +import 'preview_resolutions.dart'; + +void main() { + runApp(const MyApp()); +} + +class MyApp extends StatelessWidget { + const MyApp({super.key}); + + @override + Widget build(BuildContext context) { + return MaterialApp( + home: DefaultTabController( + length: 2, + child: Scaffold( + appBar: AppBar( + title: const Text('Tizen Interop Callbacks Example'), + bottom: const TabBar(tabs: [ + Tab(icon: Icon(Icons.battery_charging_full)), + Tab(icon: Icon(Icons.camera)), + ]), + ), + body: const TabBarView(children: [ + BatteryTab(), + PreviewResolutionsTab(), + ]), + ), + ), + ); + } +} diff --git a/packages/tizen_interop_callbacks/example/lib/preview_resolutions.dart b/packages/tizen_interop_callbacks/example/lib/preview_resolutions.dart new file mode 100644 index 0000000..7d58b3e --- /dev/null +++ b/packages/tizen_interop_callbacks/example/lib/preview_resolutions.dart @@ -0,0 +1,106 @@ +// Copyright 2023 Samsung Electronics Co., Ltd. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +// ignore_for_file: public_member_api_docs, avoid_print + +import 'dart:ffi'; +import 'dart:isolate'; + +import 'package:ffi/ffi.dart'; +import 'package:flutter/material.dart'; +import 'package:tizen_interop/4.0/tizen.dart'; +import 'package:tizen_interop_callbacks/tizen_interop_callbacks.dart'; + +class PreviewResolutionsTab extends StatefulWidget { + const PreviewResolutionsTab({super.key}); + + @override + State createState() => _PreviewResolutionsState(); +} + +class _PreviewResolutionsState extends State { + final List _resolutions = []; + + @override + void initState() { + super.initState(); + + getResolutions().then((_) => setState(() {})); + } + + @override + Widget build(BuildContext context) { + return Column( + mainAxisAlignment: MainAxisAlignment.center, + children: [ + const Text('Preview resolutions:'), + if (_resolutions.isEmpty) + const Text('None') + else + for (final resolution in _resolutions) Text(resolution) + ], + ); + } + + Future getResolutions() async { + final callbacks = TizenInteropCallbacks(); + final port = ReceivePort(); + + final callback = callbacks.register)>( + 'camera_supported_preview_resolution_cb', + Pointer.fromFunction(_previewResolutionCallback, false), + userObject: _resolutions, + ); + + await Isolate.spawn(_getResolutions, [port.sendPort, callback]); + await port.first; + + callbacks.unregister(callback); + } + + static void _getResolutions(List message) async { + final sendPort = message[0] as SendPort; + final callback = message[1] + as RegisteredCallback)>; + + final cameraHandle = using((Arena arena) { + Pointer camera = arena(); + final ret = + tizen.camera_create(camera_device_e.CAMERA_DEVICE_CAMERA0, camera); + if (ret != 0) { + final error = tizen.get_error_message(ret).toDartString(); + print('Failed to initialize camera: $error'); + return nullptr; + } + return camera.value; + }); + + if (cameraHandle != nullptr) { + final ret = tizen.camera_foreach_supported_preview_resolution( + cameraHandle, + callback.interopCallback, + callback.interopUserData, + ); + if (ret != 0) { + final error = tizen.get_error_message(ret).toDartString(); + print('Failed to query preview resolutions: $error'); + } + + tizen.camera_destroy(cameraHandle); + } + + sendPort.send(null); + } + + static bool _previewResolutionCallback( + int width, + int height, + Pointer userData, + ) { + final resolutions = + TizenInteropCallbacks.getUserObject>(userData)!; + resolutions.add('$width x $height'); + return true; + } +} diff --git a/packages/tizen_interop_callbacks/example/pubspec.yaml b/packages/tizen_interop_callbacks/example/pubspec.yaml new file mode 100644 index 0000000..035717f --- /dev/null +++ b/packages/tizen_interop_callbacks/example/pubspec.yaml @@ -0,0 +1,20 @@ +name: tizen_interop_callbacks_example +description: Demonstrates how to use the tizen_interop_callbacks plugin. +publish_to: "none" + +environment: + sdk: ">=2.18.0 <3.0.0" + +dependencies: + ffi: ^2.0.1 + flutter: + sdk: flutter + tizen_interop: ^0.2.6 + tizen_interop_callbacks: + path: ../ + +dev_dependencies: + flutter_lints: ^2.0.0 + +flutter: + uses-material-design: true diff --git a/packages/tizen_interop_callbacks/example/tizen/.gitignore b/packages/tizen_interop_callbacks/example/tizen/.gitignore new file mode 100644 index 0000000..750f3af --- /dev/null +++ b/packages/tizen_interop_callbacks/example/tizen/.gitignore @@ -0,0 +1,5 @@ +flutter/ +.vs/ +*.user +bin/ +obj/ diff --git a/packages/tizen_interop_callbacks/example/tizen/App.cs b/packages/tizen_interop_callbacks/example/tizen/App.cs new file mode 100644 index 0000000..6dd4a63 --- /dev/null +++ b/packages/tizen_interop_callbacks/example/tizen/App.cs @@ -0,0 +1,20 @@ +using Tizen.Flutter.Embedding; + +namespace Runner +{ + public class App : FlutterApplication + { + protected override void OnCreate() + { + base.OnCreate(); + + GeneratedPluginRegistrant.RegisterPlugins(this); + } + + static void Main(string[] args) + { + var app = new App(); + app.Run(args); + } + } +} diff --git a/packages/tizen_interop_callbacks/example/tizen/Runner.csproj b/packages/tizen_interop_callbacks/example/tizen/Runner.csproj new file mode 100644 index 0000000..f4e369d --- /dev/null +++ b/packages/tizen_interop_callbacks/example/tizen/Runner.csproj @@ -0,0 +1,19 @@ + + + + Exe + tizen40 + + + + + + + + + + %(RecursiveDir) + + + + diff --git a/packages/tizen_interop_callbacks/example/tizen/shared/res/ic_launcher.png b/packages/tizen_interop_callbacks/example/tizen/shared/res/ic_launcher.png new file mode 100644 index 0000000000000000000000000000000000000000..4d6372eebdb28e45604e46eeda8dd24651419bc0 GIT binary patch literal 1443 zcmb`G{WsKk6vsdJTdFg%tJav9_E4vzrOaqkWF|A724Nly!y+?N9`YV6wZ}5(X(D_N(?!*n3`|_r0Hc?=PQw&*vnU?QTFY zB_MsH|!j$PP;I}?dppoE_gA(4uc!jV&0!l7_;&p2^pxNo>PEcNJv za5_RT$o2Mf!<+r?&EbHH6nMoTsDOa;mN(wv8RNsHpG)`^ymG-S5By8=l9iVXzN_eG%Xg2@Xeq76tTZ*dGh~Lo9vl;Zfs+W#BydUw zCkZ$o1LqWQO$FC9aKlLl*7x9^0q%0}$OMlp@Kk_jHXOjofdePND+j!A{q!8~Jn+s3 z?~~w@4?egS02}8NuulUA=L~QQfm;MzCGd)XhiftT;+zFO&JVyp2mBww?;QByS_1w! zrQlx%{^cMj0|Bo1FjwY@Q8?Hx0cIPF*@-ZRFpPc#bBw{5@tD(5%sClzIfl8WU~V#u zm5Q;_F!wa$BSpqhN>W@2De?TKWR*!ujY;Yylk_X5#~V!L*Gw~;$%4Q8~Mad z@`-kG?yb$a9cHIApZDVZ^U6Xkp<*4rU82O7%}0jjHlK{id@?-wpN*fCHXyXh(bLt* zPc}H-x0e4E&nQ>y%B-(EL=9}RyC%MyX=upHuFhAk&MLbsF0LP-q`XnH78@fT+pKPW zu72MW`|?8ht^tz$iC}ZwLp4tB;Q49K!QCF3@!iB1qOI=?w z7In!}F~ij(18UYUjnbmC!qKhPo%24?8U1x{7o(+?^Zu0Hx81|FuS?bJ0jgBhEMzf< zCgUq7r2OCB(`XkKcN-TL>u5y#dD6D!)5W?`O5)V^>jb)P)GBdy%t$uUMpf$SNV31$ zb||OojAbvMP?T@$h_ZiFLFVHDmbyMhJF|-_)HX3%m=CDI+ID$0^C>kzxprBW)hw(v zr!Gmda);ICoQyhV_oP5+C%?jcG8v+D@9f?Dk*!BxY}dazmrT@64UrP3hlslANK)bq z$67n83eh}OeW&SV@HG95P|bjfqJ7gw$e+`Hxo!4cx`jdK1bJ>YDSpGKLPZ^1cv$ek zIB?0S<#tX?SJCLWdMd{-ME?$hc7A$zBOdIJ)4!KcAwb=VMov)nK;9z>x~rfT1>dS+ zZ6#`2v@`jgbqq)P22H)Tx2CpmM^o1$B+xT6`(v%5xJ(?j#>Q$+rx_R|7TzDZe{J6q zG1*EcU%tE?!kO%^M;3aM6JN*LAKUVb^xz8-Pxo#jR5(-KBeLJvA@-gxNHx0M-ZJLl z;#JwQoh~9V?`UVo#}{6ka@II>++D@%KqGpMdlQ}?9E*wFcf5(#XQnP$Dk5~%iX^>f z%$y;?M0BLp{O3a(-4A?ewryHrrD%cx#Q^%KY1H zNre$ve+vceSLZcNY4U(RBX&)oZn*Py()h)XkE?PL$!bNb{N5FVI2Y%LKEm%yvpyTP z(1P?z~7YxD~Rf<(a@_y` literal 0 HcmV?d00001 diff --git a/packages/tizen_interop_callbacks/example/tizen/tizen-manifest.xml b/packages/tizen_interop_callbacks/example/tizen/tizen-manifest.xml new file mode 100644 index 0000000..67306c6 --- /dev/null +++ b/packages/tizen_interop_callbacks/example/tizen/tizen-manifest.xml @@ -0,0 +1,10 @@ + + + + + + ic_launcher.png + + + + diff --git a/packages/tizen_interop_callbacks/lib/tizen_interop_callbacks.dart b/packages/tizen_interop_callbacks/lib/tizen_interop_callbacks.dart new file mode 100644 index 0000000..8b11033 --- /dev/null +++ b/packages/tizen_interop_callbacks/lib/tizen_interop_callbacks.dart @@ -0,0 +1,348 @@ +// Copyright 2023 Samsung Electronics Co., Ltd. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +import 'dart:ffi'; +import 'dart:isolate'; + +import 'package:ffi/ffi.dart'; +import 'package:tizen_log/tizen_log.dart'; + +const int _kProxyInstanceCount = 5; +const String _kLogTag = 'TizenInteropCallbacksPlugin'; + +/// Opaque type representing a wrapper function pointer. +class _CallbackWrapper extends Opaque {} + +// const _logDebug = Log.debug; +void _logDebug(String tag, String message) {} + +/// Class for storing data about registered callback. +/// +/// Obtained by calling [TizenInteropCallbacks.register]. +/// +/// [interopCallback] and [interopUserData] should be passed as arguments to +/// Native API calls. +class RegisteredCallback { + RegisteredCallback._( + this.id, + this.callbackName, + this.platformCallbackName, + this.proxyIndex, + Pointer> interopCallback, + ) : _proxyCallback = interopCallback.address; + + /// Unique identifier of the callback instance. + final int id; + + /// Name of the callback defined in Tizen Native API. + final String callbackName; + + /// Name of the proxy callback. [callbackName] prefixed with either + /// `platform_blocking_` or `platform_non_blocking_`. + final String platformCallbackName; + + /// Index identifying which of multiple proxies is used for this registered + /// callback. + final int proxyIndex; + + /// The pointer that will be used in native callback setter/adder. + Pointer> get interopCallback => + Pointer.fromAddress(_proxyCallback); + final int _proxyCallback; + + /// User data pointer to be used in native callback setter/adder. + Pointer get interopUserData => Pointer.fromAddress(id); +} + +/// Class which manages wrappers and registration of callbacks. +/// +/// This class must be instantiated only once, preferrably in the root isolate, +/// because the callbacks will be executed in the thread used for initialization +/// and will have access to objects in that isolate. +/// +/// The purpose of this class is to solve the issue related to error message: +/// `Cannot invoke native callback outside an isolate`. If you are not +/// receiving such an error message, that means you don't need this class. +/// +/// Before your callback can be called by some Tizen Native API module, +/// you should register it and pass [RegisteredCallback.interopCallback] +/// and [RegisteredCallback.interopUserData] to the Native API: +/// +/// ```dart +/// final batteryCallback = +/// _callbacks.register, Pointer)>( +/// 'device_changed_cb', +/// Pointer.fromFunction(_batteryChanged), +/// userObject: userObject, +/// ); +/// tizen.device_add_callback( +/// device_callback_e.DEVICE_CALLBACK_BATTERY_CAPACITY, +/// batteryCallback.interopCallback, +/// batteryCallback.interopUserData, +/// ); +/// ``` +/// +/// See [register] for additional information. +class TizenInteropCallbacks { + /// Returns an instance of [TizenInteropCallbacks]. + /// + /// The first access to this [TizenInteropCallbacks] instance should be + /// performed from the root isolate - the one with your `main` entry point + /// and `runApp` call. + /// + /// Subsequent calls will return the same instance. + factory TizenInteropCallbacks() { + _instance ??= TizenInteropCallbacks._internal(); + return _instance!; + } + + TizenInteropCallbacks._internal() { + final nativeCallbackCalls = ReceivePort()..listen(_callbackCallRequested); + + final nativePort = nativeCallbackCalls.sendPort.nativePort; + final registerSendPort = _process + .lookup>( + 'TizenInteropCallbacksRegisterSendPort') + .asFunction(); + _logDebug(_kLogTag, 'calling registerSendPort()'); + final res = registerSendPort(nativePort); + if (res == 1) { + throw Exception( + 'TizenInteropCallbacks already initialized in another isolate.'); + } + + final initApi = _process + .lookup>( + 'TizenInteropCallbacksInitDartApi') + .asFunction(); + _logDebug(_kLogTag, 'calling initApi()'); + initApi(NativeApi.initializeApiDLData); + + _registerWrappedCallback = _process + .lookup< + NativeFunction< + _RegistrationResult Function(Pointer, Pointer, + Int32)>>('TizenInteropCallbacksRegisterWrappedCallback') + .asFunction(); + _unregisterWrappedCallback = _process + .lookup>( + 'TizenInteropCallbacksUnregisterWrappedCallback') + .asFunction(); + _runCallbackNative = _process + .lookup>( + 'TizenInteropCallbacksRunCallback') + .asFunction(); + _platformProxyExists = _process + .lookup)>>( + 'TizenInteropCallbacksProxyExists') + .asFunction(); + } + + static TizenInteropCallbacks? _instance; + + final DynamicLibrary _process = DynamicLibrary.process(); + + // Input arguments: + // - user_callback (Pointer): A pointer to the Dart callback. + // - proxy_name (Pointer): A pointer to the name of multi proxy callback. + // - proxy_num (int): A proxy index number. + late final _RegistrationResult Function(Pointer, Pointer, int) + _registerWrappedCallback; + + late final void Function(int) _unregisterWrappedCallback; + late final void Function(Pointer) _runCallbackNative; + late final bool Function(Pointer) _platformProxyExists; + + static final Map _userObjectStore = {}; + static final Object _nullUserObjectMarker = Object(); + + final Map> _multiProxyFlags = {}; + + void _callbackCallRequested(dynamic message) { + final callback = Pointer<_CallbackWrapper>.fromAddress(message as int); + _logDebug(_kLogTag, + 'calling runCallbackNative(), callback: ${callback.address.toRadixString(16)}'); + _runCallbackNative(callback); + _logDebug(_kLogTag, 'after calling runCallbackNative()'); + } + + int _getFirstFreeIndex(List list) { + return list.indexWhere((bool flag) => flag == false); + } + + /// Registers a callback and returns wrapper/proxy data to be used in Native + /// API calls. + /// + /// To specify signature of wrapper callbacks, the name of Native API callback + /// defined in header file (such as `device_changed_cb`) must be provided as + /// [callbackName]. + /// + /// [Pointer.fromFunction] can be used to convert a Dart callback to an FFI + /// pointer passed as the [callback] parameter. + /// The requirements of [Pointer.fromFunction] applies, i.e. the function must + /// be a static or free function. If the function returns anything, a fallback + /// return value must be specifed - a value that will be used if the Dart + /// callback throws an exception. + /// + /// [NativeCbType] must match the signature of the Native API callback. The + /// proper type can be found in the relevant `generated_binding.dart` file, + /// by looking for the typedef of the callback. + /// The match is verified when [RegisteredCallback.interopCallback] is passed + /// to the Native API. + /// + /// Most Tizen Native API callbacks allow passing arbitrary `user_data` in the + /// form of `void*`. You can provide [userObject] and then, inside your Dart + /// callback, use [TizenInteropCallbacks.getUserObject] with the received + /// `user_data` to retrieve the object back. + /// If [userObject] is null, `nullptr` will be passed. + /// + /// The plugin chooses non-blocking callback if possible - i.e. blocking will + /// be used for callbacks which return anything. You can override the behavior + /// by setting [blocking]. + /// Note that using blocking callback will block the thread the native module + /// will call the callback on. In some cases, Native API invocation must be + /// performed in separate thread/isolate. + /// + /// ```dart + /// static void _batteryChanged( + /// int type, + /// Pointer value, + /// Pointer userData, + /// ) { + /// ... + /// } + /// + /// final batteryCallback = + /// _callbacks.register, Pointer)>( + /// 'device_changed_cb', + /// Pointer.fromFunction(_batteryChanged), + /// ); + /// ``` + RegisteredCallback register( + String callbackName, + Pointer> callback, { + Object? userObject, + bool? blocking, + }) { + final nonBlockingCallbackNamePtr = + 'platform_non_blocking_$callbackName'.toNativeUtf8(); + _logDebug(_kLogTag, 'calling platformProxyExists()'); + blocking ??= !_platformProxyExists(nonBlockingCallbackNamePtr); + calloc.free(nonBlockingCallbackNamePtr); + + String platformCallbackName; + if (blocking) { + platformCallbackName = 'platform_blocking_$callbackName'; + } else { + platformCallbackName = 'platform_non_blocking_$callbackName'; + } + + if (!_multiProxyFlags.containsKey(platformCallbackName)) { + _multiProxyFlags[platformCallbackName] = + List.filled(_kProxyInstanceCount, false); + } + + final proxyIndex = + _getFirstFreeIndex(_multiProxyFlags[platformCallbackName]!); + if (proxyIndex == -1) { + throw Exception('Exhausted pool of $platformCallbackName proxies.'); + } + _logDebug(_kLogTag, + 'setting proxy index $proxyIndex for $platformCallbackName as used'); + _multiProxyFlags[platformCallbackName]![proxyIndex] = true; + + final platformCallbackNamePtr = platformCallbackName.toNativeUtf8(); + _logDebug(_kLogTag, + 'calling registerWrappedCallback(), callback: ${callback.address.toRadixString(16)}'); + final result = + _registerWrappedCallback(callback, platformCallbackNamePtr, proxyIndex); + calloc.free(platformCallbackNamePtr); + + final platformCallback = + result.callback.cast>(); + _logDebug(_kLogTag, 'after calling registerWrappedCallback()'); + if (platformCallback == nullptr) { + throw Exception('Failed to register callback.'); + } + + _logDebug(_kLogTag, 'saving userObjectStore[${result.id}] = $userObject'); + _userObjectStore[result.id] = userObject ?? _nullUserObjectMarker; + + return RegisteredCallback._( + result.id, + callbackName, + platformCallbackName, + proxyIndex, + platformCallback, + ); + } + + /// Unregisters a callback and deletes all its associated data. + void unregister(RegisteredCallback registeredCallback) { + final platformCallbackName = registeredCallback.platformCallbackName; + final proxyIndex = registeredCallback.proxyIndex; + + if (_multiProxyFlags[platformCallbackName]![proxyIndex]) { + _multiProxyFlags[platformCallbackName]![proxyIndex] = false; + } else { + Log.warn(_kLogTag, + 'Tried to remove non-existent proxy $proxyIndex for $platformCallbackName.'); + } + _userObjectStore.remove(registeredCallback.id); + _logDebug(_kLogTag, + 'calling unregisterWrappedCallback(), id: ${registeredCallback.id}'); + _unregisterWrappedCallback(registeredCallback.id); + } + + /// Retrieves an object passed as `userObject` to [register]. + /// + /// When `userObject` is used with [register], that object is stored + /// internally and `interopUserData` of the returned [RegisteredCallback] + /// holds the key to that object. The `user_data` received by callback should + /// be passed to this function to retrieve the stored object. + /// + /// `null` is returned if no object associated with [userData] is found. + /// + /// ```dart + /// static void _batteryChanged( + /// int type, + /// Pointer value, + /// Pointer userData, + /// ) { + /// final userObject = TizenInteropCallbacks.getUserObject(userData); + /// ... + /// } + /// + /// final batteryCallback = + /// _callbacks.register, Pointer)>( + /// 'device_changed_cb', + /// Pointer.fromFunction(_batteryChanged), + /// userObject: userObject, + /// ); + /// ``` + /// + /// Note that this is not intended for passing objects across threads. + /// You should access [TizenInteropCallbacks] from a single isolate only. + static T? getUserObject(Pointer userData) { + if (_userObjectStore.containsKey(userData.address)) { + var object = _userObjectStore[userData.address]; + if (identical(object, _nullUserObjectMarker)) object = null; + _logDebug(_kLogTag, 'getting from store ${userData.address} -> $object'); + return object as T?; + } else { + Log.warn(_kLogTag, + 'getUserObject(): key ${userData.address} not found, returning null'); + return null; + } + } +} + +class _RegistrationResult extends Struct { + /// The native proxy callback to be used with Native API. + external Pointer callback; + + /// The registration ID. + @Uint32() + external int id; +} diff --git a/packages/tizen_interop_callbacks/pubspec.yaml b/packages/tizen_interop_callbacks/pubspec.yaml new file mode 100644 index 0000000..9e816fd --- /dev/null +++ b/packages/tizen_interop_callbacks/pubspec.yaml @@ -0,0 +1,25 @@ +name: tizen_interop_callbacks +description: Cross-thread callbacks for Tizen native APIs. +homepage: https://github.com/flutter-tizen/tizen_interop +repository: https://github.com/flutter-tizen/tizen_interop/tree/main/packages/tizen_interop_callbacks +version: 0.1.0 + +environment: + sdk: ">=2.18.0 <3.0.0" + flutter: ">=2.5.0" + +dependencies: + ffi: ^2.0.1 + flutter: + sdk: flutter + tizen_log: ^0.1.2 + +dev_dependencies: + flutter_lints: ^2.0.1 + +flutter: + plugin: + platforms: + tizen: + pluginClass: TizenInteropCallbacksPlugin + fileName: tizen_interop_callbacks_plugin.h diff --git a/packages/tizen_interop_callbacks/tizen/.gitignore b/packages/tizen_interop_callbacks/tizen/.gitignore new file mode 100644 index 0000000..a2a7d62 --- /dev/null +++ b/packages/tizen_interop_callbacks/tizen/.gitignore @@ -0,0 +1,5 @@ +.cproject +.sign +crash-info/ +Debug/ +Release/ diff --git a/packages/tizen_interop_callbacks/tizen/inc/tizen_interop_callbacks_plugin.h b/packages/tizen_interop_callbacks/tizen/inc/tizen_interop_callbacks_plugin.h new file mode 100644 index 0000000..a9348b3 --- /dev/null +++ b/packages/tizen_interop_callbacks/tizen/inc/tizen_interop_callbacks_plugin.h @@ -0,0 +1,53 @@ +#ifndef FLUTTER_PLUGIN_TIZEN_INTEROP_CALLBACKS_PLUGIN_H_ +#define FLUTTER_PLUGIN_TIZEN_INTEROP_CALLBACKS_PLUGIN_H_ + +#include +#include + +#include +#include + +#ifdef FLUTTER_PLUGIN_IMPL +#define FLUTTER_PLUGIN_EXPORT __attribute__((visibility("default"))) +#else +#define FLUTTER_PLUGIN_EXPORT +#endif + +struct RegistrationResult { + void *callback; + uint32_t id; +}; + +// Used to hold lambda capturing callback info and parameters. +typedef std::function CallbackWrapper; + +#if defined(__cplusplus) +extern "C" { +#endif + +FLUTTER_PLUGIN_EXPORT void TizenInteropCallbacksPluginRegisterWithRegistrar( + FlutterDesktopPluginRegistrarRef registrar); + +FLUTTER_PLUGIN_EXPORT intptr_t TizenInteropCallbacksInitDartApi(void *data); + +FLUTTER_PLUGIN_EXPORT int32_t +TizenInteropCallbacksRegisterSendPort(Dart_Port port); + +FLUTTER_PLUGIN_EXPORT RegistrationResult +TizenInteropCallbacksRegisterWrappedCallback(void *user_callback, + const char *proxy_name, + int32_t proxy_num); + +FLUTTER_PLUGIN_EXPORT void TizenInteropCallbacksUnregisterWrappedCallback( + uint32_t callback_id); + +FLUTTER_PLUGIN_EXPORT void TizenInteropCallbacksRunCallback( + CallbackWrapper *wrapper_pointer); + +FLUTTER_PLUGIN_EXPORT bool TizenInteropCallbacksProxyExists(const char *name); + +#if defined(__cplusplus) +} // extern "C" +#endif + +#endif // FLUTTER_PLUGIN_TIZEN_INTEROP_CALLBACKS_PLUGIN_H_ diff --git a/packages/tizen_interop_callbacks/tizen/project_def.prop b/packages/tizen_interop_callbacks/tizen/project_def.prop new file mode 100644 index 0000000..95e96e8 --- /dev/null +++ b/packages/tizen_interop_callbacks/tizen/project_def.prop @@ -0,0 +1,20 @@ +# See https://docs.tizen.org/application/tizen-studio/native-tools/project-conversion +# for details. + +APPNAME = tizen_interop_callbacks_plugin +type = staticLib +profile = common-4.0 + +# Source files +USER_SRCS += src/*.cc + +# User defines +USER_DEFS = +USER_UNDEFS = +USER_CPP_DEFS = FLUTTER_PLUGIN_IMPL +USER_CPP_UNDEFS = + +# User includes +USER_INC_DIRS = inc +USER_INC_FILES = +USER_CPP_INC_FILES = diff --git a/packages/tizen_interop_callbacks/tizen/src/generated_callbacks.cc b/packages/tizen_interop_callbacks/tizen/src/generated_callbacks.cc new file mode 100644 index 0000000..177416d --- /dev/null +++ b/packages/tizen_interop_callbacks/tizen/src/generated_callbacks.cc @@ -0,0 +1,5746 @@ +#include "tizen_interop_callbacks_plugin.h" + +#include +#include +#include + +#include "macros.h" +#include "types.h" + +static_assert(kProxyInstanceCount == 5, "Callbacks instances count mismatch"); +static constexpr int32_t kNoUserDataCallbackCount = 54; + +uint32_t reserved_callback_ids[kProxyInstanceCount * kNoUserDataCallbackCount] = {}; + +typedef bool (*account_cb)(void* account, void* user_data); +#define CB_PARAMS_NAMES account, user_data +PROXY_GROUP_RETURN(account_cb, bool, void* account, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*account_custom_cb)(char* key, char* value, void* user_data); +#define CB_PARAMS_NAMES key, value, user_data +PROXY_GROUP_RETURN(account_custom_cb, bool, char* key, char* value, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*account_event_cb)(const char* event_type, int account_id, void* user_data); +#define CB_PARAMS_NAMES event_type, account_id, user_data +PROXY_GROUP_RETURN(account_event_cb, bool, const char* event_type, int account_id, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*account_label_cb)(char* app_id, char* label, char* locale, void* user_data); +#define CB_PARAMS_NAMES app_id, label, locale, user_data +PROXY_GROUP_RETURN(account_label_cb, bool, char* app_id, char* label, char* locale, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*account_type_cb)(void* account_type, void* user_data); +#define CB_PARAMS_NAMES account_type, user_data +PROXY_GROUP_RETURN(account_type_cb, bool, void* account_type, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*activity_recognition_cb)(some_enum activity, const void* data, double timestamp, some_enum error, void* user_data); +#define CB_PARAMS_NAMES activity, data, timestamp, error, user_data +PROXY_GROUP_NON_BLOCKING(activity_recognition_cb, some_enum activity, const void* data, double timestamp, some_enum error, void* user_data) +PROXY_GROUP_BLOCKING(activity_recognition_cb, some_enum activity, const void* data, double timestamp, some_enum error, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*alarm_registered_alarm_cb)(int alarm_id, void* user_data); +#define CB_PARAMS_NAMES alarm_id, user_data +PROXY_GROUP_RETURN(alarm_registered_alarm_cb, bool, int alarm_id, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*app_control_action_cb)(const char* action, void* app_control, void* user_data); +#define CB_PARAMS_NAMES action, app_control, user_data +PROXY_GROUP_NON_BLOCKING(app_control_action_cb, const char* action, void* app_control, void* user_data) +PROXY_GROUP_BLOCKING(app_control_action_cb, const char* action, void* app_control, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*app_control_app_matched_cb)(void* app_control, const char* appid, void* user_data); +#define CB_PARAMS_NAMES app_control, appid, user_data +PROXY_GROUP_RETURN(app_control_app_matched_cb, bool, void* app_control, const char* appid, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*app_control_cb)(void* app_control, void* user_data); +#define CB_PARAMS_NAMES app_control, user_data +PROXY_GROUP_NON_BLOCKING(app_control_cb, void* app_control, void* user_data) +PROXY_GROUP_BLOCKING(app_control_cb, void* app_control, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*app_control_extra_data_cb)(void* app_control, const char* key, void* user_data); +#define CB_PARAMS_NAMES app_control, key, user_data +PROXY_GROUP_RETURN(app_control_extra_data_cb, bool, void* app_control, const char* key, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*app_control_reply_cb)(void* request, void* reply, some_enum result, void* user_data); +#define CB_PARAMS_NAMES request, reply, result, user_data +PROXY_GROUP_NON_BLOCKING(app_control_reply_cb, void* request, void* reply, some_enum result, void* user_data) +PROXY_GROUP_BLOCKING(app_control_reply_cb, void* request, void* reply, some_enum result, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*app_control_result_cb)(void* request, some_enum result, void* user_data); +#define CB_PARAMS_NAMES request, result, user_data +PROXY_GROUP_NON_BLOCKING(app_control_result_cb, void* request, some_enum result, void* user_data) +PROXY_GROUP_BLOCKING(app_control_result_cb, void* request, some_enum result, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*app_control_uri_query_foreach_cb)(const char* key, const char* val, void* user_data); +#define CB_PARAMS_NAMES key, val, user_data +PROXY_GROUP_RETURN(app_control_uri_query_foreach_cb, bool, const char* key, const char* val, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*app_create_cb)(void* user_data); +#define CB_PARAMS_NAMES user_data +PROXY_GROUP_RETURN(app_create_cb, bool, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*app_event_cb)(void* event_info, void* user_data); +#define CB_PARAMS_NAMES event_info, user_data +PROXY_GROUP_NON_BLOCKING(app_event_cb, void* event_info, void* user_data) +PROXY_GROUP_BLOCKING(app_event_cb, void* event_info, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*app_info_category_cb)(const char* category, void* user_data); +#define CB_PARAMS_NAMES category, user_data +PROXY_GROUP_RETURN(app_info_category_cb, bool, const char* category, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*app_info_filter_cb)(void* app_info, void* user_data); +#define CB_PARAMS_NAMES app_info, user_data +PROXY_GROUP_RETURN(app_info_filter_cb, bool, void* app_info, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*app_info_metadata_cb)(const char* metadata_key, const char* metadata_value, void* user_data); +#define CB_PARAMS_NAMES metadata_key, metadata_value, user_data +PROXY_GROUP_RETURN(app_info_metadata_cb, bool, const char* metadata_key, const char* metadata_value, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*app_info_res_control_cb)(const char* res_type, const char* min_res_version, const char* max_res_version, const char* auto_close, void* user_data); +#define CB_PARAMS_NAMES res_type, min_res_version, max_res_version, auto_close, user_data +PROXY_GROUP_RETURN(app_info_res_control_cb, bool, const char* res_type, const char* min_res_version, const char* max_res_version, const char* auto_close, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*app_manager_app_context_cb)(void* app_context, void* user_data); +#define CB_PARAMS_NAMES app_context, user_data +PROXY_GROUP_RETURN(app_manager_app_context_cb, bool, void* app_context, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*app_manager_app_context_event_cb)(void* app_context, some_enum event, void* user_data); +#define CB_PARAMS_NAMES app_context, event, user_data +PROXY_GROUP_NON_BLOCKING(app_manager_app_context_event_cb, void* app_context, some_enum event, void* user_data) +PROXY_GROUP_BLOCKING(app_manager_app_context_event_cb, void* app_context, some_enum event, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*app_manager_app_info_cb)(void* app_info, void* user_data); +#define CB_PARAMS_NAMES app_info, user_data +PROXY_GROUP_RETURN(app_manager_app_info_cb, bool, void* app_info, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*app_manager_event_cb)(const char* type, const char* app_id, some_enum event_type, some_enum event_state, void* handle, void* user_data); +#define CB_PARAMS_NAMES type, app_id, event_type, event_state, handle, user_data +PROXY_GROUP_NON_BLOCKING(app_manager_event_cb, const char* type, const char* app_id, some_enum event_type, some_enum event_state, void* handle, void* user_data) +PROXY_GROUP_BLOCKING(app_manager_event_cb, const char* type, const char* app_id, some_enum event_type, some_enum event_state, void* handle, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*app_pause_cb)(void* user_data); +#define CB_PARAMS_NAMES user_data +PROXY_GROUP_NON_BLOCKING(app_pause_cb, void* user_data) +PROXY_GROUP_BLOCKING(app_pause_cb, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*app_resume_cb)(void* user_data); +#define CB_PARAMS_NAMES user_data +PROXY_GROUP_NON_BLOCKING(app_resume_cb, void* user_data) +PROXY_GROUP_BLOCKING(app_resume_cb, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*app_terminate_cb)(void* user_data); +#define CB_PARAMS_NAMES user_data +PROXY_GROUP_NON_BLOCKING(app_terminate_cb, void* user_data) +PROXY_GROUP_BLOCKING(app_terminate_cb, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*asp_advert_status_changed_cb)(void* adv_service, some_enum status, some_enum reason, void* user_data); +#define CB_PARAMS_NAMES adv_service, status, reason, user_data +PROXY_GROUP_NON_BLOCKING(asp_advert_status_changed_cb, void* adv_service, some_enum status, some_enum reason, void* user_data) +PROXY_GROUP_BLOCKING(asp_advert_status_changed_cb, void* adv_service, some_enum status, some_enum reason, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*asp_seek_search_result_cb)(int error_code, void* seek_service, const char* service_mac, unsigned int adv_id, some_enum config_method, const char* instance_name, const char* service_info, int info_size, unsigned char status, void* user_data); +#define CB_PARAMS_NAMES error_code, seek_service, service_mac, adv_id, config_method, instance_name, service_info, info_size, status, user_data +PROXY_GROUP_NON_BLOCKING(asp_seek_search_result_cb, int error_code, void* seek_service, const char* service_mac, unsigned int adv_id, some_enum config_method, const char* instance_name, const char* service_info, int info_size, unsigned char status, void* user_data) +PROXY_GROUP_BLOCKING(asp_seek_search_result_cb, int error_code, void* seek_service, const char* service_mac, unsigned int adv_id, some_enum config_method, const char* instance_name, const char* service_info, int info_size, unsigned char status, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*asp_session_config_request_cb)(int error_code, void* session, bool get_pin, const char* config_pin, void* user_data); +#define CB_PARAMS_NAMES error_code, session, get_pin, config_pin, user_data +PROXY_GROUP_NON_BLOCKING(asp_session_config_request_cb, int error_code, void* session, bool get_pin, const char* config_pin, void* user_data) +PROXY_GROUP_BLOCKING(asp_session_config_request_cb, int error_code, void* session, bool get_pin, const char* config_pin, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*asp_session_connect_status_cb)(int error_code, void* session, some_enum status, const char* deferred_resp, int resp_size, void* user_data); +#define CB_PARAMS_NAMES error_code, session, status, deferred_resp, resp_size, user_data +PROXY_GROUP_NON_BLOCKING(asp_session_connect_status_cb, int error_code, void* session, some_enum status, const char* deferred_resp, int resp_size, void* user_data) +PROXY_GROUP_BLOCKING(asp_session_connect_status_cb, int error_code, void* session, some_enum status, const char* deferred_resp, int resp_size, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*asp_session_port_status_cb)(int error_code, void* session, const char* ip_address, int port, int proto, some_enum status, void* user_data); +#define CB_PARAMS_NAMES error_code, session, ip_address, port, proto, status, user_data +PROXY_GROUP_NON_BLOCKING(asp_session_port_status_cb, int error_code, void* session, const char* ip_address, int port, int proto, some_enum status, void* user_data) +PROXY_GROUP_BLOCKING(asp_session_port_status_cb, int error_code, void* session, const char* ip_address, int port, int proto, some_enum status, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*asp_session_request_cb)(int error_code, void* adv_service, void* session, const char* device_name, const char* info, int info_size, bool get_network_config_pin, const char* network_config_pin, void* user_data); +#define CB_PARAMS_NAMES error_code, adv_service, session, device_name, info, info_size, get_network_config_pin, network_config_pin, user_data +PROXY_GROUP_NON_BLOCKING(asp_session_request_cb, int error_code, void* adv_service, void* session, const char* device_name, const char* info, int info_size, bool get_network_config_pin, const char* network_config_pin, void* user_data) +PROXY_GROUP_BLOCKING(asp_session_request_cb, int error_code, void* adv_service, void* session, const char* device_name, const char* info, int info_size, bool get_network_config_pin, const char* network_config_pin, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*asp_session_status_cb)(int error_code, void* session, some_enum state, const char* additional_info, void* user_data); +#define CB_PARAMS_NAMES error_code, session, state, additional_info, user_data +PROXY_GROUP_NON_BLOCKING(asp_session_status_cb, int error_code, void* session, some_enum state, const char* additional_info, void* user_data) +PROXY_GROUP_BLOCKING(asp_session_status_cb, int error_code, void* session, some_enum state, const char* additional_info, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*audio_in_state_changed_cb)(void* handle, some_enum previous, some_enum current, bool by_policy, void* user_data); +#define CB_PARAMS_NAMES handle, previous, current, by_policy, user_data +PROXY_GROUP_NON_BLOCKING(audio_in_state_changed_cb, void* handle, some_enum previous, some_enum current, bool by_policy, void* user_data) +PROXY_GROUP_BLOCKING(audio_in_state_changed_cb, void* handle, some_enum previous, some_enum current, bool by_policy, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*audio_in_stream_cb)(void* handle, size_t nbytes, void* user_data); +#define CB_PARAMS_NAMES handle, nbytes, user_data +PROXY_GROUP_NON_BLOCKING(audio_in_stream_cb, void* handle, size_t nbytes, void* user_data) +PROXY_GROUP_BLOCKING(audio_in_stream_cb, void* handle, size_t nbytes, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*audio_io_interrupted_cb)(some_enum code, void* user_data); +#define CB_PARAMS_NAMES code, user_data +PROXY_GROUP_NON_BLOCKING(audio_io_interrupted_cb, some_enum code, void* user_data) +PROXY_GROUP_BLOCKING(audio_io_interrupted_cb, some_enum code, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*audio_out_state_changed_cb)(void* handle, some_enum previous, some_enum current, bool by_policy, void* user_data); +#define CB_PARAMS_NAMES handle, previous, current, by_policy, user_data +PROXY_GROUP_NON_BLOCKING(audio_out_state_changed_cb, void* handle, some_enum previous, some_enum current, bool by_policy, void* user_data) +PROXY_GROUP_BLOCKING(audio_out_state_changed_cb, void* handle, some_enum previous, some_enum current, bool by_policy, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*audio_out_stream_cb)(void* handle, size_t nbytes, void* user_data); +#define CB_PARAMS_NAMES handle, nbytes, user_data +PROXY_GROUP_NON_BLOCKING(audio_out_stream_cb, void* handle, size_t nbytes, void* user_data) +PROXY_GROUP_BLOCKING(audio_out_stream_cb, void* handle, size_t nbytes, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*autofill_auth_info_received_cb)(void* ah, void* auth_info, void* user_data); +#define CB_PARAMS_NAMES ah, auth_info, user_data +PROXY_GROUP_NON_BLOCKING(autofill_auth_info_received_cb, void* ah, void* auth_info, void* user_data) +PROXY_GROUP_BLOCKING(autofill_auth_info_received_cb, void* ah, void* auth_info, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*autofill_connection_status_changed_cb)(void* ah, some_enum status, void* user_data); +#define CB_PARAMS_NAMES ah, status, user_data +PROXY_GROUP_NON_BLOCKING(autofill_connection_status_changed_cb, void* ah, some_enum status, void* user_data) +PROXY_GROUP_BLOCKING(autofill_connection_status_changed_cb, void* ah, some_enum status, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*autofill_error_info_received_cb)(void* ah, void* error_info, void* user_data); +#define CB_PARAMS_NAMES ah, error_info, user_data +PROXY_GROUP_NON_BLOCKING(autofill_error_info_received_cb, void* ah, void* error_info, void* user_data) +PROXY_GROUP_BLOCKING(autofill_error_info_received_cb, void* ah, void* error_info, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*autofill_fill_response_group_cb)(void* item, void* user_data); +#define CB_PARAMS_NAMES item, user_data +PROXY_GROUP_RETURN(autofill_fill_response_group_cb, bool, void* item, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*autofill_fill_response_item_cb)(void* item, void* user_data); +#define CB_PARAMS_NAMES item, user_data +PROXY_GROUP_RETURN(autofill_fill_response_item_cb, bool, void* item, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*autofill_fill_response_received_cb)(void* ah, void* fill_response_h, void* user_data); +#define CB_PARAMS_NAMES ah, fill_response_h, user_data +PROXY_GROUP_NON_BLOCKING(autofill_fill_response_received_cb, void* ah, void* fill_response_h, void* user_data) +PROXY_GROUP_BLOCKING(autofill_fill_response_received_cb, void* ah, void* fill_response_h, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*autofill_item_cb)(void* item, void* user_data); +#define CB_PARAMS_NAMES item, user_data +PROXY_GROUP_RETURN(autofill_item_cb, bool, void* item, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*autofill_manager_autofill_service_cb)(const char* app_id, void* user_data); +#define CB_PARAMS_NAMES app_id, user_data +PROXY_GROUP_RETURN(autofill_manager_autofill_service_cb, bool, const char* app_id, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*autofill_manager_connection_status_changed_cb)(void* amh, some_enum status, void* user_data); +#define CB_PARAMS_NAMES amh, status, user_data +PROXY_GROUP_NON_BLOCKING(autofill_manager_connection_status_changed_cb, void* amh, some_enum status, void* user_data) +PROXY_GROUP_BLOCKING(autofill_manager_connection_status_changed_cb, void* amh, some_enum status, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*autofill_save_item_cb)(void* item, void* user_data); +#define CB_PARAMS_NAMES item, user_data +PROXY_GROUP_RETURN(autofill_save_item_cb, bool, void* item, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*autofill_service_auth_info_requested_cb)(int context_id, void* vi, void* user_data); +#define CB_PARAMS_NAMES context_id, vi, user_data +PROXY_GROUP_NON_BLOCKING(autofill_service_auth_info_requested_cb, int context_id, void* vi, void* user_data) +PROXY_GROUP_BLOCKING(autofill_service_auth_info_requested_cb, int context_id, void* vi, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*autofill_service_cancel_fill_requested_cb)(int context_id, void* vi, void* user_data); +#define CB_PARAMS_NAMES context_id, vi, user_data +PROXY_GROUP_NON_BLOCKING(autofill_service_cancel_fill_requested_cb, int context_id, void* vi, void* user_data) +PROXY_GROUP_BLOCKING(autofill_service_cancel_fill_requested_cb, int context_id, void* vi, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*autofill_service_committed_cb)(int context_id, void* vi, void* user_data); +#define CB_PARAMS_NAMES context_id, vi, user_data +PROXY_GROUP_NON_BLOCKING(autofill_service_committed_cb, int context_id, void* vi, void* user_data) +PROXY_GROUP_BLOCKING(autofill_service_committed_cb, int context_id, void* vi, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*autofill_service_fill_requested_cb)(int context_id, void* vi, void* user_data); +#define CB_PARAMS_NAMES context_id, vi, user_data +PROXY_GROUP_NON_BLOCKING(autofill_service_fill_requested_cb, int context_id, void* vi, void* user_data) +PROXY_GROUP_BLOCKING(autofill_service_fill_requested_cb, int context_id, void* vi, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*autofill_service_terminate_received_cb)(void* user_data); +#define CB_PARAMS_NAMES user_data +PROXY_GROUP_NON_BLOCKING(autofill_service_terminate_received_cb, void* user_data) +PROXY_GROUP_BLOCKING(autofill_service_terminate_received_cb, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*badge_change_cb)(unsigned int action, const char* app_id, unsigned int count, void* user_data); +#define CB_PARAMS_NAMES action, app_id, count, user_data +PROXY_GROUP_NON_BLOCKING(badge_change_cb, unsigned int action, const char* app_id, unsigned int count, void* user_data) +PROXY_GROUP_BLOCKING(badge_change_cb, unsigned int action, const char* app_id, unsigned int count, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*badge_foreach_cb)(const char* app_id, unsigned int count, void* user_data); +#define CB_PARAMS_NAMES app_id, count, user_data +PROXY_GROUP_RETURN(badge_foreach_cb, bool, const char* app_id, unsigned int count, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*bt_adapter_bonded_device_cb)(void* device_info, void* user_data); +#define CB_PARAMS_NAMES device_info, user_data +PROXY_GROUP_RETURN(bt_adapter_bonded_device_cb, bool, void* device_info, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*bt_adapter_device_discovery_state_changed_cb)(int result, some_enum discovery_state, void* discovery_info, void* user_data); +#define CB_PARAMS_NAMES result, discovery_state, discovery_info, user_data +PROXY_GROUP_NON_BLOCKING(bt_adapter_device_discovery_state_changed_cb, int result, some_enum discovery_state, void* discovery_info, void* user_data) +PROXY_GROUP_BLOCKING(bt_adapter_device_discovery_state_changed_cb, int result, some_enum discovery_state, void* discovery_info, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*bt_adapter_le_advertising_state_changed_cb)(int result, void* advertiser, some_enum adv_state, void* user_data); +#define CB_PARAMS_NAMES result, advertiser, adv_state, user_data +PROXY_GROUP_NON_BLOCKING(bt_adapter_le_advertising_state_changed_cb, int result, void* advertiser, some_enum adv_state, void* user_data) +PROXY_GROUP_BLOCKING(bt_adapter_le_advertising_state_changed_cb, int result, void* advertiser, some_enum adv_state, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*bt_adapter_le_device_discovery_state_changed_cb)(int result, some_enum discovery_state, void* discovery_info, void* user_data); +#define CB_PARAMS_NAMES result, discovery_state, discovery_info, user_data +PROXY_GROUP_NON_BLOCKING(bt_adapter_le_device_discovery_state_changed_cb, int result, some_enum discovery_state, void* discovery_info, void* user_data) +PROXY_GROUP_BLOCKING(bt_adapter_le_device_discovery_state_changed_cb, int result, some_enum discovery_state, void* discovery_info, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*bt_adapter_le_scan_result_cb)(int result, void* info, void* user_data); +#define CB_PARAMS_NAMES result, info, user_data +PROXY_GROUP_NON_BLOCKING(bt_adapter_le_scan_result_cb, int result, void* info, void* user_data) +PROXY_GROUP_BLOCKING(bt_adapter_le_scan_result_cb, int result, void* info, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*bt_adapter_name_changed_cb)(char* device_name, void* user_data); +#define CB_PARAMS_NAMES device_name, user_data +PROXY_GROUP_NON_BLOCKING(bt_adapter_name_changed_cb, char* device_name, void* user_data) +PROXY_GROUP_BLOCKING(bt_adapter_name_changed_cb, char* device_name, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*bt_adapter_state_changed_cb)(int result, some_enum adapter_state, void* user_data); +#define CB_PARAMS_NAMES result, adapter_state, user_data +PROXY_GROUP_NON_BLOCKING(bt_adapter_state_changed_cb, int result, some_enum adapter_state, void* user_data) +PROXY_GROUP_BLOCKING(bt_adapter_state_changed_cb, int result, some_enum adapter_state, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*bt_adapter_visibility_duration_changed_cb)(int duration, void* user_data); +#define CB_PARAMS_NAMES duration, user_data +PROXY_GROUP_NON_BLOCKING(bt_adapter_visibility_duration_changed_cb, int duration, void* user_data) +PROXY_GROUP_BLOCKING(bt_adapter_visibility_duration_changed_cb, int duration, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*bt_adapter_visibility_mode_changed_cb)(int result, some_enum visibility_mode, void* user_data); +#define CB_PARAMS_NAMES result, visibility_mode, user_data +PROXY_GROUP_NON_BLOCKING(bt_adapter_visibility_mode_changed_cb, int result, some_enum visibility_mode, void* user_data) +PROXY_GROUP_BLOCKING(bt_adapter_visibility_mode_changed_cb, int result, some_enum visibility_mode, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*bt_audio_connection_state_changed_cb)(int result, bool connected, const char* remote_address, some_enum type, void* user_data); +#define CB_PARAMS_NAMES result, connected, remote_address, type, user_data +PROXY_GROUP_NON_BLOCKING(bt_audio_connection_state_changed_cb, int result, bool connected, const char* remote_address, some_enum type, void* user_data) +PROXY_GROUP_BLOCKING(bt_audio_connection_state_changed_cb, int result, bool connected, const char* remote_address, some_enum type, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*bt_avrcp_control_connection_state_changed_cb)(bool connected, const char* remote_address, void* user_data); +#define CB_PARAMS_NAMES connected, remote_address, user_data +PROXY_GROUP_NON_BLOCKING(bt_avrcp_control_connection_state_changed_cb, bool connected, const char* remote_address, void* user_data) +PROXY_GROUP_BLOCKING(bt_avrcp_control_connection_state_changed_cb, bool connected, const char* remote_address, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*bt_avrcp_equalizer_state_changed_cb)(some_enum equalizer, void* user_data); +#define CB_PARAMS_NAMES equalizer, user_data +PROXY_GROUP_NON_BLOCKING(bt_avrcp_equalizer_state_changed_cb, some_enum equalizer, void* user_data) +PROXY_GROUP_BLOCKING(bt_avrcp_equalizer_state_changed_cb, some_enum equalizer, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*bt_avrcp_play_status_changed_cb)(some_enum play_state, void* user_data); +#define CB_PARAMS_NAMES play_state, user_data +PROXY_GROUP_NON_BLOCKING(bt_avrcp_play_status_changed_cb, some_enum play_state, void* user_data) +PROXY_GROUP_BLOCKING(bt_avrcp_play_status_changed_cb, some_enum play_state, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*bt_avrcp_position_changed_cb)(unsigned int position, void* user_data); +#define CB_PARAMS_NAMES position, user_data +PROXY_GROUP_NON_BLOCKING(bt_avrcp_position_changed_cb, unsigned int position, void* user_data) +PROXY_GROUP_BLOCKING(bt_avrcp_position_changed_cb, unsigned int position, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*bt_avrcp_repeat_mode_changed_cb)(some_enum repeat, void* user_data); +#define CB_PARAMS_NAMES repeat, user_data +PROXY_GROUP_NON_BLOCKING(bt_avrcp_repeat_mode_changed_cb, some_enum repeat, void* user_data) +PROXY_GROUP_BLOCKING(bt_avrcp_repeat_mode_changed_cb, some_enum repeat, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*bt_avrcp_scan_mode_changed_cb)(some_enum scan, void* user_data); +#define CB_PARAMS_NAMES scan, user_data +PROXY_GROUP_NON_BLOCKING(bt_avrcp_scan_mode_changed_cb, some_enum scan, void* user_data) +PROXY_GROUP_BLOCKING(bt_avrcp_scan_mode_changed_cb, some_enum scan, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*bt_avrcp_shuffle_mode_changed_cb)(some_enum shuffle, void* user_data); +#define CB_PARAMS_NAMES shuffle, user_data +PROXY_GROUP_NON_BLOCKING(bt_avrcp_shuffle_mode_changed_cb, some_enum shuffle, void* user_data) +PROXY_GROUP_BLOCKING(bt_avrcp_shuffle_mode_changed_cb, some_enum shuffle, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*bt_avrcp_target_connection_state_changed_cb)(bool connected, const char* remote_address, void* user_data); +#define CB_PARAMS_NAMES connected, remote_address, user_data +PROXY_GROUP_NON_BLOCKING(bt_avrcp_target_connection_state_changed_cb, bool connected, const char* remote_address, void* user_data) +PROXY_GROUP_BLOCKING(bt_avrcp_target_connection_state_changed_cb, bool connected, const char* remote_address, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*bt_avrcp_track_info_changed_cb)(void* track, void* user_data); +#define CB_PARAMS_NAMES track, user_data +PROXY_GROUP_NON_BLOCKING(bt_avrcp_track_info_changed_cb, void* track, void* user_data) +PROXY_GROUP_BLOCKING(bt_avrcp_track_info_changed_cb, void* track, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*bt_device_authorization_changed_cb)(some_enum authorization, char* remote_address, void* user_data); +#define CB_PARAMS_NAMES authorization, remote_address, user_data +PROXY_GROUP_NON_BLOCKING(bt_device_authorization_changed_cb, some_enum authorization, char* remote_address, void* user_data) +PROXY_GROUP_BLOCKING(bt_device_authorization_changed_cb, some_enum authorization, char* remote_address, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*bt_device_bond_created_cb)(int result, void* device_info, void* user_data); +#define CB_PARAMS_NAMES result, device_info, user_data +PROXY_GROUP_NON_BLOCKING(bt_device_bond_created_cb, int result, void* device_info, void* user_data) +PROXY_GROUP_BLOCKING(bt_device_bond_created_cb, int result, void* device_info, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*bt_device_bond_destroyed_cb)(int result, char* remote_address, void* user_data); +#define CB_PARAMS_NAMES result, remote_address, user_data +PROXY_GROUP_NON_BLOCKING(bt_device_bond_destroyed_cb, int result, char* remote_address, void* user_data) +PROXY_GROUP_BLOCKING(bt_device_bond_destroyed_cb, int result, char* remote_address, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*bt_device_connected_profile)(some_enum profile, void* user_data); +#define CB_PARAMS_NAMES profile, user_data +PROXY_GROUP_RETURN(bt_device_connected_profile, bool, some_enum profile, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*bt_device_connection_state_changed_cb)(bool connected, void* conn_info, void* user_data); +#define CB_PARAMS_NAMES connected, conn_info, user_data +PROXY_GROUP_NON_BLOCKING(bt_device_connection_state_changed_cb, bool connected, void* conn_info, void* user_data) +PROXY_GROUP_BLOCKING(bt_device_connection_state_changed_cb, bool connected, void* conn_info, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*bt_device_service_searched_cb)(int result, void* sdp_info, void* user_data); +#define CB_PARAMS_NAMES result, sdp_info, user_data +PROXY_GROUP_NON_BLOCKING(bt_device_service_searched_cb, int result, void* sdp_info, void* user_data) +PROXY_GROUP_BLOCKING(bt_device_service_searched_cb, int result, void* sdp_info, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*bt_gatt_characteristic_changed_cb)(void* characteristic, unsigned char* value, int value_length, void* user_data); +#define CB_PARAMS_NAMES characteristic, value, value_length, user_data +PROXY_GROUP_NON_BLOCKING(bt_gatt_characteristic_changed_cb, void* characteristic, unsigned char* value, int value_length, void* user_data) +PROXY_GROUP_BLOCKING(bt_gatt_characteristic_changed_cb, void* characteristic, unsigned char* value, int value_length, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*bt_gatt_characteristic_descriptor_discovered_cb)(int result, unsigned char characteristic_format, int total, void* characteristic_descriptor, void* user_data); +#define CB_PARAMS_NAMES result, characteristic_format, total, characteristic_descriptor, user_data +PROXY_GROUP_NON_BLOCKING(bt_gatt_characteristic_descriptor_discovered_cb, int result, unsigned char characteristic_format, int total, void* characteristic_descriptor, void* user_data) +PROXY_GROUP_BLOCKING(bt_gatt_characteristic_descriptor_discovered_cb, int result, unsigned char characteristic_format, int total, void* characteristic_descriptor, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*bt_gatt_characteristic_read_cb)(unsigned char* value, int value_length, void* user_data); +#define CB_PARAMS_NAMES value, value_length, user_data +PROXY_GROUP_NON_BLOCKING(bt_gatt_characteristic_read_cb, unsigned char* value, int value_length, void* user_data) +PROXY_GROUP_BLOCKING(bt_gatt_characteristic_read_cb, unsigned char* value, int value_length, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*bt_gatt_characteristic_write_cb)(void* user_data); +#define CB_PARAMS_NAMES user_data +PROXY_GROUP_NON_BLOCKING(bt_gatt_characteristic_write_cb, void* user_data) +PROXY_GROUP_BLOCKING(bt_gatt_characteristic_write_cb, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*bt_gatt_characteristics_discovered_cb)(int result, int index, int total, void* characteristic, void* user_data); +#define CB_PARAMS_NAMES result, index, total, characteristic, user_data +PROXY_GROUP_RETURN(bt_gatt_characteristics_discovered_cb, bool, int result, int index, int total, void* characteristic, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*bt_gatt_client_att_mtu_changed_cb)(void* client, const void* mtu_info, void* user_data); +#define CB_PARAMS_NAMES client, mtu_info, user_data +PROXY_GROUP_NON_BLOCKING(bt_gatt_client_att_mtu_changed_cb, void* client, const void* mtu_info, void* user_data) +PROXY_GROUP_BLOCKING(bt_gatt_client_att_mtu_changed_cb, void* client, const void* mtu_info, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*bt_gatt_client_characteristic_value_changed_cb)(void* characteristic, char* value, int len, void* user_data); +#define CB_PARAMS_NAMES characteristic, value, len, user_data +PROXY_GROUP_NON_BLOCKING(bt_gatt_client_characteristic_value_changed_cb, void* characteristic, char* value, int len, void* user_data) +PROXY_GROUP_BLOCKING(bt_gatt_client_characteristic_value_changed_cb, void* characteristic, char* value, int len, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*bt_gatt_client_request_completed_cb)(int result, void* request_handle, void* user_data); +#define CB_PARAMS_NAMES result, request_handle, user_data +PROXY_GROUP_NON_BLOCKING(bt_gatt_client_request_completed_cb, int result, void* request_handle, void* user_data) +PROXY_GROUP_BLOCKING(bt_gatt_client_request_completed_cb, int result, void* request_handle, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*bt_gatt_client_service_changed_cb)(void* client, some_enum change_type, const char* service_uuid, void* user_data); +#define CB_PARAMS_NAMES client, change_type, service_uuid, user_data +PROXY_GROUP_NON_BLOCKING(bt_gatt_client_service_changed_cb, void* client, some_enum change_type, const char* service_uuid, void* user_data) +PROXY_GROUP_BLOCKING(bt_gatt_client_service_changed_cb, void* client, some_enum change_type, const char* service_uuid, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*bt_gatt_connection_state_changed_cb)(int result, bool connected, const char* remote_address, void* user_data); +#define CB_PARAMS_NAMES result, connected, remote_address, user_data +PROXY_GROUP_NON_BLOCKING(bt_gatt_connection_state_changed_cb, int result, bool connected, const char* remote_address, void* user_data) +PROXY_GROUP_BLOCKING(bt_gatt_connection_state_changed_cb, int result, bool connected, const char* remote_address, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*bt_gatt_foreach_cb)(int total, int index, void* gatt_handle, void* user_data); +#define CB_PARAMS_NAMES total, index, gatt_handle, user_data +PROXY_GROUP_RETURN(bt_gatt_foreach_cb, bool, int total, int index, void* gatt_handle, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*bt_gatt_included_service_cb)(void* service, void* user_data); +#define CB_PARAMS_NAMES service, user_data +PROXY_GROUP_RETURN(bt_gatt_included_service_cb, bool, void* service, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*bt_gatt_primary_service_cb)(void* service, void* user_data); +#define CB_PARAMS_NAMES service, user_data +PROXY_GROUP_RETURN(bt_gatt_primary_service_cb, bool, void* service, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*bt_gatt_server_characteristic_notification_state_changed_cb)(bool notify, void* server, void* gatt_handle, void* user_data); +#define CB_PARAMS_NAMES notify, server, gatt_handle, user_data +PROXY_GROUP_NON_BLOCKING(bt_gatt_server_characteristic_notification_state_changed_cb, bool notify, void* server, void* gatt_handle, void* user_data) +PROXY_GROUP_BLOCKING(bt_gatt_server_characteristic_notification_state_changed_cb, bool notify, void* server, void* gatt_handle, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*bt_gatt_server_notification_sent_cb)(int result, const char* remote_address, void* server, void* characteristic, bool completed, void* user_data); +#define CB_PARAMS_NAMES result, remote_address, server, characteristic, completed, user_data +PROXY_GROUP_NON_BLOCKING(bt_gatt_server_notification_sent_cb, int result, const char* remote_address, void* server, void* characteristic, bool completed, void* user_data) +PROXY_GROUP_BLOCKING(bt_gatt_server_notification_sent_cb, int result, const char* remote_address, void* server, void* characteristic, bool completed, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*bt_gatt_server_read_value_requested_cb)(const char* remote_address, int request_id, void* server, void* gatt_handle, int offset, void* user_data); +#define CB_PARAMS_NAMES remote_address, request_id, server, gatt_handle, offset, user_data +PROXY_GROUP_NON_BLOCKING(bt_gatt_server_read_value_requested_cb, const char* remote_address, int request_id, void* server, void* gatt_handle, int offset, void* user_data) +PROXY_GROUP_BLOCKING(bt_gatt_server_read_value_requested_cb, const char* remote_address, int request_id, void* server, void* gatt_handle, int offset, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*bt_gatt_server_write_value_requested_cb)(const char* remote_address, int request_id, void* server, void* gatt_handle, bool response_needed, int offset, const char* value, int len, void* user_data); +#define CB_PARAMS_NAMES remote_address, request_id, server, gatt_handle, response_needed, offset, value, len, user_data +PROXY_GROUP_NON_BLOCKING(bt_gatt_server_write_value_requested_cb, const char* remote_address, int request_id, void* server, void* gatt_handle, bool response_needed, int offset, const char* value, int len, void* user_data) +PROXY_GROUP_BLOCKING(bt_gatt_server_write_value_requested_cb, const char* remote_address, int request_id, void* server, void* gatt_handle, bool response_needed, int offset, const char* value, int len, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*bt_hdp_connected_cb)(int result, const char* remote_address, const char* app_id, some_enum type, unsigned int channel, void* user_data); +#define CB_PARAMS_NAMES result, remote_address, app_id, type, channel, user_data +PROXY_GROUP_NON_BLOCKING(bt_hdp_connected_cb, int result, const char* remote_address, const char* app_id, some_enum type, unsigned int channel, void* user_data) +PROXY_GROUP_BLOCKING(bt_hdp_connected_cb, int result, const char* remote_address, const char* app_id, some_enum type, unsigned int channel, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*bt_hdp_data_received_cb)(unsigned int channel, const char* data, unsigned int size, void* user_data); +#define CB_PARAMS_NAMES channel, data, size, user_data +PROXY_GROUP_NON_BLOCKING(bt_hdp_data_received_cb, unsigned int channel, const char* data, unsigned int size, void* user_data) +PROXY_GROUP_BLOCKING(bt_hdp_data_received_cb, unsigned int channel, const char* data, unsigned int size, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*bt_hdp_disconnected_cb)(int result, const char* remote_address, unsigned int channel, void* user_data); +#define CB_PARAMS_NAMES result, remote_address, channel, user_data +PROXY_GROUP_NON_BLOCKING(bt_hdp_disconnected_cb, int result, const char* remote_address, unsigned int channel, void* user_data) +PROXY_GROUP_BLOCKING(bt_hdp_disconnected_cb, int result, const char* remote_address, unsigned int channel, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*bt_hid_device_connection_state_changed_cb)(int result, bool connected, const char* remote_address, void* user_data); +#define CB_PARAMS_NAMES result, connected, remote_address, user_data +PROXY_GROUP_NON_BLOCKING(bt_hid_device_connection_state_changed_cb, int result, bool connected, const char* remote_address, void* user_data) +PROXY_GROUP_BLOCKING(bt_hid_device_connection_state_changed_cb, int result, bool connected, const char* remote_address, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*bt_hid_device_data_received_cb)(const void* data, void* user_data); +#define CB_PARAMS_NAMES data, user_data +PROXY_GROUP_NON_BLOCKING(bt_hid_device_data_received_cb, const void* data, void* user_data) +PROXY_GROUP_BLOCKING(bt_hid_device_data_received_cb, const void* data, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*bt_hid_host_connection_state_changed_cb)(int result, bool connected, const char* remote_address, void* user_data); +#define CB_PARAMS_NAMES result, connected, remote_address, user_data +PROXY_GROUP_NON_BLOCKING(bt_hid_host_connection_state_changed_cb, int result, bool connected, const char* remote_address, void* user_data) +PROXY_GROUP_BLOCKING(bt_hid_host_connection_state_changed_cb, int result, bool connected, const char* remote_address, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*bt_ipsp_connection_state_changed_cb)(int result, bool connected, const char* remote_address, const char* iface_name, void* user_data); +#define CB_PARAMS_NAMES result, connected, remote_address, iface_name, user_data +PROXY_GROUP_NON_BLOCKING(bt_ipsp_connection_state_changed_cb, int result, bool connected, const char* remote_address, const char* iface_name, void* user_data) +PROXY_GROUP_BLOCKING(bt_ipsp_connection_state_changed_cb, int result, bool connected, const char* remote_address, const char* iface_name, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*bt_ipsp_init_state_changed_cb)(int result, bool ipsp_initialized, void* user_data); +#define CB_PARAMS_NAMES result, ipsp_initialized, user_data +PROXY_GROUP_NON_BLOCKING(bt_ipsp_init_state_changed_cb, int result, bool ipsp_initialized, void* user_data) +PROXY_GROUP_BLOCKING(bt_ipsp_init_state_changed_cb, int result, bool ipsp_initialized, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*bt_opp_client_push_finished_cb)(int result, const char* remote_address, void* user_data); +#define CB_PARAMS_NAMES result, remote_address, user_data +PROXY_GROUP_NON_BLOCKING(bt_opp_client_push_finished_cb, int result, const char* remote_address, void* user_data) +PROXY_GROUP_BLOCKING(bt_opp_client_push_finished_cb, int result, const char* remote_address, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*bt_opp_client_push_progress_cb)(const char* file, long long size, int percent, void* user_data); +#define CB_PARAMS_NAMES file, size, percent, user_data +PROXY_GROUP_NON_BLOCKING(bt_opp_client_push_progress_cb, const char* file, long long size, int percent, void* user_data) +PROXY_GROUP_BLOCKING(bt_opp_client_push_progress_cb, const char* file, long long size, int percent, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*bt_opp_client_push_responded_cb)(int result, const char* remote_address, void* user_data); +#define CB_PARAMS_NAMES result, remote_address, user_data +PROXY_GROUP_NON_BLOCKING(bt_opp_client_push_responded_cb, int result, const char* remote_address, void* user_data) +PROXY_GROUP_BLOCKING(bt_opp_client_push_responded_cb, int result, const char* remote_address, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*bt_opp_server_connection_requested_cb)(const char* remote_address, void* user_data); +#define CB_PARAMS_NAMES remote_address, user_data +PROXY_GROUP_NON_BLOCKING(bt_opp_server_connection_requested_cb, const char* remote_address, void* user_data) +PROXY_GROUP_BLOCKING(bt_opp_server_connection_requested_cb, const char* remote_address, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*bt_opp_server_transfer_finished_cb)(int result, const char* file, long long size, void* user_data); +#define CB_PARAMS_NAMES result, file, size, user_data +PROXY_GROUP_NON_BLOCKING(bt_opp_server_transfer_finished_cb, int result, const char* file, long long size, void* user_data) +PROXY_GROUP_BLOCKING(bt_opp_server_transfer_finished_cb, int result, const char* file, long long size, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*bt_opp_server_transfer_progress_cb)(const char* file, long long size, int percent, void* user_data); +#define CB_PARAMS_NAMES file, size, percent, user_data +PROXY_GROUP_NON_BLOCKING(bt_opp_server_transfer_progress_cb, const char* file, long long size, int percent, void* user_data) +PROXY_GROUP_BLOCKING(bt_opp_server_transfer_progress_cb, const char* file, long long size, int percent, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*bt_pbap_connection_state_changed_cb)(int result, bool connected, const char* remote_address, void* user_data); +#define CB_PARAMS_NAMES result, connected, remote_address, user_data +PROXY_GROUP_NON_BLOCKING(bt_pbap_connection_state_changed_cb, int result, bool connected, const char* remote_address, void* user_data) +PROXY_GROUP_BLOCKING(bt_pbap_connection_state_changed_cb, int result, bool connected, const char* remote_address, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*bt_pbap_list_vcards_cb)(int result, const char* remote_address, const void* vcard_info, int count, void* user_data); +#define CB_PARAMS_NAMES result, remote_address, vcard_info, count, user_data +PROXY_GROUP_NON_BLOCKING(bt_pbap_list_vcards_cb, int result, const char* remote_address, const void* vcard_info, int count, void* user_data) +PROXY_GROUP_BLOCKING(bt_pbap_list_vcards_cb, int result, const char* remote_address, const void* vcard_info, int count, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*bt_pbap_phone_book_received_cb)(int result, const char* remote_address, const char* vcf_file, void* user_data); +#define CB_PARAMS_NAMES result, remote_address, vcf_file, user_data +PROXY_GROUP_NON_BLOCKING(bt_pbap_phone_book_received_cb, int result, const char* remote_address, const char* vcf_file, void* user_data) +PROXY_GROUP_BLOCKING(bt_pbap_phone_book_received_cb, int result, const char* remote_address, const char* vcf_file, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*bt_pbap_phone_book_size_cb)(int result, const char* remote_address, int size, void* user_data); +#define CB_PARAMS_NAMES result, remote_address, size, user_data +PROXY_GROUP_NON_BLOCKING(bt_pbap_phone_book_size_cb, int result, const char* remote_address, int size, void* user_data) +PROXY_GROUP_BLOCKING(bt_pbap_phone_book_size_cb, int result, const char* remote_address, int size, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*bt_socket_connection_requested_cb)(int socket_fd, const char* remote_address, void* user_data); +#define CB_PARAMS_NAMES socket_fd, remote_address, user_data +PROXY_GROUP_NON_BLOCKING(bt_socket_connection_requested_cb, int socket_fd, const char* remote_address, void* user_data) +PROXY_GROUP_BLOCKING(bt_socket_connection_requested_cb, int socket_fd, const char* remote_address, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*bt_socket_connection_state_changed_cb)(int result, some_enum connection_state, void* connection, void* user_data); +#define CB_PARAMS_NAMES result, connection_state, connection, user_data +PROXY_GROUP_NON_BLOCKING(bt_socket_connection_state_changed_cb, int result, some_enum connection_state, void* connection, void* user_data) +PROXY_GROUP_BLOCKING(bt_socket_connection_state_changed_cb, int result, some_enum connection_state, void* connection, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*bt_socket_data_received_cb)(void* data, void* user_data); +#define CB_PARAMS_NAMES data, user_data +PROXY_GROUP_NON_BLOCKING(bt_socket_data_received_cb, void* data, void* user_data) +PROXY_GROUP_BLOCKING(bt_socket_data_received_cb, void* data, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*bt_socket_l2cap_channel_connection_state_changed_cb)(int result, some_enum connection_state, void* connection, void* user_data); +#define CB_PARAMS_NAMES result, connection_state, connection, user_data +PROXY_GROUP_NON_BLOCKING(bt_socket_l2cap_channel_connection_state_changed_cb, int result, some_enum connection_state, void* connection, void* user_data) +PROXY_GROUP_BLOCKING(bt_socket_l2cap_channel_connection_state_changed_cb, int result, some_enum connection_state, void* connection, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*bundle_iterator_t)(const char* key, const int type, const void* kv, void* user_data); +#define CB_PARAMS_NAMES key, type, kv, user_data +PROXY_GROUP_NON_BLOCKING(bundle_iterator_t, const char* key, const int type, const void* kv, void* user_data) +PROXY_GROUP_BLOCKING(bundle_iterator_t, const char* key, const int type, const void* kv, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*calendar_db_changed_cb)(const char* view_uri, void* user_data); +#define CB_PARAMS_NAMES view_uri, user_data +PROXY_GROUP_NON_BLOCKING(calendar_db_changed_cb, const char* view_uri, void* user_data) +PROXY_GROUP_BLOCKING(calendar_db_changed_cb, const char* view_uri, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*calendar_reminder_cb)(const char* param, void* user_data); +#define CB_PARAMS_NAMES param, user_data +PROXY_GROUP_NON_BLOCKING(calendar_reminder_cb, const char* param, void* user_data) +PROXY_GROUP_BLOCKING(calendar_reminder_cb, const char* param, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*calendar_vcalendar_parse_cb)(void* record, void* user_data); +#define CB_PARAMS_NAMES record, user_data +PROXY_GROUP_RETURN(calendar_vcalendar_parse_cb, bool, void* record, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*camera_attr_hdr_progress_cb)(int percent, void* user_data); +#define CB_PARAMS_NAMES percent, user_data +PROXY_GROUP_NON_BLOCKING(camera_attr_hdr_progress_cb, int percent, void* user_data) +PROXY_GROUP_BLOCKING(camera_attr_hdr_progress_cb, int percent, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*camera_attr_supported_af_mode_cb)(some_enum mode, void* user_data); +#define CB_PARAMS_NAMES mode, user_data +PROXY_GROUP_RETURN(camera_attr_supported_af_mode_cb, bool, some_enum mode, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*camera_attr_supported_effect_cb)(some_enum effect, void* user_data); +#define CB_PARAMS_NAMES effect, user_data +PROXY_GROUP_RETURN(camera_attr_supported_effect_cb, bool, some_enum effect, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*camera_attr_supported_exposure_mode_cb)(some_enum mode, void* user_data); +#define CB_PARAMS_NAMES mode, user_data +PROXY_GROUP_RETURN(camera_attr_supported_exposure_mode_cb, bool, some_enum mode, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*camera_attr_supported_flash_mode_cb)(some_enum mode, void* user_data); +#define CB_PARAMS_NAMES mode, user_data +PROXY_GROUP_RETURN(camera_attr_supported_flash_mode_cb, bool, some_enum mode, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*camera_attr_supported_fps_cb)(some_enum fps, void* user_data); +#define CB_PARAMS_NAMES fps, user_data +PROXY_GROUP_RETURN(camera_attr_supported_fps_cb, bool, some_enum fps, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*camera_attr_supported_iso_cb)(some_enum iso, void* user_data); +#define CB_PARAMS_NAMES iso, user_data +PROXY_GROUP_RETURN(camera_attr_supported_iso_cb, bool, some_enum iso, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*camera_attr_supported_ptz_type_cb)(some_enum type, void* user_data); +#define CB_PARAMS_NAMES type, user_data +PROXY_GROUP_RETURN(camera_attr_supported_ptz_type_cb, bool, some_enum type, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*camera_attr_supported_scene_mode_cb)(some_enum mode, void* user_data); +#define CB_PARAMS_NAMES mode, user_data +PROXY_GROUP_RETURN(camera_attr_supported_scene_mode_cb, bool, some_enum mode, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*camera_attr_supported_stream_flip_cb)(some_enum flip, void* user_data); +#define CB_PARAMS_NAMES flip, user_data +PROXY_GROUP_RETURN(camera_attr_supported_stream_flip_cb, bool, some_enum flip, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*camera_attr_supported_stream_rotation_cb)(some_enum rotation, void* user_data); +#define CB_PARAMS_NAMES rotation, user_data +PROXY_GROUP_RETURN(camera_attr_supported_stream_rotation_cb, bool, some_enum rotation, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*camera_attr_supported_theater_mode_cb)(some_enum mode, void* user_data); +#define CB_PARAMS_NAMES mode, user_data +PROXY_GROUP_RETURN(camera_attr_supported_theater_mode_cb, bool, some_enum mode, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*camera_attr_supported_whitebalance_cb)(some_enum wb, void* user_data); +#define CB_PARAMS_NAMES wb, user_data +PROXY_GROUP_RETURN(camera_attr_supported_whitebalance_cb, bool, some_enum wb, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*camera_capture_completed_cb)(void* user_data); +#define CB_PARAMS_NAMES user_data +PROXY_GROUP_NON_BLOCKING(camera_capture_completed_cb, void* user_data) +PROXY_GROUP_BLOCKING(camera_capture_completed_cb, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*camera_capturing_cb)(void* image, void* postview, void* thumbnail, void* user_data); +#define CB_PARAMS_NAMES image, postview, thumbnail, user_data +PROXY_GROUP_NON_BLOCKING(camera_capturing_cb, void* image, void* postview, void* thumbnail, void* user_data) +PROXY_GROUP_BLOCKING(camera_capturing_cb, void* image, void* postview, void* thumbnail, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*camera_device_connection_changed_cb)(void* device, bool is_connected, void* user_data); +#define CB_PARAMS_NAMES device, is_connected, user_data +PROXY_GROUP_NON_BLOCKING(camera_device_connection_changed_cb, void* device, bool is_connected, void* user_data) +PROXY_GROUP_BLOCKING(camera_device_connection_changed_cb, void* device, bool is_connected, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*camera_device_state_changed_cb)(some_enum device, some_enum state, void* user_data); +#define CB_PARAMS_NAMES device, state, user_data +PROXY_GROUP_NON_BLOCKING(camera_device_state_changed_cb, some_enum device, some_enum state, void* user_data) +PROXY_GROUP_BLOCKING(camera_device_state_changed_cb, some_enum device, some_enum state, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*camera_error_cb)(some_enum error, some_enum current_state, void* user_data); +#define CB_PARAMS_NAMES error, current_state, user_data +PROXY_GROUP_NON_BLOCKING(camera_error_cb, some_enum error, some_enum current_state, void* user_data) +PROXY_GROUP_BLOCKING(camera_error_cb, some_enum error, some_enum current_state, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*camera_extra_preview_cb)(void* frame, int stream_id, void* user_data); +#define CB_PARAMS_NAMES frame, stream_id, user_data +PROXY_GROUP_NON_BLOCKING(camera_extra_preview_cb, void* frame, int stream_id, void* user_data) +PROXY_GROUP_BLOCKING(camera_extra_preview_cb, void* frame, int stream_id, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*camera_face_detected_cb)(void* faces, int count, void* user_data); +#define CB_PARAMS_NAMES faces, count, user_data +PROXY_GROUP_NON_BLOCKING(camera_face_detected_cb, void* faces, int count, void* user_data) +PROXY_GROUP_BLOCKING(camera_face_detected_cb, void* faces, int count, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*camera_focus_changed_cb)(some_enum state, void* user_data); +#define CB_PARAMS_NAMES state, user_data +PROXY_GROUP_NON_BLOCKING(camera_focus_changed_cb, some_enum state, void* user_data) +PROXY_GROUP_BLOCKING(camera_focus_changed_cb, some_enum state, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*camera_interrupt_started_cb)(some_enum policy, some_enum state, void* user_data); +#define CB_PARAMS_NAMES policy, state, user_data +PROXY_GROUP_NON_BLOCKING(camera_interrupt_started_cb, some_enum policy, some_enum state, void* user_data) +PROXY_GROUP_BLOCKING(camera_interrupt_started_cb, some_enum policy, some_enum state, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*camera_interrupted_cb)(some_enum policy, some_enum previous, some_enum current, void* user_data); +#define CB_PARAMS_NAMES policy, previous, current, user_data +PROXY_GROUP_NON_BLOCKING(camera_interrupted_cb, some_enum policy, some_enum previous, some_enum current, void* user_data) +PROXY_GROUP_BLOCKING(camera_interrupted_cb, some_enum policy, some_enum previous, some_enum current, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*camera_media_packet_preview_cb)(void* pkt, void* user_data); +#define CB_PARAMS_NAMES pkt, user_data +PROXY_GROUP_NON_BLOCKING(camera_media_packet_preview_cb, void* pkt, void* user_data) +PROXY_GROUP_BLOCKING(camera_media_packet_preview_cb, void* pkt, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*camera_preview_cb)(void* frame, void* user_data); +#define CB_PARAMS_NAMES frame, user_data +PROXY_GROUP_NON_BLOCKING(camera_preview_cb, void* frame, void* user_data) +PROXY_GROUP_BLOCKING(camera_preview_cb, void* frame, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*camera_state_changed_cb)(some_enum previous, some_enum current, bool by_policy, void* user_data); +#define CB_PARAMS_NAMES previous, current, by_policy, user_data +PROXY_GROUP_NON_BLOCKING(camera_state_changed_cb, some_enum previous, some_enum current, bool by_policy, void* user_data) +PROXY_GROUP_BLOCKING(camera_state_changed_cb, some_enum previous, some_enum current, bool by_policy, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*camera_supported_capture_format_cb)(some_enum format, void* user_data); +#define CB_PARAMS_NAMES format, user_data +PROXY_GROUP_RETURN(camera_supported_capture_format_cb, bool, some_enum format, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*camera_supported_capture_resolution_cb)(int width, int height, void* user_data); +#define CB_PARAMS_NAMES width, height, user_data +PROXY_GROUP_RETURN(camera_supported_capture_resolution_cb, bool, int width, int height, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*camera_supported_device_cb)(void* device, void* user_data); +#define CB_PARAMS_NAMES device, user_data +PROXY_GROUP_RETURN(camera_supported_device_cb, bool, void* device, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*camera_supported_preview_format_cb)(some_enum format, void* user_data); +#define CB_PARAMS_NAMES format, user_data +PROXY_GROUP_RETURN(camera_supported_preview_format_cb, bool, some_enum format, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*camera_supported_preview_resolution_cb)(int width, int height, void* user_data); +#define CB_PARAMS_NAMES width, height, user_data +PROXY_GROUP_RETURN(camera_supported_preview_resolution_cb, bool, int width, int height, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*capability_cb)(const char* capability_type, some_enum capability_state, void* user_data); +#define CB_PARAMS_NAMES capability_type, capability_state, user_data +PROXY_GROUP_RETURN(capability_cb, bool, const char* capability_type, some_enum capability_state, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*cbhm_item_changed_cb)(void* cbhm_handle, int item_count, void* user_data); +#define CB_PARAMS_NAMES cbhm_handle, item_count, user_data +PROXY_GROUP_NON_BLOCKING(cbhm_item_changed_cb, void* cbhm_handle, int item_count, void* user_data) +PROXY_GROUP_BLOCKING(cbhm_item_changed_cb, void* cbhm_handle, int item_count, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*cbhm_monitor_cb)(void* cbhm_handle, bool active_state, void* user_data); +#define CB_PARAMS_NAMES cbhm_handle, active_state, user_data +PROXY_GROUP_NON_BLOCKING(cbhm_monitor_cb, void* cbhm_handle, bool active_state, void* user_data) +PROXY_GROUP_BLOCKING(cbhm_monitor_cb, void* cbhm_handle, bool active_state, void* user_data) +#undef CB_PARAMS_NAMES + +typedef int (*cbhm_selected_cb)(void* cbhm_handle, void* user_data); +#define CB_PARAMS_NAMES cbhm_handle, user_data +PROXY_GROUP_RETURN(cbhm_selected_cb, int, void* cbhm_handle, void* user_data) +#undef CB_PARAMS_NAMES + +typedef int (*cbhm_selection_data_cb)(void* cbhm_handle, const char* buf, size_t len, void* user_data); +#define CB_PARAMS_NAMES cbhm_handle, buf, len, user_data +PROXY_GROUP_RETURN(cbhm_selection_data_cb, int, void* cbhm_handle, const char* buf, size_t len, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*cion_client_connection_result_cb)(const char* service_name, const void* peer_info, const void* result, void* user_data); +#define CB_PARAMS_NAMES service_name, peer_info, result, user_data +PROXY_GROUP_NON_BLOCKING(cion_client_connection_result_cb, const char* service_name, const void* peer_info, const void* result, void* user_data) +PROXY_GROUP_BLOCKING(cion_client_connection_result_cb, const char* service_name, const void* peer_info, const void* result, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*cion_client_disconnected_cb)(const char* service_name, const void* peer_info, void* user_data); +#define CB_PARAMS_NAMES service_name, peer_info, user_data +PROXY_GROUP_NON_BLOCKING(cion_client_disconnected_cb, const char* service_name, const void* peer_info, void* user_data) +PROXY_GROUP_BLOCKING(cion_client_disconnected_cb, const char* service_name, const void* peer_info, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*cion_client_payload_async_result_cb)(const void* result, void* user_data); +#define CB_PARAMS_NAMES result, user_data +PROXY_GROUP_NON_BLOCKING(cion_client_payload_async_result_cb, const void* result, void* user_data) +PROXY_GROUP_BLOCKING(cion_client_payload_async_result_cb, const void* result, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*cion_client_payload_received_cb)(const char* service_name, const void* peer_info, const void* payload, some_enum status, void* user_data); +#define CB_PARAMS_NAMES service_name, peer_info, payload, status, user_data +PROXY_GROUP_NON_BLOCKING(cion_client_payload_received_cb, const char* service_name, const void* peer_info, const void* payload, some_enum status, void* user_data) +PROXY_GROUP_BLOCKING(cion_client_payload_received_cb, const char* service_name, const void* peer_info, const void* payload, some_enum status, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*cion_client_server_discovered_cb)(const char* service_name, const void* peer_info, void* user_data); +#define CB_PARAMS_NAMES service_name, peer_info, user_data +PROXY_GROUP_NON_BLOCKING(cion_client_server_discovered_cb, const char* service_name, const void* peer_info, void* user_data) +PROXY_GROUP_BLOCKING(cion_client_server_discovered_cb, const char* service_name, const void* peer_info, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*cion_group_joined_cb)(const char* topic_name, const void* peer_info, void* user_data); +#define CB_PARAMS_NAMES topic_name, peer_info, user_data +PROXY_GROUP_NON_BLOCKING(cion_group_joined_cb, const char* topic_name, const void* peer_info, void* user_data) +PROXY_GROUP_BLOCKING(cion_group_joined_cb, const char* topic_name, const void* peer_info, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*cion_group_left_cb)(const char* topic_name, const void* peer_info, void* user_data); +#define CB_PARAMS_NAMES topic_name, peer_info, user_data +PROXY_GROUP_NON_BLOCKING(cion_group_left_cb, const char* topic_name, const void* peer_info, void* user_data) +PROXY_GROUP_BLOCKING(cion_group_left_cb, const char* topic_name, const void* peer_info, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*cion_group_payload_received_cb)(const char* topic_name, const void* peer_info, void* payload, void* user_data); +#define CB_PARAMS_NAMES topic_name, peer_info, payload, user_data +PROXY_GROUP_NON_BLOCKING(cion_group_payload_received_cb, const char* topic_name, const void* peer_info, void* payload, void* user_data) +PROXY_GROUP_BLOCKING(cion_group_payload_received_cb, const char* topic_name, const void* peer_info, void* payload, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*cion_server_connected_peer_info_cb)(const void* peer_info, void* user_data); +#define CB_PARAMS_NAMES peer_info, user_data +PROXY_GROUP_RETURN(cion_server_connected_peer_info_cb, bool, const void* peer_info, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*cion_server_connection_request_cb)(const char* service_name, const void* peer_info, void* user_data); +#define CB_PARAMS_NAMES service_name, peer_info, user_data +PROXY_GROUP_NON_BLOCKING(cion_server_connection_request_cb, const char* service_name, const void* peer_info, void* user_data) +PROXY_GROUP_BLOCKING(cion_server_connection_request_cb, const char* service_name, const void* peer_info, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*cion_server_connection_result_cb)(const char* service_name, const void* peer_info, const void* result, void* user_data); +#define CB_PARAMS_NAMES service_name, peer_info, result, user_data +PROXY_GROUP_NON_BLOCKING(cion_server_connection_result_cb, const char* service_name, const void* peer_info, const void* result, void* user_data) +PROXY_GROUP_BLOCKING(cion_server_connection_result_cb, const char* service_name, const void* peer_info, const void* result, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*cion_server_data_received_cb)(const char* service_name, const void* peer_info, const unsigned char* data, unsigned int data_size, unsigned char** return_data, unsigned int* return_data_size, void* user_data); +#define CB_PARAMS_NAMES service_name, peer_info, data, data_size, return_data, return_data_size, user_data +PROXY_GROUP_NON_BLOCKING(cion_server_data_received_cb, const char* service_name, const void* peer_info, const unsigned char* data, unsigned int data_size, unsigned char** return_data, unsigned int* return_data_size, void* user_data) +PROXY_GROUP_BLOCKING(cion_server_data_received_cb, const char* service_name, const void* peer_info, const unsigned char* data, unsigned int data_size, unsigned char** return_data, unsigned int* return_data_size, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*cion_server_disconnected_cb)(const char* service_name, const void* peer_info, void* user_data); +#define CB_PARAMS_NAMES service_name, peer_info, user_data +PROXY_GROUP_NON_BLOCKING(cion_server_disconnected_cb, const char* service_name, const void* peer_info, void* user_data) +PROXY_GROUP_BLOCKING(cion_server_disconnected_cb, const char* service_name, const void* peer_info, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*cion_server_payload_async_result_cb)(const void* result, void* user_data); +#define CB_PARAMS_NAMES result, user_data +PROXY_GROUP_NON_BLOCKING(cion_server_payload_async_result_cb, const void* result, void* user_data) +PROXY_GROUP_BLOCKING(cion_server_payload_async_result_cb, const void* result, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*cion_server_payload_received_cb)(const char* service_name, const void* peer_info, const void* payload, some_enum status, void* user_data); +#define CB_PARAMS_NAMES service_name, peer_info, payload, status, user_data +PROXY_GROUP_NON_BLOCKING(cion_server_payload_received_cb, const char* service_name, const void* peer_info, const void* payload, some_enum status, void* user_data) +PROXY_GROUP_BLOCKING(cion_server_payload_received_cb, const char* service_name, const void* peer_info, const void* payload, some_enum status, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*connection_address_changed_cb)(const char* ipv4_address, const char* ipv6_address, void* user_data); +#define CB_PARAMS_NAMES ipv4_address, ipv6_address, user_data +PROXY_GROUP_NON_BLOCKING(connection_address_changed_cb, const char* ipv4_address, const char* ipv6_address, void* user_data) +PROXY_GROUP_BLOCKING(connection_address_changed_cb, const char* ipv4_address, const char* ipv6_address, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*connection_closed_cb)(some_enum result, void* user_data); +#define CB_PARAMS_NAMES result, user_data +PROXY_GROUP_NON_BLOCKING(connection_closed_cb, some_enum result, void* user_data) +PROXY_GROUP_BLOCKING(connection_closed_cb, some_enum result, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*connection_ethernet_cable_state_chaged_cb)(some_enum state, void* user_data); +#define CB_PARAMS_NAMES state, user_data +PROXY_GROUP_NON_BLOCKING(connection_ethernet_cable_state_chaged_cb, some_enum state, void* user_data) +PROXY_GROUP_BLOCKING(connection_ethernet_cable_state_chaged_cb, some_enum state, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*connection_ethernet_cable_state_changed_cb)(some_enum state, void* user_data); +#define CB_PARAMS_NAMES state, user_data +PROXY_GROUP_NON_BLOCKING(connection_ethernet_cable_state_changed_cb, some_enum state, void* user_data) +PROXY_GROUP_BLOCKING(connection_ethernet_cable_state_changed_cb, some_enum state, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*connection_internet_state_changed_cb)(some_enum state, void* user_data); +#define CB_PARAMS_NAMES state, user_data +PROXY_GROUP_NON_BLOCKING(connection_internet_state_changed_cb, some_enum state, void* user_data) +PROXY_GROUP_BLOCKING(connection_internet_state_changed_cb, some_enum state, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*connection_ipv6_address_cb)(char* ipv6_address, void* user_data); +#define CB_PARAMS_NAMES ipv6_address, user_data +PROXY_GROUP_RETURN(connection_ipv6_address_cb, bool, char* ipv6_address, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*connection_opened_cb)(some_enum result, void* user_data); +#define CB_PARAMS_NAMES result, user_data +PROXY_GROUP_NON_BLOCKING(connection_opened_cb, some_enum result, void* user_data) +PROXY_GROUP_BLOCKING(connection_opened_cb, some_enum result, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*connection_profile_state_changed_cb)(some_enum state, void* user_data); +#define CB_PARAMS_NAMES state, user_data +PROXY_GROUP_NON_BLOCKING(connection_profile_state_changed_cb, some_enum state, void* user_data) +PROXY_GROUP_BLOCKING(connection_profile_state_changed_cb, some_enum state, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*connection_reset_cb)(some_enum result, void* user_data); +#define CB_PARAMS_NAMES result, user_data +PROXY_GROUP_NON_BLOCKING(connection_reset_cb, some_enum result, void* user_data) +PROXY_GROUP_BLOCKING(connection_reset_cb, some_enum result, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*connection_set_default_cb)(some_enum result, void* user_data); +#define CB_PARAMS_NAMES result, user_data +PROXY_GROUP_NON_BLOCKING(connection_set_default_cb, some_enum result, void* user_data) +PROXY_GROUP_BLOCKING(connection_set_default_cb, some_enum result, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*connection_state_changed_cb)(some_enum state, void* user_data); +#define CB_PARAMS_NAMES state, user_data +PROXY_GROUP_NON_BLOCKING(connection_state_changed_cb, some_enum state, void* user_data) +PROXY_GROUP_BLOCKING(connection_state_changed_cb, some_enum state, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*connection_type_changed_cb)(some_enum type, void* user_data); +#define CB_PARAMS_NAMES type, user_data +PROXY_GROUP_NON_BLOCKING(connection_type_changed_cb, some_enum type, void* user_data) +PROXY_GROUP_BLOCKING(connection_type_changed_cb, some_enum type, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*contacts_db_changed_cb)(const char* view_uri, void* user_data); +#define CB_PARAMS_NAMES view_uri, user_data +PROXY_GROUP_NON_BLOCKING(contacts_db_changed_cb, const char* view_uri, void* user_data) +PROXY_GROUP_BLOCKING(contacts_db_changed_cb, const char* view_uri, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*contacts_db_status_changed_cb)(some_enum status, void* user_data); +#define CB_PARAMS_NAMES status, user_data +PROXY_GROUP_NON_BLOCKING(contacts_db_status_changed_cb, some_enum status, void* user_data) +PROXY_GROUP_BLOCKING(contacts_db_status_changed_cb, some_enum status, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*contacts_setting_name_display_order_changed_cb)(some_enum name_display_order, void* user_data); +#define CB_PARAMS_NAMES name_display_order, user_data +PROXY_GROUP_NON_BLOCKING(contacts_setting_name_display_order_changed_cb, some_enum name_display_order, void* user_data) +PROXY_GROUP_BLOCKING(contacts_setting_name_display_order_changed_cb, some_enum name_display_order, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*contacts_setting_name_sorting_order_changed_cb)(some_enum name_sorting_order, void* user_data); +#define CB_PARAMS_NAMES name_sorting_order, user_data +PROXY_GROUP_NON_BLOCKING(contacts_setting_name_sorting_order_changed_cb, some_enum name_sorting_order, void* user_data) +PROXY_GROUP_BLOCKING(contacts_setting_name_sorting_order_changed_cb, some_enum name_sorting_order, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*contacts_sim_import_progress_cb)(int total, int imported_cnt, void* user_data); +#define CB_PARAMS_NAMES total, imported_cnt, user_data +PROXY_GROUP_RETURN(contacts_sim_import_progress_cb, bool, int total, int imported_cnt, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*contacts_vcard_parse_cb)(void* record, void* user_data); +#define CB_PARAMS_NAMES record, user_data +PROXY_GROUP_RETURN(contacts_vcard_parse_cb, bool, void* record, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*csr_cs_cancelled_cb)(void* user_data); +#define CB_PARAMS_NAMES user_data +PROXY_GROUP_NON_BLOCKING(csr_cs_cancelled_cb, void* user_data) +PROXY_GROUP_BLOCKING(csr_cs_cancelled_cb, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*csr_cs_completed_cb)(void* user_data); +#define CB_PARAMS_NAMES user_data +PROXY_GROUP_NON_BLOCKING(csr_cs_completed_cb, void* user_data) +PROXY_GROUP_BLOCKING(csr_cs_completed_cb, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*csr_cs_detected_cb)(void* malware, void* user_data); +#define CB_PARAMS_NAMES malware, user_data +PROXY_GROUP_NON_BLOCKING(csr_cs_detected_cb, void* malware, void* user_data) +PROXY_GROUP_BLOCKING(csr_cs_detected_cb, void* malware, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*csr_cs_error_cb)(int error_code, void* user_data); +#define CB_PARAMS_NAMES error_code, user_data +PROXY_GROUP_NON_BLOCKING(csr_cs_error_cb, int error_code, void* user_data) +PROXY_GROUP_BLOCKING(csr_cs_error_cb, int error_code, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*csr_cs_file_scanned_cb)(const char* file_path, void* user_data); +#define CB_PARAMS_NAMES file_path, user_data +PROXY_GROUP_NON_BLOCKING(csr_cs_file_scanned_cb, const char* file_path, void* user_data) +PROXY_GROUP_BLOCKING(csr_cs_file_scanned_cb, const char* file_path, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*data_control_add_callback_result_cb)(void* provider, some_enum result, int callback_id, void* user_data); +#define CB_PARAMS_NAMES provider, result, callback_id, user_data +PROXY_GROUP_NON_BLOCKING(data_control_add_callback_result_cb, void* provider, some_enum result, int callback_id, void* user_data) +PROXY_GROUP_BLOCKING(data_control_add_callback_result_cb, void* provider, some_enum result, int callback_id, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*data_control_bulk_cb)(int request_id, void* provider, void* bulk_results, bool provider_result, const char* error, void* user_data); +#define CB_PARAMS_NAMES request_id, provider, bulk_results, provider_result, error, user_data +PROXY_GROUP_NON_BLOCKING(data_control_bulk_cb, int request_id, void* provider, void* bulk_results, bool provider_result, const char* error, void* user_data) +PROXY_GROUP_BLOCKING(data_control_bulk_cb, int request_id, void* provider, void* bulk_results, bool provider_result, const char* error, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*data_control_data_change_cb)(void* provider, some_enum type, void* data, void* user_data); +#define CB_PARAMS_NAMES provider, type, data, user_data +PROXY_GROUP_NON_BLOCKING(data_control_data_change_cb, void* provider, some_enum type, void* data, void* user_data) +PROXY_GROUP_BLOCKING(data_control_data_change_cb, void* provider, some_enum type, void* data, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*data_control_map_add_response_cb)(int request_id, void* provider, bool provider_result, const char* error, void* user_data); +#define CB_PARAMS_NAMES request_id, provider, provider_result, error, user_data +PROXY_GROUP_NON_BLOCKING(data_control_map_add_response_cb, int request_id, void* provider, bool provider_result, const char* error, void* user_data) +PROXY_GROUP_BLOCKING(data_control_map_add_response_cb, int request_id, void* provider, bool provider_result, const char* error, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*data_control_map_get_response_cb)(int request_id, void* provider, char** result_value_list, int result_value_count, bool provider_result, const char* error, void* user_data); +#define CB_PARAMS_NAMES request_id, provider, result_value_list, result_value_count, provider_result, error, user_data +PROXY_GROUP_NON_BLOCKING(data_control_map_get_response_cb, int request_id, void* provider, char** result_value_list, int result_value_count, bool provider_result, const char* error, void* user_data) +PROXY_GROUP_BLOCKING(data_control_map_get_response_cb, int request_id, void* provider, char** result_value_list, int result_value_count, bool provider_result, const char* error, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*data_control_map_remove_response_cb)(int request_id, void* provider, bool provider_result, const char* error, void* user_data); +#define CB_PARAMS_NAMES request_id, provider, provider_result, error, user_data +PROXY_GROUP_NON_BLOCKING(data_control_map_remove_response_cb, int request_id, void* provider, bool provider_result, const char* error, void* user_data) +PROXY_GROUP_BLOCKING(data_control_map_remove_response_cb, int request_id, void* provider, bool provider_result, const char* error, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*data_control_map_set_response_cb)(int request_id, void* provider, bool provider_result, const char* error, void* user_data); +#define CB_PARAMS_NAMES request_id, provider, provider_result, error, user_data +PROXY_GROUP_NON_BLOCKING(data_control_map_set_response_cb, int request_id, void* provider, bool provider_result, const char* error, void* user_data) +PROXY_GROUP_BLOCKING(data_control_map_set_response_cb, int request_id, void* provider, bool provider_result, const char* error, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*data_control_provider_bulk_cb)(int request_id, void* provider, void* bulk_data, void* user_data); +#define CB_PARAMS_NAMES request_id, provider, bulk_data, user_data +PROXY_GROUP_NON_BLOCKING(data_control_provider_bulk_cb, int request_id, void* provider, void* bulk_data, void* user_data) +PROXY_GROUP_BLOCKING(data_control_provider_bulk_cb, int request_id, void* provider, void* bulk_data, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*data_control_provider_data_change_consumer_cb)(void* provider, char* consumer_appid, void* user_data); +#define CB_PARAMS_NAMES provider, consumer_appid, user_data +PROXY_GROUP_RETURN(data_control_provider_data_change_consumer_cb, bool, void* provider, char* consumer_appid, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*data_control_provider_data_change_consumer_filter_cb)(void* provider, char* consumer_appid, void* user_data); +#define CB_PARAMS_NAMES provider, consumer_appid, user_data +PROXY_GROUP_RETURN(data_control_provider_data_change_consumer_filter_cb, bool, void* provider, char* consumer_appid, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*data_control_provider_map_add_value_request_cb)(int request_id, void* provider, const char* key, const char* value, void* user_data); +#define CB_PARAMS_NAMES request_id, provider, key, value, user_data +PROXY_GROUP_NON_BLOCKING(data_control_provider_map_add_value_request_cb, int request_id, void* provider, const char* key, const char* value, void* user_data) +PROXY_GROUP_BLOCKING(data_control_provider_map_add_value_request_cb, int request_id, void* provider, const char* key, const char* value, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*data_control_provider_map_get_value_request_cb)(int request_id, void* provider, const char* key, void* user_data); +#define CB_PARAMS_NAMES request_id, provider, key, user_data +PROXY_GROUP_NON_BLOCKING(data_control_provider_map_get_value_request_cb, int request_id, void* provider, const char* key, void* user_data) +PROXY_GROUP_BLOCKING(data_control_provider_map_get_value_request_cb, int request_id, void* provider, const char* key, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*data_control_provider_map_remove_value_request_cb)(int request_id, void* provider, const char* key, const char* value, void* user_data); +#define CB_PARAMS_NAMES request_id, provider, key, value, user_data +PROXY_GROUP_NON_BLOCKING(data_control_provider_map_remove_value_request_cb, int request_id, void* provider, const char* key, const char* value, void* user_data) +PROXY_GROUP_BLOCKING(data_control_provider_map_remove_value_request_cb, int request_id, void* provider, const char* key, const char* value, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*data_control_provider_map_set_value_request_cb)(int request_id, void* provider, const char* key, const char* old_value, const char* new_value, void* user_data); +#define CB_PARAMS_NAMES request_id, provider, key, old_value, new_value, user_data +PROXY_GROUP_NON_BLOCKING(data_control_provider_map_set_value_request_cb, int request_id, void* provider, const char* key, const char* old_value, const char* new_value, void* user_data) +PROXY_GROUP_BLOCKING(data_control_provider_map_set_value_request_cb, int request_id, void* provider, const char* key, const char* old_value, const char* new_value, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*data_control_provider_sql_delete_request_cb)(int request_id, void* provider, const char* where, void* user_data); +#define CB_PARAMS_NAMES request_id, provider, where, user_data +PROXY_GROUP_NON_BLOCKING(data_control_provider_sql_delete_request_cb, int request_id, void* provider, const char* where, void* user_data) +PROXY_GROUP_BLOCKING(data_control_provider_sql_delete_request_cb, int request_id, void* provider, const char* where, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*data_control_provider_sql_insert_request_cb)(int request_id, void* provider, void* insert_data, void* user_data); +#define CB_PARAMS_NAMES request_id, provider, insert_data, user_data +PROXY_GROUP_NON_BLOCKING(data_control_provider_sql_insert_request_cb, int request_id, void* provider, void* insert_data, void* user_data) +PROXY_GROUP_BLOCKING(data_control_provider_sql_insert_request_cb, int request_id, void* provider, void* insert_data, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*data_control_provider_sql_select_request_cb)(int request_id, void* provider, const char** column_list, int column_count, const char* where, const char* order, void* user_data); +#define CB_PARAMS_NAMES request_id, provider, column_list, column_count, where, order, user_data +PROXY_GROUP_NON_BLOCKING(data_control_provider_sql_select_request_cb, int request_id, void* provider, const char** column_list, int column_count, const char* where, const char* order, void* user_data) +PROXY_GROUP_BLOCKING(data_control_provider_sql_select_request_cb, int request_id, void* provider, const char** column_list, int column_count, const char* where, const char* order, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*data_control_provider_sql_update_request_cb)(int request_id, void* provider, void* update_data, const char* where, void* user_data); +#define CB_PARAMS_NAMES request_id, provider, update_data, where, user_data +PROXY_GROUP_NON_BLOCKING(data_control_provider_sql_update_request_cb, int request_id, void* provider, void* update_data, const char* where, void* user_data) +PROXY_GROUP_BLOCKING(data_control_provider_sql_update_request_cb, int request_id, void* provider, void* update_data, const char* where, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*data_control_sql_delete_response_cb)(int request_id, void* provider, bool provider_result, const char* error, void* user_data); +#define CB_PARAMS_NAMES request_id, provider, provider_result, error, user_data +PROXY_GROUP_NON_BLOCKING(data_control_sql_delete_response_cb, int request_id, void* provider, bool provider_result, const char* error, void* user_data) +PROXY_GROUP_BLOCKING(data_control_sql_delete_response_cb, int request_id, void* provider, bool provider_result, const char* error, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*data_control_sql_insert_response_cb)(int request_id, void* provider, long long inserted_row_id, bool provider_result, const char* error, void* user_data); +#define CB_PARAMS_NAMES request_id, provider, inserted_row_id, provider_result, error, user_data +PROXY_GROUP_NON_BLOCKING(data_control_sql_insert_response_cb, int request_id, void* provider, long long inserted_row_id, bool provider_result, const char* error, void* user_data) +PROXY_GROUP_BLOCKING(data_control_sql_insert_response_cb, int request_id, void* provider, long long inserted_row_id, bool provider_result, const char* error, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*data_control_sql_select_response_cb)(int request_id, void* provider, void* enumerator, bool provider_result, const char* error, void* user_data); +#define CB_PARAMS_NAMES request_id, provider, enumerator, provider_result, error, user_data +PROXY_GROUP_NON_BLOCKING(data_control_sql_select_response_cb, int request_id, void* provider, void* enumerator, bool provider_result, const char* error, void* user_data) +PROXY_GROUP_BLOCKING(data_control_sql_select_response_cb, int request_id, void* provider, void* enumerator, bool provider_result, const char* error, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*data_control_sql_update_response_cb)(int request_id, void* provider, bool provider_result, const char* error, void* user_data); +#define CB_PARAMS_NAMES request_id, provider, provider_result, error, user_data +PROXY_GROUP_NON_BLOCKING(data_control_sql_update_response_cb, int request_id, void* provider, bool provider_result, const char* error, void* user_data) +PROXY_GROUP_BLOCKING(data_control_sql_update_response_cb, int request_id, void* provider, bool provider_result, const char* error, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*device_changed_cb)(some_enum type, void* value, void* user_data); +#define CB_PARAMS_NAMES type, value, user_data +PROXY_GROUP_NON_BLOCKING(device_changed_cb, some_enum type, void* value, void* user_data) +PROXY_GROUP_BLOCKING(device_changed_cb, some_enum type, void* value, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*diagnostics_notification_cb)(void* ctx, void* user_data); +#define CB_PARAMS_NAMES ctx, user_data +PROXY_GROUP_NON_BLOCKING(diagnostics_notification_cb, void* ctx, void* user_data) +PROXY_GROUP_BLOCKING(diagnostics_notification_cb, void* ctx, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*diagnostics_request_cb)(void* data, char** params, int params_size, void* ctx, void* user_data); +#define CB_PARAMS_NAMES data, params, params_size, ctx, user_data +PROXY_GROUP_NON_BLOCKING(diagnostics_request_cb, void* data, char** params, int params_size, void* ctx, void* user_data) +PROXY_GROUP_BLOCKING(diagnostics_request_cb, void* data, char** params, int params_size, void* ctx, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*dnssd_found_cb)(some_enum service_state, unsigned int remote_service, void* user_data); +#define CB_PARAMS_NAMES service_state, remote_service, user_data +PROXY_GROUP_NON_BLOCKING(dnssd_found_cb, some_enum service_state, unsigned int remote_service, void* user_data) +PROXY_GROUP_BLOCKING(dnssd_found_cb, some_enum service_state, unsigned int remote_service, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*dnssd_registered_cb)(some_enum result, unsigned int local_service, void* user_data); +#define CB_PARAMS_NAMES result, local_service, user_data +PROXY_GROUP_NON_BLOCKING(dnssd_registered_cb, some_enum result, unsigned int local_service, void* user_data) +PROXY_GROUP_BLOCKING(dnssd_registered_cb, some_enum result, unsigned int local_service, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*dnssd_resolved_cb)(some_enum result, unsigned int remote_service, void* user_data); +#define CB_PARAMS_NAMES result, remote_service, user_data +PROXY_GROUP_NON_BLOCKING(dnssd_resolved_cb, some_enum result, unsigned int remote_service, void* user_data) +PROXY_GROUP_BLOCKING(dnssd_resolved_cb, some_enum result, unsigned int remote_service, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*download_progress_cb)(int download_id, unsigned long long received, void* user_data); +#define CB_PARAMS_NAMES download_id, received, user_data +PROXY_GROUP_NON_BLOCKING(download_progress_cb, int download_id, unsigned long long received, void* user_data) +PROXY_GROUP_BLOCKING(download_progress_cb, int download_id, unsigned long long received, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*download_state_changed_cb)(int download_id, some_enum state, void* user_data); +#define CB_PARAMS_NAMES download_id, state, user_data +PROXY_GROUP_NON_BLOCKING(download_state_changed_cb, int download_id, some_enum state, void* user_data) +PROXY_GROUP_BLOCKING(download_state_changed_cb, int download_id, some_enum state, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*dpm_policy_changed_cb)(const char* name, const char* state, void* user_data); +#define CB_PARAMS_NAMES name, state, user_data +PROXY_GROUP_NON_BLOCKING(dpm_policy_changed_cb, const char* name, const char* state, void* user_data) +PROXY_GROUP_BLOCKING(dpm_policy_changed_cb, const char* name, const char* state, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*dpm_signal_cb)(const char* name, const char* object, void* user_data); +#define CB_PARAMS_NAMES name, object, user_data +PROXY_GROUP_NON_BLOCKING(dpm_signal_cb, const char* name, const char* object, void* user_data) +PROXY_GROUP_BLOCKING(dpm_signal_cb, const char* name, const char* object, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*dpm_zone_foreach_name_cb)(const char* name, void* user_data); +#define CB_PARAMS_NAMES name, user_data +PROXY_GROUP_RETURN(dpm_zone_foreach_name_cb, bool, const char* name, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*email_message_sent_cb)(void* email, some_enum result, void* user_data); +#define CB_PARAMS_NAMES email, result, user_data +PROXY_GROUP_NON_BLOCKING(email_message_sent_cb, void* email, some_enum result, void* user_data) +PROXY_GROUP_BLOCKING(email_message_sent_cb, void* email, some_enum result, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*eom_attribute_changed_cb)(unsigned int output_id, void* user_data); +#define CB_PARAMS_NAMES output_id, user_data +PROXY_GROUP_NON_BLOCKING(eom_attribute_changed_cb, unsigned int output_id, void* user_data) +PROXY_GROUP_BLOCKING(eom_attribute_changed_cb, unsigned int output_id, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*eom_mode_changed_cb)(unsigned int output_id, void* user_data); +#define CB_PARAMS_NAMES output_id, user_data +PROXY_GROUP_NON_BLOCKING(eom_mode_changed_cb, unsigned int output_id, void* user_data) +PROXY_GROUP_BLOCKING(eom_mode_changed_cb, unsigned int output_id, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*eom_output_added_cb)(unsigned int output_id, void* user_data); +#define CB_PARAMS_NAMES output_id, user_data +PROXY_GROUP_NON_BLOCKING(eom_output_added_cb, unsigned int output_id, void* user_data) +PROXY_GROUP_BLOCKING(eom_output_added_cb, unsigned int output_id, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*eom_output_removed_cb)(unsigned int output_id, void* user_data); +#define CB_PARAMS_NAMES output_id, user_data +PROXY_GROUP_NON_BLOCKING(eom_output_removed_cb, unsigned int output_id, void* user_data) +PROXY_GROUP_BLOCKING(eom_output_removed_cb, unsigned int output_id, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*event_cb)(const char* event_name, void* event_data, void* user_data); +#define CB_PARAMS_NAMES event_name, event_data, user_data +PROXY_GROUP_NON_BLOCKING(event_cb, const char* event_name, void* event_data, void* user_data) +PROXY_GROUP_BLOCKING(event_cb, const char* event_name, void* event_data, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*fido_attestation_type_cb)(some_enum att_type, void* user_data); +#define CB_PARAMS_NAMES att_type, user_data +PROXY_GROUP_NON_BLOCKING(fido_attestation_type_cb, some_enum att_type, void* user_data) +PROXY_GROUP_BLOCKING(fido_attestation_type_cb, some_enum att_type, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*fido_authenticator_cb)(const void* auth_info, void* user_data); +#define CB_PARAMS_NAMES auth_info, user_data +PROXY_GROUP_NON_BLOCKING(fido_authenticator_cb, const void* auth_info, void* user_data) +PROXY_GROUP_BLOCKING(fido_authenticator_cb, const void* auth_info, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*fido_uaf_response_message_cb)(some_enum tizen_error_code, const char* uaf_response_json, void* user_data); +#define CB_PARAMS_NAMES tizen_error_code, uaf_response_json, user_data +PROXY_GROUP_NON_BLOCKING(fido_uaf_response_message_cb, some_enum tizen_error_code, const char* uaf_response_json, void* user_data) +PROXY_GROUP_BLOCKING(fido_uaf_response_message_cb, some_enum tizen_error_code, const char* uaf_response_json, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*geofence_event_cb)(int place_id, int geofence_id, some_enum error, some_enum manage, void* user_data); +#define CB_PARAMS_NAMES place_id, geofence_id, error, manage, user_data +PROXY_GROUP_NON_BLOCKING(geofence_event_cb, int place_id, int geofence_id, some_enum error, some_enum manage, void* user_data) +PROXY_GROUP_BLOCKING(geofence_event_cb, int place_id, int geofence_id, some_enum error, some_enum manage, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*geofence_manager_fence_cb)(int geofence_id, void* fence, int fence_index, int fence_cnt, void* user_data); +#define CB_PARAMS_NAMES geofence_id, fence, fence_index, fence_cnt, user_data +PROXY_GROUP_RETURN(geofence_manager_fence_cb, bool, int geofence_id, void* fence, int fence_index, int fence_cnt, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*geofence_manager_place_cb)(int place_id, const char* place_name, int place_index, int place_cnt, void* user_data); +#define CB_PARAMS_NAMES place_id, place_name, place_index, place_cnt, user_data +PROXY_GROUP_RETURN(geofence_manager_place_cb, bool, int place_id, const char* place_name, int place_index, int place_cnt, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*geofence_proximity_state_changed_cb)(int geofence_id, some_enum state, some_enum provider, void* user_data); +#define CB_PARAMS_NAMES geofence_id, state, provider, user_data +PROXY_GROUP_NON_BLOCKING(geofence_proximity_state_changed_cb, int geofence_id, some_enum state, some_enum provider, void* user_data) +PROXY_GROUP_BLOCKING(geofence_proximity_state_changed_cb, int geofence_id, some_enum state, some_enum provider, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*geofence_state_changed_cb)(int geofence_id, some_enum state, void* user_data); +#define CB_PARAMS_NAMES geofence_id, state, user_data +PROXY_GROUP_NON_BLOCKING(geofence_state_changed_cb, int geofence_id, some_enum state, void* user_data) +PROXY_GROUP_BLOCKING(geofence_state_changed_cb, int geofence_id, some_enum state, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*gesture_recognition_cb)(some_enum gesture, const void* data, double timestamp, some_enum error, void* user_data); +#define CB_PARAMS_NAMES gesture, data, timestamp, error, user_data +PROXY_GROUP_NON_BLOCKING(gesture_recognition_cb, some_enum gesture, const void* data, double timestamp, some_enum error, void* user_data) +PROXY_GROUP_BLOCKING(gesture_recognition_cb, some_enum gesture, const void* data, double timestamp, some_enum error, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*gps_status_get_satellites_cb)(unsigned int azimuth, unsigned int elevation, unsigned int prn, int snr, bool is_active, void* user_data); +#define CB_PARAMS_NAMES azimuth, elevation, prn, snr, is_active, user_data +PROXY_GROUP_RETURN(gps_status_get_satellites_cb, bool, unsigned int azimuth, unsigned int elevation, unsigned int prn, int snr, bool is_active, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*gps_status_satellite_updated_cb)(int num_of_active, int num_of_inview, time_t timestamp, void* user_data); +#define CB_PARAMS_NAMES num_of_active, num_of_inview, timestamp, user_data +PROXY_GROUP_NON_BLOCKING(gps_status_satellite_updated_cb, int num_of_active, int num_of_inview, time_t timestamp, void* user_data) +PROXY_GROUP_BLOCKING(gps_status_satellite_updated_cb, int num_of_active, int num_of_inview, time_t timestamp, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*http_transaction_aborted_cb)(void* http_transaction, some_enum error, void* user_data); +#define CB_PARAMS_NAMES http_transaction, error, user_data +PROXY_GROUP_NON_BLOCKING(http_transaction_aborted_cb, void* http_transaction, some_enum error, void* user_data) +PROXY_GROUP_BLOCKING(http_transaction_aborted_cb, void* http_transaction, some_enum error, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*http_transaction_body_cb)(void* http_transaction, char* body, size_t size, size_t count, void* user_data); +#define CB_PARAMS_NAMES http_transaction, body, size, count, user_data +PROXY_GROUP_NON_BLOCKING(http_transaction_body_cb, void* http_transaction, char* body, size_t size, size_t count, void* user_data) +PROXY_GROUP_BLOCKING(http_transaction_body_cb, void* http_transaction, char* body, size_t size, size_t count, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*http_transaction_completed_cb)(void* http_transaction, void* user_data); +#define CB_PARAMS_NAMES http_transaction, user_data +PROXY_GROUP_NON_BLOCKING(http_transaction_completed_cb, void* http_transaction, void* user_data) +PROXY_GROUP_BLOCKING(http_transaction_completed_cb, void* http_transaction, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*http_transaction_header_cb)(void* http_transaction, char* header, size_t header_len, void* user_data); +#define CB_PARAMS_NAMES http_transaction, header, header_len, user_data +PROXY_GROUP_NON_BLOCKING(http_transaction_header_cb, void* http_transaction, char* header, size_t header_len, void* user_data) +PROXY_GROUP_BLOCKING(http_transaction_header_cb, void* http_transaction, char* header, size_t header_len, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*http_transaction_progress_cb)(void* http_transaction, double download_total, double download_now, double upload_total, double upload_now, void* user_data); +#define CB_PARAMS_NAMES http_transaction, download_total, download_now, upload_total, upload_now, user_data +PROXY_GROUP_NON_BLOCKING(http_transaction_progress_cb, void* http_transaction, double download_total, double download_now, double upload_total, double upload_now, void* user_data) +PROXY_GROUP_BLOCKING(http_transaction_progress_cb, void* http_transaction, double download_total, double download_now, double upload_total, double upload_now, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*http_transaction_write_cb)(void* http_transaction, int recommended_chunk_size, void* user_data); +#define CB_PARAMS_NAMES http_transaction, recommended_chunk_size, user_data +PROXY_GROUP_NON_BLOCKING(http_transaction_write_cb, void* http_transaction, int recommended_chunk_size, void* user_data) +PROXY_GROUP_BLOCKING(http_transaction_write_cb, void* http_transaction, int recommended_chunk_size, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*image_util_decode_completed2_cb)(int error_code, void* image, void* user_data); +#define CB_PARAMS_NAMES error_code, image, user_data +PROXY_GROUP_NON_BLOCKING(image_util_decode_completed2_cb, int error_code, void* image, void* user_data) +PROXY_GROUP_BLOCKING(image_util_decode_completed2_cb, int error_code, void* image, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*image_util_decode_completed_cb)(int error_code, void* user_data, unsigned long width, unsigned long height, unsigned long long size); +#define CB_PARAMS_NAMES error_code, user_data, width, height, size +PROXY_GROUP_NON_BLOCKING(image_util_decode_completed_cb, int error_code, void* user_data, unsigned long width, unsigned long height, unsigned long long size) +PROXY_GROUP_BLOCKING(image_util_decode_completed_cb, int error_code, void* user_data, unsigned long width, unsigned long height, unsigned long long size) +#undef CB_PARAMS_NAMES + +typedef void (*image_util_encode_completed_cb)(int error_code, void* user_data, unsigned long long size); +#define CB_PARAMS_NAMES error_code, user_data, size +PROXY_GROUP_NON_BLOCKING(image_util_encode_completed_cb, int error_code, void* user_data, unsigned long long size) +PROXY_GROUP_BLOCKING(image_util_encode_completed_cb, int error_code, void* user_data, unsigned long long size) +#undef CB_PARAMS_NAMES + +typedef void (*image_util_encode_to_buffer_completed_cb)(some_enum error_code, unsigned char* buffer, size_t buffer_size, void* user_data); +#define CB_PARAMS_NAMES error_code, buffer, buffer_size, user_data +PROXY_GROUP_NON_BLOCKING(image_util_encode_to_buffer_completed_cb, some_enum error_code, unsigned char* buffer, size_t buffer_size, void* user_data) +PROXY_GROUP_BLOCKING(image_util_encode_to_buffer_completed_cb, some_enum error_code, unsigned char* buffer, size_t buffer_size, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*image_util_encode_to_file_completed_cb)(some_enum error_code, void* user_data); +#define CB_PARAMS_NAMES error_code, user_data +PROXY_GROUP_NON_BLOCKING(image_util_encode_to_file_completed_cb, some_enum error_code, void* user_data) +PROXY_GROUP_BLOCKING(image_util_encode_to_file_completed_cb, some_enum error_code, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*image_util_supported_colorspace_cb)(some_enum colorspace, void* user_data); +#define CB_PARAMS_NAMES colorspace, user_data +PROXY_GROUP_RETURN(image_util_supported_colorspace_cb, bool, some_enum colorspace, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*image_util_transform_completed2_cb)(void* dst, int error_code, void* user_data); +#define CB_PARAMS_NAMES dst, error_code, user_data +PROXY_GROUP_NON_BLOCKING(image_util_transform_completed2_cb, void* dst, int error_code, void* user_data) +PROXY_GROUP_BLOCKING(image_util_transform_completed2_cb, void* dst, int error_code, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*image_util_transform_completed_cb)(void* dst, int error_code, void* user_data); +#define CB_PARAMS_NAMES dst, error_code, user_data +PROXY_GROUP_NON_BLOCKING(image_util_transform_completed_cb, void* dst, int error_code, void* user_data) +PROXY_GROUP_BLOCKING(image_util_transform_completed_cb, void* dst, int error_code, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*ime_accessibility_state_changed_cb)(bool state, void* user_data); +#define CB_PARAMS_NAMES state, user_data +PROXY_GROUP_NON_BLOCKING(ime_accessibility_state_changed_cb, bool state, void* user_data) +PROXY_GROUP_BLOCKING(ime_accessibility_state_changed_cb, bool state, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*ime_create_cb)(void* user_data); +#define CB_PARAMS_NAMES user_data +PROXY_GROUP_NON_BLOCKING(ime_create_cb, void* user_data) +PROXY_GROUP_BLOCKING(ime_create_cb, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*ime_cursor_position_updated_cb)(int cursor_pos, void* user_data); +#define CB_PARAMS_NAMES cursor_pos, user_data +PROXY_GROUP_NON_BLOCKING(ime_cursor_position_updated_cb, int cursor_pos, void* user_data) +PROXY_GROUP_BLOCKING(ime_cursor_position_updated_cb, int cursor_pos, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*ime_display_language_changed_cb)(const char* language, void* user_data); +#define CB_PARAMS_NAMES language, user_data +PROXY_GROUP_NON_BLOCKING(ime_display_language_changed_cb, const char* language, void* user_data) +PROXY_GROUP_BLOCKING(ime_display_language_changed_cb, const char* language, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*ime_focus_in_cb)(int context_id, void* user_data); +#define CB_PARAMS_NAMES context_id, user_data +PROXY_GROUP_NON_BLOCKING(ime_focus_in_cb, int context_id, void* user_data) +PROXY_GROUP_BLOCKING(ime_focus_in_cb, int context_id, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*ime_focus_out_cb)(int context_id, void* user_data); +#define CB_PARAMS_NAMES context_id, user_data +PROXY_GROUP_NON_BLOCKING(ime_focus_out_cb, int context_id, void* user_data) +PROXY_GROUP_BLOCKING(ime_focus_out_cb, int context_id, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*ime_geometry_requested_cb)(void* user_data, int* x, int* y, int* w, int* h); +#define CB_PARAMS_NAMES user_data, x, y, w, h +PROXY_GROUP_NON_BLOCKING(ime_geometry_requested_cb, void* user_data, int* x, int* y, int* w, int* h) +PROXY_GROUP_BLOCKING(ime_geometry_requested_cb, void* user_data, int* x, int* y, int* w, int* h) +#undef CB_PARAMS_NAMES + +typedef void (*ime_hide_cb)(int context_id, void* user_data); +#define CB_PARAMS_NAMES context_id, user_data +PROXY_GROUP_NON_BLOCKING(ime_hide_cb, int context_id, void* user_data) +PROXY_GROUP_BLOCKING(ime_hide_cb, int context_id, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*ime_imdata_requested_cb)(void* user_data, void** data, unsigned int* data_length); +#define CB_PARAMS_NAMES user_data, data, data_length +PROXY_GROUP_NON_BLOCKING(ime_imdata_requested_cb, void* user_data, void** data, unsigned int* data_length) +PROXY_GROUP_BLOCKING(ime_imdata_requested_cb, void* user_data, void** data, unsigned int* data_length) +#undef CB_PARAMS_NAMES + +typedef void (*ime_imdata_set_cb)(void* data, unsigned int data_length, void* user_data); +#define CB_PARAMS_NAMES data, data_length, user_data +PROXY_GROUP_NON_BLOCKING(ime_imdata_set_cb, void* data, unsigned int data_length, void* user_data) +PROXY_GROUP_BLOCKING(ime_imdata_set_cb, void* data, unsigned int data_length, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*ime_input_context_reset_cb)(void* user_data); +#define CB_PARAMS_NAMES user_data +PROXY_GROUP_NON_BLOCKING(ime_input_context_reset_cb, void* user_data) +PROXY_GROUP_BLOCKING(ime_input_context_reset_cb, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*ime_input_hint_set_cb)(some_enum input_hint, void* user_data); +#define CB_PARAMS_NAMES input_hint, user_data +PROXY_GROUP_NON_BLOCKING(ime_input_hint_set_cb, some_enum input_hint, void* user_data) +PROXY_GROUP_BLOCKING(ime_input_hint_set_cb, some_enum input_hint, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*ime_language_requested_cb)(void* user_data, char** lang_code); +#define CB_PARAMS_NAMES user_data, lang_code +PROXY_GROUP_NON_BLOCKING(ime_language_requested_cb, void* user_data, char** lang_code) +PROXY_GROUP_BLOCKING(ime_language_requested_cb, void* user_data, char** lang_code) +#undef CB_PARAMS_NAMES + +typedef void (*ime_language_set_cb)(some_enum language, void* user_data); +#define CB_PARAMS_NAMES language, user_data +PROXY_GROUP_NON_BLOCKING(ime_language_set_cb, some_enum language, void* user_data) +PROXY_GROUP_BLOCKING(ime_language_set_cb, some_enum language, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*ime_layout_set_cb)(some_enum layout, void* user_data); +#define CB_PARAMS_NAMES layout, user_data +PROXY_GROUP_NON_BLOCKING(ime_layout_set_cb, some_enum layout, void* user_data) +PROXY_GROUP_BLOCKING(ime_layout_set_cb, some_enum layout, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*ime_mime_type_set_request_cb)(const char* mime_type, void* user_data); +#define CB_PARAMS_NAMES mime_type, user_data +PROXY_GROUP_NON_BLOCKING(ime_mime_type_set_request_cb, const char* mime_type, void* user_data) +PROXY_GROUP_BLOCKING(ime_mime_type_set_request_cb, const char* mime_type, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*ime_option_window_created_cb)(void* window, some_enum type, void* user_data); +#define CB_PARAMS_NAMES window, type, user_data +PROXY_GROUP_NON_BLOCKING(ime_option_window_created_cb, void* window, some_enum type, void* user_data) +PROXY_GROUP_BLOCKING(ime_option_window_created_cb, void* window, some_enum type, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*ime_option_window_destroyed_cb)(void* window, void* user_data); +#define CB_PARAMS_NAMES window, user_data +PROXY_GROUP_NON_BLOCKING(ime_option_window_destroyed_cb, void* window, void* user_data) +PROXY_GROUP_BLOCKING(ime_option_window_destroyed_cb, void* window, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*ime_prediction_hint_data_set_cb)(const char* key, const char* value, void* user_data); +#define CB_PARAMS_NAMES key, value, user_data +PROXY_GROUP_NON_BLOCKING(ime_prediction_hint_data_set_cb, const char* key, const char* value, void* user_data) +PROXY_GROUP_BLOCKING(ime_prediction_hint_data_set_cb, const char* key, const char* value, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*ime_prediction_hint_set_cb)(const char* prediction_hint, void* user_data); +#define CB_PARAMS_NAMES prediction_hint, user_data +PROXY_GROUP_NON_BLOCKING(ime_prediction_hint_set_cb, const char* prediction_hint, void* user_data) +PROXY_GROUP_BLOCKING(ime_prediction_hint_set_cb, const char* prediction_hint, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*ime_process_key_event_cb)(some_enum key_code, some_enum key_mask, void* dev_info, void* user_data); +#define CB_PARAMS_NAMES key_code, key_mask, dev_info, user_data +PROXY_GROUP_RETURN(ime_process_key_event_cb, bool, some_enum key_code, some_enum key_mask, void* dev_info, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*ime_process_key_event_with_keycode_cb)(unsigned int key_code, some_enum key_sym, some_enum key_mask, void* dev_info, void* user_data); +#define CB_PARAMS_NAMES key_code, key_sym, key_mask, dev_info, user_data +PROXY_GROUP_RETURN(ime_process_key_event_with_keycode_cb, bool, unsigned int key_code, some_enum key_sym, some_enum key_mask, void* dev_info, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*ime_return_key_state_set_cb)(bool disabled, void* user_data); +#define CB_PARAMS_NAMES disabled, user_data +PROXY_GROUP_NON_BLOCKING(ime_return_key_state_set_cb, bool disabled, void* user_data) +PROXY_GROUP_BLOCKING(ime_return_key_state_set_cb, bool disabled, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*ime_return_key_type_set_cb)(some_enum type, void* user_data); +#define CB_PARAMS_NAMES type, user_data +PROXY_GROUP_NON_BLOCKING(ime_return_key_type_set_cb, some_enum type, void* user_data) +PROXY_GROUP_BLOCKING(ime_return_key_type_set_cb, some_enum type, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*ime_rotation_degree_changed_cb)(int degree, void* user_data); +#define CB_PARAMS_NAMES degree, user_data +PROXY_GROUP_NON_BLOCKING(ime_rotation_degree_changed_cb, int degree, void* user_data) +PROXY_GROUP_BLOCKING(ime_rotation_degree_changed_cb, int degree, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*ime_show_cb)(int context_id, void* context, void* user_data); +#define CB_PARAMS_NAMES context_id, context, user_data +PROXY_GROUP_NON_BLOCKING(ime_show_cb, int context_id, void* context, void* user_data) +PROXY_GROUP_BLOCKING(ime_show_cb, int context_id, void* context, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*ime_surrounding_text_updated_cb)(int context_id, const char* text, int cursor_pos, void* user_data); +#define CB_PARAMS_NAMES context_id, text, cursor_pos, user_data +PROXY_GROUP_NON_BLOCKING(ime_surrounding_text_updated_cb, int context_id, const char* text, int cursor_pos, void* user_data) +PROXY_GROUP_BLOCKING(ime_surrounding_text_updated_cb, int context_id, const char* text, int cursor_pos, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*ime_terminate_cb)(void* user_data); +#define CB_PARAMS_NAMES user_data +PROXY_GROUP_NON_BLOCKING(ime_terminate_cb, void* user_data) +PROXY_GROUP_BLOCKING(ime_terminate_cb, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*inm_arp_request_ip_found_cb)(bool found, const char* ip, void* user_data); +#define CB_PARAMS_NAMES found, ip, user_data +PROXY_GROUP_NON_BLOCKING(inm_arp_request_ip_found_cb, bool found, const char* ip, void* user_data) +PROXY_GROUP_BLOCKING(inm_arp_request_ip_found_cb, bool found, const char* ip, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*inm_cellular_state_changed_cb)(some_enum state, void* user_data); +#define CB_PARAMS_NAMES state, user_data +PROXY_GROUP_NON_BLOCKING(inm_cellular_state_changed_cb, some_enum state, void* user_data) +PROXY_GROUP_BLOCKING(inm_cellular_state_changed_cb, some_enum state, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*inm_channel_interference_cb)(int freq, double channel_intf, void* user_data); +#define CB_PARAMS_NAMES freq, channel_intf, user_data +PROXY_GROUP_NON_BLOCKING(inm_channel_interference_cb, int freq, double channel_intf, void* user_data) +PROXY_GROUP_BLOCKING(inm_channel_interference_cb, int freq, double channel_intf, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*inm_congestion_level_cb)(some_enum level, void* user_data); +#define CB_PARAMS_NAMES level, user_data +PROXY_GROUP_NON_BLOCKING(inm_congestion_level_cb, some_enum level, void* user_data) +PROXY_GROUP_BLOCKING(inm_congestion_level_cb, some_enum level, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*inm_default_dns_lookup_result_cb)(bool found, void* user_data); +#define CB_PARAMS_NAMES found, user_data +PROXY_GROUP_NON_BLOCKING(inm_default_dns_lookup_result_cb, bool found, void* user_data) +PROXY_GROUP_BLOCKING(inm_default_dns_lookup_result_cb, bool found, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*inm_default_gateway_found_cb)(bool found, const char* gateway_ip, void* user_data); +#define CB_PARAMS_NAMES found, gateway_ip, user_data +PROXY_GROUP_NON_BLOCKING(inm_default_gateway_found_cb, bool found, const char* gateway_ip, void* user_data) +PROXY_GROUP_BLOCKING(inm_default_gateway_found_cb, bool found, const char* gateway_ip, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*inm_ethernet_cable_state_changed_cb)(some_enum state, void* user_data); +#define CB_PARAMS_NAMES state, user_data +PROXY_GROUP_NON_BLOCKING(inm_ethernet_cable_state_changed_cb, some_enum state, void* user_data) +PROXY_GROUP_BLOCKING(inm_ethernet_cable_state_changed_cb, some_enum state, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*inm_ethernet_state_changed_cb)(some_enum state, void* user_data); +#define CB_PARAMS_NAMES state, user_data +PROXY_GROUP_NON_BLOCKING(inm_ethernet_state_changed_cb, some_enum state, void* user_data) +PROXY_GROUP_BLOCKING(inm_ethernet_state_changed_cb, some_enum state, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*inm_ip_conflict_cb)(char* if_name, char* ip, some_enum state, void* user_data); +#define CB_PARAMS_NAMES if_name, ip, state, user_data +PROXY_GROUP_NON_BLOCKING(inm_ip_conflict_cb, char* if_name, char* ip, some_enum state, void* user_data) +PROXY_GROUP_BLOCKING(inm_ip_conflict_cb, char* if_name, char* ip, some_enum state, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*inm_link_address_cb)(void* address, void* user_data); +#define CB_PARAMS_NAMES address, user_data +PROXY_GROUP_RETURN(inm_link_address_cb, bool, void* address, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*inm_link_cb)(void* link, void* user_data); +#define CB_PARAMS_NAMES link, user_data +PROXY_GROUP_RETURN(inm_link_cb, bool, void* link, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*inm_link_route_cb)(void* route, void* user_data); +#define CB_PARAMS_NAMES route, user_data +PROXY_GROUP_RETURN(inm_link_route_cb, bool, void* route, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*inm_reachable_urls_check_result_cb)(some_enum result, const char* url, void* user_data); +#define CB_PARAMS_NAMES result, url, user_data +PROXY_GROUP_NON_BLOCKING(inm_reachable_urls_check_result_cb, some_enum result, const char* url, void* user_data) +PROXY_GROUP_BLOCKING(inm_reachable_urls_check_result_cb, some_enum result, const char* url, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*inm_retry_tx_rate_cb)(int rate, void* user_data); +#define CB_PARAMS_NAMES rate, user_data +PROXY_GROUP_NON_BLOCKING(inm_retry_tx_rate_cb, int rate, void* user_data) +PROXY_GROUP_BLOCKING(inm_retry_tx_rate_cb, int rate, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*inm_wifi_ap_vsie_cb)(unsigned char* vsie, int length, void* user_data); +#define CB_PARAMS_NAMES vsie, length, user_data +PROXY_GROUP_RETURN(inm_wifi_ap_vsie_cb, bool, unsigned char* vsie, int length, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*inm_wifi_found_ap_cb)(void* ap, void* user_data); +#define CB_PARAMS_NAMES ap, user_data +PROXY_GROUP_RETURN(inm_wifi_found_ap_cb, bool, void* ap, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*inm_wifi_module_state_changed_cb)(some_enum state, void* user_data); +#define CB_PARAMS_NAMES state, user_data +PROXY_GROUP_NON_BLOCKING(inm_wifi_module_state_changed_cb, some_enum state, void* user_data) +PROXY_GROUP_BLOCKING(inm_wifi_module_state_changed_cb, some_enum state, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*inm_wifi_scan_state_changed_cb)(some_enum state, void* user_data); +#define CB_PARAMS_NAMES state, user_data +PROXY_GROUP_NON_BLOCKING(inm_wifi_scan_state_changed_cb, some_enum state, void* user_data) +PROXY_GROUP_BLOCKING(inm_wifi_scan_state_changed_cb, some_enum state, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*inm_wifi_state_changed_cb)(some_enum state, void* user_data); +#define CB_PARAMS_NAMES state, user_data +PROXY_GROUP_NON_BLOCKING(inm_wifi_state_changed_cb, some_enum state, void* user_data) +PROXY_GROUP_BLOCKING(inm_wifi_state_changed_cb, some_enum state, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*iotcon_attributes_cb)(void* attributes, const char* key, void* user_data); +#define CB_PARAMS_NAMES attributes, key, user_data +PROXY_GROUP_RETURN(iotcon_attributes_cb, bool, void* attributes, const char* key, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*iotcon_children_cb)(void* child, void* user_data); +#define CB_PARAMS_NAMES child, user_data +PROXY_GROUP_RETURN(iotcon_children_cb, bool, void* child, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*iotcon_device_info_cb)(void* device_info, some_enum result, void* user_data); +#define CB_PARAMS_NAMES device_info, result, user_data +PROXY_GROUP_RETURN(iotcon_device_info_cb, bool, void* device_info, some_enum result, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*iotcon_found_resource_cb)(void* resource, some_enum result, void* user_data); +#define CB_PARAMS_NAMES resource, result, user_data +PROXY_GROUP_RETURN(iotcon_found_resource_cb, bool, void* resource, some_enum result, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*iotcon_generated_pin_cb)(const char* pin, void* user_data); +#define CB_PARAMS_NAMES pin, user_data +PROXY_GROUP_NON_BLOCKING(iotcon_generated_pin_cb, const char* pin, void* user_data) +PROXY_GROUP_BLOCKING(iotcon_generated_pin_cb, const char* pin, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*iotcon_list_attributes_cb)(int pos, void* value, void* user_data); +#define CB_PARAMS_NAMES pos, value, user_data +PROXY_GROUP_RETURN(iotcon_list_attributes_cb, bool, int pos, void* value, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*iotcon_list_bool_cb)(int pos, bool value, void* user_data); +#define CB_PARAMS_NAMES pos, value, user_data +PROXY_GROUP_RETURN(iotcon_list_bool_cb, bool, int pos, bool value, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*iotcon_list_byte_str_cb)(int pos, const unsigned char* value, int len, void* user_data); +#define CB_PARAMS_NAMES pos, value, len, user_data +PROXY_GROUP_RETURN(iotcon_list_byte_str_cb, bool, int pos, const unsigned char* value, int len, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*iotcon_list_double_cb)(int pos, double value, void* user_data); +#define CB_PARAMS_NAMES pos, value, user_data +PROXY_GROUP_RETURN(iotcon_list_double_cb, bool, int pos, double value, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*iotcon_list_int_cb)(int pos, int value, void* user_data); +#define CB_PARAMS_NAMES pos, value, user_data +PROXY_GROUP_RETURN(iotcon_list_int_cb, bool, int pos, int value, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*iotcon_list_list_cb)(int pos, void* value, void* user_data); +#define CB_PARAMS_NAMES pos, value, user_data +PROXY_GROUP_RETURN(iotcon_list_list_cb, bool, int pos, void* value, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*iotcon_list_str_cb)(int pos, const char* value, void* user_data); +#define CB_PARAMS_NAMES pos, value, user_data +PROXY_GROUP_RETURN(iotcon_list_str_cb, bool, int pos, const char* value, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*iotcon_lite_resource_post_request_cb)(void* resource, void* attributes, void* user_data); +#define CB_PARAMS_NAMES resource, attributes, user_data +PROXY_GROUP_RETURN(iotcon_lite_resource_post_request_cb, bool, void* resource, void* attributes, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*iotcon_options_foreach_cb)(unsigned short id, const char* data, void* user_data); +#define CB_PARAMS_NAMES id, data, user_data +PROXY_GROUP_RETURN(iotcon_options_foreach_cb, bool, unsigned short id, const char* data, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*iotcon_platform_info_cb)(void* platform_info, some_enum result, void* user_data); +#define CB_PARAMS_NAMES platform_info, result, user_data +PROXY_GROUP_RETURN(iotcon_platform_info_cb, bool, void* platform_info, some_enum result, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*iotcon_presence_cb)(void* presence, some_enum err, void* response, void* user_data); +#define CB_PARAMS_NAMES presence, err, response, user_data +PROXY_GROUP_NON_BLOCKING(iotcon_presence_cb, void* presence, some_enum err, void* response, void* user_data) +PROXY_GROUP_BLOCKING(iotcon_presence_cb, void* presence, some_enum err, void* response, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*iotcon_query_foreach_cb)(const char* key, const char* value, void* user_data); +#define CB_PARAMS_NAMES key, value, user_data +PROXY_GROUP_RETURN(iotcon_query_foreach_cb, bool, const char* key, const char* value, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*iotcon_remote_resource_cached_representation_changed_cb)(void* resource, void* representation, void* user_data); +#define CB_PARAMS_NAMES resource, representation, user_data +PROXY_GROUP_NON_BLOCKING(iotcon_remote_resource_cached_representation_changed_cb, void* resource, void* representation, void* user_data) +PROXY_GROUP_BLOCKING(iotcon_remote_resource_cached_representation_changed_cb, void* resource, void* representation, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*iotcon_remote_resource_observe_cb)(void* resource, some_enum err, int sequence_number, void* response, void* user_data); +#define CB_PARAMS_NAMES resource, err, sequence_number, response, user_data +PROXY_GROUP_NON_BLOCKING(iotcon_remote_resource_observe_cb, void* resource, some_enum err, int sequence_number, void* response, void* user_data) +PROXY_GROUP_BLOCKING(iotcon_remote_resource_observe_cb, void* resource, some_enum err, int sequence_number, void* response, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*iotcon_remote_resource_response_cb)(void* resource, some_enum err, some_enum request_type, void* response, void* user_data); +#define CB_PARAMS_NAMES resource, err, request_type, response, user_data +PROXY_GROUP_NON_BLOCKING(iotcon_remote_resource_response_cb, void* resource, some_enum err, some_enum request_type, void* response, void* user_data) +PROXY_GROUP_BLOCKING(iotcon_remote_resource_response_cb, void* resource, some_enum err, some_enum request_type, void* response, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*iotcon_remote_resource_state_changed_cb)(void* resource, some_enum state, void* user_data); +#define CB_PARAMS_NAMES resource, state, user_data +PROXY_GROUP_NON_BLOCKING(iotcon_remote_resource_state_changed_cb, void* resource, some_enum state, void* user_data) +PROXY_GROUP_BLOCKING(iotcon_remote_resource_state_changed_cb, void* resource, some_enum state, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*iotcon_request_handler_cb)(void* resource, void* request, void* user_data); +#define CB_PARAMS_NAMES resource, request, user_data +PROXY_GROUP_NON_BLOCKING(iotcon_request_handler_cb, void* resource, void* request, void* user_data) +PROXY_GROUP_BLOCKING(iotcon_request_handler_cb, void* resource, void* request, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*iotcon_resource_interfaces_foreach_cb)(const char* iface, void* user_data); +#define CB_PARAMS_NAMES iface, user_data +PROXY_GROUP_RETURN(iotcon_resource_interfaces_foreach_cb, bool, const char* iface, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*iotcon_resource_types_foreach_cb)(const char* type, void* user_data); +#define CB_PARAMS_NAMES type, user_data +PROXY_GROUP_RETURN(iotcon_resource_types_foreach_cb, bool, const char* type, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*job_scheduler_foreach_job_cb)(void* job_info, void* user_data); +#define CB_PARAMS_NAMES job_info, user_data +PROXY_GROUP_RETURN(job_scheduler_foreach_job_cb, bool, void* job_info, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*job_service_start_cb)(void* job_info, void* user_data); +#define CB_PARAMS_NAMES job_info, user_data +PROXY_GROUP_NON_BLOCKING(job_service_start_cb, void* job_info, void* user_data) +PROXY_GROUP_BLOCKING(job_service_start_cb, void* job_info, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*job_service_stop_cb)(void* job_info, void* user_data); +#define CB_PARAMS_NAMES job_info, user_data +PROXY_GROUP_NON_BLOCKING(job_service_stop_cb, void* job_info, void* user_data) +PROXY_GROUP_BLOCKING(job_service_stop_cb, void* job_info, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*location_batch_cb)(int num_of_location, void* user_data); +#define CB_PARAMS_NAMES num_of_location, user_data +PROXY_GROUP_NON_BLOCKING(location_batch_cb, int num_of_location, void* user_data) +PROXY_GROUP_BLOCKING(location_batch_cb, int num_of_location, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*location_batch_get_location_cb)(double latitude, double longitude, double altitude, double speed, double direction, double horizontal, double vertical, time_t timestamp, void* user_data); +#define CB_PARAMS_NAMES latitude, longitude, altitude, speed, direction, horizontal, vertical, timestamp, user_data +PROXY_GROUP_RETURN(location_batch_get_location_cb, bool, double latitude, double longitude, double altitude, double speed, double direction, double horizontal, double vertical, time_t timestamp, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*location_bounds_cb)(void* bounds, void* user_data); +#define CB_PARAMS_NAMES bounds, user_data +PROXY_GROUP_RETURN(location_bounds_cb, bool, void* bounds, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*location_bounds_state_changed_cb)(some_enum state, void* user_data); +#define CB_PARAMS_NAMES state, user_data +PROXY_GROUP_NON_BLOCKING(location_bounds_state_changed_cb, some_enum state, void* user_data) +PROXY_GROUP_BLOCKING(location_bounds_state_changed_cb, some_enum state, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*location_changed_cb)(double latitude, double longitude, double altitude, double speed, double direction, double horizontal_accuracy, time_t timestamp, void* user_data); +#define CB_PARAMS_NAMES latitude, longitude, altitude, speed, direction, horizontal_accuracy, timestamp, user_data +PROXY_GROUP_NON_BLOCKING(location_changed_cb, double latitude, double longitude, double altitude, double speed, double direction, double horizontal_accuracy, time_t timestamp, void* user_data) +PROXY_GROUP_BLOCKING(location_changed_cb, double latitude, double longitude, double altitude, double speed, double direction, double horizontal_accuracy, time_t timestamp, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*location_position_updated_cb)(double latitude, double longitude, double altitude, time_t timestamp, void* user_data); +#define CB_PARAMS_NAMES latitude, longitude, altitude, timestamp, user_data +PROXY_GROUP_NON_BLOCKING(location_position_updated_cb, double latitude, double longitude, double altitude, time_t timestamp, void* user_data) +PROXY_GROUP_BLOCKING(location_position_updated_cb, double latitude, double longitude, double altitude, time_t timestamp, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*location_service_state_changed_cb)(some_enum state, void* user_data); +#define CB_PARAMS_NAMES state, user_data +PROXY_GROUP_NON_BLOCKING(location_service_state_changed_cb, some_enum state, void* user_data) +PROXY_GROUP_BLOCKING(location_service_state_changed_cb, some_enum state, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*location_setting_changed_cb)(some_enum method, bool enable, void* user_data); +#define CB_PARAMS_NAMES method, enable, user_data +PROXY_GROUP_NON_BLOCKING(location_setting_changed_cb, some_enum method, bool enable, void* user_data) +PROXY_GROUP_BLOCKING(location_setting_changed_cb, some_enum method, bool enable, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*location_updated_cb)(some_enum error, double latitude, double longitude, double altitude, time_t timestamp, double speed, double direction, double climb, void* user_data); +#define CB_PARAMS_NAMES error, latitude, longitude, altitude, timestamp, speed, direction, climb, user_data +PROXY_GROUP_NON_BLOCKING(location_updated_cb, some_enum error, double latitude, double longitude, double altitude, time_t timestamp, double speed, double direction, double climb, void* user_data) +PROXY_GROUP_BLOCKING(location_updated_cb, some_enum error, double latitude, double longitude, double altitude, time_t timestamp, double speed, double direction, double climb, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*location_velocity_updated_cb)(double speed, double direction, double climb, time_t timestamp, void* user_data); +#define CB_PARAMS_NAMES speed, direction, climb, timestamp, user_data +PROXY_GROUP_NON_BLOCKING(location_velocity_updated_cb, double speed, double direction, double climb, time_t timestamp, void* user_data) +PROXY_GROUP_BLOCKING(location_velocity_updated_cb, double speed, double direction, double climb, time_t timestamp, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*location_zone_changed_cb)(some_enum state, double latitude, double longitude, double altitude, time_t timestamp, void* user_data); +#define CB_PARAMS_NAMES state, latitude, longitude, altitude, timestamp, user_data +PROXY_GROUP_NON_BLOCKING(location_zone_changed_cb, some_enum state, double latitude, double longitude, double altitude, time_t timestamp, void* user_data) +PROXY_GROUP_BLOCKING(location_zone_changed_cb, some_enum state, double latitude, double longitude, double altitude, time_t timestamp, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*ma_active_state_changed_cb)(some_enum previous, some_enum current, void* user_data); +#define CB_PARAMS_NAMES previous, current, user_data +PROXY_GROUP_NON_BLOCKING(ma_active_state_changed_cb, some_enum previous, some_enum current, void* user_data) +PROXY_GROUP_BLOCKING(ma_active_state_changed_cb, some_enum previous, some_enum current, void* user_data) +#undef CB_PARAMS_NAMES + +typedef int (*ma_assistant_info_list_cb)(void* handle, void* user_data); +#define CB_PARAMS_NAMES handle, user_data +PROXY_GROUP_RETURN(ma_assistant_info_list_cb, int, void* handle, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*ma_audio_streaming_cb)(some_enum event, char* buffer, int len, void* user_data); +#define CB_PARAMS_NAMES event, buffer, len, user_data +PROXY_GROUP_NON_BLOCKING(ma_audio_streaming_cb, some_enum event, char* buffer, int len, void* user_data) +PROXY_GROUP_BLOCKING(ma_audio_streaming_cb, some_enum event, char* buffer, int len, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*ma_audio_streaming_data_section_changed_cb)(some_enum section, void* user_data); +#define CB_PARAMS_NAMES section, user_data +PROXY_GROUP_NON_BLOCKING(ma_audio_streaming_data_section_changed_cb, some_enum section, void* user_data) +PROXY_GROUP_BLOCKING(ma_audio_streaming_data_section_changed_cb, some_enum section, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*ma_error_cb)(some_enum reason, void* user_data); +#define CB_PARAMS_NAMES reason, user_data +PROXY_GROUP_NON_BLOCKING(ma_error_cb, some_enum reason, void* user_data) +PROXY_GROUP_BLOCKING(ma_error_cb, some_enum reason, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*ma_language_changed_cb)(const char* previous, const char* current, void* user_data); +#define CB_PARAMS_NAMES previous, current, user_data +PROXY_GROUP_NON_BLOCKING(ma_language_changed_cb, const char* previous, const char* current, void* user_data) +PROXY_GROUP_BLOCKING(ma_language_changed_cb, const char* previous, const char* current, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*ma_preprocessing_information_changed_cb)(const char* app_id, void* user_data); +#define CB_PARAMS_NAMES app_id, user_data +PROXY_GROUP_NON_BLOCKING(ma_preprocessing_information_changed_cb, const char* app_id, void* user_data) +PROXY_GROUP_BLOCKING(ma_preprocessing_information_changed_cb, const char* app_id, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*ma_service_state_changed_cb)(some_enum previous, some_enum current, void* user_data); +#define CB_PARAMS_NAMES previous, current, user_data +PROXY_GROUP_NON_BLOCKING(ma_service_state_changed_cb, some_enum previous, some_enum current, void* user_data) +PROXY_GROUP_BLOCKING(ma_service_state_changed_cb, some_enum previous, some_enum current, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*ma_state_changed_cb)(some_enum previous, some_enum current, void* user_data); +#define CB_PARAMS_NAMES previous, current, user_data +PROXY_GROUP_NON_BLOCKING(ma_state_changed_cb, some_enum previous, some_enum current, void* user_data) +PROXY_GROUP_BLOCKING(ma_state_changed_cb, some_enum previous, some_enum current, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*ma_voice_key_status_changed_cb)(some_enum status, void* user_data); +#define CB_PARAMS_NAMES status, user_data +PROXY_GROUP_NON_BLOCKING(ma_voice_key_status_changed_cb, some_enum status, void* user_data) +PROXY_GROUP_BLOCKING(ma_voice_key_status_changed_cb, some_enum status, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*ma_wakeup_engine_command_cb)(const char* command, void* user_data); +#define CB_PARAMS_NAMES command, user_data +PROXY_GROUP_NON_BLOCKING(ma_wakeup_engine_command_cb, const char* command, void* user_data) +PROXY_GROUP_BLOCKING(ma_wakeup_engine_command_cb, const char* command, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*mc_ability_support_updated_cb)(const char* server_name, some_enum ability, some_enum support, void* user_data); +#define CB_PARAMS_NAMES server_name, ability, support, user_data +PROXY_GROUP_NON_BLOCKING(mc_ability_support_updated_cb, const char* server_name, some_enum ability, some_enum support, void* user_data) +PROXY_GROUP_BLOCKING(mc_ability_support_updated_cb, const char* server_name, some_enum ability, some_enum support, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*mc_ability_supported_items_updated_cb)(const char* server_name, unsigned int supported_items, void* user_data); +#define CB_PARAMS_NAMES server_name, supported_items, user_data +PROXY_GROUP_NON_BLOCKING(mc_ability_supported_items_updated_cb, const char* server_name, unsigned int supported_items, void* user_data) +PROXY_GROUP_BLOCKING(mc_ability_supported_items_updated_cb, const char* server_name, unsigned int supported_items, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*mc_activated_client_cb)(const char* client_name, void* user_data); +#define CB_PARAMS_NAMES client_name, user_data +PROXY_GROUP_RETURN(mc_activated_client_cb, bool, const char* client_name, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*mc_activated_server_cb)(const char* server_name, void* user_data); +#define CB_PARAMS_NAMES server_name, user_data +PROXY_GROUP_RETURN(mc_activated_server_cb, bool, const char* server_name, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*mc_bool_attribute_updated_cb)(const char* server_name, bool enabled, void* user_data); +#define CB_PARAMS_NAMES server_name, enabled, user_data +PROXY_GROUP_NON_BLOCKING(mc_bool_attribute_updated_cb, const char* server_name, bool enabled, void* user_data) +PROXY_GROUP_BLOCKING(mc_bool_attribute_updated_cb, const char* server_name, bool enabled, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*mc_client_custom_event_received_cb)(const char* server_name, const char* request_id, const char* event, void* data, void* user_data); +#define CB_PARAMS_NAMES server_name, request_id, event, data, user_data +PROXY_GROUP_NON_BLOCKING(mc_client_custom_event_received_cb, const char* server_name, const char* request_id, const char* event, void* data, void* user_data) +PROXY_GROUP_BLOCKING(mc_client_custom_event_received_cb, const char* server_name, const char* request_id, const char* event, void* data, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*mc_cmd_reply_received_cb)(const char* server_name, const char* request_id, int result_code, void* data, void* user_data); +#define CB_PARAMS_NAMES server_name, request_id, result_code, data, user_data +PROXY_GROUP_NON_BLOCKING(mc_cmd_reply_received_cb, const char* server_name, const char* request_id, int result_code, void* data, void* user_data) +PROXY_GROUP_BLOCKING(mc_cmd_reply_received_cb, const char* server_name, const char* request_id, int result_code, void* data, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*mc_command_reply_received_cb)(const char* server_name, int result_code, void* data, void* user_data); +#define CB_PARAMS_NAMES server_name, result_code, data, user_data +PROXY_GROUP_NON_BLOCKING(mc_command_reply_received_cb, const char* server_name, int result_code, void* data, void* user_data) +PROXY_GROUP_BLOCKING(mc_command_reply_received_cb, const char* server_name, int result_code, void* data, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*mc_display_mode_updated_cb)(const char* server_name, some_enum mode, void* user_data); +#define CB_PARAMS_NAMES server_name, mode, user_data +PROXY_GROUP_NON_BLOCKING(mc_display_mode_updated_cb, const char* server_name, some_enum mode, void* user_data) +PROXY_GROUP_BLOCKING(mc_display_mode_updated_cb, const char* server_name, some_enum mode, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*mc_display_rotation_updated_cb)(const char* server_name, some_enum rotation, void* user_data); +#define CB_PARAMS_NAMES server_name, rotation, user_data +PROXY_GROUP_NON_BLOCKING(mc_display_rotation_updated_cb, const char* server_name, some_enum rotation, void* user_data) +PROXY_GROUP_BLOCKING(mc_display_rotation_updated_cb, const char* server_name, some_enum rotation, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*mc_metadata_updated_cb)(const char* server_name, void* metadata, void* user_data); +#define CB_PARAMS_NAMES server_name, metadata, user_data +PROXY_GROUP_NON_BLOCKING(mc_metadata_updated_cb, const char* server_name, void* metadata, void* user_data) +PROXY_GROUP_BLOCKING(mc_metadata_updated_cb, const char* server_name, void* metadata, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*mc_playback_ability_updated_cb)(const char* server_name, void* ability, void* user_data); +#define CB_PARAMS_NAMES server_name, ability, user_data +PROXY_GROUP_NON_BLOCKING(mc_playback_ability_updated_cb, const char* server_name, void* ability, void* user_data) +PROXY_GROUP_BLOCKING(mc_playback_ability_updated_cb, const char* server_name, void* ability, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*mc_playback_updated_cb)(const char* server_name, void* playback, void* user_data); +#define CB_PARAMS_NAMES server_name, playback, user_data +PROXY_GROUP_NON_BLOCKING(mc_playback_updated_cb, const char* server_name, void* playback, void* user_data) +PROXY_GROUP_BLOCKING(mc_playback_updated_cb, const char* server_name, void* playback, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*mc_playlist_cb)(void* playlist, void* user_data); +#define CB_PARAMS_NAMES playlist, user_data +PROXY_GROUP_RETURN(mc_playlist_cb, bool, void* playlist, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*mc_playlist_item_cb)(const char* index, void* metadata, void* user_data); +#define CB_PARAMS_NAMES index, metadata, user_data +PROXY_GROUP_RETURN(mc_playlist_item_cb, bool, const char* index, void* metadata, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*mc_playlist_updated_cb)(const char* server_name, some_enum mode, const char* playlist_name, void* playlist, void* user_data); +#define CB_PARAMS_NAMES server_name, mode, playlist_name, playlist, user_data +PROXY_GROUP_NON_BLOCKING(mc_playlist_updated_cb, const char* server_name, some_enum mode, const char* playlist_name, void* playlist, void* user_data) +PROXY_GROUP_BLOCKING(mc_playlist_updated_cb, const char* server_name, some_enum mode, const char* playlist_name, void* playlist, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*mc_repeat_ability_updated_cb)(const char* server_name, some_enum support, void* user_data); +#define CB_PARAMS_NAMES server_name, support, user_data +PROXY_GROUP_NON_BLOCKING(mc_repeat_ability_updated_cb, const char* server_name, some_enum support, void* user_data) +PROXY_GROUP_BLOCKING(mc_repeat_ability_updated_cb, const char* server_name, some_enum support, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*mc_repeat_mode_changed_cb)(const char* server_name, some_enum mode, void* user_data); +#define CB_PARAMS_NAMES server_name, mode, user_data +PROXY_GROUP_NON_BLOCKING(mc_repeat_mode_changed_cb, const char* server_name, some_enum mode, void* user_data) +PROXY_GROUP_BLOCKING(mc_repeat_mode_changed_cb, const char* server_name, some_enum mode, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*mc_repeat_mode_updated_cb)(const char* server_name, some_enum mode, void* user_data); +#define CB_PARAMS_NAMES server_name, mode, user_data +PROXY_GROUP_NON_BLOCKING(mc_repeat_mode_updated_cb, const char* server_name, some_enum mode, void* user_data) +PROXY_GROUP_BLOCKING(mc_repeat_mode_updated_cb, const char* server_name, some_enum mode, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*mc_search_condition_cb)(some_enum content_type, some_enum category, const char* search_keyword, void* data, void* user_data); +#define CB_PARAMS_NAMES content_type, category, search_keyword, data, user_data +PROXY_GROUP_RETURN(mc_search_condition_cb, bool, some_enum content_type, some_enum category, const char* search_keyword, void* data, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*mc_server_custom_cmd_received_cb)(const char* client_name, const char* request_id, const char* command, void* data, void* user_data); +#define CB_PARAMS_NAMES client_name, request_id, command, data, user_data +PROXY_GROUP_NON_BLOCKING(mc_server_custom_cmd_received_cb, const char* client_name, const char* request_id, const char* command, void* data, void* user_data) +PROXY_GROUP_BLOCKING(mc_server_custom_cmd_received_cb, const char* client_name, const char* request_id, const char* command, void* data, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*mc_server_custom_command_received_cb)(const char* client_name, const char* command, void* data, void* user_data); +#define CB_PARAMS_NAMES client_name, command, data, user_data +PROXY_GROUP_NON_BLOCKING(mc_server_custom_command_received_cb, const char* client_name, const char* command, void* data, void* user_data) +PROXY_GROUP_BLOCKING(mc_server_custom_command_received_cb, const char* client_name, const char* command, void* data, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*mc_server_display_mode_cmd_received_cb)(const char* client_name, const char* request_id, some_enum mode, void* user_data); +#define CB_PARAMS_NAMES client_name, request_id, mode, user_data +PROXY_GROUP_NON_BLOCKING(mc_server_display_mode_cmd_received_cb, const char* client_name, const char* request_id, some_enum mode, void* user_data) +PROXY_GROUP_BLOCKING(mc_server_display_mode_cmd_received_cb, const char* client_name, const char* request_id, some_enum mode, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*mc_server_display_rotation_cmd_received_cb)(const char* client_name, const char* request_id, some_enum rotation, void* user_data); +#define CB_PARAMS_NAMES client_name, request_id, rotation, user_data +PROXY_GROUP_NON_BLOCKING(mc_server_display_rotation_cmd_received_cb, const char* client_name, const char* request_id, some_enum rotation, void* user_data) +PROXY_GROUP_BLOCKING(mc_server_display_rotation_cmd_received_cb, const char* client_name, const char* request_id, some_enum rotation, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*mc_server_enable_cmd_received_cb)(const char* client_name, const char* request_id, bool enabled, void* user_data); +#define CB_PARAMS_NAMES client_name, request_id, enabled, user_data +PROXY_GROUP_NON_BLOCKING(mc_server_enable_cmd_received_cb, const char* client_name, const char* request_id, bool enabled, void* user_data) +PROXY_GROUP_BLOCKING(mc_server_enable_cmd_received_cb, const char* client_name, const char* request_id, bool enabled, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*mc_server_event_reply_received_cb)(const char* client_name, const char* request_id, int result_code, void* data, void* user_data); +#define CB_PARAMS_NAMES client_name, request_id, result_code, data, user_data +PROXY_GROUP_NON_BLOCKING(mc_server_event_reply_received_cb, const char* client_name, const char* request_id, int result_code, void* data, void* user_data) +PROXY_GROUP_BLOCKING(mc_server_event_reply_received_cb, const char* client_name, const char* request_id, int result_code, void* data, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*mc_server_playback_action_cmd_received_cb)(const char* client_name, const char* request_id, some_enum action, void* user_data); +#define CB_PARAMS_NAMES client_name, request_id, action, user_data +PROXY_GROUP_NON_BLOCKING(mc_server_playback_action_cmd_received_cb, const char* client_name, const char* request_id, some_enum action, void* user_data) +PROXY_GROUP_BLOCKING(mc_server_playback_action_cmd_received_cb, const char* client_name, const char* request_id, some_enum action, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*mc_server_playback_position_cmd_received_cb)(const char* client_name, const char* request_id, unsigned long long position, void* user_data); +#define CB_PARAMS_NAMES client_name, request_id, position, user_data +PROXY_GROUP_NON_BLOCKING(mc_server_playback_position_cmd_received_cb, const char* client_name, const char* request_id, unsigned long long position, void* user_data) +PROXY_GROUP_BLOCKING(mc_server_playback_position_cmd_received_cb, const char* client_name, const char* request_id, unsigned long long position, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*mc_server_playback_state_command_received_cb)(const char* client_name, some_enum state, void* user_data); +#define CB_PARAMS_NAMES client_name, state, user_data +PROXY_GROUP_NON_BLOCKING(mc_server_playback_state_command_received_cb, const char* client_name, some_enum state, void* user_data) +PROXY_GROUP_BLOCKING(mc_server_playback_state_command_received_cb, const char* client_name, some_enum state, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*mc_server_playlist_cmd_received_cb)(const char* client_name, const char* request_id, const char* playlist_name, const char* index, some_enum action, unsigned long long position, void* user_data); +#define CB_PARAMS_NAMES client_name, request_id, playlist_name, index, action, position, user_data +PROXY_GROUP_NON_BLOCKING(mc_server_playlist_cmd_received_cb, const char* client_name, const char* request_id, const char* playlist_name, const char* index, some_enum action, unsigned long long position, void* user_data) +PROXY_GROUP_BLOCKING(mc_server_playlist_cmd_received_cb, const char* client_name, const char* request_id, const char* playlist_name, const char* index, some_enum action, unsigned long long position, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*mc_server_repeat_mode_cmd_received_cb)(const char* client_name, const char* request_id, some_enum repeat_mode, void* user_data); +#define CB_PARAMS_NAMES client_name, request_id, repeat_mode, user_data +PROXY_GROUP_NON_BLOCKING(mc_server_repeat_mode_cmd_received_cb, const char* client_name, const char* request_id, some_enum repeat_mode, void* user_data) +PROXY_GROUP_BLOCKING(mc_server_repeat_mode_cmd_received_cb, const char* client_name, const char* request_id, some_enum repeat_mode, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*mc_server_search_cmd_received_cb)(const char* client_name, const char* request_id, void* search, void* user_data); +#define CB_PARAMS_NAMES client_name, request_id, search, user_data +PROXY_GROUP_NON_BLOCKING(mc_server_search_cmd_received_cb, const char* client_name, const char* request_id, void* search, void* user_data) +PROXY_GROUP_BLOCKING(mc_server_search_cmd_received_cb, const char* client_name, const char* request_id, void* search, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*mc_server_shuffle_mode_cmd_received_cb)(const char* client_name, const char* request_id, some_enum shuffle_mode, void* user_data); +#define CB_PARAMS_NAMES client_name, request_id, shuffle_mode, user_data +PROXY_GROUP_NON_BLOCKING(mc_server_shuffle_mode_cmd_received_cb, const char* client_name, const char* request_id, some_enum shuffle_mode, void* user_data) +PROXY_GROUP_BLOCKING(mc_server_shuffle_mode_cmd_received_cb, const char* client_name, const char* request_id, some_enum shuffle_mode, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*mc_server_state_updated_cb)(const char* server_name, some_enum state, void* user_data); +#define CB_PARAMS_NAMES server_name, state, user_data +PROXY_GROUP_NON_BLOCKING(mc_server_state_updated_cb, const char* server_name, some_enum state, void* user_data) +PROXY_GROUP_BLOCKING(mc_server_state_updated_cb, const char* server_name, some_enum state, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*mc_shuffle_ability_updated_cb)(const char* server_name, some_enum support, void* user_data); +#define CB_PARAMS_NAMES server_name, support, user_data +PROXY_GROUP_NON_BLOCKING(mc_shuffle_ability_updated_cb, const char* server_name, some_enum support, void* user_data) +PROXY_GROUP_BLOCKING(mc_shuffle_ability_updated_cb, const char* server_name, some_enum support, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*mc_shuffle_mode_changed_cb)(const char* server_name, some_enum mode, void* user_data); +#define CB_PARAMS_NAMES server_name, mode, user_data +PROXY_GROUP_NON_BLOCKING(mc_shuffle_mode_changed_cb, const char* server_name, some_enum mode, void* user_data) +PROXY_GROUP_BLOCKING(mc_shuffle_mode_changed_cb, const char* server_name, some_enum mode, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*mc_shuffle_mode_updated_cb)(const char* server_name, some_enum mode, void* user_data); +#define CB_PARAMS_NAMES server_name, mode, user_data +PROXY_GROUP_NON_BLOCKING(mc_shuffle_mode_updated_cb, const char* server_name, some_enum mode, void* user_data) +PROXY_GROUP_BLOCKING(mc_shuffle_mode_updated_cb, const char* server_name, some_enum mode, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*mc_subscribed_server_cb)(const char* server_name, void* user_data); +#define CB_PARAMS_NAMES server_name, user_data +PROXY_GROUP_RETURN(mc_subscribed_server_cb, bool, const char* server_name, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*media_album_cb)(void* album, void* user_data); +#define CB_PARAMS_NAMES album, user_data +PROXY_GROUP_RETURN(media_album_cb, bool, void* album, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*media_bookmark_cb)(void* bookmark, void* user_data); +#define CB_PARAMS_NAMES bookmark, user_data +PROXY_GROUP_RETURN(media_bookmark_cb, bool, void* bookmark, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*media_content_db_update_cb)(some_enum error, int pid, some_enum update_item, some_enum update_type, some_enum media_type, char* uuid, char* path, char* mime_type, void* user_data); +#define CB_PARAMS_NAMES error, pid, update_item, update_type, media_type, uuid, path, mime_type, user_data +PROXY_GROUP_NON_BLOCKING(media_content_db_update_cb, some_enum error, int pid, some_enum update_item, some_enum update_type, some_enum media_type, char* uuid, char* path, char* mime_type, void* user_data) +PROXY_GROUP_BLOCKING(media_content_db_update_cb, some_enum error, int pid, some_enum update_item, some_enum update_type, some_enum media_type, char* uuid, char* path, char* mime_type, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*media_face_cb)(void* face, void* user_data); +#define CB_PARAMS_NAMES face, user_data +PROXY_GROUP_RETURN(media_face_cb, bool, void* face, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*media_face_detection_completed_cb)(some_enum error, const int face_count, void* user_data); +#define CB_PARAMS_NAMES error, face_count, user_data +PROXY_GROUP_NON_BLOCKING(media_face_detection_completed_cb, some_enum error, const int face_count, void* user_data) +PROXY_GROUP_BLOCKING(media_face_detection_completed_cb, some_enum error, const int face_count, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*media_folder_cb)(void* folder, void* user_data); +#define CB_PARAMS_NAMES folder, user_data +PROXY_GROUP_RETURN(media_folder_cb, bool, void* folder, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*media_group_cb)(const char* group_name, void* user_data); +#define CB_PARAMS_NAMES group_name, user_data +PROXY_GROUP_RETURN(media_group_cb, bool, const char* group_name, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*media_info_cb)(void* media, void* user_data); +#define CB_PARAMS_NAMES media, user_data +PROXY_GROUP_RETURN(media_info_cb, bool, void* media, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*media_insert_burst_shot_completed_cb)(some_enum error, void* user_data); +#define CB_PARAMS_NAMES error, user_data +PROXY_GROUP_NON_BLOCKING(media_insert_burst_shot_completed_cb, some_enum error, void* user_data) +PROXY_GROUP_BLOCKING(media_insert_burst_shot_completed_cb, some_enum error, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*media_insert_completed_cb)(some_enum error, void* user_data); +#define CB_PARAMS_NAMES error, user_data +PROXY_GROUP_NON_BLOCKING(media_insert_completed_cb, some_enum error, void* user_data) +PROXY_GROUP_BLOCKING(media_insert_completed_cb, some_enum error, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*media_key_event_cb)(some_enum key, some_enum status, void* user_data); +#define CB_PARAMS_NAMES key, status, user_data +PROXY_GROUP_NON_BLOCKING(media_key_event_cb, some_enum key, some_enum status, void* user_data) +PROXY_GROUP_BLOCKING(media_key_event_cb, some_enum key, some_enum status, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*media_packet_dispose_cb)(void* packet, void* user_data); +#define CB_PARAMS_NAMES packet, user_data +PROXY_GROUP_NON_BLOCKING(media_packet_dispose_cb, void* packet, void* user_data) +PROXY_GROUP_BLOCKING(media_packet_dispose_cb, void* packet, void* user_data) +#undef CB_PARAMS_NAMES + +typedef int (*media_packet_finalize_cb)(void* packet, int error_code, void* user_data); +#define CB_PARAMS_NAMES packet, error_code, user_data +PROXY_GROUP_RETURN(media_packet_finalize_cb, int, void* packet, int error_code, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*media_playlist_cb)(void* playlist, void* user_data); +#define CB_PARAMS_NAMES playlist, user_data +PROXY_GROUP_RETURN(media_playlist_cb, bool, void* playlist, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*media_scan_completed_cb)(some_enum error, void* user_data); +#define CB_PARAMS_NAMES error, user_data +PROXY_GROUP_NON_BLOCKING(media_scan_completed_cb, some_enum error, void* user_data) +PROXY_GROUP_BLOCKING(media_scan_completed_cb, some_enum error, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*media_storage_cb)(void* storage, void* user_data); +#define CB_PARAMS_NAMES storage, user_data +PROXY_GROUP_RETURN(media_storage_cb, bool, void* storage, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*media_streamer_custom_buffer_status_cb)(void* src, some_enum status, void* user_data); +#define CB_PARAMS_NAMES src, status, user_data +PROXY_GROUP_NON_BLOCKING(media_streamer_custom_buffer_status_cb, void* src, some_enum status, void* user_data) +PROXY_GROUP_BLOCKING(media_streamer_custom_buffer_status_cb, void* src, some_enum status, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*media_streamer_error_cb)(void* streamer, some_enum error, void* user_data); +#define CB_PARAMS_NAMES streamer, error, user_data +PROXY_GROUP_NON_BLOCKING(media_streamer_error_cb, void* streamer, some_enum error, void* user_data) +PROXY_GROUP_BLOCKING(media_streamer_error_cb, void* streamer, some_enum error, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*media_streamer_interrupted_cb)(some_enum code, void* user_data); +#define CB_PARAMS_NAMES code, user_data +PROXY_GROUP_NON_BLOCKING(media_streamer_interrupted_cb, some_enum code, void* user_data) +PROXY_GROUP_BLOCKING(media_streamer_interrupted_cb, some_enum code, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*media_streamer_node_decoded_ready_cb)(void* node, const char* src_pad_name, const char* media_type, void* user_data); +#define CB_PARAMS_NAMES node, src_pad_name, media_type, user_data +PROXY_GROUP_NON_BLOCKING(media_streamer_node_decoded_ready_cb, void* node, const char* src_pad_name, const char* media_type, void* user_data) +PROXY_GROUP_BLOCKING(media_streamer_node_decoded_ready_cb, void* node, const char* src_pad_name, const char* media_type, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*media_streamer_position_changed_cb)(void* user_data); +#define CB_PARAMS_NAMES user_data +PROXY_GROUP_NON_BLOCKING(media_streamer_position_changed_cb, void* user_data) +PROXY_GROUP_BLOCKING(media_streamer_position_changed_cb, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*media_streamer_sink_data_ready_cb)(void* sink, void* user_data); +#define CB_PARAMS_NAMES sink, user_data +PROXY_GROUP_NON_BLOCKING(media_streamer_sink_data_ready_cb, void* sink, void* user_data) +PROXY_GROUP_BLOCKING(media_streamer_sink_data_ready_cb, void* sink, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*media_streamer_sink_eos_cb)(void* sink, void* user_data); +#define CB_PARAMS_NAMES sink, user_data +PROXY_GROUP_NON_BLOCKING(media_streamer_sink_eos_cb, void* sink, void* user_data) +PROXY_GROUP_BLOCKING(media_streamer_sink_eos_cb, void* sink, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*media_streamer_state_changed_cb)(void* streamer, some_enum previous_state, some_enum current_state, void* user_data); +#define CB_PARAMS_NAMES streamer, previous_state, current_state, user_data +PROXY_GROUP_NON_BLOCKING(media_streamer_state_changed_cb, void* streamer, some_enum previous_state, some_enum current_state, void* user_data) +PROXY_GROUP_BLOCKING(media_streamer_state_changed_cb, void* streamer, some_enum previous_state, some_enum current_state, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*media_streamer_webrtc_message_cb)(void* webrtc, const char* message, void* user_data); +#define CB_PARAMS_NAMES webrtc, message, user_data +PROXY_GROUP_NON_BLOCKING(media_streamer_webrtc_message_cb, void* webrtc, const char* message, void* user_data) +PROXY_GROUP_BLOCKING(media_streamer_webrtc_message_cb, void* webrtc, const char* message, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*media_tag_cb)(void* tag, void* user_data); +#define CB_PARAMS_NAMES tag, user_data +PROXY_GROUP_RETURN(media_tag_cb, bool, void* tag, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*media_thumbnail_completed_cb)(some_enum error, const char* path, void* user_data); +#define CB_PARAMS_NAMES error, path, user_data +PROXY_GROUP_NON_BLOCKING(media_thumbnail_completed_cb, some_enum error, const char* path, void* user_data) +PROXY_GROUP_BLOCKING(media_thumbnail_completed_cb, some_enum error, const char* path, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*mediacodec_buffer_status_cb)(some_enum status, void* user_data); +#define CB_PARAMS_NAMES status, user_data +PROXY_GROUP_NON_BLOCKING(mediacodec_buffer_status_cb, some_enum status, void* user_data) +PROXY_GROUP_BLOCKING(mediacodec_buffer_status_cb, some_enum status, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*mediacodec_eos_cb)(void* user_data); +#define CB_PARAMS_NAMES user_data +PROXY_GROUP_NON_BLOCKING(mediacodec_eos_cb, void* user_data) +PROXY_GROUP_BLOCKING(mediacodec_eos_cb, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*mediacodec_error_cb)(some_enum error, void* user_data); +#define CB_PARAMS_NAMES error, user_data +PROXY_GROUP_NON_BLOCKING(mediacodec_error_cb, some_enum error, void* user_data) +PROXY_GROUP_BLOCKING(mediacodec_error_cb, some_enum error, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*mediacodec_input_buffer_used_cb)(void* packet, void* user_data); +#define CB_PARAMS_NAMES packet, user_data +PROXY_GROUP_NON_BLOCKING(mediacodec_input_buffer_used_cb, void* packet, void* user_data) +PROXY_GROUP_BLOCKING(mediacodec_input_buffer_used_cb, void* packet, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*mediacodec_output_buffer_available_cb)(void* packet, void* user_data); +#define CB_PARAMS_NAMES packet, user_data +PROXY_GROUP_NON_BLOCKING(mediacodec_output_buffer_available_cb, void* packet, void* user_data) +PROXY_GROUP_BLOCKING(mediacodec_output_buffer_available_cb, void* packet, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*mediacodec_supported_codec_cb)(some_enum codec_type, void* user_data); +#define CB_PARAMS_NAMES codec_type, user_data +PROXY_GROUP_RETURN(mediacodec_supported_codec_cb, bool, some_enum codec_type, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*mediademuxer_eos_cb)(int track_num, void* user_data); +#define CB_PARAMS_NAMES track_num, user_data +PROXY_GROUP_NON_BLOCKING(mediademuxer_eos_cb, int track_num, void* user_data) +PROXY_GROUP_BLOCKING(mediademuxer_eos_cb, int track_num, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*mediademuxer_error_cb)(some_enum error, void* user_data); +#define CB_PARAMS_NAMES error, user_data +PROXY_GROUP_NON_BLOCKING(mediademuxer_error_cb, some_enum error, void* user_data) +PROXY_GROUP_BLOCKING(mediademuxer_error_cb, some_enum error, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*mediaeditor_error_cb)(some_enum error, some_enum state, void* user_data); +#define CB_PARAMS_NAMES error, state, user_data +PROXY_GROUP_NON_BLOCKING(mediaeditor_error_cb, some_enum error, some_enum state, void* user_data) +PROXY_GROUP_BLOCKING(mediaeditor_error_cb, some_enum error, some_enum state, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*mediaeditor_layer_priority_changed_cb)(void* layer_infos, unsigned int size, void* user_data); +#define CB_PARAMS_NAMES layer_infos, size, user_data +PROXY_GROUP_NON_BLOCKING(mediaeditor_layer_priority_changed_cb, void* layer_infos, unsigned int size, void* user_data) +PROXY_GROUP_BLOCKING(mediaeditor_layer_priority_changed_cb, void* layer_infos, unsigned int size, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*mediaeditor_project_loaded_cb)(void* user_data); +#define CB_PARAMS_NAMES user_data +PROXY_GROUP_NON_BLOCKING(mediaeditor_project_loaded_cb, void* user_data) +PROXY_GROUP_BLOCKING(mediaeditor_project_loaded_cb, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*mediaeditor_render_completed_cb)(void* user_data); +#define CB_PARAMS_NAMES user_data +PROXY_GROUP_NON_BLOCKING(mediaeditor_render_completed_cb, void* user_data) +PROXY_GROUP_BLOCKING(mediaeditor_render_completed_cb, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*mediaeditor_state_changed_cb)(some_enum previous, some_enum current, void* user_data); +#define CB_PARAMS_NAMES previous, current, user_data +PROXY_GROUP_NON_BLOCKING(mediaeditor_state_changed_cb, some_enum previous, some_enum current, void* user_data) +PROXY_GROUP_BLOCKING(mediaeditor_state_changed_cb, some_enum previous, some_enum current, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*mediamuxer_eos_cb)(void* user_data); +#define CB_PARAMS_NAMES user_data +PROXY_GROUP_NON_BLOCKING(mediamuxer_eos_cb, void* user_data) +PROXY_GROUP_BLOCKING(mediamuxer_eos_cb, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*mediamuxer_error_cb)(some_enum error, void* user_data); +#define CB_PARAMS_NAMES error, user_data +PROXY_GROUP_NON_BLOCKING(mediamuxer_error_cb, some_enum error, void* user_data) +PROXY_GROUP_BLOCKING(mediamuxer_error_cb, some_enum error, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*message_port_message_cb)(int local_port_id, const char* remote_app_id, const char* remote_port, bool trusted_remote_port, void* message, void* user_data); +#define CB_PARAMS_NAMES local_port_id, remote_app_id, remote_port, trusted_remote_port, message, user_data +PROXY_GROUP_NON_BLOCKING(message_port_message_cb, int local_port_id, const char* remote_app_id, const char* remote_port, bool trusted_remote_port, void* message, void* user_data) +PROXY_GROUP_BLOCKING(message_port_message_cb, int local_port_id, const char* remote_app_id, const char* remote_port, bool trusted_remote_port, void* message, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*message_port_registration_event_cb)(const char* remote_app_id, const char* remote_port, bool trusted_remote_port, void* user_data); +#define CB_PARAMS_NAMES remote_app_id, remote_port, trusted_remote_port, user_data +PROXY_GROUP_NON_BLOCKING(message_port_registration_event_cb, const char* remote_app_id, const char* remote_port, bool trusted_remote_port, void* user_data) +PROXY_GROUP_BLOCKING(message_port_registration_event_cb, const char* remote_app_id, const char* remote_port, bool trusted_remote_port, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*message_port_trusted_message_cb)(int trusted_local_port_id, const char* remote_app_id, const char* remote_port, bool trusted_remote_port, void* message, void* user_data); +#define CB_PARAMS_NAMES trusted_local_port_id, remote_app_id, remote_port, trusted_remote_port, message, user_data +PROXY_GROUP_NON_BLOCKING(message_port_trusted_message_cb, int trusted_local_port_id, const char* remote_app_id, const char* remote_port, bool trusted_remote_port, void* message, void* user_data) +PROXY_GROUP_BLOCKING(message_port_trusted_message_cb, int trusted_local_port_id, const char* remote_app_id, const char* remote_port, bool trusted_remote_port, void* message, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*messages_incoming_cb)(void* incoming_msg, void* user_data); +#define CB_PARAMS_NAMES incoming_msg, user_data +PROXY_GROUP_NON_BLOCKING(messages_incoming_cb, void* incoming_msg, void* user_data) +PROXY_GROUP_BLOCKING(messages_incoming_cb, void* incoming_msg, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*messages_push_incoming_cb)(const char* header, const char* body, int body_length, void* user_data); +#define CB_PARAMS_NAMES header, body, body_length, user_data +PROXY_GROUP_NON_BLOCKING(messages_push_incoming_cb, const char* header, const char* body, int body_length, void* user_data) +PROXY_GROUP_BLOCKING(messages_push_incoming_cb, const char* header, const char* body, int body_length, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*messages_search_cb)(void* msg, int index, int result_count, int total_count, void* user_data); +#define CB_PARAMS_NAMES msg, index, result_count, total_count, user_data +PROXY_GROUP_RETURN(messages_search_cb, bool, void* msg, int index, int result_count, int total_count, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*messages_sent_cb)(some_enum result, void* user_data); +#define CB_PARAMS_NAMES result, user_data +PROXY_GROUP_NON_BLOCKING(messages_sent_cb, some_enum result, void* user_data) +PROXY_GROUP_BLOCKING(messages_sent_cb, some_enum result, void* user_data) +#undef CB_PARAMS_NAMES + +typedef int (*ml_custom_easy_invoke_cb)(const void* in, void* out, void* user_data); +#define CB_PARAMS_NAMES in, out, user_data +PROXY_GROUP_RETURN(ml_custom_easy_invoke_cb, int, const void* in, void* out, void* user_data) +#undef CB_PARAMS_NAMES + +#define BASE_CALLBACK_ID_ml_data_destroy_cb 0 +typedef void (*ml_data_destroy_cb)(void* data); +#define CB_PARAMS_NAMES data +PROXY_GROUP_NON_BLOCKING_NO_USER_DATA(ml_data_destroy_cb, void* data) +PROXY_GROUP_BLOCKING_NO_USER_DATA(ml_data_destroy_cb, void* data) +#undef CB_PARAMS_NAMES + +typedef int (*ml_pipeline_if_custom_cb)(const void* data, const void* info, int* result, void* user_data); +#define CB_PARAMS_NAMES data, info, result, user_data +PROXY_GROUP_RETURN(ml_pipeline_if_custom_cb, int, const void* data, const void* info, int* result, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*ml_pipeline_sink_cb)(const void* data, const void* info, void* user_data); +#define CB_PARAMS_NAMES data, info, user_data +PROXY_GROUP_NON_BLOCKING(ml_pipeline_sink_cb, const void* data, const void* info, void* user_data) +PROXY_GROUP_BLOCKING(ml_pipeline_sink_cb, const void* data, const void* info, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*ml_pipeline_state_cb)(some_enum state, void* user_data); +#define CB_PARAMS_NAMES state, user_data +PROXY_GROUP_NON_BLOCKING(ml_pipeline_state_cb, some_enum state, void* user_data) +PROXY_GROUP_BLOCKING(ml_pipeline_state_cb, some_enum state, void* user_data) +#undef CB_PARAMS_NAMES + +typedef int (*ml_train_datagen_cb)(float** input, float** label, bool* last, void* user_data); +#define CB_PARAMS_NAMES input, label, last, user_data +PROXY_GROUP_RETURN(ml_train_datagen_cb, int, float** input, float** label, bool* last, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*mtp_event_cb)(some_enum event, int event_parameter, void* user_data); +#define CB_PARAMS_NAMES event, event_parameter, user_data +PROXY_GROUP_NON_BLOCKING(mtp_event_cb, some_enum event, int event_parameter, void* user_data) +PROXY_GROUP_BLOCKING(mtp_event_cb, some_enum event, int event_parameter, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*mv_3d_depth_cb)(void* source, void* depth, unsigned int width, unsigned int height, void* user_data); +#define CB_PARAMS_NAMES source, depth, width, height, user_data +PROXY_GROUP_NON_BLOCKING(mv_3d_depth_cb, void* source, void* depth, unsigned int width, unsigned int height, void* user_data) +PROXY_GROUP_BLOCKING(mv_3d_depth_cb, void* source, void* depth, unsigned int width, unsigned int height, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*mv_3d_pointcloud_cb)(void* source, void* pointcloud, void* user_data); +#define CB_PARAMS_NAMES source, pointcloud, user_data +PROXY_GROUP_NON_BLOCKING(mv_3d_pointcloud_cb, void* source, void* pointcloud, void* user_data) +PROXY_GROUP_BLOCKING(mv_3d_pointcloud_cb, void* source, void* pointcloud, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*mv_barcode_detected_cb)(void* source, void* engine_cfg, const void* barcode_locations, const char** messages, const void* types, int number_of_barcodes, void* user_data); +#define CB_PARAMS_NAMES source, engine_cfg, barcode_locations, messages, types, number_of_barcodes, user_data +PROXY_GROUP_NON_BLOCKING(mv_barcode_detected_cb, void* source, void* engine_cfg, const void* barcode_locations, const char** messages, const void* types, int number_of_barcodes, void* user_data) +PROXY_GROUP_BLOCKING(mv_barcode_detected_cb, void* source, void* engine_cfg, const void* barcode_locations, const char** messages, const void* types, int number_of_barcodes, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*mv_face_detected_cb)(void* source, void* engine_cfg, void* faces_locations, int number_of_faces, void* user_data); +#define CB_PARAMS_NAMES source, engine_cfg, faces_locations, number_of_faces, user_data +PROXY_GROUP_NON_BLOCKING(mv_face_detected_cb, void* source, void* engine_cfg, void* faces_locations, int number_of_faces, void* user_data) +PROXY_GROUP_BLOCKING(mv_face_detected_cb, void* source, void* engine_cfg, void* faces_locations, int number_of_faces, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*mv_face_eye_condition_recognized_cb)(void* source, void* engine_cfg, mv_rectangle_s_copy face_location, some_enum eye_condition, void* user_data); +#define CB_PARAMS_NAMES source, engine_cfg, face_location, eye_condition, user_data +PROXY_GROUP_NON_BLOCKING(mv_face_eye_condition_recognized_cb, void* source, void* engine_cfg, mv_rectangle_s_copy face_location, some_enum eye_condition, void* user_data) +PROXY_GROUP_BLOCKING(mv_face_eye_condition_recognized_cb, void* source, void* engine_cfg, mv_rectangle_s_copy face_location, some_enum eye_condition, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*mv_face_facial_expression_recognized_cb)(void* source, void* engine_cfg, mv_rectangle_s_copy face_location, some_enum facial_expression, void* user_data); +#define CB_PARAMS_NAMES source, engine_cfg, face_location, facial_expression, user_data +PROXY_GROUP_NON_BLOCKING(mv_face_facial_expression_recognized_cb, void* source, void* engine_cfg, mv_rectangle_s_copy face_location, some_enum facial_expression, void* user_data) +PROXY_GROUP_BLOCKING(mv_face_facial_expression_recognized_cb, void* source, void* engine_cfg, mv_rectangle_s_copy face_location, some_enum facial_expression, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*mv_face_recognized_cb)(void* source, void* recognition_model, void* engine_cfg, void* face_location, const int* face_label, double confidence, void* user_data); +#define CB_PARAMS_NAMES source, recognition_model, engine_cfg, face_location, face_label, confidence, user_data +PROXY_GROUP_NON_BLOCKING(mv_face_recognized_cb, void* source, void* recognition_model, void* engine_cfg, void* face_location, const int* face_label, double confidence, void* user_data) +PROXY_GROUP_BLOCKING(mv_face_recognized_cb, void* source, void* recognition_model, void* engine_cfg, void* face_location, const int* face_label, double confidence, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*mv_face_tracked_cb)(void* source, void* tracking_model, void* engine_cfg, void* location, double confidence, void* user_data); +#define CB_PARAMS_NAMES source, tracking_model, engine_cfg, location, confidence, user_data +PROXY_GROUP_NON_BLOCKING(mv_face_tracked_cb, void* source, void* tracking_model, void* engine_cfg, void* location, double confidence, void* user_data) +PROXY_GROUP_BLOCKING(mv_face_tracked_cb, void* source, void* tracking_model, void* engine_cfg, void* location, double confidence, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*mv_image_recognized_cb)(void* source, void* engine_cfg, const void* image_objects, void* locations, unsigned int number_of_objects, void* user_data); +#define CB_PARAMS_NAMES source, engine_cfg, image_objects, locations, number_of_objects, user_data +PROXY_GROUP_NON_BLOCKING(mv_image_recognized_cb, void* source, void* engine_cfg, const void* image_objects, void* locations, unsigned int number_of_objects, void* user_data) +PROXY_GROUP_BLOCKING(mv_image_recognized_cb, void* source, void* engine_cfg, const void* image_objects, void* locations, unsigned int number_of_objects, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*mv_image_tracked_cb)(void* source, void* image_tracking_model, void* engine_cfg, void* location, void* user_data); +#define CB_PARAMS_NAMES source, image_tracking_model, engine_cfg, location, user_data +PROXY_GROUP_NON_BLOCKING(mv_image_tracked_cb, void* source, void* image_tracking_model, void* engine_cfg, void* location, void* user_data) +PROXY_GROUP_BLOCKING(mv_image_tracked_cb, void* source, void* image_tracking_model, void* engine_cfg, void* location, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*mv_inference_face_detected_cb)(void* source, int number_of_faces, const float* confidences, const void* locations, void* user_data); +#define CB_PARAMS_NAMES source, number_of_faces, confidences, locations, user_data +PROXY_GROUP_NON_BLOCKING(mv_inference_face_detected_cb, void* source, int number_of_faces, const float* confidences, const void* locations, void* user_data) +PROXY_GROUP_BLOCKING(mv_inference_face_detected_cb, void* source, int number_of_faces, const float* confidences, const void* locations, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*mv_inference_facial_landmark_detected_cb)(void* source, int number_of_landmarks, const void* locations, void* user_data); +#define CB_PARAMS_NAMES source, number_of_landmarks, locations, user_data +PROXY_GROUP_NON_BLOCKING(mv_inference_facial_landmark_detected_cb, void* source, int number_of_landmarks, const void* locations, void* user_data) +PROXY_GROUP_BLOCKING(mv_inference_facial_landmark_detected_cb, void* source, int number_of_landmarks, const void* locations, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*mv_inference_image_classified_cb)(void* source, int number_of_classes, const int* indices, const char** names, const float* confidences, void* user_data); +#define CB_PARAMS_NAMES source, number_of_classes, indices, names, confidences, user_data +PROXY_GROUP_NON_BLOCKING(mv_inference_image_classified_cb, void* source, int number_of_classes, const int* indices, const char** names, const float* confidences, void* user_data) +PROXY_GROUP_BLOCKING(mv_inference_image_classified_cb, void* source, int number_of_classes, const int* indices, const char** names, const float* confidences, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*mv_inference_object_detected_cb)(void* source, int number_of_objects, const int* indices, const char** names, const float* confidences, const void* locations, void* user_data); +#define CB_PARAMS_NAMES source, number_of_objects, indices, names, confidences, locations, user_data +PROXY_GROUP_NON_BLOCKING(mv_inference_object_detected_cb, void* source, int number_of_objects, const int* indices, const char** names, const float* confidences, const void* locations, void* user_data) +PROXY_GROUP_BLOCKING(mv_inference_object_detected_cb, void* source, int number_of_objects, const int* indices, const char** names, const float* confidences, const void* locations, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*mv_inference_pose_landmark_detected_cb)(void* source, void* locations, void* user_data); +#define CB_PARAMS_NAMES source, locations, user_data +PROXY_GROUP_NON_BLOCKING(mv_inference_pose_landmark_detected_cb, void* source, void* locations, void* user_data) +PROXY_GROUP_BLOCKING(mv_inference_pose_landmark_detected_cb, void* source, void* locations, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*mv_inference_supported_engine_cb)(const char* engine, bool supported, void* user_data); +#define CB_PARAMS_NAMES engine, supported, user_data +PROXY_GROUP_RETURN(mv_inference_supported_engine_cb, bool, const char* engine, bool supported, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*mv_roi_tracker_tracked_cb)(void* source, mv_rectangle_s_copy roi, void* user_data); +#define CB_PARAMS_NAMES source, roi, user_data +PROXY_GROUP_NON_BLOCKING(mv_roi_tracker_tracked_cb, void* source, mv_rectangle_s_copy roi, void* user_data) +PROXY_GROUP_BLOCKING(mv_roi_tracker_tracked_cb, void* source, mv_rectangle_s_copy roi, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*mv_supported_attribute_cb)(some_enum attribute_type, const char* attribute_name, void* user_data); +#define CB_PARAMS_NAMES attribute_type, attribute_name, user_data +PROXY_GROUP_RETURN(mv_supported_attribute_cb, bool, some_enum attribute_type, const char* attribute_name, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*mv_surveillance_event_occurred_cb)(void* trigger, void* source, int video_stream_id, void* event_result, void* user_data); +#define CB_PARAMS_NAMES trigger, source, video_stream_id, event_result, user_data +PROXY_GROUP_NON_BLOCKING(mv_surveillance_event_occurred_cb, void* trigger, void* source, int video_stream_id, void* event_result, void* user_data) +PROXY_GROUP_BLOCKING(mv_surveillance_event_occurred_cb, void* trigger, void* source, int video_stream_id, void* event_result, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*mv_surveillance_event_result_name_cb)(const char* name, void* user_data); +#define CB_PARAMS_NAMES name, user_data +PROXY_GROUP_RETURN(mv_surveillance_event_result_name_cb, bool, const char* name, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*mv_surveillance_event_type_cb)(const char* event_type, void* user_data); +#define CB_PARAMS_NAMES event_type, user_data +PROXY_GROUP_RETURN(mv_surveillance_event_type_cb, bool, const char* event_type, void* user_data) +#undef CB_PARAMS_NAMES + +typedef int (*noti_ex_item_group_foreach_child_cb)(void* handle, void* user_data); +#define CB_PARAMS_NAMES handle, user_data +PROXY_GROUP_RETURN(noti_ex_item_group_foreach_child_cb, int, void* handle, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*noti_ex_manager_events_add_cb)(void* handle, void* info, void* added_items, int count, void* user_data); +#define CB_PARAMS_NAMES handle, info, added_items, count, user_data +PROXY_GROUP_NON_BLOCKING(noti_ex_manager_events_add_cb, void* handle, void* info, void* added_items, int count, void* user_data) +PROXY_GROUP_BLOCKING(noti_ex_manager_events_add_cb, void* handle, void* info, void* added_items, int count, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*noti_ex_manager_events_delete_cb)(void* handle, void* info, void* deleted_item, void* user_data); +#define CB_PARAMS_NAMES handle, info, deleted_item, user_data +PROXY_GROUP_NON_BLOCKING(noti_ex_manager_events_delete_cb, void* handle, void* info, void* deleted_item, void* user_data) +PROXY_GROUP_BLOCKING(noti_ex_manager_events_delete_cb, void* handle, void* info, void* deleted_item, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*noti_ex_manager_events_error_cb)(void* handle, some_enum error, int request_id, void* user_data); +#define CB_PARAMS_NAMES handle, error, request_id, user_data +PROXY_GROUP_NON_BLOCKING(noti_ex_manager_events_error_cb, void* handle, some_enum error, int request_id, void* user_data) +PROXY_GROUP_BLOCKING(noti_ex_manager_events_error_cb, void* handle, some_enum error, int request_id, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*noti_ex_manager_events_update_cb)(void* handle, void* info, void* updated_item, void* user_data); +#define CB_PARAMS_NAMES handle, info, updated_item, user_data +PROXY_GROUP_NON_BLOCKING(noti_ex_manager_events_update_cb, void* handle, void* info, void* updated_item, void* user_data) +PROXY_GROUP_BLOCKING(noti_ex_manager_events_update_cb, void* handle, void* info, void* updated_item, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*noti_ex_reporter_events_error_cb)(void* handle, some_enum error, int request_id, void* user_data); +#define CB_PARAMS_NAMES handle, error, request_id, user_data +PROXY_GROUP_NON_BLOCKING(noti_ex_reporter_events_error_cb, void* handle, some_enum error, int request_id, void* user_data) +PROXY_GROUP_BLOCKING(noti_ex_reporter_events_error_cb, void* handle, some_enum error, int request_id, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*noti_ex_reporter_events_event_cb)(void* handle, void* info, void* items, int count, void* user_data); +#define CB_PARAMS_NAMES handle, info, items, count, user_data +PROXY_GROUP_NON_BLOCKING(noti_ex_reporter_events_event_cb, void* handle, void* info, void* items, int count, void* user_data) +PROXY_GROUP_BLOCKING(noti_ex_reporter_events_event_cb, void* handle, void* info, void* items, int count, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*package_info_app_cb)(some_enum comp_type, const char* app_id, void* user_data); +#define CB_PARAMS_NAMES comp_type, app_id, user_data +PROXY_GROUP_RETURN(package_info_app_cb, bool, some_enum comp_type, const char* app_id, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*package_info_cert_info_cb)(void* handle, some_enum cert_type, const char* cert_value, void* user_data); +#define CB_PARAMS_NAMES handle, cert_type, cert_value, user_data +PROXY_GROUP_RETURN(package_info_cert_info_cb, bool, void* handle, some_enum cert_type, const char* cert_value, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*package_info_dependency_info_cb)(const char* from, const char* to, const char* type, const char* required_version, void* user_data); +#define CB_PARAMS_NAMES from, to, type, required_version, user_data +PROXY_GROUP_RETURN(package_info_dependency_info_cb, bool, const char* from, const char* to, const char* type, const char* required_version, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*package_info_privilege_info_cb)(const char* privilege_name, void* user_data); +#define CB_PARAMS_NAMES privilege_name, user_data +PROXY_GROUP_RETURN(package_info_privilege_info_cb, bool, const char* privilege_name, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*package_info_res_allowed_package_cb)(const char* allowed_package, void* privilege_handle, void* user_data); +#define CB_PARAMS_NAMES allowed_package, privilege_handle, user_data +PROXY_GROUP_RETURN(package_info_res_allowed_package_cb, bool, const char* allowed_package, void* privilege_handle, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*package_info_updateinfo_cb)(void* info, void* user_data); +#define CB_PARAMS_NAMES info, user_data +PROXY_GROUP_RETURN(package_info_updateinfo_cb, bool, void* info, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*package_manager_event_cb)(const char* type, const char* package, some_enum event_type, some_enum event_state, int progress, some_enum error, void* user_data); +#define CB_PARAMS_NAMES type, package, event_type, event_state, progress, error, user_data +PROXY_GROUP_NON_BLOCKING(package_manager_event_cb, const char* type, const char* package, some_enum event_type, some_enum event_state, int progress, some_enum error, void* user_data) +PROXY_GROUP_BLOCKING(package_manager_event_cb, const char* type, const char* package, some_enum event_type, some_enum event_state, int progress, some_enum error, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*package_manager_package_info_cb)(void* package_info, void* user_data); +#define CB_PARAMS_NAMES package_info, user_data +PROXY_GROUP_RETURN(package_manager_package_info_cb, bool, void* package_info, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*package_manager_request_event_cb)(int id, const char* type, const char* package, some_enum event_type, some_enum event_state, int progress, some_enum error, void* user_data); +#define CB_PARAMS_NAMES id, type, package, event_type, event_state, progress, error, user_data +PROXY_GROUP_NON_BLOCKING(package_manager_request_event_cb, int id, const char* type, const char* package, some_enum event_type, some_enum event_state, int progress, some_enum error, void* user_data) +PROXY_GROUP_BLOCKING(package_manager_request_event_cb, int id, const char* type, const char* package, some_enum event_type, some_enum event_state, int progress, some_enum error, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*package_manager_request_res_event_cb)(int req_id, const char* pkgid, some_enum event_type, some_enum event_state, void* handle, void* user_data); +#define CB_PARAMS_NAMES req_id, pkgid, event_type, event_state, handle, user_data +PROXY_GROUP_NON_BLOCKING(package_manager_request_res_event_cb, int req_id, const char* pkgid, some_enum event_type, some_enum event_state, void* handle, void* user_data) +PROXY_GROUP_BLOCKING(package_manager_request_res_event_cb, int req_id, const char* pkgid, some_enum event_type, some_enum event_state, void* handle, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*package_manager_res_event_cb)(const char* pkgid, some_enum event_type, some_enum event_state, void* handle, void* user_data); +#define CB_PARAMS_NAMES pkgid, event_type, event_state, handle, user_data +PROXY_GROUP_NON_BLOCKING(package_manager_res_event_cb, const char* pkgid, some_enum event_type, some_enum event_state, void* handle, void* user_data) +PROXY_GROUP_BLOCKING(package_manager_res_event_cb, const char* pkgid, some_enum event_type, some_enum event_state, void* handle, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*package_manager_res_event_path_cb)(const char* path, some_enum state, void* user_data); +#define CB_PARAMS_NAMES path, state, user_data +PROXY_GROUP_RETURN(package_manager_res_event_path_cb, bool, const char* path, some_enum state, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*package_manager_size_info_receive_cb)(const char* package_id, const void* size_info, void* user_data); +#define CB_PARAMS_NAMES package_id, size_info, user_data +PROXY_GROUP_NON_BLOCKING(package_manager_size_info_receive_cb, const char* package_id, const void* size_info, void* user_data) +PROXY_GROUP_BLOCKING(package_manager_size_info_receive_cb, const char* package_id, const void* size_info, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*package_manager_total_size_info_receive_cb)(const void* size_info, void* user_data); +#define CB_PARAMS_NAMES size_info, user_data +PROXY_GROUP_NON_BLOCKING(package_manager_total_size_info_receive_cb, const void* size_info, void* user_data) +PROXY_GROUP_BLOCKING(package_manager_total_size_info_receive_cb, const void* size_info, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*peripheral_gpio_interrupted_cb)(void* gpio, some_enum error, void* user_data); +#define CB_PARAMS_NAMES gpio, error, user_data +PROXY_GROUP_NON_BLOCKING(peripheral_gpio_interrupted_cb, void* gpio, some_enum error, void* user_data) +PROXY_GROUP_BLOCKING(peripheral_gpio_interrupted_cb, void* gpio, some_enum error, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*player_adaptive_variant_cb)(int bandwidth, int width, int height, void* user_data); +#define CB_PARAMS_NAMES bandwidth, width, height, user_data +PROXY_GROUP_NON_BLOCKING(player_adaptive_variant_cb, int bandwidth, int width, int height, void* user_data) +PROXY_GROUP_BLOCKING(player_adaptive_variant_cb, int bandwidth, int width, int height, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*player_buffering_cb)(int percent, void* user_data); +#define CB_PARAMS_NAMES percent, user_data +PROXY_GROUP_NON_BLOCKING(player_buffering_cb, int percent, void* user_data) +PROXY_GROUP_BLOCKING(player_buffering_cb, int percent, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*player_completed_cb)(void* user_data); +#define CB_PARAMS_NAMES user_data +PROXY_GROUP_NON_BLOCKING(player_completed_cb, void* user_data) +PROXY_GROUP_BLOCKING(player_completed_cb, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*player_error_cb)(int error_code, void* user_data); +#define CB_PARAMS_NAMES error_code, user_data +PROXY_GROUP_NON_BLOCKING(player_error_cb, int error_code, void* user_data) +PROXY_GROUP_BLOCKING(player_error_cb, int error_code, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*player_interrupted_cb)(some_enum code, void* user_data); +#define CB_PARAMS_NAMES code, user_data +PROXY_GROUP_NON_BLOCKING(player_interrupted_cb, some_enum code, void* user_data) +PROXY_GROUP_BLOCKING(player_interrupted_cb, some_enum code, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*player_media_packet_audio_decoded_cb)(void* packet, void* user_data); +#define CB_PARAMS_NAMES packet, user_data +PROXY_GROUP_NON_BLOCKING(player_media_packet_audio_decoded_cb, void* packet, void* user_data) +PROXY_GROUP_BLOCKING(player_media_packet_audio_decoded_cb, void* packet, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*player_media_packet_video_decoded_cb)(void* packet, void* user_data); +#define CB_PARAMS_NAMES packet, user_data +PROXY_GROUP_NON_BLOCKING(player_media_packet_video_decoded_cb, void* packet, void* user_data) +PROXY_GROUP_BLOCKING(player_media_packet_video_decoded_cb, void* packet, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*player_media_stream_buffer_status_cb)(some_enum status, void* user_data); +#define CB_PARAMS_NAMES status, user_data +PROXY_GROUP_NON_BLOCKING(player_media_stream_buffer_status_cb, some_enum status, void* user_data) +PROXY_GROUP_BLOCKING(player_media_stream_buffer_status_cb, some_enum status, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*player_media_stream_seek_cb)(unsigned long long offset, void* user_data); +#define CB_PARAMS_NAMES offset, user_data +PROXY_GROUP_NON_BLOCKING(player_media_stream_seek_cb, unsigned long long offset, void* user_data) +PROXY_GROUP_BLOCKING(player_media_stream_seek_cb, unsigned long long offset, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*player_pd_message_cb)(some_enum type, void* user_data); +#define CB_PARAMS_NAMES type, user_data +PROXY_GROUP_NON_BLOCKING(player_pd_message_cb, some_enum type, void* user_data) +PROXY_GROUP_BLOCKING(player_pd_message_cb, some_enum type, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*player_prepared_cb)(void* user_data); +#define CB_PARAMS_NAMES user_data +PROXY_GROUP_NON_BLOCKING(player_prepared_cb, void* user_data) +PROXY_GROUP_BLOCKING(player_prepared_cb, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*player_seek_completed_cb)(void* user_data); +#define CB_PARAMS_NAMES user_data +PROXY_GROUP_NON_BLOCKING(player_seek_completed_cb, void* user_data) +PROXY_GROUP_BLOCKING(player_seek_completed_cb, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*player_subtitle_updated_cb)(unsigned long duration, char* text, void* user_data); +#define CB_PARAMS_NAMES duration, text, user_data +PROXY_GROUP_NON_BLOCKING(player_subtitle_updated_cb, unsigned long duration, char* text, void* user_data) +PROXY_GROUP_BLOCKING(player_subtitle_updated_cb, unsigned long duration, char* text, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*player_supported_media_format_cb)(some_enum format, void* user_data); +#define CB_PARAMS_NAMES format, user_data +PROXY_GROUP_RETURN(player_supported_media_format_cb, bool, some_enum format, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*player_video_captured_cb)(unsigned char* captured_data, int width, int height, unsigned int size, void* user_data); +#define CB_PARAMS_NAMES captured_data, width, height, size, user_data +PROXY_GROUP_NON_BLOCKING(player_video_captured_cb, unsigned char* captured_data, int width, int height, unsigned int size, void* user_data) +PROXY_GROUP_BLOCKING(player_video_captured_cb, unsigned char* captured_data, int width, int height, unsigned int size, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*player_video_stream_changed_cb)(int width, int height, int fps, int bit_rate, void* user_data); +#define CB_PARAMS_NAMES width, height, fps, bit_rate, user_data +PROXY_GROUP_NON_BLOCKING(player_video_stream_changed_cb, int width, int height, int fps, int bit_rate, void* user_data) +PROXY_GROUP_BLOCKING(player_video_stream_changed_cb, int width, int height, int fps, int bit_rate, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*playlist_member_cb)(int playlist_member_id, void* media, void* user_data); +#define CB_PARAMS_NAMES playlist_member_id, media, user_data +PROXY_GROUP_RETURN(playlist_member_cb, bool, int playlist_member_id, void* media, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*polygon_coords_cb)(location_coords_s_copy coords, void* user_data); +#define CB_PARAMS_NAMES coords, user_data +PROXY_GROUP_RETURN(polygon_coords_cb, bool, location_coords_s_copy coords, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*ppm_request_multiple_response_cb)(some_enum cause, const void* results, const char** privileges, size_t privileges_count, void* user_data); +#define CB_PARAMS_NAMES cause, results, privileges, privileges_count, user_data +PROXY_GROUP_NON_BLOCKING(ppm_request_multiple_response_cb, some_enum cause, const void* results, const char** privileges, size_t privileges_count, void* user_data) +PROXY_GROUP_BLOCKING(ppm_request_multiple_response_cb, some_enum cause, const void* results, const char** privileges, size_t privileges_count, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*ppm_request_response_cb)(some_enum cause, some_enum result, const char* privilege, void* user_data); +#define CB_PARAMS_NAMES cause, result, privilege, user_data +PROXY_GROUP_NON_BLOCKING(ppm_request_response_cb, some_enum cause, some_enum result, const char* privilege, void* user_data) +PROXY_GROUP_BLOCKING(ppm_request_response_cb, some_enum cause, some_enum result, const char* privilege, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*preference_changed_cb)(const char* key, void* user_data); +#define CB_PARAMS_NAMES key, user_data +PROXY_GROUP_NON_BLOCKING(preference_changed_cb, const char* key, void* user_data) +PROXY_GROUP_BLOCKING(preference_changed_cb, const char* key, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*preference_item_cb)(const char* key, void* user_data); +#define CB_PARAMS_NAMES key, user_data +PROXY_GROUP_RETURN(preference_item_cb, bool, const char* key, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*provider_feature_cb)(char* app_id, char* key, void* user_data); +#define CB_PARAMS_NAMES app_id, key, user_data +PROXY_GROUP_RETURN(provider_feature_cb, bool, char* app_id, char* key, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*push_service_notify_cb)(void* noti, void* user_data); +#define CB_PARAMS_NAMES noti, user_data +PROXY_GROUP_NON_BLOCKING(push_service_notify_cb, void* noti, void* user_data) +PROXY_GROUP_BLOCKING(push_service_notify_cb, void* noti, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*push_service_result_cb)(some_enum result, const char* msg, void* user_data); +#define CB_PARAMS_NAMES result, msg, user_data +PROXY_GROUP_NON_BLOCKING(push_service_result_cb, some_enum result, const char* msg, void* user_data) +PROXY_GROUP_BLOCKING(push_service_result_cb, some_enum result, const char* msg, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*push_service_state_cb)(some_enum state, const char* err, void* user_data); +#define CB_PARAMS_NAMES state, err, user_data +PROXY_GROUP_NON_BLOCKING(push_service_state_cb, some_enum state, const char* err, void* user_data) +PROXY_GROUP_BLOCKING(push_service_state_cb, some_enum state, const char* err, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*radio_interrupted_cb)(some_enum code, void* user_data); +#define CB_PARAMS_NAMES code, user_data +PROXY_GROUP_NON_BLOCKING(radio_interrupted_cb, some_enum code, void* user_data) +PROXY_GROUP_BLOCKING(radio_interrupted_cb, some_enum code, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*radio_scan_completed_cb)(void* user_data); +#define CB_PARAMS_NAMES user_data +PROXY_GROUP_NON_BLOCKING(radio_scan_completed_cb, void* user_data) +PROXY_GROUP_BLOCKING(radio_scan_completed_cb, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*radio_scan_stopped_cb)(void* user_data); +#define CB_PARAMS_NAMES user_data +PROXY_GROUP_NON_BLOCKING(radio_scan_stopped_cb, void* user_data) +PROXY_GROUP_BLOCKING(radio_scan_stopped_cb, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*radio_scan_updated_cb)(int frequency, void* user_data); +#define CB_PARAMS_NAMES frequency, user_data +PROXY_GROUP_NON_BLOCKING(radio_scan_updated_cb, int frequency, void* user_data) +PROXY_GROUP_BLOCKING(radio_scan_updated_cb, int frequency, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*radio_seek_completed_cb)(int frequency, void* user_data); +#define CB_PARAMS_NAMES frequency, user_data +PROXY_GROUP_NON_BLOCKING(radio_seek_completed_cb, int frequency, void* user_data) +PROXY_GROUP_BLOCKING(radio_seek_completed_cb, int frequency, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*recorder_audio_stream_cb)(void* stream, int size, some_enum format, int channel, unsigned int timestamp, void* user_data); +#define CB_PARAMS_NAMES stream, size, format, channel, timestamp, user_data +PROXY_GROUP_NON_BLOCKING(recorder_audio_stream_cb, void* stream, int size, some_enum format, int channel, unsigned int timestamp, void* user_data) +PROXY_GROUP_BLOCKING(recorder_audio_stream_cb, void* stream, int size, some_enum format, int channel, unsigned int timestamp, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*recorder_device_state_changed_cb)(some_enum type, some_enum state, void* user_data); +#define CB_PARAMS_NAMES type, state, user_data +PROXY_GROUP_NON_BLOCKING(recorder_device_state_changed_cb, some_enum type, some_enum state, void* user_data) +PROXY_GROUP_BLOCKING(recorder_device_state_changed_cb, some_enum type, some_enum state, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*recorder_error_cb)(some_enum error, some_enum current_state, void* user_data); +#define CB_PARAMS_NAMES error, current_state, user_data +PROXY_GROUP_NON_BLOCKING(recorder_error_cb, some_enum error, some_enum current_state, void* user_data) +PROXY_GROUP_BLOCKING(recorder_error_cb, some_enum error, some_enum current_state, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*recorder_interrupt_started_cb)(some_enum policy, some_enum state, void* user_data); +#define CB_PARAMS_NAMES policy, state, user_data +PROXY_GROUP_NON_BLOCKING(recorder_interrupt_started_cb, some_enum policy, some_enum state, void* user_data) +PROXY_GROUP_BLOCKING(recorder_interrupt_started_cb, some_enum policy, some_enum state, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*recorder_interrupted_cb)(some_enum policy, some_enum previous, some_enum current, void* user_data); +#define CB_PARAMS_NAMES policy, previous, current, user_data +PROXY_GROUP_NON_BLOCKING(recorder_interrupted_cb, some_enum policy, some_enum previous, some_enum current, void* user_data) +PROXY_GROUP_BLOCKING(recorder_interrupted_cb, some_enum policy, some_enum previous, some_enum current, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*recorder_muxed_stream_cb)(void* stream, int size, unsigned long long offset, void* user_data); +#define CB_PARAMS_NAMES stream, size, offset, user_data +PROXY_GROUP_NON_BLOCKING(recorder_muxed_stream_cb, void* stream, int size, unsigned long long offset, void* user_data) +PROXY_GROUP_BLOCKING(recorder_muxed_stream_cb, void* stream, int size, unsigned long long offset, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*recorder_recording_limit_reached_cb)(some_enum type, void* user_data); +#define CB_PARAMS_NAMES type, user_data +PROXY_GROUP_NON_BLOCKING(recorder_recording_limit_reached_cb, some_enum type, void* user_data) +PROXY_GROUP_BLOCKING(recorder_recording_limit_reached_cb, some_enum type, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*recorder_recording_status_cb)(unsigned long long elapsed_time, unsigned long long file_size, void* user_data); +#define CB_PARAMS_NAMES elapsed_time, file_size, user_data +PROXY_GROUP_NON_BLOCKING(recorder_recording_status_cb, unsigned long long elapsed_time, unsigned long long file_size, void* user_data) +PROXY_GROUP_BLOCKING(recorder_recording_status_cb, unsigned long long elapsed_time, unsigned long long file_size, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*recorder_state_changed_cb)(some_enum previous, some_enum current, bool by_policy, void* user_data); +#define CB_PARAMS_NAMES previous, current, by_policy, user_data +PROXY_GROUP_NON_BLOCKING(recorder_state_changed_cb, some_enum previous, some_enum current, bool by_policy, void* user_data) +PROXY_GROUP_BLOCKING(recorder_state_changed_cb, some_enum previous, some_enum current, bool by_policy, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*recorder_supported_audio_encoder_cb)(some_enum codec, void* user_data); +#define CB_PARAMS_NAMES codec, user_data +PROXY_GROUP_RETURN(recorder_supported_audio_encoder_cb, bool, some_enum codec, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*recorder_supported_file_format_cb)(some_enum format, void* user_data); +#define CB_PARAMS_NAMES format, user_data +PROXY_GROUP_RETURN(recorder_supported_file_format_cb, bool, some_enum format, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*recorder_supported_video_encoder_cb)(some_enum codec, void* user_data); +#define CB_PARAMS_NAMES codec, user_data +PROXY_GROUP_RETURN(recorder_supported_video_encoder_cb, bool, some_enum codec, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*recorder_supported_video_resolution_cb)(int width, int height, void* user_data); +#define CB_PARAMS_NAMES width, height, user_data +PROXY_GROUP_RETURN(recorder_supported_video_resolution_cb, bool, int width, int height, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*recorder_video_encode_decision_cb)(void* frame, void* user_data); +#define CB_PARAMS_NAMES frame, user_data +PROXY_GROUP_RETURN(recorder_video_encode_decision_cb, bool, void* frame, void* user_data) +#undef CB_PARAMS_NAMES + +typedef int (*result_cb)(int ret, void* user_data); +#define CB_PARAMS_NAMES ret, user_data +PROXY_GROUP_RETURN(result_cb, int, int ret, void* user_data) +#undef CB_PARAMS_NAMES + +#define BASE_CALLBACK_ID_result_cb_t 5 +typedef int (*result_cb_t)(int ret, void* data); +#define CB_PARAMS_NAMES ret, data +PROXY_GROUP_RETURN_NO_USER_DATA(result_cb_t, int, int ret, void* data) +#undef CB_PARAMS_NAMES + +typedef void (*rpc_port_proxy_connected_event_cb)(const char* receiver, const char* port_name, void* port, void* user_data); +#define CB_PARAMS_NAMES receiver, port_name, port, user_data +PROXY_GROUP_NON_BLOCKING(rpc_port_proxy_connected_event_cb, const char* receiver, const char* port_name, void* port, void* user_data) +PROXY_GROUP_BLOCKING(rpc_port_proxy_connected_event_cb, const char* receiver, const char* port_name, void* port, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*rpc_port_proxy_disconnected_event_cb)(const char* receiver, const char* port_name, void* user_data); +#define CB_PARAMS_NAMES receiver, port_name, user_data +PROXY_GROUP_NON_BLOCKING(rpc_port_proxy_disconnected_event_cb, const char* receiver, const char* port_name, void* user_data) +PROXY_GROUP_BLOCKING(rpc_port_proxy_disconnected_event_cb, const char* receiver, const char* port_name, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*rpc_port_proxy_received_event_cb)(const char* receiver, const char* port_name, void* user_data); +#define CB_PARAMS_NAMES receiver, port_name, user_data +PROXY_GROUP_NON_BLOCKING(rpc_port_proxy_received_event_cb, const char* receiver, const char* port_name, void* user_data) +PROXY_GROUP_BLOCKING(rpc_port_proxy_received_event_cb, const char* receiver, const char* port_name, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*rpc_port_proxy_rejected_event_cb)(const char* receiver, const char* port_name, void* user_data); +#define CB_PARAMS_NAMES receiver, port_name, user_data +PROXY_GROUP_NON_BLOCKING(rpc_port_proxy_rejected_event_cb, const char* receiver, const char* port_name, void* user_data) +PROXY_GROUP_BLOCKING(rpc_port_proxy_rejected_event_cb, const char* receiver, const char* port_name, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*rpc_port_stub_connected_event_cb)(const char* sender, const char* instance, void* user_data); +#define CB_PARAMS_NAMES sender, instance, user_data +PROXY_GROUP_NON_BLOCKING(rpc_port_stub_connected_event_cb, const char* sender, const char* instance, void* user_data) +PROXY_GROUP_BLOCKING(rpc_port_stub_connected_event_cb, const char* sender, const char* instance, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*rpc_port_stub_disconnected_event_cb)(const char* sender, const char* instance, void* user_data); +#define CB_PARAMS_NAMES sender, instance, user_data +PROXY_GROUP_NON_BLOCKING(rpc_port_stub_disconnected_event_cb, const char* sender, const char* instance, void* user_data) +PROXY_GROUP_BLOCKING(rpc_port_stub_disconnected_event_cb, const char* sender, const char* instance, void* user_data) +#undef CB_PARAMS_NAMES + +typedef int (*rpc_port_stub_received_event_cb)(const char* sender, const char* instance, void* port, void* user_data); +#define CB_PARAMS_NAMES sender, instance, port, user_data +PROXY_GROUP_RETURN(rpc_port_stub_received_event_cb, int, const char* sender, const char* instance, void* port, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*runtime_info_changed_cb)(some_enum key, void* user_data); +#define CB_PARAMS_NAMES key, user_data +PROXY_GROUP_NON_BLOCKING(runtime_info_changed_cb, some_enum key, void* user_data) +PROXY_GROUP_BLOCKING(runtime_info_changed_cb, some_enum key, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*scmirroring_sink_state_cb)(some_enum error, some_enum state, void* user_data); +#define CB_PARAMS_NAMES error, state, user_data +PROXY_GROUP_NON_BLOCKING(scmirroring_sink_state_cb, some_enum error, some_enum state, void* user_data) +PROXY_GROUP_BLOCKING(scmirroring_sink_state_cb, some_enum error, some_enum state, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*sensor_accuracy_changed_cb)(void* sensor, unsigned long long timestamp, some_enum accuracy, void* user_data); +#define CB_PARAMS_NAMES sensor, timestamp, accuracy, user_data +PROXY_GROUP_NON_BLOCKING(sensor_accuracy_changed_cb, void* sensor, unsigned long long timestamp, some_enum accuracy, void* user_data) +PROXY_GROUP_BLOCKING(sensor_accuracy_changed_cb, void* sensor, unsigned long long timestamp, some_enum accuracy, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*sensor_added_cb)(const char* uri, void* user_data); +#define CB_PARAMS_NAMES uri, user_data +PROXY_GROUP_NON_BLOCKING(sensor_added_cb, const char* uri, void* user_data) +PROXY_GROUP_BLOCKING(sensor_added_cb, const char* uri, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*sensor_event_cb)(void* sensor, void* event, void* user_data); +#define CB_PARAMS_NAMES sensor, event, user_data +PROXY_GROUP_NON_BLOCKING(sensor_event_cb, void* sensor, void* event, void* user_data) +PROXY_GROUP_BLOCKING(sensor_event_cb, void* sensor, void* event, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*sensor_events_cb)(void* sensor, void* events, int events_count, void* user_data); +#define CB_PARAMS_NAMES sensor, events, events_count, user_data +PROXY_GROUP_NON_BLOCKING(sensor_events_cb, void* sensor, void* events, int events_count, void* user_data) +PROXY_GROUP_BLOCKING(sensor_events_cb, void* sensor, void* events, int events_count, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*sensor_provider_interval_changed_cb)(void* provider, unsigned int interval_ms, void* user_data); +#define CB_PARAMS_NAMES provider, interval_ms, user_data +PROXY_GROUP_NON_BLOCKING(sensor_provider_interval_changed_cb, void* provider, unsigned int interval_ms, void* user_data) +PROXY_GROUP_BLOCKING(sensor_provider_interval_changed_cb, void* provider, unsigned int interval_ms, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*sensor_provider_start_cb)(void* provider, void* user_data); +#define CB_PARAMS_NAMES provider, user_data +PROXY_GROUP_NON_BLOCKING(sensor_provider_start_cb, void* provider, void* user_data) +PROXY_GROUP_BLOCKING(sensor_provider_start_cb, void* provider, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*sensor_provider_stop_cb)(void* provider, void* user_data); +#define CB_PARAMS_NAMES provider, user_data +PROXY_GROUP_NON_BLOCKING(sensor_provider_stop_cb, void* provider, void* user_data) +PROXY_GROUP_BLOCKING(sensor_provider_stop_cb, void* provider, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*sensor_recorder_data_cb)(some_enum type, void* data, int remains, some_enum error, void* user_data); +#define CB_PARAMS_NAMES type, data, remains, error, user_data +PROXY_GROUP_RETURN(sensor_recorder_data_cb, bool, some_enum type, void* data, int remains, some_enum error, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*sensor_removed_cb)(const char* uri, void* user_data); +#define CB_PARAMS_NAMES uri, user_data +PROXY_GROUP_NON_BLOCKING(sensor_removed_cb, const char* uri, void* user_data) +PROXY_GROUP_BLOCKING(sensor_removed_cb, const char* uri, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*service_app_control_cb)(void* app_control, void* user_data); +#define CB_PARAMS_NAMES app_control, user_data +PROXY_GROUP_NON_BLOCKING(service_app_control_cb, void* app_control, void* user_data) +PROXY_GROUP_BLOCKING(service_app_control_cb, void* app_control, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*service_app_create_cb)(void* user_data); +#define CB_PARAMS_NAMES user_data +PROXY_GROUP_RETURN(service_app_create_cb, bool, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*service_app_terminate_cb)(void* user_data); +#define CB_PARAMS_NAMES user_data +PROXY_GROUP_NON_BLOCKING(service_app_terminate_cb, void* user_data) +PROXY_GROUP_BLOCKING(service_app_terminate_cb, void* user_data) +#undef CB_PARAMS_NAMES + +typedef int (*shortcut_list_cb)(const char* package_name, const char* icon, const char* name, const char* extra_key, const char* extra_data, void* user_data); +#define CB_PARAMS_NAMES package_name, icon, name, extra_key, extra_data, user_data +PROXY_GROUP_RETURN(shortcut_list_cb, int, const char* package_name, const char* icon, const char* name, const char* extra_key, const char* extra_data, void* user_data) +#undef CB_PARAMS_NAMES + +typedef int (*shortcut_remove_cb)(const char* package_name, const char* name, int sender_pid, void* user_data); +#define CB_PARAMS_NAMES package_name, name, sender_pid, user_data +PROXY_GROUP_RETURN(shortcut_remove_cb, int, const char* package_name, const char* name, int sender_pid, void* user_data) +#undef CB_PARAMS_NAMES + +typedef int (*shortcut_request_cb)(const char* package_name, const char* name, int type, const char* content_info, const char* icon, int pid, double period, int allow_duplicate, void* user_data); +#define CB_PARAMS_NAMES package_name, name, type, content_info, icon, pid, period, allow_duplicate, user_data +PROXY_GROUP_RETURN(shortcut_request_cb, int, const char* package_name, const char* name, int type, const char* content_info, const char* icon, int pid, double period, int allow_duplicate, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*smartcard_reader_event_cb)(int reader, some_enum event_type, void* user_data); +#define CB_PARAMS_NAMES reader, event_type, user_data +PROXY_GROUP_NON_BLOCKING(smartcard_reader_event_cb, int reader, some_enum event_type, void* user_data) +PROXY_GROUP_BLOCKING(smartcard_reader_event_cb, int reader, some_enum event_type, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*softap_client_connection_state_changed_cb)(void* client, bool opened, void* user_data); +#define CB_PARAMS_NAMES client, opened, user_data +PROXY_GROUP_NON_BLOCKING(softap_client_connection_state_changed_cb, void* client, bool opened, void* user_data) +PROXY_GROUP_BLOCKING(softap_client_connection_state_changed_cb, void* client, bool opened, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*softap_connected_client_cb)(void* client, void* user_data); +#define CB_PARAMS_NAMES client, user_data +PROXY_GROUP_RETURN(softap_connected_client_cb, bool, void* client, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*softap_disabled_cb)(some_enum result, some_enum cause, void* user_data); +#define CB_PARAMS_NAMES result, cause, user_data +PROXY_GROUP_NON_BLOCKING(softap_disabled_cb, some_enum result, some_enum cause, void* user_data) +PROXY_GROUP_BLOCKING(softap_disabled_cb, some_enum result, some_enum cause, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*softap_enabled_cb)(some_enum result, bool is_requested, void* user_data); +#define CB_PARAMS_NAMES result, is_requested, user_data +PROXY_GROUP_NON_BLOCKING(softap_enabled_cb, some_enum result, bool is_requested, void* user_data) +PROXY_GROUP_BLOCKING(softap_enabled_cb, some_enum result, bool is_requested, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*softap_passphrase_changed_cb)(void* user_data); +#define CB_PARAMS_NAMES user_data +PROXY_GROUP_NON_BLOCKING(softap_passphrase_changed_cb, void* user_data) +PROXY_GROUP_BLOCKING(softap_passphrase_changed_cb, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*softap_security_type_changed_cb)(some_enum changed_type, void* user_data); +#define CB_PARAMS_NAMES changed_type, user_data +PROXY_GROUP_NON_BLOCKING(softap_security_type_changed_cb, some_enum changed_type, void* user_data) +PROXY_GROUP_BLOCKING(softap_security_type_changed_cb, some_enum changed_type, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*softap_settings_reloaded_cb)(some_enum result, void* user_data); +#define CB_PARAMS_NAMES result, user_data +PROXY_GROUP_NON_BLOCKING(softap_settings_reloaded_cb, some_enum result, void* user_data) +PROXY_GROUP_BLOCKING(softap_settings_reloaded_cb, some_enum result, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*softap_ssid_visibility_changed_cb)(bool changed_visible, void* user_data); +#define CB_PARAMS_NAMES changed_visible, user_data +PROXY_GROUP_NON_BLOCKING(softap_ssid_visibility_changed_cb, bool changed_visible, void* user_data) +PROXY_GROUP_BLOCKING(softap_ssid_visibility_changed_cb, bool changed_visible, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*sound_device_connected_cb)(void* device, bool is_connected, void* user_data); +#define CB_PARAMS_NAMES device, is_connected, user_data +PROXY_GROUP_NON_BLOCKING(sound_device_connected_cb, void* device, bool is_connected, void* user_data) +PROXY_GROUP_BLOCKING(sound_device_connected_cb, void* device, bool is_connected, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*sound_device_connection_changed_cb)(void* device, bool is_connected, void* user_data); +#define CB_PARAMS_NAMES device, is_connected, user_data +PROXY_GROUP_NON_BLOCKING(sound_device_connection_changed_cb, void* device, bool is_connected, void* user_data) +PROXY_GROUP_BLOCKING(sound_device_connection_changed_cb, void* device, bool is_connected, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*sound_device_information_changed_cb)(void* device, some_enum changed_info, void* user_data); +#define CB_PARAMS_NAMES device, changed_info, user_data +PROXY_GROUP_NON_BLOCKING(sound_device_information_changed_cb, void* device, some_enum changed_info, void* user_data) +PROXY_GROUP_BLOCKING(sound_device_information_changed_cb, void* device, some_enum changed_info, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*sound_device_running_changed_cb)(void* device, bool is_running, void* user_data); +#define CB_PARAMS_NAMES device, is_running, user_data +PROXY_GROUP_NON_BLOCKING(sound_device_running_changed_cb, void* device, bool is_running, void* user_data) +PROXY_GROUP_BLOCKING(sound_device_running_changed_cb, void* device, bool is_running, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*sound_device_state_changed_cb)(void* device, some_enum state, void* user_data); +#define CB_PARAMS_NAMES device, state, user_data +PROXY_GROUP_NON_BLOCKING(sound_device_state_changed_cb, void* device, some_enum state, void* user_data) +PROXY_GROUP_BLOCKING(sound_device_state_changed_cb, void* device, some_enum state, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*sound_manager_volume_changed_cb)(some_enum type, unsigned int volume, void* user_data); +#define CB_PARAMS_NAMES type, volume, user_data +PROXY_GROUP_NON_BLOCKING(sound_manager_volume_changed_cb, some_enum type, unsigned int volume, void* user_data) +PROXY_GROUP_BLOCKING(sound_manager_volume_changed_cb, some_enum type, unsigned int volume, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*sound_pool_state_changed_cb)(void* pool, some_enum prev_state, some_enum cur_state, void* user_data); +#define CB_PARAMS_NAMES pool, prev_state, cur_state, user_data +PROXY_GROUP_NON_BLOCKING(sound_pool_state_changed_cb, void* pool, some_enum prev_state, some_enum cur_state, void* user_data) +PROXY_GROUP_BLOCKING(sound_pool_state_changed_cb, void* pool, some_enum prev_state, some_enum cur_state, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*sound_pool_stream_state_changed_cb)(void* pool, unsigned id, some_enum prev_state, some_enum cur_state, void* user_data); +#define CB_PARAMS_NAMES pool, id, prev_state, cur_state, user_data +PROXY_GROUP_NON_BLOCKING(sound_pool_stream_state_changed_cb, void* pool, unsigned id, some_enum prev_state, some_enum cur_state, void* user_data) +PROXY_GROUP_BLOCKING(sound_pool_stream_state_changed_cb, void* pool, unsigned id, some_enum prev_state, some_enum cur_state, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*sound_session_interrupted_cb)(some_enum code, void* user_data); +#define CB_PARAMS_NAMES code, user_data +PROXY_GROUP_NON_BLOCKING(sound_session_interrupted_cb, some_enum code, void* user_data) +PROXY_GROUP_BLOCKING(sound_session_interrupted_cb, some_enum code, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*sound_stream_ducking_state_changed_cb)(void* stream_ducking, bool is_ducked, void* user_data); +#define CB_PARAMS_NAMES stream_ducking, is_ducked, user_data +PROXY_GROUP_NON_BLOCKING(sound_stream_ducking_state_changed_cb, void* stream_ducking, bool is_ducked, void* user_data) +PROXY_GROUP_BLOCKING(sound_stream_ducking_state_changed_cb, void* stream_ducking, bool is_ducked, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*sound_stream_focus_state_changed_cb)(void* stream_info, some_enum focus_mask, some_enum focus_state, some_enum reason, int sound_behavior, const char* extra_info, void* user_data); +#define CB_PARAMS_NAMES stream_info, focus_mask, focus_state, reason, sound_behavior, extra_info, user_data +PROXY_GROUP_NON_BLOCKING(sound_stream_focus_state_changed_cb, void* stream_info, some_enum focus_mask, some_enum focus_state, some_enum reason, int sound_behavior, const char* extra_info, void* user_data) +PROXY_GROUP_BLOCKING(sound_stream_focus_state_changed_cb, void* stream_info, some_enum focus_mask, some_enum focus_state, some_enum reason, int sound_behavior, const char* extra_info, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*sound_stream_focus_state_watch_cb)(int id, some_enum focus_mask, some_enum focus_state, some_enum reason, const char* extra_info, void* user_data); +#define CB_PARAMS_NAMES id, focus_mask, focus_state, reason, extra_info, user_data +PROXY_GROUP_NON_BLOCKING(sound_stream_focus_state_watch_cb, int id, some_enum focus_mask, some_enum focus_state, some_enum reason, const char* extra_info, void* user_data) +PROXY_GROUP_BLOCKING(sound_stream_focus_state_watch_cb, int id, some_enum focus_mask, some_enum focus_state, some_enum reason, const char* extra_info, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*ssdp_found_cb)(some_enum state, unsigned int ssdp_remote_service, void* user_data); +#define CB_PARAMS_NAMES state, ssdp_remote_service, user_data +PROXY_GROUP_NON_BLOCKING(ssdp_found_cb, some_enum state, unsigned int ssdp_remote_service, void* user_data) +PROXY_GROUP_BLOCKING(ssdp_found_cb, some_enum state, unsigned int ssdp_remote_service, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*ssdp_registered_cb)(some_enum result, unsigned int ssdp_local_service, void* user_data); +#define CB_PARAMS_NAMES result, ssdp_local_service, user_data +PROXY_GROUP_NON_BLOCKING(ssdp_registered_cb, some_enum result, unsigned int ssdp_local_service, void* user_data) +PROXY_GROUP_BLOCKING(ssdp_registered_cb, some_enum result, unsigned int ssdp_local_service, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*stc_get_all_stats_finished_cb)(some_enum result, void* info, void* user_data); +#define CB_PARAMS_NAMES result, info, user_data +PROXY_GROUP_NON_BLOCKING(stc_get_all_stats_finished_cb, some_enum result, void* info, void* user_data) +PROXY_GROUP_BLOCKING(stc_get_all_stats_finished_cb, some_enum result, void* info, void* user_data) +#undef CB_PARAMS_NAMES + +typedef some_enum (*stc_stats_info_cb)(some_enum result, void* info, void* user_data); +#define CB_PARAMS_NAMES result, info, user_data +PROXY_GROUP_RETURN(stc_stats_info_cb, some_enum, some_enum result, void* info, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*storage_changed_cb)(int storage_id, some_enum dev, some_enum state, const char* fstype, const char* fsuuid, const char* mountpath, bool primary, int flags, void* user_data); +#define CB_PARAMS_NAMES storage_id, dev, state, fstype, fsuuid, mountpath, primary, flags, user_data +PROXY_GROUP_NON_BLOCKING(storage_changed_cb, int storage_id, some_enum dev, some_enum state, const char* fstype, const char* fsuuid, const char* mountpath, bool primary, int flags, void* user_data) +PROXY_GROUP_BLOCKING(storage_changed_cb, int storage_id, some_enum dev, some_enum state, const char* fstype, const char* fsuuid, const char* mountpath, bool primary, int flags, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*storage_device_supported_cb)(int storage_id, some_enum type, some_enum state, const char* path, void* user_data); +#define CB_PARAMS_NAMES storage_id, type, state, path, user_data +PROXY_GROUP_RETURN(storage_device_supported_cb, bool, int storage_id, some_enum type, some_enum state, const char* path, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*storage_state_changed_cb)(int storage_id, some_enum state, void* user_data); +#define CB_PARAMS_NAMES storage_id, state, user_data +PROXY_GROUP_NON_BLOCKING(storage_state_changed_cb, int storage_id, some_enum state, void* user_data) +PROXY_GROUP_BLOCKING(storage_state_changed_cb, int storage_id, some_enum state, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*streamrecorder_consume_completed_cb)(void* buffer, void* user_data); +#define CB_PARAMS_NAMES buffer, user_data +PROXY_GROUP_NON_BLOCKING(streamrecorder_consume_completed_cb, void* buffer, void* user_data) +PROXY_GROUP_BLOCKING(streamrecorder_consume_completed_cb, void* buffer, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*streamrecorder_error_cb)(some_enum error, some_enum current_state, void* user_data); +#define CB_PARAMS_NAMES error, current_state, user_data +PROXY_GROUP_NON_BLOCKING(streamrecorder_error_cb, some_enum error, some_enum current_state, void* user_data) +PROXY_GROUP_BLOCKING(streamrecorder_error_cb, some_enum error, some_enum current_state, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*streamrecorder_notify_cb)(some_enum previous, some_enum current, some_enum notification, void* user_data); +#define CB_PARAMS_NAMES previous, current, notification, user_data +PROXY_GROUP_NON_BLOCKING(streamrecorder_notify_cb, some_enum previous, some_enum current, some_enum notification, void* user_data) +PROXY_GROUP_BLOCKING(streamrecorder_notify_cb, some_enum previous, some_enum current, some_enum notification, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*streamrecorder_recording_limit_reached_cb)(some_enum type, void* user_data); +#define CB_PARAMS_NAMES type, user_data +PROXY_GROUP_NON_BLOCKING(streamrecorder_recording_limit_reached_cb, some_enum type, void* user_data) +PROXY_GROUP_BLOCKING(streamrecorder_recording_limit_reached_cb, some_enum type, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*streamrecorder_recording_status_cb)(unsigned long long elapsed_time, unsigned long long file_size, void* user_data); +#define CB_PARAMS_NAMES elapsed_time, file_size, user_data +PROXY_GROUP_NON_BLOCKING(streamrecorder_recording_status_cb, unsigned long long elapsed_time, unsigned long long file_size, void* user_data) +PROXY_GROUP_BLOCKING(streamrecorder_recording_status_cb, unsigned long long elapsed_time, unsigned long long file_size, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*streamrecorder_supported_audio_encoder_cb)(some_enum codec, void* user_data); +#define CB_PARAMS_NAMES codec, user_data +PROXY_GROUP_RETURN(streamrecorder_supported_audio_encoder_cb, bool, some_enum codec, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*streamrecorder_supported_file_format_cb)(some_enum format, void* user_data); +#define CB_PARAMS_NAMES format, user_data +PROXY_GROUP_RETURN(streamrecorder_supported_file_format_cb, bool, some_enum format, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*streamrecorder_supported_video_encoder_cb)(some_enum codec, void* user_data); +#define CB_PARAMS_NAMES codec, user_data +PROXY_GROUP_RETURN(streamrecorder_supported_video_encoder_cb, bool, some_enum codec, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*streamrecorder_supported_video_resolution_cb)(int width, int height, void* user_data); +#define CB_PARAMS_NAMES width, height, user_data +PROXY_GROUP_RETURN(streamrecorder_supported_video_resolution_cb, bool, int width, int height, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*stt_default_language_changed_cb)(void* stt, const char* previous_language, const char* current_language, void* user_data); +#define CB_PARAMS_NAMES stt, previous_language, current_language, user_data +PROXY_GROUP_NON_BLOCKING(stt_default_language_changed_cb, void* stt, const char* previous_language, const char* current_language, void* user_data) +PROXY_GROUP_BLOCKING(stt_default_language_changed_cb, void* stt, const char* previous_language, const char* current_language, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*stt_engine_changed_cb)(void* stt, const char* engine_id, const char* language, bool support_silence, bool need_credential, void* user_data); +#define CB_PARAMS_NAMES stt, engine_id, language, support_silence, need_credential, user_data +PROXY_GROUP_NON_BLOCKING(stt_engine_changed_cb, void* stt, const char* engine_id, const char* language, bool support_silence, bool need_credential, void* user_data) +PROXY_GROUP_BLOCKING(stt_engine_changed_cb, void* stt, const char* engine_id, const char* language, bool support_silence, bool need_credential, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*stt_error_cb)(void* stt, some_enum reason, void* user_data); +#define CB_PARAMS_NAMES stt, reason, user_data +PROXY_GROUP_NON_BLOCKING(stt_error_cb, void* stt, some_enum reason, void* user_data) +PROXY_GROUP_BLOCKING(stt_error_cb, void* stt, some_enum reason, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*stt_recognition_result_cb)(void* stt, some_enum event, const char** data, int data_count, const char* msg, void* user_data); +#define CB_PARAMS_NAMES stt, event, data, data_count, msg, user_data +PROXY_GROUP_NON_BLOCKING(stt_recognition_result_cb, void* stt, some_enum event, const char** data, int data_count, const char* msg, void* user_data) +PROXY_GROUP_BLOCKING(stt_recognition_result_cb, void* stt, some_enum event, const char** data, int data_count, const char* msg, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*stt_result_time_cb)(void* stt, int index, some_enum event, const char* text, long start_time, long end_time, void* user_data); +#define CB_PARAMS_NAMES stt, index, event, text, start_time, end_time, user_data +PROXY_GROUP_RETURN(stt_result_time_cb, bool, void* stt, int index, some_enum event, const char* text, long start_time, long end_time, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*stt_speech_status_cb)(void* stt, some_enum status, void* user_data); +#define CB_PARAMS_NAMES stt, status, user_data +PROXY_GROUP_NON_BLOCKING(stt_speech_status_cb, void* stt, some_enum status, void* user_data) +PROXY_GROUP_BLOCKING(stt_speech_status_cb, void* stt, some_enum status, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*stt_state_changed_cb)(void* stt, some_enum previous, some_enum current, void* user_data); +#define CB_PARAMS_NAMES stt, previous, current, user_data +PROXY_GROUP_NON_BLOCKING(stt_state_changed_cb, void* stt, some_enum previous, some_enum current, void* user_data) +PROXY_GROUP_BLOCKING(stt_state_changed_cb, void* stt, some_enum previous, some_enum current, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*stt_supported_engine_cb)(void* stt, const char* engine_id, const char* engine_name, void* user_data); +#define CB_PARAMS_NAMES stt, engine_id, engine_name, user_data +PROXY_GROUP_RETURN(stt_supported_engine_cb, bool, void* stt, const char* engine_id, const char* engine_name, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*stt_supported_language_cb)(void* stt, const char* language, void* user_data); +#define CB_PARAMS_NAMES stt, language, user_data +PROXY_GROUP_RETURN(stt_supported_language_cb, bool, void* stt, const char* language, void* user_data) +#undef CB_PARAMS_NAMES + +typedef int (*stte_audio_type_cb)(const char* audio_type, void* user_data); +#define CB_PARAMS_NAMES audio_type, user_data +PROXY_GROUP_RETURN(stte_audio_type_cb, int, const char* audio_type, void* user_data) +#undef CB_PARAMS_NAMES + +#define BASE_CALLBACK_ID_stte_cancel_cb 10 +typedef int (*stte_cancel_cb)(); +PROXY_GROUP_RETURN_NO_USER_DATA_NO_PARAM(stte_cancel_cb, int) + +#define BASE_CALLBACK_ID_stte_check_app_agreed_cb 15 +typedef int (*stte_check_app_agreed_cb)(const char* appid, bool* is_agreed); +#define CB_PARAMS_NAMES appid, is_agreed +PROXY_GROUP_RETURN_NO_USER_DATA(stte_check_app_agreed_cb, int, const char* appid, bool* is_agreed) +#undef CB_PARAMS_NAMES + +#define BASE_CALLBACK_ID_stte_deinitialize_cb 20 +typedef int (*stte_deinitialize_cb)(); +PROXY_GROUP_RETURN_NO_USER_DATA_NO_PARAM(stte_deinitialize_cb, int) + +typedef int (*stte_foreach_result_time_cb)(void* time_info, void* callback, void* user_data); +#define CB_PARAMS_NAMES time_info, callback, user_data +PROXY_GROUP_RETURN(stte_foreach_result_time_cb, int, void* time_info, void* callback, void* user_data) +#undef CB_PARAMS_NAMES + +typedef int (*stte_foreach_supported_langs_cb)(void* callback, void* user_data); +#define CB_PARAMS_NAMES callback, user_data +PROXY_GROUP_RETURN(stte_foreach_supported_langs_cb, int, void* callback, void* user_data) +#undef CB_PARAMS_NAMES + +#define BASE_CALLBACK_ID_stte_get_info_cb 25 +typedef int (*stte_get_info_cb)(char** engine_uuid, char** engine_name, char** engine_setting, bool* use_network); +#define CB_PARAMS_NAMES engine_uuid, engine_name, engine_setting, use_network +PROXY_GROUP_RETURN_NO_USER_DATA(stte_get_info_cb, int, char** engine_uuid, char** engine_name, char** engine_setting, bool* use_network) +#undef CB_PARAMS_NAMES + +#define BASE_CALLBACK_ID_stte_get_recording_format_cb 30 +typedef int (*stte_get_recording_format_cb)(void* types, int* rate, int* channels); +#define CB_PARAMS_NAMES types, rate, channels +PROXY_GROUP_RETURN_NO_USER_DATA(stte_get_recording_format_cb, int, void* types, int* rate, int* channels) +#undef CB_PARAMS_NAMES + +#define BASE_CALLBACK_ID_stte_initialize_cb 35 +typedef int (*stte_initialize_cb)(); +PROXY_GROUP_RETURN_NO_USER_DATA_NO_PARAM(stte_initialize_cb, int) + +#define BASE_CALLBACK_ID_stte_is_valid_language_cb 40 +typedef int (*stte_is_valid_language_cb)(const char* language, bool* is_valid); +#define CB_PARAMS_NAMES language, is_valid +PROXY_GROUP_RETURN_NO_USER_DATA(stte_is_valid_language_cb, int, const char* language, bool* is_valid) +#undef CB_PARAMS_NAMES + +#define BASE_CALLBACK_ID_stte_need_app_credential_cb 45 +typedef bool (*stte_need_app_credential_cb)(); +PROXY_GROUP_RETURN_NO_USER_DATA_NO_PARAM(stte_need_app_credential_cb, bool) + +#define BASE_CALLBACK_ID_stte_private_data_requested_cb 50 +typedef int (*stte_private_data_requested_cb)(const char* key, char** data); +#define CB_PARAMS_NAMES key, data +PROXY_GROUP_RETURN_NO_USER_DATA(stte_private_data_requested_cb, int, const char* key, char** data) +#undef CB_PARAMS_NAMES + +#define BASE_CALLBACK_ID_stte_private_data_set_cb 55 +typedef int (*stte_private_data_set_cb)(const char* key, const char* data); +#define CB_PARAMS_NAMES key, data +PROXY_GROUP_RETURN_NO_USER_DATA(stte_private_data_set_cb, int, const char* key, const char* data) +#undef CB_PARAMS_NAMES + +typedef bool (*stte_result_time_cb)(int index, some_enum event, const char* text, long start_time, long end_time, void* user_data); +#define CB_PARAMS_NAMES index, event, text, start_time, end_time, user_data +PROXY_GROUP_RETURN(stte_result_time_cb, bool, int index, some_enum event, const char* text, long start_time, long end_time, void* user_data) +#undef CB_PARAMS_NAMES + +#define BASE_CALLBACK_ID_stte_set_recording_data_cb 60 +typedef int (*stte_set_recording_data_cb)(const void* data, unsigned int length); +#define CB_PARAMS_NAMES data, length +PROXY_GROUP_RETURN_NO_USER_DATA(stte_set_recording_data_cb, int, const void* data, unsigned int length) +#undef CB_PARAMS_NAMES + +#define BASE_CALLBACK_ID_stte_set_silence_detection_cb 65 +typedef int (*stte_set_silence_detection_cb)(bool is_set); +#define CB_PARAMS_NAMES is_set +PROXY_GROUP_RETURN_NO_USER_DATA(stte_set_silence_detection_cb, int, bool is_set) +#undef CB_PARAMS_NAMES + +typedef int (*stte_start_cb)(const char* language, const char* type, const char* appid, const char* credential, void* user_data); +#define CB_PARAMS_NAMES language, type, appid, credential, user_data +PROXY_GROUP_RETURN(stte_start_cb, int, const char* language, const char* type, const char* appid, const char* credential, void* user_data) +#undef CB_PARAMS_NAMES + +#define BASE_CALLBACK_ID_stte_stop_cb 70 +typedef int (*stte_stop_cb)(); +PROXY_GROUP_RETURN_NO_USER_DATA_NO_PARAM(stte_stop_cb, int) + +#define BASE_CALLBACK_ID_stte_support_recognition_type_cb 75 +typedef int (*stte_support_recognition_type_cb)(const char* type, bool* is_supported); +#define CB_PARAMS_NAMES type, is_supported +PROXY_GROUP_RETURN_NO_USER_DATA(stte_support_recognition_type_cb, int, const char* type, bool* is_supported) +#undef CB_PARAMS_NAMES + +#define BASE_CALLBACK_ID_stte_support_silence_detection_cb 80 +typedef bool (*stte_support_silence_detection_cb)(); +PROXY_GROUP_RETURN_NO_USER_DATA_NO_PARAM(stte_support_silence_detection_cb, bool) + +typedef bool (*stte_supported_language_cb)(const char* language, void* user_data); +#define CB_PARAMS_NAMES language, user_data +PROXY_GROUP_RETURN(stte_supported_language_cb, bool, const char* language, void* user_data) +#undef CB_PARAMS_NAMES + +#define BASE_CALLBACK_ID_sync_adapter_cancel_sync_cb 85 +typedef void (*sync_adapter_cancel_sync_cb)(void* account, const char* sync_job_name, const char* sync_capability, void* sync_job_user_data); +#define CB_PARAMS_NAMES account, sync_job_name, sync_capability, sync_job_user_data +PROXY_GROUP_NON_BLOCKING_NO_USER_DATA(sync_adapter_cancel_sync_cb, void* account, const char* sync_job_name, const char* sync_capability, void* sync_job_user_data) +PROXY_GROUP_BLOCKING_NO_USER_DATA(sync_adapter_cancel_sync_cb, void* account, const char* sync_job_name, const char* sync_capability, void* sync_job_user_data) +#undef CB_PARAMS_NAMES + +#define BASE_CALLBACK_ID_sync_adapter_start_sync_cb 90 +typedef bool (*sync_adapter_start_sync_cb)(void* account, const char* sync_job_name, const char* sync_capability, void* sync_job_user_data); +#define CB_PARAMS_NAMES account, sync_job_name, sync_capability, sync_job_user_data +PROXY_GROUP_RETURN_NO_USER_DATA(sync_adapter_start_sync_cb, bool, void* account, const char* sync_job_name, const char* sync_capability, void* sync_job_user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*sync_manager_sync_job_cb)(void* account, const char* sync_job_name, const char* sync_capability, int sync_job_id, void* sync_job_user_data, void* user_data); +#define CB_PARAMS_NAMES account, sync_job_name, sync_capability, sync_job_id, sync_job_user_data, user_data +PROXY_GROUP_RETURN(sync_manager_sync_job_cb, bool, void* account, const char* sync_job_name, const char* sync_capability, int sync_job_id, void* sync_job_user_data, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*system_settings_changed_cb)(some_enum key, void* user_data); +#define CB_PARAMS_NAMES key, user_data +PROXY_GROUP_NON_BLOCKING(system_settings_changed_cb, some_enum key, void* user_data) +PROXY_GROUP_BLOCKING(system_settings_changed_cb, some_enum key, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*system_settings_iter_cb)(int index, const char* value, void* user_data); +#define CB_PARAMS_NAMES index, value, user_data +PROXY_GROUP_RETURN(system_settings_iter_cb, bool, int index, const char* value, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*telephony_noti_cb)(void* handle, some_enum noti_id, void* data, void* user_data); +#define CB_PARAMS_NAMES handle, noti_id, data, user_data +PROXY_GROUP_NON_BLOCKING(telephony_noti_cb, void* handle, some_enum noti_id, void* data, void* user_data) +PROXY_GROUP_BLOCKING(telephony_noti_cb, void* handle, some_enum noti_id, void* data, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*telephony_state_changed_cb)(some_enum state, void* user_data); +#define CB_PARAMS_NAMES state, user_data +PROXY_GROUP_NON_BLOCKING(telephony_state_changed_cb, some_enum state, void* user_data) +PROXY_GROUP_BLOCKING(telephony_state_changed_cb, some_enum state, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*thumbnail_extracted_cb)(some_enum error, const char* request_id, int thumb_width, int thumb_height, unsigned char* thumb_data, int thumb_size, void* user_data); +#define CB_PARAMS_NAMES error, request_id, thumb_width, thumb_height, thumb_data, thumb_size, user_data +PROXY_GROUP_NON_BLOCKING(thumbnail_extracted_cb, some_enum error, const char* request_id, int thumb_width, int thumb_height, unsigned char* thumb_data, int thumb_size, void* user_data) +PROXY_GROUP_BLOCKING(thumbnail_extracted_cb, some_enum error, const char* request_id, int thumb_width, int thumb_height, unsigned char* thumb_data, int thumb_size, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*tts_default_voice_changed_cb)(void* tts, const char* previous_language, int previous_voice_type, const char* current_language, int current_voice_type, void* user_data); +#define CB_PARAMS_NAMES tts, previous_language, previous_voice_type, current_language, current_voice_type, user_data +PROXY_GROUP_NON_BLOCKING(tts_default_voice_changed_cb, void* tts, const char* previous_language, int previous_voice_type, const char* current_language, int current_voice_type, void* user_data) +PROXY_GROUP_BLOCKING(tts_default_voice_changed_cb, void* tts, const char* previous_language, int previous_voice_type, const char* current_language, int current_voice_type, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*tts_engine_changed_cb)(void* tts, const char* engine_id, const char* language, int voice_type, bool need_credential, void* user_data); +#define CB_PARAMS_NAMES tts, engine_id, language, voice_type, need_credential, user_data +PROXY_GROUP_NON_BLOCKING(tts_engine_changed_cb, void* tts, const char* engine_id, const char* language, int voice_type, bool need_credential, void* user_data) +PROXY_GROUP_BLOCKING(tts_engine_changed_cb, void* tts, const char* engine_id, const char* language, int voice_type, bool need_credential, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*tts_error_cb)(void* tts, int utt_id, some_enum reason, void* user_data); +#define CB_PARAMS_NAMES tts, utt_id, reason, user_data +PROXY_GROUP_NON_BLOCKING(tts_error_cb, void* tts, int utt_id, some_enum reason, void* user_data) +PROXY_GROUP_BLOCKING(tts_error_cb, void* tts, int utt_id, some_enum reason, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*tts_screen_reader_changed_cb)(void* tts, bool is_on, void* user_data); +#define CB_PARAMS_NAMES tts, is_on, user_data +PROXY_GROUP_NON_BLOCKING(tts_screen_reader_changed_cb, void* tts, bool is_on, void* user_data) +PROXY_GROUP_BLOCKING(tts_screen_reader_changed_cb, void* tts, bool is_on, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*tts_service_state_changed_cb)(void* tts, some_enum previous, some_enum current, void* user_data); +#define CB_PARAMS_NAMES tts, previous, current, user_data +PROXY_GROUP_NON_BLOCKING(tts_service_state_changed_cb, void* tts, some_enum previous, some_enum current, void* user_data) +PROXY_GROUP_BLOCKING(tts_service_state_changed_cb, void* tts, some_enum previous, some_enum current, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*tts_state_changed_cb)(void* tts, some_enum previous, some_enum current, void* user_data); +#define CB_PARAMS_NAMES tts, previous, current, user_data +PROXY_GROUP_NON_BLOCKING(tts_state_changed_cb, void* tts, some_enum previous, some_enum current, void* user_data) +PROXY_GROUP_BLOCKING(tts_state_changed_cb, void* tts, some_enum previous, some_enum current, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*tts_supported_voice_cb)(void* tts, const char* language, int voice_type, void* user_data); +#define CB_PARAMS_NAMES tts, language, voice_type, user_data +PROXY_GROUP_RETURN(tts_supported_voice_cb, bool, void* tts, const char* language, int voice_type, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*tts_utterance_completed_cb)(void* tts, int utt_id, void* user_data); +#define CB_PARAMS_NAMES tts, utt_id, user_data +PROXY_GROUP_NON_BLOCKING(tts_utterance_completed_cb, void* tts, int utt_id, void* user_data) +PROXY_GROUP_BLOCKING(tts_utterance_completed_cb, void* tts, int utt_id, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*tts_utterance_started_cb)(void* tts, int utt_id, void* user_data); +#define CB_PARAMS_NAMES tts, utt_id, user_data +PROXY_GROUP_NON_BLOCKING(tts_utterance_started_cb, void* tts, int utt_id, void* user_data) +PROXY_GROUP_BLOCKING(tts_utterance_started_cb, void* tts, int utt_id, void* user_data) +#undef CB_PARAMS_NAMES + +#define BASE_CALLBACK_ID_ttse_activated_mode_changed_cb 95 +typedef void (*ttse_activated_mode_changed_cb)(int activated_mode); +#define CB_PARAMS_NAMES activated_mode +PROXY_GROUP_NON_BLOCKING_NO_USER_DATA(ttse_activated_mode_changed_cb, int activated_mode) +PROXY_GROUP_BLOCKING_NO_USER_DATA(ttse_activated_mode_changed_cb, int activated_mode) +#undef CB_PARAMS_NAMES + +#define BASE_CALLBACK_ID_ttse_cancel_synthesis_cb 100 +typedef int (*ttse_cancel_synthesis_cb)(); +PROXY_GROUP_RETURN_NO_USER_DATA_NO_PARAM(ttse_cancel_synthesis_cb, int) + +#define BASE_CALLBACK_ID_ttse_check_app_agreed_cb 105 +typedef int (*ttse_check_app_agreed_cb)(const char* appid, bool* is_agreed); +#define CB_PARAMS_NAMES appid, is_agreed +PROXY_GROUP_RETURN_NO_USER_DATA(ttse_check_app_agreed_cb, int, const char* appid, bool* is_agreed) +#undef CB_PARAMS_NAMES + +#define BASE_CALLBACK_ID_ttse_deinitialize_cb 110 +typedef int (*ttse_deinitialize_cb)(); +PROXY_GROUP_RETURN_NO_USER_DATA_NO_PARAM(ttse_deinitialize_cb, int) + +typedef int (*ttse_foreach_supported_voices_cb)(void* callback, void* user_data); +#define CB_PARAMS_NAMES callback, user_data +PROXY_GROUP_RETURN(ttse_foreach_supported_voices_cb, int, void* callback, void* user_data) +#undef CB_PARAMS_NAMES + +#define BASE_CALLBACK_ID_ttse_get_info_cb 115 +typedef int (*ttse_get_info_cb)(char** engine_uuid, char** engine_name, char** engine_setting, bool* use_network); +#define CB_PARAMS_NAMES engine_uuid, engine_name, engine_setting, use_network +PROXY_GROUP_RETURN_NO_USER_DATA(ttse_get_info_cb, int, char** engine_uuid, char** engine_name, char** engine_setting, bool* use_network) +#undef CB_PARAMS_NAMES + +#define BASE_CALLBACK_ID_ttse_initialize_cb 120 +typedef int (*ttse_initialize_cb)(); +PROXY_GROUP_RETURN_NO_USER_DATA_NO_PARAM(ttse_initialize_cb, int) + +#define BASE_CALLBACK_ID_ttse_is_valid_voice_cb 125 +typedef int (*ttse_is_valid_voice_cb)(const char* language, int type, bool* is_valid); +#define CB_PARAMS_NAMES language, type, is_valid +PROXY_GROUP_RETURN_NO_USER_DATA(ttse_is_valid_voice_cb, int, const char* language, int type, bool* is_valid) +#undef CB_PARAMS_NAMES + +#define BASE_CALLBACK_ID_ttse_load_voice_cb 130 +typedef int (*ttse_load_voice_cb)(const char* language, int type); +#define CB_PARAMS_NAMES language, type +PROXY_GROUP_RETURN_NO_USER_DATA(ttse_load_voice_cb, int, const char* language, int type) +#undef CB_PARAMS_NAMES + +#define BASE_CALLBACK_ID_ttse_need_app_credential_cb 135 +typedef bool (*ttse_need_app_credential_cb)(); +PROXY_GROUP_RETURN_NO_USER_DATA_NO_PARAM(ttse_need_app_credential_cb, bool) + +#define BASE_CALLBACK_ID_ttse_private_data_requested_cb 140 +typedef int (*ttse_private_data_requested_cb)(const char* key, char** data); +#define CB_PARAMS_NAMES key, data +PROXY_GROUP_RETURN_NO_USER_DATA(ttse_private_data_requested_cb, int, const char* key, char** data) +#undef CB_PARAMS_NAMES + +#define BASE_CALLBACK_ID_ttse_private_data_set_cb 145 +typedef int (*ttse_private_data_set_cb)(const char* key, const char* data); +#define CB_PARAMS_NAMES key, data +PROXY_GROUP_RETURN_NO_USER_DATA(ttse_private_data_set_cb, int, const char* key, const char* data) +#undef CB_PARAMS_NAMES + +#define BASE_CALLBACK_ID_ttse_set_pitch_cb 150 +typedef int (*ttse_set_pitch_cb)(int pitch); +#define CB_PARAMS_NAMES pitch +PROXY_GROUP_RETURN_NO_USER_DATA(ttse_set_pitch_cb, int, int pitch) +#undef CB_PARAMS_NAMES + +typedef int (*ttse_start_synthesis_cb)(const char* language, int type, const char* text, int speed, const char* appid, const char* credential, void* user_data); +#define CB_PARAMS_NAMES language, type, text, speed, appid, credential, user_data +PROXY_GROUP_RETURN(ttse_start_synthesis_cb, int, const char* language, int type, const char* text, int speed, const char* appid, const char* credential, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*ttse_supported_voice_cb)(const char* language, int type, void* user_data); +#define CB_PARAMS_NAMES language, type, user_data +PROXY_GROUP_RETURN(ttse_supported_voice_cb, bool, const char* language, int type, void* user_data) +#undef CB_PARAMS_NAMES + +#define BASE_CALLBACK_ID_ttse_unload_voice_cb 155 +typedef int (*ttse_unload_voice_cb)(const char* language, int type); +#define CB_PARAMS_NAMES language, type +PROXY_GROUP_RETURN_NO_USER_DATA(ttse_unload_voice_cb, int, const char* language, int type) +#undef CB_PARAMS_NAMES + +typedef void (*usb_host_hotplug_cb)(void* dev, void* user_data); +#define CB_PARAMS_NAMES dev, user_data +PROXY_GROUP_NON_BLOCKING(usb_host_hotplug_cb, void* dev, void* user_data) +PROXY_GROUP_BLOCKING(usb_host_hotplug_cb, void* dev, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*usb_host_transferred_cb)(void* transfer, void* user_data); +#define CB_PARAMS_NAMES transfer, user_data +PROXY_GROUP_NON_BLOCKING(usb_host_transferred_cb, void* transfer, void* user_data) +PROXY_GROUP_BLOCKING(usb_host_transferred_cb, void* transfer, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*vc_mgr_all_result_cb)(some_enum event, void* vc_cmd_list, const char* result, const char* msg, void* user_data); +#define CB_PARAMS_NAMES event, vc_cmd_list, result, msg, user_data +PROXY_GROUP_RETURN(vc_mgr_all_result_cb, bool, some_enum event, void* vc_cmd_list, const char* result, const char* msg, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*vc_mgr_begin_speech_detected_cb)(void* user_data); +#define CB_PARAMS_NAMES user_data +PROXY_GROUP_NON_BLOCKING(vc_mgr_begin_speech_detected_cb, void* user_data) +PROXY_GROUP_BLOCKING(vc_mgr_begin_speech_detected_cb, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*vc_mgr_dialog_request_cb)(int pid, const char* disp_text, const char* utt_text, bool continuous, void* user_data); +#define CB_PARAMS_NAMES pid, disp_text, utt_text, continuous, user_data +PROXY_GROUP_NON_BLOCKING(vc_mgr_dialog_request_cb, int pid, const char* disp_text, const char* utt_text, bool continuous, void* user_data) +PROXY_GROUP_BLOCKING(vc_mgr_dialog_request_cb, int pid, const char* disp_text, const char* utt_text, bool continuous, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*vc_mgr_feedback_audio_format_cb)(int rate, some_enum channel, some_enum audio_type, void* user_data); +#define CB_PARAMS_NAMES rate, channel, audio_type, user_data +PROXY_GROUP_NON_BLOCKING(vc_mgr_feedback_audio_format_cb, int rate, some_enum channel, some_enum audio_type, void* user_data) +PROXY_GROUP_BLOCKING(vc_mgr_feedback_audio_format_cb, int rate, some_enum channel, some_enum audio_type, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*vc_mgr_feedback_streaming_cb)(some_enum event, char* buffer, int len, void* user_data); +#define CB_PARAMS_NAMES event, buffer, len, user_data +PROXY_GROUP_NON_BLOCKING(vc_mgr_feedback_streaming_cb, some_enum event, char* buffer, int len, void* user_data) +PROXY_GROUP_BLOCKING(vc_mgr_feedback_streaming_cb, some_enum event, char* buffer, int len, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*vc_mgr_pre_result_cb)(some_enum event, const char* result, void* user_data); +#define CB_PARAMS_NAMES event, result, user_data +PROXY_GROUP_NON_BLOCKING(vc_mgr_pre_result_cb, some_enum event, const char* result, void* user_data) +PROXY_GROUP_BLOCKING(vc_mgr_pre_result_cb, some_enum event, const char* result, void* user_data) +#undef CB_PARAMS_NAMES + +typedef int (*vc_mgr_private_data_requested_cb)(const char* key, char** data, void* user_data); +#define CB_PARAMS_NAMES key, data, user_data +PROXY_GROUP_RETURN(vc_mgr_private_data_requested_cb, int, const char* key, char** data, void* user_data) +#undef CB_PARAMS_NAMES + +typedef int (*vc_mgr_private_data_set_cb)(const char* key, const char* data, void* user_data); +#define CB_PARAMS_NAMES key, data, user_data +PROXY_GROUP_RETURN(vc_mgr_private_data_set_cb, int, const char* key, const char* data, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*vc_mgr_specific_engine_result_cb)(const char* engine_app_id, const char* event, const char* result, void* user_data); +#define CB_PARAMS_NAMES engine_app_id, event, result, user_data +PROXY_GROUP_NON_BLOCKING(vc_mgr_specific_engine_result_cb, const char* engine_app_id, const char* event, const char* result, void* user_data) +PROXY_GROUP_BLOCKING(vc_mgr_specific_engine_result_cb, const char* engine_app_id, const char* event, const char* result, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*vc_mgr_vc_tts_streaming_cb)(int pid, int utt_id, some_enum event, char* buffer, int len, void* user_data); +#define CB_PARAMS_NAMES pid, utt_id, event, buffer, len, user_data +PROXY_GROUP_NON_BLOCKING(vc_mgr_vc_tts_streaming_cb, int pid, int utt_id, some_enum event, char* buffer, int len, void* user_data) +PROXY_GROUP_BLOCKING(vc_mgr_vc_tts_streaming_cb, int pid, int utt_id, some_enum event, char* buffer, int len, void* user_data) +#undef CB_PARAMS_NAMES + +#define BASE_CALLBACK_ID_vce_cancel_cb 160 +typedef int (*vce_cancel_cb)(); +PROXY_GROUP_RETURN_NO_USER_DATA_NO_PARAM(vce_cancel_cb, int) + +typedef int (*vce_cancel_tts_cb)(int pid, int utt_id, void* user_data); +#define CB_PARAMS_NAMES pid, utt_id, user_data +PROXY_GROUP_RETURN(vce_cancel_tts_cb, int, int pid, int utt_id, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*vce_command_cb)(int id, int type, int format, const char* command, const char* param, int domain, void* user_data); +#define CB_PARAMS_NAMES id, type, format, command, param, domain, user_data +PROXY_GROUP_RETURN(vce_command_cb, bool, int id, int type, int format, const char* command, const char* param, int domain, void* user_data) +#undef CB_PARAMS_NAMES + +#define BASE_CALLBACK_ID_vce_deinitialize_cb 165 +typedef int (*vce_deinitialize_cb)(); +PROXY_GROUP_RETURN_NO_USER_DATA_NO_PARAM(vce_deinitialize_cb, int) + +typedef int (*vce_foreach_supported_languages_cb)(void* callback, void* user_data); +#define CB_PARAMS_NAMES callback, user_data +PROXY_GROUP_RETURN(vce_foreach_supported_languages_cb, int, void* callback, void* user_data) +#undef CB_PARAMS_NAMES + +#define BASE_CALLBACK_ID_vce_get_info_cb 170 +typedef int (*vce_get_info_cb)(char** engine_uuid, char** engine_name, char** engine_settings_app_id, bool* use_network); +#define CB_PARAMS_NAMES engine_uuid, engine_name, engine_settings_app_id, use_network +PROXY_GROUP_RETURN_NO_USER_DATA(vce_get_info_cb, int, char** engine_uuid, char** engine_name, char** engine_settings_app_id, bool* use_network) +#undef CB_PARAMS_NAMES + +#define BASE_CALLBACK_ID_vce_get_recording_format_cb 175 +typedef int (*vce_get_recording_format_cb)(const char* audio_id, void* types, int* rate, int* channels); +#define CB_PARAMS_NAMES audio_id, types, rate, channels +PROXY_GROUP_RETURN_NO_USER_DATA(vce_get_recording_format_cb, int, const char* audio_id, void* types, int* rate, int* channels) +#undef CB_PARAMS_NAMES + +#define BASE_CALLBACK_ID_vce_initialize_cb 180 +typedef int (*vce_initialize_cb)(); +PROXY_GROUP_RETURN_NO_USER_DATA_NO_PARAM(vce_initialize_cb, int) + +#define BASE_CALLBACK_ID_vce_is_language_supported_cb 185 +typedef bool (*vce_is_language_supported_cb)(const char* language); +#define CB_PARAMS_NAMES language +PROXY_GROUP_RETURN_NO_USER_DATA(vce_is_language_supported_cb, bool, const char* language) +#undef CB_PARAMS_NAMES + +#define BASE_CALLBACK_ID_vce_nlu_base_info_requested_cb 190 +typedef int (*vce_nlu_base_info_requested_cb)(const char* key, char** value); +#define CB_PARAMS_NAMES key, value +PROXY_GROUP_RETURN_NO_USER_DATA(vce_nlu_base_info_requested_cb, int, const char* key, char** value) +#undef CB_PARAMS_NAMES + +#define BASE_CALLBACK_ID_vce_private_data_requested_cb 195 +typedef int (*vce_private_data_requested_cb)(const char* key, char** data); +#define CB_PARAMS_NAMES key, data +PROXY_GROUP_RETURN_NO_USER_DATA(vce_private_data_requested_cb, int, const char* key, char** data) +#undef CB_PARAMS_NAMES + +#define BASE_CALLBACK_ID_vce_private_data_set_cb 200 +typedef int (*vce_private_data_set_cb)(const char* key, const char* data); +#define CB_PARAMS_NAMES key, data +PROXY_GROUP_RETURN_NO_USER_DATA(vce_private_data_set_cb, int, const char* key, const char* data) +#undef CB_PARAMS_NAMES + +#define BASE_CALLBACK_ID_vce_process_haptic_event_cb 205 +typedef int (*vce_process_haptic_event_cb)(const char* event); +#define CB_PARAMS_NAMES event +PROXY_GROUP_RETURN_NO_USER_DATA(vce_process_haptic_event_cb, int, const char* event) +#undef CB_PARAMS_NAMES + +#define BASE_CALLBACK_ID_vce_process_list_event_cb 210 +typedef int (*vce_process_list_event_cb)(const char* event); +#define CB_PARAMS_NAMES event +PROXY_GROUP_RETURN_NO_USER_DATA(vce_process_list_event_cb, int, const char* event) +#undef CB_PARAMS_NAMES + +#define BASE_CALLBACK_ID_vce_process_text_cb 215 +typedef int (*vce_process_text_cb)(const char* text); +#define CB_PARAMS_NAMES text +PROXY_GROUP_RETURN_NO_USER_DATA(vce_process_text_cb, int, const char* text) +#undef CB_PARAMS_NAMES + +typedef int (*vce_request_tts_cb)(int pid, int utt_id, const char* text, const char* language, void* user_data); +#define CB_PARAMS_NAMES pid, utt_id, text, language, user_data +PROXY_GROUP_RETURN(vce_request_tts_cb, int, int pid, int utt_id, const char* text, const char* language, void* user_data) +#undef CB_PARAMS_NAMES + +#define BASE_CALLBACK_ID_vce_set_audio_type_cb 220 +typedef int (*vce_set_audio_type_cb)(const char* audio_type); +#define CB_PARAMS_NAMES audio_type +PROXY_GROUP_RETURN_NO_USER_DATA(vce_set_audio_type_cb, int, const char* audio_type) +#undef CB_PARAMS_NAMES + +#define BASE_CALLBACK_ID_vce_set_commands_cb 225 +typedef int (*vce_set_commands_cb)(void* vc_command); +#define CB_PARAMS_NAMES vc_command +PROXY_GROUP_RETURN_NO_USER_DATA(vce_set_commands_cb, int, void* vc_command) +#undef CB_PARAMS_NAMES + +#define BASE_CALLBACK_ID_vce_set_domain_cb 230 +typedef int (*vce_set_domain_cb)(const char* domain); +#define CB_PARAMS_NAMES domain +PROXY_GROUP_RETURN_NO_USER_DATA(vce_set_domain_cb, int, const char* domain) +#undef CB_PARAMS_NAMES + +#define BASE_CALLBACK_ID_vce_set_language_cb 235 +typedef int (*vce_set_language_cb)(const char* language); +#define CB_PARAMS_NAMES language +PROXY_GROUP_RETURN_NO_USER_DATA(vce_set_language_cb, int, const char* language) +#undef CB_PARAMS_NAMES + +#define BASE_CALLBACK_ID_vce_set_recording_data_cb 240 +typedef int (*vce_set_recording_data_cb)(const void* data, unsigned int length, void* speech_detected); +#define CB_PARAMS_NAMES data, length, speech_detected +PROXY_GROUP_RETURN_NO_USER_DATA(vce_set_recording_data_cb, int, const void* data, unsigned int length, void* speech_detected) +#undef CB_PARAMS_NAMES + +#define BASE_CALLBACK_ID_vce_set_server_dialog_cb 245 +typedef int (*vce_set_server_dialog_cb)(const char* app_id, const char* credential); +#define CB_PARAMS_NAMES app_id, credential +PROXY_GROUP_RETURN_NO_USER_DATA(vce_set_server_dialog_cb, int, const char* app_id, const char* credential) +#undef CB_PARAMS_NAMES + +#define BASE_CALLBACK_ID_vce_specific_engine_request_cb 250 +typedef int (*vce_specific_engine_request_cb)(const char* engine_app_id, const char* event, const char* request); +#define CB_PARAMS_NAMES engine_app_id, event, request +PROXY_GROUP_RETURN_NO_USER_DATA(vce_specific_engine_request_cb, int, const char* engine_app_id, const char* event, const char* request) +#undef CB_PARAMS_NAMES + +#define BASE_CALLBACK_ID_vce_start_cb 255 +typedef int (*vce_start_cb)(bool stop_by_silence); +#define CB_PARAMS_NAMES stop_by_silence +PROXY_GROUP_RETURN_NO_USER_DATA(vce_start_cb, int, bool stop_by_silence) +#undef CB_PARAMS_NAMES + +#define BASE_CALLBACK_ID_vce_stop_cb 260 +typedef int (*vce_stop_cb)(); +PROXY_GROUP_RETURN_NO_USER_DATA_NO_PARAM(vce_stop_cb, int) + +typedef bool (*vce_supported_language_cb)(const char* language, void* user_data); +#define CB_PARAMS_NAMES language, user_data +PROXY_GROUP_RETURN(vce_supported_language_cb, bool, const char* language, void* user_data) +#undef CB_PARAMS_NAMES + +typedef int (*vce_tts_audio_format_request_cb)(int* rate, int* channel, int* audio_type, void* user_data); +#define CB_PARAMS_NAMES rate, channel, audio_type, user_data +PROXY_GROUP_RETURN(vce_tts_audio_format_request_cb, int, int* rate, int* channel, int* audio_type, void* user_data) +#undef CB_PARAMS_NAMES + +#define BASE_CALLBACK_ID_vce_unset_commands_cb 265 +typedef int (*vce_unset_commands_cb)(); +PROXY_GROUP_RETURN_NO_USER_DATA_NO_PARAM(vce_unset_commands_cb, int) + +typedef bool (*video_util_supported_audio_encoder_cb)(some_enum codec, void* user_data); +#define CB_PARAMS_NAMES codec, user_data +PROXY_GROUP_RETURN(video_util_supported_audio_encoder_cb, bool, some_enum codec, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*video_util_supported_file_format_cb)(some_enum format, void* user_data); +#define CB_PARAMS_NAMES format, user_data +PROXY_GROUP_RETURN(video_util_supported_file_format_cb, bool, some_enum format, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*video_util_supported_video_encoder_cb)(some_enum codec, void* user_data); +#define CB_PARAMS_NAMES codec, user_data +PROXY_GROUP_RETURN(video_util_supported_video_encoder_cb, bool, some_enum codec, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*video_util_transcoding_completed_cb)(some_enum error_code, void* user_data); +#define CB_PARAMS_NAMES error_code, user_data +PROXY_GROUP_NON_BLOCKING(video_util_transcoding_completed_cb, some_enum error_code, void* user_data) +PROXY_GROUP_BLOCKING(video_util_transcoding_completed_cb, some_enum error_code, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*video_util_transcoding_progress_cb)(unsigned long current_position, unsigned long duration, void* user_data); +#define CB_PARAMS_NAMES current_position, duration, user_data +PROXY_GROUP_NON_BLOCKING(video_util_transcoding_progress_cb, unsigned long current_position, unsigned long duration, void* user_data) +PROXY_GROUP_BLOCKING(video_util_transcoding_progress_cb, unsigned long current_position, unsigned long duration, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*wav_player_playback_completed_cb)(int id, void* user_data); +#define CB_PARAMS_NAMES id, user_data +PROXY_GROUP_NON_BLOCKING(wav_player_playback_completed_cb, int id, void* user_data) +PROXY_GROUP_BLOCKING(wav_player_playback_completed_cb, int id, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*webrtc_data_channel_buffered_amount_low_cb)(void* channel, void* user_data); +#define CB_PARAMS_NAMES channel, user_data +PROXY_GROUP_NON_BLOCKING(webrtc_data_channel_buffered_amount_low_cb, void* channel, void* user_data) +PROXY_GROUP_BLOCKING(webrtc_data_channel_buffered_amount_low_cb, void* channel, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*webrtc_data_channel_cb)(void* webrtc, void* channel, void* user_data); +#define CB_PARAMS_NAMES webrtc, channel, user_data +PROXY_GROUP_NON_BLOCKING(webrtc_data_channel_cb, void* webrtc, void* channel, void* user_data) +PROXY_GROUP_BLOCKING(webrtc_data_channel_cb, void* webrtc, void* channel, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*webrtc_data_channel_close_cb)(void* channel, void* user_data); +#define CB_PARAMS_NAMES channel, user_data +PROXY_GROUP_NON_BLOCKING(webrtc_data_channel_close_cb, void* channel, void* user_data) +PROXY_GROUP_BLOCKING(webrtc_data_channel_close_cb, void* channel, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*webrtc_data_channel_error_cb)(void* channel, some_enum error, void* user_data); +#define CB_PARAMS_NAMES channel, error, user_data +PROXY_GROUP_NON_BLOCKING(webrtc_data_channel_error_cb, void* channel, some_enum error, void* user_data) +PROXY_GROUP_BLOCKING(webrtc_data_channel_error_cb, void* channel, some_enum error, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*webrtc_data_channel_message_cb)(void* channel, some_enum type, void* message, void* user_data); +#define CB_PARAMS_NAMES channel, type, message, user_data +PROXY_GROUP_NON_BLOCKING(webrtc_data_channel_message_cb, void* channel, some_enum type, void* message, void* user_data) +PROXY_GROUP_BLOCKING(webrtc_data_channel_message_cb, void* channel, some_enum type, void* message, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*webrtc_data_channel_open_cb)(void* channel, void* user_data); +#define CB_PARAMS_NAMES channel, user_data +PROXY_GROUP_NON_BLOCKING(webrtc_data_channel_open_cb, void* channel, void* user_data) +PROXY_GROUP_BLOCKING(webrtc_data_channel_open_cb, void* channel, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*webrtc_encoded_frame_cb)(void* webrtc, some_enum type, unsigned int track_id, void* packet, void* user_data); +#define CB_PARAMS_NAMES webrtc, type, track_id, packet, user_data +PROXY_GROUP_NON_BLOCKING(webrtc_encoded_frame_cb, void* webrtc, some_enum type, unsigned int track_id, void* packet, void* user_data) +PROXY_GROUP_BLOCKING(webrtc_encoded_frame_cb, void* webrtc, some_enum type, unsigned int track_id, void* packet, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*webrtc_error_cb)(void* webrtc, some_enum error, some_enum state, void* user_data); +#define CB_PARAMS_NAMES webrtc, error, state, user_data +PROXY_GROUP_NON_BLOCKING(webrtc_error_cb, void* webrtc, some_enum error, some_enum state, void* user_data) +PROXY_GROUP_BLOCKING(webrtc_error_cb, void* webrtc, some_enum error, some_enum state, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*webrtc_ice_candidate_cb)(void* webrtc, const char* candidate, void* user_data); +#define CB_PARAMS_NAMES webrtc, candidate, user_data +PROXY_GROUP_NON_BLOCKING(webrtc_ice_candidate_cb, void* webrtc, const char* candidate, void* user_data) +PROXY_GROUP_BLOCKING(webrtc_ice_candidate_cb, void* webrtc, const char* candidate, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*webrtc_ice_connection_state_change_cb)(void* webrtc, some_enum state, void* user_data); +#define CB_PARAMS_NAMES webrtc, state, user_data +PROXY_GROUP_NON_BLOCKING(webrtc_ice_connection_state_change_cb, void* webrtc, some_enum state, void* user_data) +PROXY_GROUP_BLOCKING(webrtc_ice_connection_state_change_cb, void* webrtc, some_enum state, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*webrtc_ice_gathering_state_change_cb)(void* webrtc, some_enum state, void* user_data); +#define CB_PARAMS_NAMES webrtc, state, user_data +PROXY_GROUP_NON_BLOCKING(webrtc_ice_gathering_state_change_cb, void* webrtc, some_enum state, void* user_data) +PROXY_GROUP_BLOCKING(webrtc_ice_gathering_state_change_cb, void* webrtc, some_enum state, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*webrtc_media_packet_source_buffer_state_changed_cb)(unsigned int source_id, some_enum state, void* user_data); +#define CB_PARAMS_NAMES source_id, state, user_data +PROXY_GROUP_NON_BLOCKING(webrtc_media_packet_source_buffer_state_changed_cb, unsigned int source_id, some_enum state, void* user_data) +PROXY_GROUP_BLOCKING(webrtc_media_packet_source_buffer_state_changed_cb, unsigned int source_id, some_enum state, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*webrtc_media_source_supported_transceiver_codec_cb)(some_enum codec, void* user_data); +#define CB_PARAMS_NAMES codec, user_data +PROXY_GROUP_RETURN(webrtc_media_source_supported_transceiver_codec_cb, bool, some_enum codec, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*webrtc_negotiation_needed_cb)(void* webrtc, void* user_data); +#define CB_PARAMS_NAMES webrtc, user_data +PROXY_GROUP_NON_BLOCKING(webrtc_negotiation_needed_cb, void* webrtc, void* user_data) +PROXY_GROUP_BLOCKING(webrtc_negotiation_needed_cb, void* webrtc, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*webrtc_peer_connection_state_change_cb)(void* webrtc, some_enum state, void* user_data); +#define CB_PARAMS_NAMES webrtc, state, user_data +PROXY_GROUP_NON_BLOCKING(webrtc_peer_connection_state_change_cb, void* webrtc, some_enum state, void* user_data) +PROXY_GROUP_BLOCKING(webrtc_peer_connection_state_change_cb, void* webrtc, some_enum state, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*webrtc_session_description_created_cb)(void* webrtc, const char* description, void* user_data); +#define CB_PARAMS_NAMES webrtc, description, user_data +PROXY_GROUP_NON_BLOCKING(webrtc_session_description_created_cb, void* webrtc, const char* description, void* user_data) +PROXY_GROUP_BLOCKING(webrtc_session_description_created_cb, void* webrtc, const char* description, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*webrtc_signaling_state_change_cb)(void* webrtc, some_enum state, void* user_data); +#define CB_PARAMS_NAMES webrtc, state, user_data +PROXY_GROUP_NON_BLOCKING(webrtc_signaling_state_change_cb, void* webrtc, some_enum state, void* user_data) +PROXY_GROUP_BLOCKING(webrtc_signaling_state_change_cb, void* webrtc, some_enum state, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*webrtc_state_changed_cb)(void* webrtc, some_enum previous, some_enum current, void* user_data); +#define CB_PARAMS_NAMES webrtc, previous, current, user_data +PROXY_GROUP_NON_BLOCKING(webrtc_state_changed_cb, void* webrtc, some_enum previous, some_enum current, void* user_data) +PROXY_GROUP_BLOCKING(webrtc_state_changed_cb, void* webrtc, some_enum previous, some_enum current, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*webrtc_stats_cb)(some_enum type, const void* prop_info, void* user_data); +#define CB_PARAMS_NAMES type, prop_info, user_data +PROXY_GROUP_RETURN(webrtc_stats_cb, bool, some_enum type, const void* prop_info, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*webrtc_track_added_cb)(void* webrtc, some_enum type, unsigned int track_id, void* user_data); +#define CB_PARAMS_NAMES webrtc, type, track_id, user_data +PROXY_GROUP_NON_BLOCKING(webrtc_track_added_cb, void* webrtc, some_enum type, unsigned int track_id, void* user_data) +PROXY_GROUP_BLOCKING(webrtc_track_added_cb, void* webrtc, some_enum type, unsigned int track_id, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*webrtc_turn_server_cb)(const char* turn_server, void* user_data); +#define CB_PARAMS_NAMES turn_server, user_data +PROXY_GROUP_RETURN(webrtc_turn_server_cb, bool, const char* turn_server, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*wifi_direct_client_ip_address_assigned_cb)(const char* mac_address, const char* ip_address, const char* interface_address, void* user_data); +#define CB_PARAMS_NAMES mac_address, ip_address, interface_address, user_data +PROXY_GROUP_NON_BLOCKING(wifi_direct_client_ip_address_assigned_cb, const char* mac_address, const char* ip_address, const char* interface_address, void* user_data) +PROXY_GROUP_BLOCKING(wifi_direct_client_ip_address_assigned_cb, const char* mac_address, const char* ip_address, const char* interface_address, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*wifi_direct_connected_peer_cb)(void* peer, void* user_data); +#define CB_PARAMS_NAMES peer, user_data +PROXY_GROUP_RETURN(wifi_direct_connected_peer_cb, bool, void* peer, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*wifi_direct_connection_state_changed_cb)(int error_code, some_enum connection_state, const char* mac_address, void* user_data); +#define CB_PARAMS_NAMES error_code, connection_state, mac_address, user_data +PROXY_GROUP_NON_BLOCKING(wifi_direct_connection_state_changed_cb, int error_code, some_enum connection_state, const char* mac_address, void* user_data) +PROXY_GROUP_BLOCKING(wifi_direct_connection_state_changed_cb, int error_code, some_enum connection_state, const char* mac_address, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*wifi_direct_device_state_changed_cb)(int error_code, some_enum device_state, void* user_data); +#define CB_PARAMS_NAMES error_code, device_state, user_data +PROXY_GROUP_NON_BLOCKING(wifi_direct_device_state_changed_cb, int error_code, some_enum device_state, void* user_data) +PROXY_GROUP_BLOCKING(wifi_direct_device_state_changed_cb, int error_code, some_enum device_state, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*wifi_direct_discovered_peer_cb)(void* peer, void* user_data); +#define CB_PARAMS_NAMES peer, user_data +PROXY_GROUP_RETURN(wifi_direct_discovered_peer_cb, bool, void* peer, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*wifi_direct_discovery_state_chagned_cb)(int error_code, some_enum discovery_state, void* user_data); +#define CB_PARAMS_NAMES error_code, discovery_state, user_data +PROXY_GROUP_NON_BLOCKING(wifi_direct_discovery_state_chagned_cb, int error_code, some_enum discovery_state, void* user_data) +PROXY_GROUP_BLOCKING(wifi_direct_discovery_state_chagned_cb, int error_code, some_enum discovery_state, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*wifi_direct_peer_found_cb)(int error_code, some_enum discovery_state, const char* mac_address, void* user_data); +#define CB_PARAMS_NAMES error_code, discovery_state, mac_address, user_data +PROXY_GROUP_NON_BLOCKING(wifi_direct_peer_found_cb, int error_code, some_enum discovery_state, const char* mac_address, void* user_data) +PROXY_GROUP_BLOCKING(wifi_direct_peer_found_cb, int error_code, some_enum discovery_state, const char* mac_address, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*wifi_direct_peer_info_connection_state_changed_cb)(some_enum error_code, some_enum connection_state, wifi_direct_connection_state_cb_data_s_copy data_s, void* user_data); +#define CB_PARAMS_NAMES error_code, connection_state, data_s, user_data +PROXY_GROUP_NON_BLOCKING(wifi_direct_peer_info_connection_state_changed_cb, some_enum error_code, some_enum connection_state, wifi_direct_connection_state_cb_data_s_copy data_s, void* user_data) +PROXY_GROUP_BLOCKING(wifi_direct_peer_info_connection_state_changed_cb, some_enum error_code, some_enum connection_state, wifi_direct_connection_state_cb_data_s_copy data_s, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*wifi_direct_persistent_group_cb)(const char* mac_address, const char* ssid, void* user_data); +#define CB_PARAMS_NAMES mac_address, ssid, user_data +PROXY_GROUP_RETURN(wifi_direct_persistent_group_cb, bool, const char* mac_address, const char* ssid, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*wifi_direct_service_state_changed_cb)(int error_code, some_enum service_state, some_enum service_type, void* response_data, const char* mac_address, void* user_data); +#define CB_PARAMS_NAMES error_code, service_state, service_type, response_data, mac_address, user_data +PROXY_GROUP_NON_BLOCKING(wifi_direct_service_state_changed_cb, int error_code, some_enum service_state, some_enum service_type, void* response_data, const char* mac_address, void* user_data) +PROXY_GROUP_BLOCKING(wifi_direct_service_state_changed_cb, int error_code, some_enum service_state, some_enum service_type, void* response_data, const char* mac_address, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*wifi_direct_state_changed_cb)(some_enum state, void* user_data); +#define CB_PARAMS_NAMES state, user_data +PROXY_GROUP_NON_BLOCKING(wifi_direct_state_changed_cb, some_enum state, void* user_data) +PROXY_GROUP_BLOCKING(wifi_direct_state_changed_cb, some_enum state, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*wifi_direct_supported_wps_type_cb)(some_enum type, void* user_data); +#define CB_PARAMS_NAMES type, user_data +PROXY_GROUP_RETURN(wifi_direct_supported_wps_type_cb, bool, some_enum type, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*wifi_manager_activated_cb)(some_enum result, void* user_data); +#define CB_PARAMS_NAMES result, user_data +PROXY_GROUP_NON_BLOCKING(wifi_manager_activated_cb, some_enum result, void* user_data) +PROXY_GROUP_BLOCKING(wifi_manager_activated_cb, some_enum result, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*wifi_manager_ap_ipv6_address_cb)(char* ipv6_address, void* user_data); +#define CB_PARAMS_NAMES ipv6_address, user_data +PROXY_GROUP_RETURN(wifi_manager_ap_ipv6_address_cb, bool, char* ipv6_address, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*wifi_manager_ap_vsie_cb)(unsigned char* vsie, int length, void* user_data); +#define CB_PARAMS_NAMES vsie, length, user_data +PROXY_GROUP_RETURN(wifi_manager_ap_vsie_cb, bool, unsigned char* vsie, int length, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*wifi_manager_bssid_scan_finished_cb)(some_enum error_code, void* user_data); +#define CB_PARAMS_NAMES error_code, user_data +PROXY_GROUP_NON_BLOCKING(wifi_manager_bssid_scan_finished_cb, some_enum error_code, void* user_data) +PROXY_GROUP_BLOCKING(wifi_manager_bssid_scan_finished_cb, some_enum error_code, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*wifi_manager_config_list_cb)(const void* config, void* user_data); +#define CB_PARAMS_NAMES config, user_data +PROXY_GROUP_RETURN(wifi_manager_config_list_cb, bool, const void* config, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*wifi_manager_connected_cb)(some_enum result, void* user_data); +#define CB_PARAMS_NAMES result, user_data +PROXY_GROUP_NON_BLOCKING(wifi_manager_connected_cb, some_enum result, void* user_data) +PROXY_GROUP_BLOCKING(wifi_manager_connected_cb, some_enum result, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*wifi_manager_connection_state_changed_cb)(some_enum state, void* ap, void* user_data); +#define CB_PARAMS_NAMES state, ap, user_data +PROXY_GROUP_NON_BLOCKING(wifi_manager_connection_state_changed_cb, some_enum state, void* ap, void* user_data) +PROXY_GROUP_BLOCKING(wifi_manager_connection_state_changed_cb, some_enum state, void* ap, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*wifi_manager_deactivated_cb)(some_enum result, void* user_data); +#define CB_PARAMS_NAMES result, user_data +PROXY_GROUP_NON_BLOCKING(wifi_manager_deactivated_cb, some_enum result, void* user_data) +PROXY_GROUP_BLOCKING(wifi_manager_deactivated_cb, some_enum result, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*wifi_manager_device_state_changed_cb)(some_enum state, void* user_data); +#define CB_PARAMS_NAMES state, user_data +PROXY_GROUP_NON_BLOCKING(wifi_manager_device_state_changed_cb, some_enum state, void* user_data) +PROXY_GROUP_BLOCKING(wifi_manager_device_state_changed_cb, some_enum state, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*wifi_manager_disconnected_cb)(some_enum result, void* user_data); +#define CB_PARAMS_NAMES result, user_data +PROXY_GROUP_NON_BLOCKING(wifi_manager_disconnected_cb, some_enum result, void* user_data) +PROXY_GROUP_BLOCKING(wifi_manager_disconnected_cb, some_enum result, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*wifi_manager_forget_ap_finished_cb)(some_enum result, void* user_data); +#define CB_PARAMS_NAMES result, user_data +PROXY_GROUP_NON_BLOCKING(wifi_manager_forget_ap_finished_cb, some_enum result, void* user_data) +PROXY_GROUP_BLOCKING(wifi_manager_forget_ap_finished_cb, some_enum result, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*wifi_manager_found_ap_cb)(void* ap, void* user_data); +#define CB_PARAMS_NAMES ap, user_data +PROXY_GROUP_RETURN(wifi_manager_found_ap_cb, bool, void* ap, void* user_data) +#undef CB_PARAMS_NAMES + +typedef bool (*wifi_manager_found_bssid_cb)(const char* bssid, int rssi, int freq, void* user_data); +#define CB_PARAMS_NAMES bssid, rssi, freq, user_data +PROXY_GROUP_RETURN(wifi_manager_found_bssid_cb, bool, const char* bssid, int rssi, int freq, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*wifi_manager_ip_conflict_cb)(char* mac, some_enum state, void* user_data); +#define CB_PARAMS_NAMES mac, state, user_data +PROXY_GROUP_NON_BLOCKING(wifi_manager_ip_conflict_cb, char* mac, some_enum state, void* user_data) +PROXY_GROUP_BLOCKING(wifi_manager_ip_conflict_cb, char* mac, some_enum state, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*wifi_manager_module_state_changed_cb)(some_enum wifi_module_state, void* user_data); +#define CB_PARAMS_NAMES wifi_module_state, user_data +PROXY_GROUP_NON_BLOCKING(wifi_manager_module_state_changed_cb, some_enum wifi_module_state, void* user_data) +PROXY_GROUP_BLOCKING(wifi_manager_module_state_changed_cb, some_enum wifi_module_state, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*wifi_manager_rssi_level_changed_cb)(some_enum rssi_level, void* user_data); +#define CB_PARAMS_NAMES rssi_level, user_data +PROXY_GROUP_NON_BLOCKING(wifi_manager_rssi_level_changed_cb, some_enum rssi_level, void* user_data) +PROXY_GROUP_BLOCKING(wifi_manager_rssi_level_changed_cb, some_enum rssi_level, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*wifi_manager_scan_finished_cb)(some_enum error_code, void* user_data); +#define CB_PARAMS_NAMES error_code, user_data +PROXY_GROUP_NON_BLOCKING(wifi_manager_scan_finished_cb, some_enum error_code, void* user_data) +PROXY_GROUP_BLOCKING(wifi_manager_scan_finished_cb, some_enum error_code, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*wifi_manager_scan_state_changed_cb)(some_enum state, void* user_data); +#define CB_PARAMS_NAMES state, user_data +PROXY_GROUP_NON_BLOCKING(wifi_manager_scan_state_changed_cb, some_enum state, void* user_data) +PROXY_GROUP_BLOCKING(wifi_manager_scan_state_changed_cb, some_enum state, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*wifi_manager_tdls_discovered_cb)(some_enum state, char* peer_mac_addr, void* user_data); +#define CB_PARAMS_NAMES state, peer_mac_addr, user_data +PROXY_GROUP_NON_BLOCKING(wifi_manager_tdls_discovered_cb, some_enum state, char* peer_mac_addr, void* user_data) +PROXY_GROUP_BLOCKING(wifi_manager_tdls_discovered_cb, some_enum state, char* peer_mac_addr, void* user_data) +#undef CB_PARAMS_NAMES + +typedef void (*wifi_manager_tdls_state_changed_cb)(some_enum state, char* peer_mac_addr, void* user_data); +#define CB_PARAMS_NAMES state, peer_mac_addr, user_data +PROXY_GROUP_NON_BLOCKING(wifi_manager_tdls_state_changed_cb, some_enum state, char* peer_mac_addr, void* user_data) +PROXY_GROUP_BLOCKING(wifi_manager_tdls_state_changed_cb, some_enum state, char* peer_mac_addr, void* user_data) +#undef CB_PARAMS_NAMES + + +std::map multi_proxy_map = { + MULTI_PROXY_MAP_ENTRY(platform_blocking_account_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_account_custom_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_account_event_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_account_label_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_account_type_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_activity_recognition_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_activity_recognition_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_alarm_registered_alarm_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_app_control_action_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_app_control_action_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_app_control_app_matched_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_app_control_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_app_control_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_app_control_extra_data_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_app_control_reply_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_app_control_reply_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_app_control_result_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_app_control_result_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_app_control_uri_query_foreach_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_app_create_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_app_event_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_app_event_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_app_info_category_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_app_info_filter_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_app_info_metadata_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_app_info_res_control_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_app_manager_app_context_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_app_manager_app_context_event_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_app_manager_app_context_event_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_app_manager_app_info_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_app_manager_event_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_app_manager_event_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_app_pause_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_app_pause_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_app_resume_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_app_resume_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_app_terminate_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_app_terminate_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_asp_advert_status_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_asp_advert_status_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_asp_seek_search_result_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_asp_seek_search_result_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_asp_session_config_request_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_asp_session_config_request_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_asp_session_connect_status_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_asp_session_connect_status_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_asp_session_port_status_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_asp_session_port_status_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_asp_session_request_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_asp_session_request_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_asp_session_status_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_asp_session_status_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_audio_in_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_audio_in_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_audio_in_stream_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_audio_in_stream_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_audio_io_interrupted_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_audio_io_interrupted_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_audio_out_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_audio_out_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_audio_out_stream_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_audio_out_stream_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_autofill_auth_info_received_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_autofill_auth_info_received_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_autofill_connection_status_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_autofill_connection_status_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_autofill_error_info_received_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_autofill_error_info_received_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_autofill_fill_response_group_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_autofill_fill_response_item_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_autofill_fill_response_received_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_autofill_fill_response_received_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_autofill_item_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_autofill_manager_autofill_service_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_autofill_manager_connection_status_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_autofill_manager_connection_status_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_autofill_save_item_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_autofill_service_auth_info_requested_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_autofill_service_auth_info_requested_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_autofill_service_cancel_fill_requested_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_autofill_service_cancel_fill_requested_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_autofill_service_committed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_autofill_service_committed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_autofill_service_fill_requested_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_autofill_service_fill_requested_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_autofill_service_terminate_received_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_autofill_service_terminate_received_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_badge_change_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_badge_change_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_badge_foreach_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_bt_adapter_bonded_device_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_bt_adapter_device_discovery_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_bt_adapter_device_discovery_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_bt_adapter_le_advertising_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_bt_adapter_le_advertising_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_bt_adapter_le_device_discovery_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_bt_adapter_le_device_discovery_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_bt_adapter_le_scan_result_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_bt_adapter_le_scan_result_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_bt_adapter_name_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_bt_adapter_name_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_bt_adapter_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_bt_adapter_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_bt_adapter_visibility_duration_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_bt_adapter_visibility_duration_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_bt_adapter_visibility_mode_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_bt_adapter_visibility_mode_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_bt_audio_connection_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_bt_audio_connection_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_bt_avrcp_control_connection_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_bt_avrcp_control_connection_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_bt_avrcp_equalizer_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_bt_avrcp_equalizer_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_bt_avrcp_play_status_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_bt_avrcp_play_status_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_bt_avrcp_position_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_bt_avrcp_position_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_bt_avrcp_repeat_mode_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_bt_avrcp_repeat_mode_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_bt_avrcp_scan_mode_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_bt_avrcp_scan_mode_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_bt_avrcp_shuffle_mode_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_bt_avrcp_shuffle_mode_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_bt_avrcp_target_connection_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_bt_avrcp_target_connection_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_bt_avrcp_track_info_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_bt_avrcp_track_info_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_bt_device_authorization_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_bt_device_authorization_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_bt_device_bond_created_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_bt_device_bond_created_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_bt_device_bond_destroyed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_bt_device_bond_destroyed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_bt_device_connected_profile) + MULTI_PROXY_MAP_ENTRY(platform_blocking_bt_device_connection_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_bt_device_connection_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_bt_device_service_searched_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_bt_device_service_searched_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_bt_gatt_characteristic_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_bt_gatt_characteristic_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_bt_gatt_characteristic_descriptor_discovered_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_bt_gatt_characteristic_descriptor_discovered_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_bt_gatt_characteristic_read_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_bt_gatt_characteristic_read_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_bt_gatt_characteristic_write_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_bt_gatt_characteristic_write_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_bt_gatt_characteristics_discovered_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_bt_gatt_client_att_mtu_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_bt_gatt_client_att_mtu_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_bt_gatt_client_characteristic_value_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_bt_gatt_client_characteristic_value_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_bt_gatt_client_request_completed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_bt_gatt_client_request_completed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_bt_gatt_client_service_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_bt_gatt_client_service_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_bt_gatt_connection_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_bt_gatt_connection_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_bt_gatt_foreach_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_bt_gatt_included_service_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_bt_gatt_primary_service_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_bt_gatt_server_characteristic_notification_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_bt_gatt_server_characteristic_notification_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_bt_gatt_server_notification_sent_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_bt_gatt_server_notification_sent_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_bt_gatt_server_read_value_requested_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_bt_gatt_server_read_value_requested_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_bt_gatt_server_write_value_requested_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_bt_gatt_server_write_value_requested_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_bt_hdp_connected_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_bt_hdp_connected_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_bt_hdp_data_received_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_bt_hdp_data_received_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_bt_hdp_disconnected_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_bt_hdp_disconnected_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_bt_hid_device_connection_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_bt_hid_device_connection_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_bt_hid_device_data_received_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_bt_hid_device_data_received_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_bt_hid_host_connection_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_bt_hid_host_connection_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_bt_ipsp_connection_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_bt_ipsp_connection_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_bt_ipsp_init_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_bt_ipsp_init_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_bt_opp_client_push_finished_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_bt_opp_client_push_finished_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_bt_opp_client_push_progress_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_bt_opp_client_push_progress_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_bt_opp_client_push_responded_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_bt_opp_client_push_responded_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_bt_opp_server_connection_requested_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_bt_opp_server_connection_requested_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_bt_opp_server_transfer_finished_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_bt_opp_server_transfer_finished_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_bt_opp_server_transfer_progress_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_bt_opp_server_transfer_progress_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_bt_pbap_connection_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_bt_pbap_connection_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_bt_pbap_list_vcards_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_bt_pbap_list_vcards_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_bt_pbap_phone_book_received_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_bt_pbap_phone_book_received_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_bt_pbap_phone_book_size_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_bt_pbap_phone_book_size_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_bt_socket_connection_requested_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_bt_socket_connection_requested_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_bt_socket_connection_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_bt_socket_connection_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_bt_socket_data_received_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_bt_socket_data_received_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_bt_socket_l2cap_channel_connection_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_bt_socket_l2cap_channel_connection_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_bundle_iterator_t) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_bundle_iterator_t) + MULTI_PROXY_MAP_ENTRY(platform_blocking_calendar_db_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_calendar_db_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_calendar_reminder_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_calendar_reminder_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_calendar_vcalendar_parse_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_camera_attr_hdr_progress_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_camera_attr_hdr_progress_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_camera_attr_supported_af_mode_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_camera_attr_supported_effect_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_camera_attr_supported_exposure_mode_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_camera_attr_supported_flash_mode_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_camera_attr_supported_fps_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_camera_attr_supported_iso_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_camera_attr_supported_ptz_type_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_camera_attr_supported_scene_mode_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_camera_attr_supported_stream_flip_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_camera_attr_supported_stream_rotation_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_camera_attr_supported_theater_mode_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_camera_attr_supported_whitebalance_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_camera_capture_completed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_camera_capture_completed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_camera_capturing_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_camera_capturing_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_camera_device_connection_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_camera_device_connection_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_camera_device_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_camera_device_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_camera_error_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_camera_error_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_camera_extra_preview_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_camera_extra_preview_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_camera_face_detected_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_camera_face_detected_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_camera_focus_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_camera_focus_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_camera_interrupt_started_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_camera_interrupt_started_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_camera_interrupted_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_camera_interrupted_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_camera_media_packet_preview_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_camera_media_packet_preview_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_camera_preview_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_camera_preview_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_camera_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_camera_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_camera_supported_capture_format_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_camera_supported_capture_resolution_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_camera_supported_device_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_camera_supported_preview_format_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_camera_supported_preview_resolution_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_capability_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_cbhm_item_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_cbhm_item_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_cbhm_monitor_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_cbhm_monitor_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_cbhm_selected_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_cbhm_selection_data_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_cion_client_connection_result_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_cion_client_connection_result_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_cion_client_disconnected_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_cion_client_disconnected_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_cion_client_payload_async_result_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_cion_client_payload_async_result_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_cion_client_payload_received_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_cion_client_payload_received_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_cion_client_server_discovered_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_cion_client_server_discovered_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_cion_group_joined_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_cion_group_joined_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_cion_group_left_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_cion_group_left_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_cion_group_payload_received_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_cion_group_payload_received_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_cion_server_connected_peer_info_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_cion_server_connection_request_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_cion_server_connection_request_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_cion_server_connection_result_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_cion_server_connection_result_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_cion_server_data_received_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_cion_server_data_received_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_cion_server_disconnected_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_cion_server_disconnected_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_cion_server_payload_async_result_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_cion_server_payload_async_result_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_cion_server_payload_received_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_cion_server_payload_received_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_connection_address_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_connection_address_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_connection_closed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_connection_closed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_connection_ethernet_cable_state_chaged_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_connection_ethernet_cable_state_chaged_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_connection_ethernet_cable_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_connection_ethernet_cable_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_connection_internet_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_connection_internet_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_connection_ipv6_address_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_connection_opened_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_connection_opened_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_connection_profile_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_connection_profile_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_connection_reset_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_connection_reset_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_connection_set_default_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_connection_set_default_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_connection_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_connection_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_connection_type_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_connection_type_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_contacts_db_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_contacts_db_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_contacts_db_status_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_contacts_db_status_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_contacts_setting_name_display_order_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_contacts_setting_name_display_order_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_contacts_setting_name_sorting_order_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_contacts_setting_name_sorting_order_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_contacts_sim_import_progress_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_contacts_vcard_parse_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_csr_cs_cancelled_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_csr_cs_cancelled_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_csr_cs_completed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_csr_cs_completed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_csr_cs_detected_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_csr_cs_detected_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_csr_cs_error_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_csr_cs_error_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_csr_cs_file_scanned_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_csr_cs_file_scanned_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_data_control_add_callback_result_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_data_control_add_callback_result_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_data_control_bulk_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_data_control_bulk_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_data_control_data_change_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_data_control_data_change_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_data_control_map_add_response_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_data_control_map_add_response_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_data_control_map_get_response_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_data_control_map_get_response_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_data_control_map_remove_response_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_data_control_map_remove_response_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_data_control_map_set_response_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_data_control_map_set_response_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_data_control_provider_bulk_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_data_control_provider_bulk_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_data_control_provider_data_change_consumer_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_data_control_provider_data_change_consumer_filter_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_data_control_provider_map_add_value_request_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_data_control_provider_map_add_value_request_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_data_control_provider_map_get_value_request_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_data_control_provider_map_get_value_request_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_data_control_provider_map_remove_value_request_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_data_control_provider_map_remove_value_request_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_data_control_provider_map_set_value_request_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_data_control_provider_map_set_value_request_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_data_control_provider_sql_delete_request_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_data_control_provider_sql_delete_request_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_data_control_provider_sql_insert_request_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_data_control_provider_sql_insert_request_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_data_control_provider_sql_select_request_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_data_control_provider_sql_select_request_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_data_control_provider_sql_update_request_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_data_control_provider_sql_update_request_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_data_control_sql_delete_response_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_data_control_sql_delete_response_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_data_control_sql_insert_response_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_data_control_sql_insert_response_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_data_control_sql_select_response_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_data_control_sql_select_response_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_data_control_sql_update_response_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_data_control_sql_update_response_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_device_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_device_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_diagnostics_notification_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_diagnostics_notification_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_diagnostics_request_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_diagnostics_request_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_dnssd_found_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_dnssd_found_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_dnssd_registered_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_dnssd_registered_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_dnssd_resolved_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_dnssd_resolved_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_download_progress_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_download_progress_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_download_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_download_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_dpm_policy_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_dpm_policy_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_dpm_signal_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_dpm_signal_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_dpm_zone_foreach_name_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_email_message_sent_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_email_message_sent_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_eom_attribute_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_eom_attribute_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_eom_mode_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_eom_mode_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_eom_output_added_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_eom_output_added_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_eom_output_removed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_eom_output_removed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_event_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_event_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_fido_attestation_type_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_fido_attestation_type_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_fido_authenticator_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_fido_authenticator_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_fido_uaf_response_message_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_fido_uaf_response_message_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_geofence_event_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_geofence_event_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_geofence_manager_fence_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_geofence_manager_place_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_geofence_proximity_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_geofence_proximity_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_geofence_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_geofence_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_gesture_recognition_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_gesture_recognition_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_gps_status_get_satellites_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_gps_status_satellite_updated_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_gps_status_satellite_updated_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_http_transaction_aborted_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_http_transaction_aborted_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_http_transaction_body_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_http_transaction_body_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_http_transaction_completed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_http_transaction_completed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_http_transaction_header_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_http_transaction_header_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_http_transaction_progress_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_http_transaction_progress_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_http_transaction_write_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_http_transaction_write_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_image_util_decode_completed2_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_image_util_decode_completed2_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_image_util_decode_completed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_image_util_decode_completed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_image_util_encode_completed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_image_util_encode_completed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_image_util_encode_to_buffer_completed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_image_util_encode_to_buffer_completed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_image_util_encode_to_file_completed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_image_util_encode_to_file_completed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_image_util_supported_colorspace_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_image_util_transform_completed2_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_image_util_transform_completed2_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_image_util_transform_completed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_image_util_transform_completed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_ime_accessibility_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_ime_accessibility_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_ime_create_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_ime_create_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_ime_cursor_position_updated_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_ime_cursor_position_updated_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_ime_display_language_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_ime_display_language_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_ime_focus_in_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_ime_focus_in_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_ime_focus_out_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_ime_focus_out_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_ime_geometry_requested_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_ime_geometry_requested_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_ime_hide_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_ime_hide_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_ime_imdata_requested_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_ime_imdata_requested_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_ime_imdata_set_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_ime_imdata_set_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_ime_input_context_reset_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_ime_input_context_reset_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_ime_input_hint_set_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_ime_input_hint_set_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_ime_language_requested_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_ime_language_requested_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_ime_language_set_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_ime_language_set_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_ime_layout_set_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_ime_layout_set_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_ime_mime_type_set_request_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_ime_mime_type_set_request_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_ime_option_window_created_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_ime_option_window_created_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_ime_option_window_destroyed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_ime_option_window_destroyed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_ime_prediction_hint_data_set_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_ime_prediction_hint_data_set_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_ime_prediction_hint_set_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_ime_prediction_hint_set_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_ime_process_key_event_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_ime_process_key_event_with_keycode_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_ime_return_key_state_set_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_ime_return_key_state_set_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_ime_return_key_type_set_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_ime_return_key_type_set_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_ime_rotation_degree_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_ime_rotation_degree_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_ime_show_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_ime_show_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_ime_surrounding_text_updated_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_ime_surrounding_text_updated_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_ime_terminate_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_ime_terminate_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_inm_arp_request_ip_found_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_inm_arp_request_ip_found_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_inm_cellular_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_inm_cellular_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_inm_channel_interference_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_inm_channel_interference_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_inm_congestion_level_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_inm_congestion_level_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_inm_default_dns_lookup_result_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_inm_default_dns_lookup_result_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_inm_default_gateway_found_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_inm_default_gateway_found_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_inm_ethernet_cable_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_inm_ethernet_cable_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_inm_ethernet_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_inm_ethernet_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_inm_ip_conflict_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_inm_ip_conflict_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_inm_link_address_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_inm_link_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_inm_link_route_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_inm_reachable_urls_check_result_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_inm_reachable_urls_check_result_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_inm_retry_tx_rate_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_inm_retry_tx_rate_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_inm_wifi_ap_vsie_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_inm_wifi_found_ap_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_inm_wifi_module_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_inm_wifi_module_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_inm_wifi_scan_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_inm_wifi_scan_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_inm_wifi_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_inm_wifi_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_iotcon_attributes_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_iotcon_children_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_iotcon_device_info_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_iotcon_found_resource_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_iotcon_generated_pin_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_iotcon_generated_pin_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_iotcon_list_attributes_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_iotcon_list_bool_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_iotcon_list_byte_str_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_iotcon_list_double_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_iotcon_list_int_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_iotcon_list_list_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_iotcon_list_str_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_iotcon_lite_resource_post_request_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_iotcon_options_foreach_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_iotcon_platform_info_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_iotcon_presence_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_iotcon_presence_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_iotcon_query_foreach_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_iotcon_remote_resource_cached_representation_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_iotcon_remote_resource_cached_representation_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_iotcon_remote_resource_observe_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_iotcon_remote_resource_observe_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_iotcon_remote_resource_response_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_iotcon_remote_resource_response_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_iotcon_remote_resource_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_iotcon_remote_resource_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_iotcon_request_handler_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_iotcon_request_handler_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_iotcon_resource_interfaces_foreach_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_iotcon_resource_types_foreach_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_job_scheduler_foreach_job_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_job_service_start_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_job_service_start_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_job_service_stop_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_job_service_stop_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_location_batch_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_location_batch_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_location_batch_get_location_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_location_bounds_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_location_bounds_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_location_bounds_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_location_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_location_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_location_position_updated_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_location_position_updated_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_location_service_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_location_service_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_location_setting_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_location_setting_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_location_updated_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_location_updated_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_location_velocity_updated_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_location_velocity_updated_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_location_zone_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_location_zone_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_ma_active_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_ma_active_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_ma_assistant_info_list_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_ma_audio_streaming_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_ma_audio_streaming_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_ma_audio_streaming_data_section_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_ma_audio_streaming_data_section_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_ma_error_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_ma_error_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_ma_language_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_ma_language_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_ma_preprocessing_information_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_ma_preprocessing_information_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_ma_service_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_ma_service_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_ma_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_ma_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_ma_voice_key_status_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_ma_voice_key_status_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_ma_wakeup_engine_command_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_ma_wakeup_engine_command_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_mc_ability_support_updated_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_mc_ability_support_updated_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_mc_ability_supported_items_updated_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_mc_ability_supported_items_updated_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_mc_activated_client_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_mc_activated_server_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_mc_bool_attribute_updated_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_mc_bool_attribute_updated_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_mc_client_custom_event_received_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_mc_client_custom_event_received_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_mc_cmd_reply_received_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_mc_cmd_reply_received_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_mc_command_reply_received_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_mc_command_reply_received_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_mc_display_mode_updated_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_mc_display_mode_updated_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_mc_display_rotation_updated_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_mc_display_rotation_updated_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_mc_metadata_updated_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_mc_metadata_updated_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_mc_playback_ability_updated_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_mc_playback_ability_updated_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_mc_playback_updated_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_mc_playback_updated_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_mc_playlist_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_mc_playlist_item_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_mc_playlist_updated_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_mc_playlist_updated_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_mc_repeat_ability_updated_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_mc_repeat_ability_updated_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_mc_repeat_mode_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_mc_repeat_mode_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_mc_repeat_mode_updated_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_mc_repeat_mode_updated_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_mc_search_condition_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_mc_server_custom_cmd_received_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_mc_server_custom_cmd_received_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_mc_server_custom_command_received_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_mc_server_custom_command_received_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_mc_server_display_mode_cmd_received_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_mc_server_display_mode_cmd_received_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_mc_server_display_rotation_cmd_received_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_mc_server_display_rotation_cmd_received_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_mc_server_enable_cmd_received_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_mc_server_enable_cmd_received_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_mc_server_event_reply_received_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_mc_server_event_reply_received_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_mc_server_playback_action_cmd_received_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_mc_server_playback_action_cmd_received_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_mc_server_playback_position_cmd_received_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_mc_server_playback_position_cmd_received_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_mc_server_playback_state_command_received_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_mc_server_playback_state_command_received_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_mc_server_playlist_cmd_received_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_mc_server_playlist_cmd_received_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_mc_server_repeat_mode_cmd_received_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_mc_server_repeat_mode_cmd_received_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_mc_server_search_cmd_received_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_mc_server_search_cmd_received_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_mc_server_shuffle_mode_cmd_received_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_mc_server_shuffle_mode_cmd_received_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_mc_server_state_updated_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_mc_server_state_updated_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_mc_shuffle_ability_updated_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_mc_shuffle_ability_updated_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_mc_shuffle_mode_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_mc_shuffle_mode_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_mc_shuffle_mode_updated_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_mc_shuffle_mode_updated_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_mc_subscribed_server_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_media_album_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_media_bookmark_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_media_content_db_update_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_media_content_db_update_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_media_face_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_media_face_detection_completed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_media_face_detection_completed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_media_folder_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_media_group_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_media_info_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_media_insert_burst_shot_completed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_media_insert_burst_shot_completed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_media_insert_completed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_media_insert_completed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_media_key_event_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_media_key_event_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_media_packet_dispose_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_media_packet_dispose_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_media_packet_finalize_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_media_playlist_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_media_scan_completed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_media_scan_completed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_media_storage_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_media_streamer_custom_buffer_status_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_media_streamer_custom_buffer_status_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_media_streamer_error_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_media_streamer_error_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_media_streamer_interrupted_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_media_streamer_interrupted_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_media_streamer_node_decoded_ready_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_media_streamer_node_decoded_ready_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_media_streamer_position_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_media_streamer_position_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_media_streamer_sink_data_ready_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_media_streamer_sink_data_ready_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_media_streamer_sink_eos_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_media_streamer_sink_eos_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_media_streamer_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_media_streamer_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_media_streamer_webrtc_message_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_media_streamer_webrtc_message_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_media_tag_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_media_thumbnail_completed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_media_thumbnail_completed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_mediacodec_buffer_status_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_mediacodec_buffer_status_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_mediacodec_eos_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_mediacodec_eos_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_mediacodec_error_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_mediacodec_error_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_mediacodec_input_buffer_used_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_mediacodec_input_buffer_used_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_mediacodec_output_buffer_available_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_mediacodec_output_buffer_available_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_mediacodec_supported_codec_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_mediademuxer_eos_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_mediademuxer_eos_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_mediademuxer_error_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_mediademuxer_error_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_mediaeditor_error_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_mediaeditor_error_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_mediaeditor_layer_priority_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_mediaeditor_layer_priority_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_mediaeditor_project_loaded_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_mediaeditor_project_loaded_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_mediaeditor_render_completed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_mediaeditor_render_completed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_mediaeditor_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_mediaeditor_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_mediamuxer_eos_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_mediamuxer_eos_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_mediamuxer_error_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_mediamuxer_error_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_message_port_message_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_message_port_message_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_message_port_registration_event_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_message_port_registration_event_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_message_port_trusted_message_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_message_port_trusted_message_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_messages_incoming_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_messages_incoming_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_messages_push_incoming_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_messages_push_incoming_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_messages_search_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_messages_sent_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_messages_sent_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_ml_custom_easy_invoke_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_ml_data_destroy_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_ml_data_destroy_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_ml_pipeline_if_custom_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_ml_pipeline_sink_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_ml_pipeline_sink_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_ml_pipeline_state_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_ml_pipeline_state_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_ml_train_datagen_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_mtp_event_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_mtp_event_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_mv_3d_depth_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_mv_3d_depth_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_mv_3d_pointcloud_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_mv_3d_pointcloud_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_mv_barcode_detected_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_mv_barcode_detected_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_mv_face_detected_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_mv_face_detected_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_mv_face_eye_condition_recognized_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_mv_face_eye_condition_recognized_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_mv_face_facial_expression_recognized_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_mv_face_facial_expression_recognized_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_mv_face_recognized_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_mv_face_recognized_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_mv_face_tracked_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_mv_face_tracked_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_mv_image_recognized_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_mv_image_recognized_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_mv_image_tracked_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_mv_image_tracked_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_mv_inference_face_detected_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_mv_inference_face_detected_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_mv_inference_facial_landmark_detected_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_mv_inference_facial_landmark_detected_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_mv_inference_image_classified_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_mv_inference_image_classified_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_mv_inference_object_detected_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_mv_inference_object_detected_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_mv_inference_pose_landmark_detected_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_mv_inference_pose_landmark_detected_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_mv_inference_supported_engine_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_mv_roi_tracker_tracked_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_mv_roi_tracker_tracked_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_mv_supported_attribute_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_mv_surveillance_event_occurred_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_mv_surveillance_event_occurred_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_mv_surveillance_event_result_name_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_mv_surveillance_event_type_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_noti_ex_item_group_foreach_child_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_noti_ex_manager_events_add_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_noti_ex_manager_events_add_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_noti_ex_manager_events_delete_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_noti_ex_manager_events_delete_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_noti_ex_manager_events_error_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_noti_ex_manager_events_error_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_noti_ex_manager_events_update_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_noti_ex_manager_events_update_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_noti_ex_reporter_events_error_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_noti_ex_reporter_events_error_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_noti_ex_reporter_events_event_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_noti_ex_reporter_events_event_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_package_info_app_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_package_info_cert_info_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_package_info_dependency_info_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_package_info_privilege_info_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_package_info_res_allowed_package_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_package_info_updateinfo_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_package_manager_event_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_package_manager_event_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_package_manager_package_info_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_package_manager_request_event_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_package_manager_request_event_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_package_manager_request_res_event_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_package_manager_request_res_event_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_package_manager_res_event_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_package_manager_res_event_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_package_manager_res_event_path_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_package_manager_size_info_receive_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_package_manager_size_info_receive_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_package_manager_total_size_info_receive_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_package_manager_total_size_info_receive_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_peripheral_gpio_interrupted_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_peripheral_gpio_interrupted_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_player_adaptive_variant_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_player_adaptive_variant_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_player_buffering_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_player_buffering_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_player_completed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_player_completed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_player_error_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_player_error_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_player_interrupted_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_player_interrupted_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_player_media_packet_audio_decoded_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_player_media_packet_audio_decoded_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_player_media_packet_video_decoded_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_player_media_packet_video_decoded_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_player_media_stream_buffer_status_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_player_media_stream_buffer_status_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_player_media_stream_seek_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_player_media_stream_seek_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_player_pd_message_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_player_pd_message_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_player_prepared_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_player_prepared_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_player_seek_completed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_player_seek_completed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_player_subtitle_updated_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_player_subtitle_updated_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_player_supported_media_format_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_player_video_captured_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_player_video_captured_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_player_video_stream_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_player_video_stream_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_playlist_member_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_polygon_coords_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_ppm_request_multiple_response_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_ppm_request_multiple_response_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_ppm_request_response_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_ppm_request_response_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_preference_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_preference_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_preference_item_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_provider_feature_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_push_service_notify_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_push_service_notify_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_push_service_result_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_push_service_result_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_push_service_state_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_push_service_state_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_radio_interrupted_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_radio_interrupted_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_radio_scan_completed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_radio_scan_completed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_radio_scan_stopped_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_radio_scan_stopped_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_radio_scan_updated_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_radio_scan_updated_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_radio_seek_completed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_radio_seek_completed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_recorder_audio_stream_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_recorder_audio_stream_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_recorder_device_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_recorder_device_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_recorder_error_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_recorder_error_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_recorder_interrupt_started_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_recorder_interrupt_started_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_recorder_interrupted_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_recorder_interrupted_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_recorder_muxed_stream_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_recorder_muxed_stream_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_recorder_recording_limit_reached_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_recorder_recording_limit_reached_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_recorder_recording_status_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_recorder_recording_status_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_recorder_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_recorder_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_recorder_supported_audio_encoder_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_recorder_supported_file_format_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_recorder_supported_video_encoder_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_recorder_supported_video_resolution_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_recorder_video_encode_decision_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_result_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_result_cb_t) + MULTI_PROXY_MAP_ENTRY(platform_blocking_rpc_port_proxy_connected_event_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_rpc_port_proxy_connected_event_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_rpc_port_proxy_disconnected_event_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_rpc_port_proxy_disconnected_event_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_rpc_port_proxy_received_event_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_rpc_port_proxy_received_event_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_rpc_port_proxy_rejected_event_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_rpc_port_proxy_rejected_event_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_rpc_port_stub_connected_event_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_rpc_port_stub_connected_event_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_rpc_port_stub_disconnected_event_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_rpc_port_stub_disconnected_event_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_rpc_port_stub_received_event_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_runtime_info_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_runtime_info_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_scmirroring_sink_state_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_scmirroring_sink_state_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_sensor_accuracy_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_sensor_accuracy_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_sensor_added_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_sensor_added_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_sensor_event_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_sensor_event_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_sensor_events_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_sensor_events_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_sensor_provider_interval_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_sensor_provider_interval_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_sensor_provider_start_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_sensor_provider_start_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_sensor_provider_stop_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_sensor_provider_stop_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_sensor_recorder_data_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_sensor_removed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_sensor_removed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_service_app_control_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_service_app_control_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_service_app_create_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_service_app_terminate_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_service_app_terminate_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_shortcut_list_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_shortcut_remove_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_shortcut_request_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_smartcard_reader_event_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_smartcard_reader_event_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_softap_client_connection_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_softap_client_connection_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_softap_connected_client_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_softap_disabled_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_softap_disabled_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_softap_enabled_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_softap_enabled_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_softap_passphrase_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_softap_passphrase_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_softap_security_type_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_softap_security_type_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_softap_settings_reloaded_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_softap_settings_reloaded_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_softap_ssid_visibility_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_softap_ssid_visibility_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_sound_device_connected_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_sound_device_connected_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_sound_device_connection_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_sound_device_connection_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_sound_device_information_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_sound_device_information_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_sound_device_running_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_sound_device_running_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_sound_device_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_sound_device_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_sound_manager_volume_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_sound_manager_volume_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_sound_pool_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_sound_pool_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_sound_pool_stream_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_sound_pool_stream_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_sound_session_interrupted_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_sound_session_interrupted_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_sound_stream_ducking_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_sound_stream_ducking_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_sound_stream_focus_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_sound_stream_focus_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_sound_stream_focus_state_watch_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_sound_stream_focus_state_watch_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_ssdp_found_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_ssdp_found_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_ssdp_registered_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_ssdp_registered_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_stc_get_all_stats_finished_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_stc_get_all_stats_finished_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_stc_stats_info_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_storage_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_storage_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_storage_device_supported_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_storage_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_storage_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_streamrecorder_consume_completed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_streamrecorder_consume_completed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_streamrecorder_error_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_streamrecorder_error_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_streamrecorder_notify_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_streamrecorder_notify_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_streamrecorder_recording_limit_reached_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_streamrecorder_recording_limit_reached_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_streamrecorder_recording_status_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_streamrecorder_recording_status_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_streamrecorder_supported_audio_encoder_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_streamrecorder_supported_file_format_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_streamrecorder_supported_video_encoder_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_streamrecorder_supported_video_resolution_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_stt_default_language_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_stt_default_language_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_stt_engine_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_stt_engine_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_stt_error_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_stt_error_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_stt_recognition_result_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_stt_recognition_result_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_stt_result_time_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_stt_speech_status_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_stt_speech_status_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_stt_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_stt_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_stt_supported_engine_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_stt_supported_language_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_stte_audio_type_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_stte_cancel_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_stte_check_app_agreed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_stte_deinitialize_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_stte_foreach_result_time_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_stte_foreach_supported_langs_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_stte_get_info_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_stte_get_recording_format_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_stte_initialize_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_stte_is_valid_language_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_stte_need_app_credential_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_stte_private_data_requested_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_stte_private_data_set_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_stte_result_time_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_stte_set_recording_data_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_stte_set_silence_detection_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_stte_start_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_stte_stop_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_stte_support_recognition_type_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_stte_support_silence_detection_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_stte_supported_language_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_sync_adapter_cancel_sync_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_sync_adapter_cancel_sync_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_sync_adapter_start_sync_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_sync_manager_sync_job_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_system_settings_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_system_settings_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_system_settings_iter_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_telephony_noti_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_telephony_noti_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_telephony_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_telephony_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_thumbnail_extracted_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_thumbnail_extracted_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_tts_default_voice_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_tts_default_voice_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_tts_engine_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_tts_engine_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_tts_error_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_tts_error_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_tts_screen_reader_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_tts_screen_reader_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_tts_service_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_tts_service_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_tts_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_tts_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_tts_supported_voice_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_tts_utterance_completed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_tts_utterance_completed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_tts_utterance_started_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_tts_utterance_started_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_ttse_activated_mode_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_ttse_activated_mode_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_ttse_cancel_synthesis_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_ttse_check_app_agreed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_ttse_deinitialize_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_ttse_foreach_supported_voices_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_ttse_get_info_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_ttse_initialize_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_ttse_is_valid_voice_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_ttse_load_voice_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_ttse_need_app_credential_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_ttse_private_data_requested_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_ttse_private_data_set_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_ttse_set_pitch_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_ttse_start_synthesis_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_ttse_supported_voice_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_ttse_unload_voice_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_usb_host_hotplug_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_usb_host_hotplug_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_usb_host_transferred_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_usb_host_transferred_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_vc_mgr_all_result_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_vc_mgr_begin_speech_detected_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_vc_mgr_begin_speech_detected_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_vc_mgr_dialog_request_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_vc_mgr_dialog_request_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_vc_mgr_feedback_audio_format_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_vc_mgr_feedback_audio_format_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_vc_mgr_feedback_streaming_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_vc_mgr_feedback_streaming_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_vc_mgr_pre_result_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_vc_mgr_pre_result_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_vc_mgr_private_data_requested_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_vc_mgr_private_data_set_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_vc_mgr_specific_engine_result_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_vc_mgr_specific_engine_result_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_vc_mgr_vc_tts_streaming_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_vc_mgr_vc_tts_streaming_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_vce_cancel_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_vce_cancel_tts_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_vce_command_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_vce_deinitialize_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_vce_foreach_supported_languages_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_vce_get_info_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_vce_get_recording_format_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_vce_initialize_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_vce_is_language_supported_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_vce_nlu_base_info_requested_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_vce_private_data_requested_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_vce_private_data_set_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_vce_process_haptic_event_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_vce_process_list_event_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_vce_process_text_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_vce_request_tts_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_vce_set_audio_type_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_vce_set_commands_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_vce_set_domain_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_vce_set_language_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_vce_set_recording_data_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_vce_set_server_dialog_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_vce_specific_engine_request_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_vce_start_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_vce_stop_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_vce_supported_language_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_vce_tts_audio_format_request_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_vce_unset_commands_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_video_util_supported_audio_encoder_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_video_util_supported_file_format_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_video_util_supported_video_encoder_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_video_util_transcoding_completed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_video_util_transcoding_completed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_video_util_transcoding_progress_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_video_util_transcoding_progress_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_wav_player_playback_completed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_wav_player_playback_completed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_webrtc_data_channel_buffered_amount_low_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_webrtc_data_channel_buffered_amount_low_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_webrtc_data_channel_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_webrtc_data_channel_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_webrtc_data_channel_close_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_webrtc_data_channel_close_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_webrtc_data_channel_error_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_webrtc_data_channel_error_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_webrtc_data_channel_message_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_webrtc_data_channel_message_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_webrtc_data_channel_open_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_webrtc_data_channel_open_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_webrtc_encoded_frame_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_webrtc_encoded_frame_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_webrtc_error_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_webrtc_error_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_webrtc_ice_candidate_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_webrtc_ice_candidate_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_webrtc_ice_connection_state_change_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_webrtc_ice_connection_state_change_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_webrtc_ice_gathering_state_change_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_webrtc_ice_gathering_state_change_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_webrtc_media_packet_source_buffer_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_webrtc_media_packet_source_buffer_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_webrtc_media_source_supported_transceiver_codec_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_webrtc_negotiation_needed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_webrtc_negotiation_needed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_webrtc_peer_connection_state_change_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_webrtc_peer_connection_state_change_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_webrtc_session_description_created_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_webrtc_session_description_created_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_webrtc_signaling_state_change_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_webrtc_signaling_state_change_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_webrtc_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_webrtc_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_webrtc_stats_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_webrtc_track_added_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_webrtc_track_added_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_webrtc_turn_server_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_wifi_direct_client_ip_address_assigned_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_wifi_direct_client_ip_address_assigned_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_wifi_direct_connected_peer_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_wifi_direct_connection_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_wifi_direct_connection_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_wifi_direct_device_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_wifi_direct_device_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_wifi_direct_discovered_peer_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_wifi_direct_discovery_state_chagned_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_wifi_direct_discovery_state_chagned_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_wifi_direct_peer_found_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_wifi_direct_peer_found_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_wifi_direct_peer_info_connection_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_wifi_direct_peer_info_connection_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_wifi_direct_persistent_group_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_wifi_direct_service_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_wifi_direct_service_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_wifi_direct_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_wifi_direct_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_wifi_direct_supported_wps_type_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_wifi_manager_activated_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_wifi_manager_activated_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_wifi_manager_ap_ipv6_address_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_wifi_manager_ap_vsie_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_wifi_manager_bssid_scan_finished_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_wifi_manager_bssid_scan_finished_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_wifi_manager_config_list_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_wifi_manager_connected_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_wifi_manager_connected_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_wifi_manager_connection_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_wifi_manager_connection_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_wifi_manager_deactivated_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_wifi_manager_deactivated_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_wifi_manager_device_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_wifi_manager_device_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_wifi_manager_disconnected_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_wifi_manager_disconnected_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_wifi_manager_forget_ap_finished_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_wifi_manager_forget_ap_finished_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_wifi_manager_found_ap_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_wifi_manager_found_bssid_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_wifi_manager_ip_conflict_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_wifi_manager_ip_conflict_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_wifi_manager_module_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_wifi_manager_module_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_wifi_manager_rssi_level_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_wifi_manager_rssi_level_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_wifi_manager_scan_finished_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_wifi_manager_scan_finished_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_wifi_manager_scan_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_wifi_manager_scan_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_wifi_manager_tdls_discovered_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_wifi_manager_tdls_discovered_cb) + MULTI_PROXY_MAP_ENTRY(platform_blocking_wifi_manager_tdls_state_changed_cb) + MULTI_PROXY_MAP_ENTRY(platform_non_blocking_wifi_manager_tdls_state_changed_cb) +}; + +std::map reserved_base_id_map = { + {"ml_data_destroy_cb", BASE_CALLBACK_ID_ml_data_destroy_cb}, + {"result_cb_t", BASE_CALLBACK_ID_result_cb_t}, + {"stte_cancel_cb", BASE_CALLBACK_ID_stte_cancel_cb}, + {"stte_check_app_agreed_cb", BASE_CALLBACK_ID_stte_check_app_agreed_cb}, + {"stte_deinitialize_cb", BASE_CALLBACK_ID_stte_deinitialize_cb}, + {"stte_get_info_cb", BASE_CALLBACK_ID_stte_get_info_cb}, + {"stte_get_recording_format_cb", BASE_CALLBACK_ID_stte_get_recording_format_cb}, + {"stte_initialize_cb", BASE_CALLBACK_ID_stte_initialize_cb}, + {"stte_is_valid_language_cb", BASE_CALLBACK_ID_stte_is_valid_language_cb}, + {"stte_need_app_credential_cb", BASE_CALLBACK_ID_stte_need_app_credential_cb}, + {"stte_private_data_requested_cb", BASE_CALLBACK_ID_stte_private_data_requested_cb}, + {"stte_private_data_set_cb", BASE_CALLBACK_ID_stte_private_data_set_cb}, + {"stte_set_recording_data_cb", BASE_CALLBACK_ID_stte_set_recording_data_cb}, + {"stte_set_silence_detection_cb", BASE_CALLBACK_ID_stte_set_silence_detection_cb}, + {"stte_stop_cb", BASE_CALLBACK_ID_stte_stop_cb}, + {"stte_support_recognition_type_cb", BASE_CALLBACK_ID_stte_support_recognition_type_cb}, + {"stte_support_silence_detection_cb", BASE_CALLBACK_ID_stte_support_silence_detection_cb}, + {"sync_adapter_cancel_sync_cb", BASE_CALLBACK_ID_sync_adapter_cancel_sync_cb}, + {"sync_adapter_start_sync_cb", BASE_CALLBACK_ID_sync_adapter_start_sync_cb}, + {"ttse_activated_mode_changed_cb", BASE_CALLBACK_ID_ttse_activated_mode_changed_cb}, + {"ttse_cancel_synthesis_cb", BASE_CALLBACK_ID_ttse_cancel_synthesis_cb}, + {"ttse_check_app_agreed_cb", BASE_CALLBACK_ID_ttse_check_app_agreed_cb}, + {"ttse_deinitialize_cb", BASE_CALLBACK_ID_ttse_deinitialize_cb}, + {"ttse_get_info_cb", BASE_CALLBACK_ID_ttse_get_info_cb}, + {"ttse_initialize_cb", BASE_CALLBACK_ID_ttse_initialize_cb}, + {"ttse_is_valid_voice_cb", BASE_CALLBACK_ID_ttse_is_valid_voice_cb}, + {"ttse_load_voice_cb", BASE_CALLBACK_ID_ttse_load_voice_cb}, + {"ttse_need_app_credential_cb", BASE_CALLBACK_ID_ttse_need_app_credential_cb}, + {"ttse_private_data_requested_cb", BASE_CALLBACK_ID_ttse_private_data_requested_cb}, + {"ttse_private_data_set_cb", BASE_CALLBACK_ID_ttse_private_data_set_cb}, + {"ttse_set_pitch_cb", BASE_CALLBACK_ID_ttse_set_pitch_cb}, + {"ttse_unload_voice_cb", BASE_CALLBACK_ID_ttse_unload_voice_cb}, + {"vce_cancel_cb", BASE_CALLBACK_ID_vce_cancel_cb}, + {"vce_deinitialize_cb", BASE_CALLBACK_ID_vce_deinitialize_cb}, + {"vce_get_info_cb", BASE_CALLBACK_ID_vce_get_info_cb}, + {"vce_get_recording_format_cb", BASE_CALLBACK_ID_vce_get_recording_format_cb}, + {"vce_initialize_cb", BASE_CALLBACK_ID_vce_initialize_cb}, + {"vce_is_language_supported_cb", BASE_CALLBACK_ID_vce_is_language_supported_cb}, + {"vce_nlu_base_info_requested_cb", BASE_CALLBACK_ID_vce_nlu_base_info_requested_cb}, + {"vce_private_data_requested_cb", BASE_CALLBACK_ID_vce_private_data_requested_cb}, + {"vce_private_data_set_cb", BASE_CALLBACK_ID_vce_private_data_set_cb}, + {"vce_process_haptic_event_cb", BASE_CALLBACK_ID_vce_process_haptic_event_cb}, + {"vce_process_list_event_cb", BASE_CALLBACK_ID_vce_process_list_event_cb}, + {"vce_process_text_cb", BASE_CALLBACK_ID_vce_process_text_cb}, + {"vce_set_audio_type_cb", BASE_CALLBACK_ID_vce_set_audio_type_cb}, + {"vce_set_commands_cb", BASE_CALLBACK_ID_vce_set_commands_cb}, + {"vce_set_domain_cb", BASE_CALLBACK_ID_vce_set_domain_cb}, + {"vce_set_language_cb", BASE_CALLBACK_ID_vce_set_language_cb}, + {"vce_set_recording_data_cb", BASE_CALLBACK_ID_vce_set_recording_data_cb}, + {"vce_set_server_dialog_cb", BASE_CALLBACK_ID_vce_set_server_dialog_cb}, + {"vce_specific_engine_request_cb", BASE_CALLBACK_ID_vce_specific_engine_request_cb}, + {"vce_start_cb", BASE_CALLBACK_ID_vce_start_cb}, + {"vce_stop_cb", BASE_CALLBACK_ID_vce_stop_cb}, + {"vce_unset_commands_cb", BASE_CALLBACK_ID_vce_unset_commands_cb}, +}; diff --git a/packages/tizen_interop_callbacks/tizen/src/log.h b/packages/tizen_interop_callbacks/tizen/src/log.h new file mode 100644 index 0000000..92876b7 --- /dev/null +++ b/packages/tizen_interop_callbacks/tizen/src/log.h @@ -0,0 +1,31 @@ +#ifndef __LOG_H__ +#define __LOG_H__ + +#include + +#ifdef LOG_TAG +#undef LOG_TAG +#endif +#define LOG_TAG "TizenInteropCallbacksPlugin" + +#ifndef __MODULE__ +#define __MODULE__ strrchr("/" __FILE__, '/') + 1 +#endif + +#define LOG(prio, fmt, arg...) \ + dlog_print(prio, LOG_TAG, "%s: %s(%d) > " fmt, __MODULE__, __func__, \ + __LINE__, ##arg) + +#define LOG_DEBUG(fmt, args...) LOG(DLOG_DEBUG, fmt, ##args) +#define LOG_INFO(fmt, args...) LOG(DLOG_INFO, fmt, ##args) +#define LOG_WARN(fmt, args...) LOG(DLOG_WARN, fmt, ##args) +#define LOG_ERROR(fmt, args...) LOG(DLOG_ERROR, fmt, ##args) + +// You can switch detailed debugging here: 0 - disabled +#if 0 +#define LDEBUG(...) LOG_DEBUG(__VA_ARGS__) +#else +#define LDEBUG(...) +#endif + +#endif // __LOG_H__ diff --git a/packages/tizen_interop_callbacks/tizen/src/macros.h b/packages/tizen_interop_callbacks/tizen/src/macros.h new file mode 100644 index 0000000..dfcc7b3 --- /dev/null +++ b/packages/tizen_interop_callbacks/tizen/src/macros.h @@ -0,0 +1,454 @@ +// Copyright 2023 Samsung Electronics Co., Ltd. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#ifndef TIZEN_INTEROP_CALLBACKS_MACROS_H_ +#define TIZEN_INTEROP_CALLBACKS_MACROS_H_ + +#include +#include + +#include +#include +#include +#include + +#include "log.h" + +static constexpr int32_t kProxyInstanceCount = 5; + +// The function pointer given to TizenInteropCallbacksRegisterWrappedCallback. +// Should be a pointer created in Dart with Pointer.fromFunction(). +typedef void *CallbackPointer; + +// Sends the given wrapped callback to Dart to be called from there. +void RequestCallbackCall(CallbackWrapper *wrapper); + +extern std::map callback_pointers; +extern unsigned long interop_callbacks_thread_id; + +#define gettid() syscall(SYS_gettid) + +#define GET_CALLBACK_ID(CB_NAME, OFFSET) \ + reserved_callback_ids[BASE_CALLBACK_ID_##CB_NAME + OFFSET] + +// Note: CB_PARAMS_NAMES should be defined before calling PROXY_GROUP_*. +#define PROXY_GROUP_RETURN(CB_NAME, CB_RETURN, CB_PARAMS...) \ + CB_RETURN platform_blocking_##CB_NAME(CB_PARAMS) { \ + if (!user_data || reinterpret_cast(user_data) > UINT32_MAX) { \ + LOG_ERROR("Received bad user_data in %s: %p - ignoring.", #CB_NAME, \ + user_data); \ + return CB_RETURN(); \ + } \ + uint32_t _callback_id = \ + static_cast(reinterpret_cast(user_data)); \ + LDEBUG("enter id: %d", _callback_id); \ + auto _iter = callback_pointers.find(_callback_id); \ + if (_iter == callback_pointers.end()) { \ + LOG_ERROR("No callback registered for id %d - ignoring.", _callback_id); \ + return CB_RETURN(); \ + } \ + CallbackPointer _callback = _iter->second; \ + if (gettid() == interop_callbacks_thread_id) { \ + LDEBUG("calling Dart callback directly"); \ + return (reinterpret_cast(_callback))(CB_PARAMS_NAMES); \ + } \ + CB_RETURN _return_value = CB_RETURN(); \ + std::mutex _mutex; \ + std::unique_lock lock(_mutex); \ + std::condition_variable _cv; \ + bool _callback_finished = false; \ + \ + CallbackWrapper _wrapper = [_callback, CB_PARAMS_NAMES, &_cv, \ + &_callback_finished, &_return_value] { \ + CB_NAME local_callback = reinterpret_cast(_callback); \ + LDEBUG("calling local_callback() %p, user_data: %p", local_callback, \ + user_data); \ + if (local_callback) { \ + _return_value = local_callback(CB_PARAMS_NAMES); \ + } \ + _callback_finished = true; \ + LDEBUG("calling notify_one()"); \ + _cv.notify_one(); \ + }; \ + \ + LDEBUG("calling RequestCallbackCall()"); \ + RequestCallbackCall(new CallbackWrapper(_wrapper)); \ + \ + LDEBUG("waiting for notification"); \ + while (!_callback_finished) { \ + _cv.wait(lock); \ + } \ + LDEBUG("exit, return_value: %d", (int)_return_value); \ + return _return_value; \ + } \ + \ + CB_RETURN platform_blocking_##CB_NAME##_0(CB_PARAMS) { \ + return platform_blocking_##CB_NAME(CB_PARAMS_NAMES); \ + } \ + CB_RETURN platform_blocking_##CB_NAME##_1(CB_PARAMS) { \ + return platform_blocking_##CB_NAME(CB_PARAMS_NAMES); \ + } \ + CB_RETURN platform_blocking_##CB_NAME##_2(CB_PARAMS) { \ + return platform_blocking_##CB_NAME(CB_PARAMS_NAMES); \ + } \ + CB_RETURN platform_blocking_##CB_NAME##_3(CB_PARAMS) { \ + return platform_blocking_##CB_NAME(CB_PARAMS_NAMES); \ + } \ + CB_RETURN platform_blocking_##CB_NAME##_4(CB_PARAMS) { \ + return platform_blocking_##CB_NAME(CB_PARAMS_NAMES); \ + } +// end of PROXY_GROUP_RETURN + +#define PROXY_GROUP_BLOCKING(CB_NAME, CB_PARAMS...) \ + void platform_blocking_##CB_NAME(CB_PARAMS) { \ + if (!user_data || reinterpret_cast(user_data) > UINT32_MAX) { \ + LOG_ERROR("Received bad user_data in %s: %p - ignoring.", #CB_NAME, \ + user_data); \ + return; \ + } \ + uint32_t _callback_id = \ + static_cast(reinterpret_cast(user_data)); \ + LDEBUG("enter id: %d", _callback_id); \ + auto _iter = callback_pointers.find(_callback_id); \ + if (_iter == callback_pointers.end()) { \ + LOG_ERROR("No callback registered for id %d - ignoring.", _callback_id); \ + return; \ + } \ + CallbackPointer _callback = _iter->second; \ + if (gettid() == interop_callbacks_thread_id) { \ + LDEBUG("calling Dart callback directly"); \ + return (reinterpret_cast(_callback))(CB_PARAMS_NAMES); \ + } \ + std::mutex _mutex; \ + std::unique_lock lock(_mutex); \ + std::condition_variable _cv; \ + bool _callback_finished = false; \ + \ + CallbackWrapper _wrapper = [_callback, CB_PARAMS_NAMES, &_cv, \ + &_callback_finished] { \ + CB_NAME local_callback = reinterpret_cast(_callback); \ + LDEBUG("calling local_callback() %p, user_data: %p", local_callback, \ + user_data); \ + if (local_callback) { \ + local_callback(CB_PARAMS_NAMES); \ + } \ + _callback_finished = true; \ + LDEBUG("calling notify_one()"); \ + _cv.notify_one(); \ + }; \ + \ + LDEBUG("calling RequestCallbackCall()"); \ + RequestCallbackCall(new CallbackWrapper(_wrapper)); \ + \ + LDEBUG("waiting for notification"); \ + while (!_callback_finished) { \ + _cv.wait(lock); \ + } \ + LDEBUG("exit"); \ + } \ + \ + void platform_blocking_##CB_NAME##_0(CB_PARAMS) { \ + platform_blocking_##CB_NAME(CB_PARAMS_NAMES); \ + } \ + void platform_blocking_##CB_NAME##_1(CB_PARAMS) { \ + platform_blocking_##CB_NAME(CB_PARAMS_NAMES); \ + } \ + void platform_blocking_##CB_NAME##_2(CB_PARAMS) { \ + platform_blocking_##CB_NAME(CB_PARAMS_NAMES); \ + } \ + void platform_blocking_##CB_NAME##_3(CB_PARAMS) { \ + platform_blocking_##CB_NAME(CB_PARAMS_NAMES); \ + } \ + void platform_blocking_##CB_NAME##_4(CB_PARAMS) { \ + platform_blocking_##CB_NAME(CB_PARAMS_NAMES); \ + } +// end of PROXY_GROUP_BLOCKING + +#define PROXY_GROUP_NON_BLOCKING(CB_NAME, CB_PARAMS...) \ + void platform_non_blocking_##CB_NAME(CB_PARAMS) { \ + if (!user_data || reinterpret_cast(user_data) > UINT32_MAX) { \ + LOG_ERROR("Received bad user_data in %s: %p - ignoring.", #CB_NAME, \ + user_data); \ + return; \ + } \ + uint32_t _callback_id = \ + static_cast(reinterpret_cast(user_data)); \ + LDEBUG("enter id: %d", _callback_id); \ + auto _iter = callback_pointers.find(_callback_id); \ + if (_iter == callback_pointers.end()) { \ + LOG_ERROR("No callback registered for id %d - ignoring.", _callback_id); \ + return; \ + } \ + CallbackPointer _callback = _iter->second; \ + \ + CallbackWrapper _wrapper = [_callback, CB_PARAMS_NAMES] { \ + CB_NAME local_callback = reinterpret_cast(_callback); \ + LDEBUG("calling local_callback() %p, user_data: %p", local_callback, \ + user_data); \ + if (local_callback) { \ + local_callback(CB_PARAMS_NAMES); \ + } \ + }; \ + \ + LDEBUG("calling RequestCallbackCall()"); \ + RequestCallbackCall(new CallbackWrapper(_wrapper)); \ + } \ + \ + void platform_non_blocking_##CB_NAME##_0(CB_PARAMS) { \ + platform_non_blocking_##CB_NAME(CB_PARAMS_NAMES); \ + } \ + void platform_non_blocking_##CB_NAME##_1(CB_PARAMS) { \ + platform_non_blocking_##CB_NAME(CB_PARAMS_NAMES); \ + } \ + void platform_non_blocking_##CB_NAME##_2(CB_PARAMS) { \ + platform_non_blocking_##CB_NAME(CB_PARAMS_NAMES); \ + } \ + void platform_non_blocking_##CB_NAME##_3(CB_PARAMS) { \ + platform_non_blocking_##CB_NAME(CB_PARAMS_NAMES); \ + } \ + void platform_non_blocking_##CB_NAME##_4(CB_PARAMS) { \ + platform_non_blocking_##CB_NAME(CB_PARAMS_NAMES); \ + } +// end of PROXY_GROUP_NON_BLOCKING + +#define PROXY_GROUP_RETURN_NO_USER_DATA(CB_NAME, CB_RETURN, CB_PARAMS...) \ + CB_RETURN platform_blocking_##CB_NAME(uint32_t _callback_id, CB_PARAMS) { \ + LDEBUG("enter id: %d", _callback_id); \ + auto _iter = callback_pointers.find(_callback_id); \ + if (_iter == callback_pointers.end()) { \ + LOG_ERROR("No callback registered for id %d - ignoring.", _callback_id); \ + return CB_RETURN(); \ + } \ + CallbackPointer _callback = _iter->second; \ + if (gettid() == interop_callbacks_thread_id) { \ + LDEBUG("calling Dart callback directly"); \ + return (reinterpret_cast(_callback))(CB_PARAMS_NAMES); \ + } \ + CB_RETURN _return_value = CB_RETURN(); \ + std::mutex _mutex; \ + std::unique_lock lock(_mutex); \ + std::condition_variable _cv; \ + bool _callback_finished = false; \ + \ + CallbackWrapper _wrapper = [_callback, CB_PARAMS_NAMES, &_cv, \ + &_callback_finished, &_return_value] { \ + CB_NAME local_callback = reinterpret_cast(_callback); \ + LDEBUG("calling local_callback() %p", local_callback); \ + if (local_callback) { \ + _return_value = local_callback(CB_PARAMS_NAMES); \ + } \ + _callback_finished = true; \ + LDEBUG("calling notify_one()"); \ + _cv.notify_one(); \ + }; \ + \ + LDEBUG("calling RequestCallbackCall()"); \ + RequestCallbackCall(new CallbackWrapper(_wrapper)); \ + \ + LDEBUG("waiting for notification"); \ + while (!_callback_finished) { \ + _cv.wait(lock); \ + } \ + LDEBUG("exit, return_value: %d", (int)_return_value); \ + return _return_value; \ + } \ + \ + CB_RETURN platform_blocking_##CB_NAME##_0(CB_PARAMS) { \ + return platform_blocking_##CB_NAME(GET_CALLBACK_ID(CB_NAME, 0), \ + CB_PARAMS_NAMES); \ + } \ + CB_RETURN platform_blocking_##CB_NAME##_1(CB_PARAMS) { \ + return platform_blocking_##CB_NAME(GET_CALLBACK_ID(CB_NAME, 1), \ + CB_PARAMS_NAMES); \ + } \ + CB_RETURN platform_blocking_##CB_NAME##_2(CB_PARAMS) { \ + return platform_blocking_##CB_NAME(GET_CALLBACK_ID(CB_NAME, 2), \ + CB_PARAMS_NAMES); \ + } \ + CB_RETURN platform_blocking_##CB_NAME##_3(CB_PARAMS) { \ + return platform_blocking_##CB_NAME(GET_CALLBACK_ID(CB_NAME, 3), \ + CB_PARAMS_NAMES); \ + } \ + CB_RETURN platform_blocking_##CB_NAME##_4(CB_PARAMS) { \ + return platform_blocking_##CB_NAME(GET_CALLBACK_ID(CB_NAME, 4), \ + CB_PARAMS_NAMES); \ + } +// end of PROXY_GROUP_RETURN_NO_USER_DATA + +#define PROXY_GROUP_BLOCKING_NO_USER_DATA(CB_NAME, CB_PARAMS...) \ + void platform_blocking_##CB_NAME(uint32_t _callback_id, CB_PARAMS) { \ + LDEBUG("enter id: %d", _callback_id); \ + auto _iter = callback_pointers.find(_callback_id); \ + if (_iter == callback_pointers.end()) { \ + LOG_ERROR("No callback registered for id %d - ignoring.", _callback_id); \ + return; \ + } \ + CallbackPointer _callback = _iter->second; \ + if (gettid() == interop_callbacks_thread_id) { \ + LDEBUG("calling Dart callback directly"); \ + return (reinterpret_cast(_callback))(CB_PARAMS_NAMES); \ + } \ + std::mutex _mutex; \ + std::unique_lock lock(_mutex); \ + std::condition_variable _cv; \ + bool _callback_finished = false; \ + \ + CallbackWrapper _wrapper = [_callback, CB_PARAMS_NAMES, &_cv, \ + &_callback_finished] { \ + CB_NAME local_callback = reinterpret_cast(_callback); \ + LDEBUG("calling local_callback() %p", local_callback); \ + if (local_callback) { \ + local_callback(CB_PARAMS_NAMES); \ + } \ + _callback_finished = true; \ + LDEBUG("calling notify_one()"); \ + _cv.notify_one(); \ + }; \ + \ + LDEBUG("calling RequestCallbackCall()"); \ + RequestCallbackCall(new CallbackWrapper(_wrapper)); \ + \ + LDEBUG("waiting for notification"); \ + while (!_callback_finished) { \ + _cv.wait(lock); \ + } \ + LDEBUG("exit"); \ + } \ + \ + void platform_blocking_##CB_NAME##_0(CB_PARAMS) { \ + platform_blocking_##CB_NAME(GET_CALLBACK_ID(CB_NAME, 0), CB_PARAMS_NAMES); \ + } \ + void platform_blocking_##CB_NAME##_1(CB_PARAMS) { \ + platform_blocking_##CB_NAME(GET_CALLBACK_ID(CB_NAME, 1), CB_PARAMS_NAMES); \ + } \ + void platform_blocking_##CB_NAME##_2(CB_PARAMS) { \ + platform_blocking_##CB_NAME(GET_CALLBACK_ID(CB_NAME, 2), CB_PARAMS_NAMES); \ + } \ + void platform_blocking_##CB_NAME##_3(CB_PARAMS) { \ + platform_blocking_##CB_NAME(GET_CALLBACK_ID(CB_NAME, 3), CB_PARAMS_NAMES); \ + } \ + void platform_blocking_##CB_NAME##_4(CB_PARAMS) { \ + platform_blocking_##CB_NAME(GET_CALLBACK_ID(CB_NAME, 4), CB_PARAMS_NAMES); \ + } +// end of PROXY_GROUP_BLOCKING_NO_USER_DATA + +#define PROXY_GROUP_NON_BLOCKING_NO_USER_DATA(CB_NAME, CB_PARAMS...) \ + void platform_non_blocking_##CB_NAME(uint32_t _callback_id, CB_PARAMS) { \ + LDEBUG("enter id: %d", _callback_id); \ + auto _iter = callback_pointers.find(_callback_id); \ + if (_iter == callback_pointers.end()) { \ + LOG_ERROR("No callback registered for id %d - ignoring.", _callback_id); \ + return; \ + } \ + CallbackPointer _callback = _iter->second; \ + \ + CallbackWrapper _wrapper = [_callback, CB_PARAMS_NAMES] { \ + CB_NAME local_callback = reinterpret_cast(_callback); \ + LDEBUG("calling local_callback() %p", local_callback); \ + if (local_callback) { \ + local_callback(CB_PARAMS_NAMES); \ + } \ + }; \ + \ + LDEBUG("calling RequestCallbackCall()"); \ + RequestCallbackCall(new CallbackWrapper(_wrapper)); \ + } \ + \ + void platform_non_blocking_##CB_NAME##_0(CB_PARAMS) { \ + platform_non_blocking_##CB_NAME(GET_CALLBACK_ID(CB_NAME, 0), \ + CB_PARAMS_NAMES); \ + } \ + void platform_non_blocking_##CB_NAME##_1(CB_PARAMS) { \ + platform_non_blocking_##CB_NAME(GET_CALLBACK_ID(CB_NAME, 1), \ + CB_PARAMS_NAMES); \ + } \ + void platform_non_blocking_##CB_NAME##_2(CB_PARAMS) { \ + platform_non_blocking_##CB_NAME(GET_CALLBACK_ID(CB_NAME, 2), \ + CB_PARAMS_NAMES); \ + } \ + void platform_non_blocking_##CB_NAME##_3(CB_PARAMS) { \ + platform_non_blocking_##CB_NAME(GET_CALLBACK_ID(CB_NAME, 3), \ + CB_PARAMS_NAMES); \ + } \ + void platform_non_blocking_##CB_NAME##_4(CB_PARAMS) { \ + platform_non_blocking_##CB_NAME(GET_CALLBACK_ID(CB_NAME, 4), \ + CB_PARAMS_NAMES); \ + } +// end of PROXY_GROUP_NON_BLOCKING_NO_USER_DATA + +#define PROXY_GROUP_RETURN_NO_USER_DATA_NO_PARAM(CB_NAME, CB_RETURN) \ + CB_RETURN platform_blocking_##CB_NAME(uint32_t _callback_id) { \ + LDEBUG("enter id: %d", _callback_id); \ + auto _iter = callback_pointers.find(_callback_id); \ + if (_iter == callback_pointers.end()) { \ + LOG_ERROR("No callback registered for id %d - ignoring.", _callback_id); \ + return CB_RETURN(); \ + } \ + CallbackPointer _callback = _iter->second; \ + if (gettid() == interop_callbacks_thread_id) { \ + LDEBUG("calling Dart callback directly"); \ + return (reinterpret_cast(_callback))(); \ + } \ + CB_RETURN _return_value = CB_RETURN(); \ + std::mutex _mutex; \ + std::unique_lock lock(_mutex); \ + std::condition_variable _cv; \ + bool _callback_finished = false; \ + \ + CallbackWrapper _wrapper = [_callback, &_cv, &_callback_finished, \ + &_return_value] { \ + CB_NAME local_callback = reinterpret_cast(_callback); \ + LDEBUG("calling local_callback() %p", local_callback); \ + if (local_callback) _return_value = local_callback(); \ + _callback_finished = true; \ + LDEBUG("calling notify_one()"); \ + _cv.notify_one(); \ + }; \ + \ + LDEBUG("calling RequestCallbackCall()"); \ + RequestCallbackCall(new CallbackWrapper(_wrapper)); \ + \ + LDEBUG("waiting for notification"); \ + while (!_callback_finished) { \ + _cv.wait(lock); \ + } \ + LDEBUG("exit, return_value: %d", (int)_return_value); \ + return _return_value; \ + } \ + \ + CB_RETURN platform_blocking_##CB_NAME##_0() { \ + return platform_blocking_##CB_NAME(GET_CALLBACK_ID(CB_NAME, 0)); \ + } \ + CB_RETURN platform_blocking_##CB_NAME##_1() { \ + return platform_blocking_##CB_NAME(GET_CALLBACK_ID(CB_NAME, 1)); \ + } \ + CB_RETURN platform_blocking_##CB_NAME##_2() { \ + return platform_blocking_##CB_NAME(GET_CALLBACK_ID(CB_NAME, 2)); \ + } \ + CB_RETURN platform_blocking_##CB_NAME##_3() { \ + return platform_blocking_##CB_NAME(GET_CALLBACK_ID(CB_NAME, 3)); \ + } \ + CB_RETURN platform_blocking_##CB_NAME##_4() { \ + return platform_blocking_##CB_NAME(GET_CALLBACK_ID(CB_NAME, 4)); \ + } +// end of PROXY_GROUP_RETURN_NO_USER_DATA_NO_PARAM + +// CB_NAME does not contain indices. +#define MULTI_PROXY_MAP_ENTRY(CB_NAME) \ + {std::string(#CB_NAME), \ + {{ \ + reinterpret_cast(CB_NAME##_0), \ + reinterpret_cast(CB_NAME##_1), \ + reinterpret_cast(CB_NAME##_2), \ + reinterpret_cast(CB_NAME##_3), \ + reinterpret_cast(CB_NAME##_4), \ + }}}, + +typedef void *MultiProxyFunctions[kProxyInstanceCount]; + +struct MultiProxyFunctionsContainer { + MultiProxyFunctions mp; +}; + +#endif // TIZEN_INTEROP_CALLBACKS_MACROS_H_ diff --git a/packages/tizen_interop_callbacks/tizen/src/tizen_interop_callbacks_plugin.cc b/packages/tizen_interop_callbacks/tizen/src/tizen_interop_callbacks_plugin.cc new file mode 100644 index 0000000..6661391 --- /dev/null +++ b/packages/tizen_interop_callbacks/tizen/src/tizen_interop_callbacks_plugin.cc @@ -0,0 +1,179 @@ +// Copyright 2023 Samsung Electronics Co., Ltd. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#include "tizen_interop_callbacks_plugin.h" + +#include + +#include +#include +#include + +#include "log.h" +#include "macros.h" + +// Maps unique callback registration ID to registered user callback. +std::map callback_pointers; + +// The thread where the plugin was initialized with +// TizenInteropCallbacksRegisterSendPort(). The callbacks provided by the user +// will be executed in it. +unsigned long interop_callbacks_thread_id = 0; + +namespace { + +// The port to communicate with isolate that initialized TizenInteropCallbacks. +Dart_Port send_port = 0; + +uint32_t last_used_callback_id = 99; + +class TizenInteropCallbacksPlugin : public flutter::Plugin { + public: + static void RegisterWithRegistrar(flutter::PluginRegistrar *registrar) { + auto plugin = std::make_unique(); + registrar->AddPlugin(std::move(plugin)); + } + + TizenInteropCallbacksPlugin() {} + + virtual ~TizenInteropCallbacksPlugin() {} +}; + +} // namespace + +void TizenInteropCallbacksPluginRegisterWithRegistrar( + FlutterDesktopPluginRegistrarRef registrar) { + TizenInteropCallbacksPlugin::RegisterWithRegistrar( + flutter::PluginRegistrarManager::GetInstance() + ->GetRegistrar(registrar)); +} + +#include "generated_callbacks.cc" + +void RequestCallbackCall(CallbackWrapper *wrapper) { + LDEBUG("in RequestCallbackCall(), wrapper: %p", wrapper); + + Dart_CObject wrapper_cobj; + wrapper_cobj.type = Dart_CObject_kInt64; + wrapper_cobj.value.as_int64 = reinterpret_cast(wrapper); + + bool posted = Dart_PostCObject_DL(send_port, &wrapper_cobj); + if (!posted) { + LOG_ERROR("Dart_PostCObject_DL(): message %p not posted.", wrapper); + delete wrapper; + } + LDEBUG("after calling Dart_PostCObject_DL()"); +} + +intptr_t TizenInteropCallbacksInitDartApi(void *data) { + auto error = Dart_InitializeApiDL(data); + if (error) { + LOG_ERROR("Dart_InitializeApiDL() failed."); + } + return error; +} + +// Stores the SendPort ID created in Dart for communication. Returns non-zero if +// called twice. +int32_t TizenInteropCallbacksRegisterSendPort(Dart_Port port) { + if (send_port) { + if (interop_callbacks_thread_id != gettid()) { + LOG_ERROR( + "Attempted TizenInteropCallbacks initialization from another " + "thread."); + return 1; + } else { + LOG_WARN( + "Attempted TizenInteropCallbacks initialization again - resetting."); + send_port = port; + callback_pointers.clear(); + return 2; + } + } + send_port = port; + interop_callbacks_thread_id = gettid(); + return 0; +} + +// Finds an ID not existing in callback_pointers. Returns 0 on failure. +uint32_t FindFreeCallbackId() { + uint32_t callback_id = ++last_used_callback_id; + auto iter = callback_pointers.find(callback_id); + if (!callback_id || iter != callback_pointers.end()) { + // in an unusual case of wrapping or taken id, loop over used ones + if (!callback_id) { + iter = callback_pointers.find(++callback_id); + } + while (iter != callback_pointers.end() && iter->first == callback_id) { + ++iter; + ++callback_id; + } + last_used_callback_id = callback_id; + } + return callback_id; +} + +RegistrationResult TizenInteropCallbacksRegisterWrappedCallback( + void *user_callback, const char *proxy_name, int32_t proxy_num) { + if (proxy_num < 0 || proxy_num >= kProxyInstanceCount) { + LOG_ERROR("proxy_num %d is out of acceptable range.", proxy_num); + return {nullptr, 0}; + } + const auto &multi_proxy_iter = multi_proxy_map.find(std::string(proxy_name)); + if (multi_proxy_iter == multi_proxy_map.end()) { + LOG_ERROR("Wrong proxy_name: %s", proxy_name); + return {nullptr, 0}; + } + + uint32_t callback_id = FindFreeCallbackId(); + if (!callback_id) { + LOG_ERROR("Failed to find unused callback ID for %s.", proxy_name); + return {nullptr, 0}; + } + + LDEBUG("%s id: %d, user_callback: %p", proxy_name, callback_id, + user_callback); + callback_pointers[callback_id] = user_callback; + + // We are only expecting proxy_name to be either platform_blocking_{CALLBACK} + // or platform_non_blocking_{CALLBACK}. Test the 9th character to check which + // one is it, and depending on that remove the ..._blocking_ prefix which ends + // at either 22nd (non_blocking variant) or 18th (blocking one) character. + const auto &base_id_iter = reserved_base_id_map.find( + std::string(proxy_name + ((proxy_name[9] == 'n') ? 22 : 18))); + if (base_id_iter != reserved_base_id_map.end()) { + int base_id = base_id_iter->second; + LDEBUG("storing remap callback id %s: %d+%d -> %d", + base_id_iter->first.c_str(), base_id, proxy_num, callback_id); + reserved_callback_ids[base_id + proxy_num] = callback_id; + } + + LDEBUG("will use proxy callback %p", multi_proxy_iter->second.mp[proxy_num]); + return {multi_proxy_iter->second.mp[proxy_num], callback_id}; +} + +void TizenInteropCallbacksUnregisterWrappedCallback(uint32_t callback_id) { + const auto &iter = callback_pointers.find(callback_id); + if (iter != callback_pointers.end()) { + callback_pointers.erase(callback_id); + } else { + LOG_WARN("Callback with id %d not found, ignoring.", callback_id); + } +} + +// Executes the given wrapper. It is called from Dart, so the wrapped code is +// executed in the proper thread. +void TizenInteropCallbacksRunCallback(CallbackWrapper *wrapper_pointer) { + CallbackWrapper wrapper = *wrapper_pointer; + LDEBUG("calling wrapper() at %p", wrapper_pointer); + wrapper(); + LDEBUG("after calling wrapper()"); + delete wrapper_pointer; +} + +// Returns true if the given platform callback exists. Used to check if +// non-blocking variant is available. +bool TizenInteropCallbacksProxyExists(const char *name) { + return multi_proxy_map.count(std::string(name)); +} diff --git a/packages/tizen_interop_callbacks/tizen/src/types.h b/packages/tizen_interop_callbacks/tizen/src/types.h new file mode 100644 index 0000000..777e46c --- /dev/null +++ b/packages/tizen_interop_callbacks/tizen/src/types.h @@ -0,0 +1,39 @@ +// Copyright 2023 Samsung Electronics Co., Ltd. All rights reserved. +// Use of this source code is governed by a BSD-style license that can be +// found in the LICENSE file. + +#ifndef TIZEN_INTEROP_CALLBACKS_TYPES_H_ +#define TIZEN_INTEROP_CALLBACKS_TYPES_H_ + +// This file contains a few structures copied from Tizen native API headers, +// as we need their full definitions if they are used directly in callback +// signatures but not as pointers. + +typedef struct { + double latitude; + double longitude; +} location_coords_s_copy; + +typedef struct { + int x; + int y; +} mv_point_s_copy; + +typedef struct { + mv_point_s_copy point; + int width; + int height; +} mv_rectangle_s_copy; + +#define WIFI_DIRECT_MAX_DEVICE_NAME_LEN 32 +#define WIFI_DIRECT_MAC_ADDRESS_LEN 18 +typedef struct { + char device_name[WIFI_DIRECT_MAX_DEVICE_NAME_LEN + 1]; + char mac_address[WIFI_DIRECT_MAC_ADDRESS_LEN + 1]; +} wifi_direct_connection_state_cb_data_s_copy; + +typedef enum { SOME_ENUM_0 } some_enum; + +typedef void *void_pointer; + +#endif // TIZEN_INTEROP_CALLBACKS_TYPES_H_ diff --git a/scripts/README.md b/scripts/README.md index af49bc7..a531cac 100644 --- a/scripts/README.md +++ b/scripts/README.md @@ -22,3 +22,10 @@ ```sh scripts/ffigen_helper.sh ``` + +4. Update callbacks data + * Run `./generate_callbacks.sh verify` to check type substitution. + Build errors will have to be addressed by editing `gen_callbacks.py`. + If substitution is not found or assert fails - edit the type mapping + (see CallbackDataCollector.type_substitute() and maps used there: KNOWN\_TYPES, SPECIAL\_TYPES). + * Run `./generate_callbacks.sh` to update `callbacks.cc` with callbacks data. diff --git a/scripts/callbacks_generator/README.md b/scripts/callbacks_generator/README.md new file mode 100644 index 0000000..be3b564 --- /dev/null +++ b/scripts/callbacks_generator/README.md @@ -0,0 +1,44 @@ +# callbacks\_generator + +The purpose of this script is to process a Tizen Native API header, extract callbacks declaration, and generate a set of macros like this: + +``` c +typedef void (*bt_avrcp_repeat_mode_changed_cb)(some_enum repeat, void* user_data); +#define CB_PARAMS_NAMES repeat, user_data +PROXY_GROUP_NON_BLOCKING(bt_avrcp_repeat_mode_changed_cb, some_enum repeat, void* user_data) +PROXY_GROUP_BLOCKING(bt_avrcp_repeat_mode_changed_cb, some_enum repeat, void* user_data) +#undef CB_PARAMS_NAMES +``` + +The callbacks parameters seen here has been substituted to avoid dependency on actual API headers, while ensure binary compatibility (i.e. the size of each parameter must match). See substitution verification below. + +If `--config` switch is used to pass a ffigen config file/files, script will scan rootstrap include directory for matching headers and process all of them. + +## Supported callbacks + +The following callback patterns are supported: +* void returning callbacks with user_data parameter - those are the most common +* simple type returning callbacks with user_data parameter +* void returning callbacks without user_data parameter - including no parameters at all + +## Callbacks without user_data parameter + +For callbacks that does not have `user_data` parameter, additional : +``` c +#define BASE_CALLBACK_ID_stte_deinitialize_cb 30 +typedef int (*stte_deinitialize_cb)(); +PROXY_GROUP_RETURN_NO_USER_DATA_NO_PARAM(stte_deinitialize_cb, int) +``` + +The total number of callbacks like this is included at the beginning of the generated code: +``` c +static constexpr int32_t kNoUserDataCallbackCount = 56; +``` + +## Verification of type substitution + +If the script is called with `-a` / `--asserts` switch it will generate a set of static asserts for the type substitution used in callbacks parameters, like this: +``` c +static_assert(sizeof(ppm_request_result_e) == sizeof(some_enum), "Wrong type substitution - ppm_request_result_e and some_enum have different sizes."); +``` +When this code is compiled, it will report any wrong type substitution. diff --git a/scripts/callbacks_generator/__init__.py b/scripts/callbacks_generator/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/scripts/callbacks_generator/gen_callbacks.py b/scripts/callbacks_generator/gen_callbacks.py new file mode 100755 index 0000000..23f270b --- /dev/null +++ b/scripts/callbacks_generator/gen_callbacks.py @@ -0,0 +1,1002 @@ +#!/usr/bin/env python3 +# Copyright 2023 Samsung Electronics Co., Ltd. All rights reserved. +# Use of this source code is governed by a BSD-style license that can be +# found in the LICENSE file. + +import os +import sys +import copy +import glob +import yaml +import logging +import argparse +from io import StringIO +from typing import List, Mapping, Callable, Set + +log = logging.getLogger('gen_callbacks') + +PROXY_INSTANCES_COUNT = 5 + +# Callbacks which have user_data parameter, but are not detected: +CB_USER_DATA_OVERRIDES = { + 'ime_language_requested_cb', + 'ime_imdata_requested_cb', + 'ime_geometry_requested_cb', + 'image_util_decode_completed_cb', + 'image_util_encode_completed_cb', +} + +CB_PARAMETER_PATCHES: Mapping[str, Callable] = { + 'sensor_accuracy_changed_cb': + lambda cb: cb.params[-1].set_name('user_data'), + 'system_settings_iter_cb': + lambda cb: cb.params[-1].set_name('user_data'), + 'sensor_events_cb': + lambda cb: cb.params[1].set_type('sensor_event_s*').set_name('events'), + 'mv_barcode_detected_cb': + lambda cb: cb.params[3].set_type('const char**').set_name('messages'), +} + +KNOWN_TYPES = { + 'bool', + 'bool*', + 'char*', + 'char**', + 'double', + 'float*', + 'float**', + 'int', + 'int*', + 'long', + 'long long', + 'unsigned', + 'unsigned char', + 'unsigned char*', + 'unsigned char**', + 'unsigned int', + 'unsigned int*', + 'unsigned long', + 'unsigned long long', + 'unsigned short', + 'void', + 'void*', + 'void**', + 'bool', + 'bool*', + 'char*', + 'char**', + 'double', + 'float*', + 'float**', + 'int', + 'int*', + 'long', + 'long long', + 'size_t', + 'time_t', + 'unsigned', + 'unsigned char', + 'unsigned char*', + 'unsigned char**', + 'unsigned int', + 'unsigned int*', + 'unsigned long', + 'unsigned long long', + 'unsigned short', + 'void', + 'void*', + 'void**', + 'size_t', + 'time_t', +} + +SPECIAL_TYPES = { + 'dnssd_browser_h': 'unsigned int', + 'dnssd_service_h': 'unsigned int', + 'mtp_device_h': 'int', + 'mtp_object_h': 'int', + 'mtp_storage_h': 'int', + 'ssdp_browser_h': 'unsigned int', + 'ssdp_service_h': 'unsigned int', + 'result_set_cursor': 'void*', + 'stte_result_time_cb': 'void*', + 'stte_supported_language_cb': 'void*', + 'ttse_supported_voice_cb': 'void*', + 'vce_supported_language_cb': 'void*', + 'Ecore_IMF_Input_Hints': 'some_enum', + 'Ecore_IMF_Input_Panel_Lang': 'some_enum', + 'Ecore_IMF_Input_Panel_Layout': 'some_enum', + 'Ecore_IMF_Input_Panel_Return_Key_Type': 'some_enum', + 'eom_output_id': 'unsigned int', + 'location_coords_s': 'location_coords_s_copy', + 'mv_rectangle_s': 'mv_rectangle_s_copy', + 'wifi_direct_connection_state_cb_data_s': 'wifi_direct_connection_state_cb_data_s_copy', +} + + +class Token: + def __init__(self, _type): + self._type = _type + self.word = '' + self.contents = '' + + def __repr__(self): + if self._type == 'W': + return '' % (self.word) + elif self._type == 'X': + return '' % (self.contents) + else: + return '<%s>' % (self._type) + + def __eq__(self, other): + return self._type == other._type and \ + self.word == other.word and \ + self.contents == other.contents + + +class ParamInfo: + def __init__(self, _type, name): + self._type = _type + self.name = name + + def __repr__(self): + return '

' % (self._type, self.name) + + def __eq__(self, other): + return self._type == other._type and \ + self.name == other.name + + def set_name(self, name): + self.name = name + return self + + def set_type(self, _type): + self._type = _type + return self + + +class CallbackInfo: + def __init__(self): + self.filename = '' + self.ret_type = '' + self.name = '' + self.params: List[ParamInfo] = [] + self._has_user_data: bool = None + + def __repr__(self): + rep = ' 0: + rep += ', ' + rep += repr(self.params[i]) + rep += ')>' + return rep + + def __eq__(self, other): + return self.ret_type == other.ret_type and \ + self.name == other.name and \ + self.params == other.params + + def compatible_signature(self, other): + param_types = [p._type for p in self.params] + param_types_other = [p._type for p in other.params] + return self.ret_type == other.ret_type and param_types == param_types_other + + @property + def allow_non_blocking(self): + return self.ret_type == 'void' + + @property + def has_user_data(self): + if self._has_user_data is None: + self._has_user_data = bool( + self.params) and self.params[-1].name == 'user_data' + return self._has_user_data + + def override_has_user_data(self, has_user_data): + self._has_user_data = has_user_data + + @property + def param_names(self) -> str: + if self.params and self.params[0].name != 'void': + return ', '.join(p.name for p in self.params) + else: + return '' + + @property + def param_list(self) -> str: + """ + Parameters to append in macro. + """ + if not self.params or (len(self.params) == 1 and self.params[0].name == 'void'): + return '' + return ', ' + ', '.join('%s %s' % (p._type, p.name) for p in self.params) + + +class CallbackSignatureReader: + def __init__(self, code_reader, tokens): + self.cr = code_reader + self.tokens = tokens + self.cur_idx = -1 + self.params = [] + + def is_end_of_param(self, token): + return token._type == self.cr.TOKEN_COMMA or token._type == self.cr.TOKEN_PAREN_RIGHT + + # Reads parameter tokens starting at cur_idx. + # Sets cur_idx to the ',' or ')' after the parameter. + def read_param(self): + t = self.tokens + + # Reading param tokens while accounting for newline tokens would make + # the code needlessly complex. + # Instead, we analyze param tokens with newlines removed. + param_tokens = [] # without newlines + i = self.cur_idx + while not self.is_end_of_param(t[i]): + if t[i]._type != self.cr.TOKEN_NEWLINE: + param_tokens.append(t[i]) + i += 1 + self.cur_idx = i + + _type = '' + pt = param_tokens + # len(pt) - 1 because the last token is the name, + # all others before it are parts of type. + for i in range(0, len(pt) - 1): + if pt[i]._type == self.cr.TOKEN_WORD: + _type += ' ' + _type += pt[i].word + else: # This is an asterisk + if _type.endswith('*'): + _type += '*' + else: + _type += ' *' + + name = pt[-1].word + self.params.append(ParamInfo(_type.strip(), name)) + + def read_signature(self, typedef_token_idx): + t = self.tokens + cb_info = CallbackInfo() + cb_info.filename = self.cr.filename + + # Set cur_idx so that we are at 'typedef': + # typedef void (*done_cb)(int id, void *user_data); + # ^^^^^^^ + self.cur_idx = typedef_token_idx + + # Move until we find a word (skips newline tokens): + # typedef void (*done_cb)(int id, void *user_data); + # ^^^^ + self.cur_idx += 1 + while t[self.cur_idx]._type != self.cr.TOKEN_WORD: + self.cur_idx += 1 + + cb_info.ret_type = t[self.cur_idx].word + + # Move until we find the next word, which will be the callback's name: + # typedef void (*done_cb)(int id, void *user_data); + # ^^^^^^^ + self.cur_idx += 1 + while t[self.cur_idx]._type != self.cr.TOKEN_WORD: + self.cur_idx += 1 + + cb_info.name = t[self.cur_idx].word + + # Move until we find '(', which opens the parameters. + # Then move to the next token, which will be type of the first parameter: + # typedef void (*done_cb)(int id, void *user_data); + # ^^^ + # Or, in case of a parameterless callback, the closing ')': + # typedef void (*done_cb)(); + # ^ + self.cur_idx += 1 + while t[self.cur_idx]._type != self.cr.TOKEN_PAREN_LEFT: + self.cur_idx += 1 + self.cur_idx += 1 + + # Read parameters until we reach the closing ')'. + while t[self.cur_idx]._type != self.cr.TOKEN_PAREN_RIGHT: + self.read_param() + if t[self.cur_idx]._type == self.cr.TOKEN_COMMA: + # We are here: + # typedef void (*done_cb)(int id, void *user_data); + # ^ + + # Move to the next parameter (skip newlines) + while t[self.cur_idx]._type != self.cr.TOKEN_WORD: + self.cur_idx += 1 + + # We are now here: + # typedef void (*done_cb)(int id, void *user_data); + # ^ + + for p in self.params: + cb_info.params.append(p) + + return cb_info + + +class CodeReader: + def __init__(self): + self.filename = '' + self.string = '' + self.tokens = [] + + # Key: handle name, value: underlying type + # Example: + # typedef void *handle_h; + # Key: 'handle_h', value: 'void *' + self.handles = {} + + self.callbacks = [] + + self.TOKEN_WORD = 'W' + self.TOKEN_NEWLINE = '\n' + self.TOKEN_ASTERISK = '*' + self.TOKEN_COMMA = ',' + self.TOKEN_PERIOD = '.' + self.TOKEN_SEMICOLON = ';' + self.TOKEN_PAREN_LEFT = '(' + self.TOKEN_PAREN_RIGHT = ')' + self.TOKEN_BRACE_LEFT = '{' + self.TOKEN_BRACE_RIGHT = '}' + self.TOKEN_BRACKET_LEFT = '[' + self.TOKEN_BRACKET_RIGHT = ']' + self.TOKEN_LINE_CMNT_START = '//' + self.TOKEN_COMMENT_START = '/*' + self.TOKEN_DOXYGEN_CMNT_START = '/**' + self.TOKEN_COMMENT_END = '*/' + self.TOKEN_AT = '@' + self.TOKEN_OTHER = 'X' + + def read_file(self, filename): + self.filename = filename + f = open(filename, encoding='UTF-8') + self.string = f.read() + f.close() + + @classmethod + def read_callbacks_from_string(class_, code): + cr = class_() + cr.filename = '' + cr.string = code + cr.tokenize() + cr.find_typedefs() + return cr.callbacks + + def is_part_of_word(self, c, is_first_char): + if is_first_char: + return c.isalpha() or c == '_' + else: + return c.isalnum() or c == '_' + + def tokenize(self): + self.tokens = [] + cur_word = '' + s = self.string + ' ' # two spaces allow safe checks for '/**' + slen = len(s) + i = 0 + while i < slen: + c = s[i] + + is_first_word_char = cur_word == '' + if self.is_part_of_word(c, is_first_word_char): + cur_word += c + i += 1 + continue + else: + if cur_word != '': + t = Token(self.TOKEN_WORD) + t.word = cur_word + self.tokens.append(t) + cur_word = '' + + if c.isspace(): + if c == '\n': + # Why store newlines as tokens while ignoring other whitespace + # characters? + # Newlines are needed for detecting '//' comments. + # Also, if we wanted to detect asterisks that are part of a multi-line + # comment: + # /** + # * + # */ + # then newlines are going to be useful. + self.tokens.append(Token(self.TOKEN_NEWLINE)) + i += 1 + continue + elif c == '*': + if s[i + 1] == '/': + self.tokens.append(Token(self.TOKEN_COMMENT_END)) + i += 2 # skip one character, as we have a two-char token '*/' + continue + else: + self.tokens.append(Token(self.TOKEN_ASTERISK)) + i += 1 + continue + elif c == ',': + self.tokens.append(Token(self.TOKEN_COMMA)) + i += 1 + continue + elif c == '.': + self.tokens.append(Token(self.TOKEN_PERIOD)) + i += 1 + continue + elif c == ';': + self.tokens.append(Token(self.TOKEN_SEMICOLON)) + i += 1 + continue + elif c == '(': + self.tokens.append(Token(self.TOKEN_PAREN_LEFT)) + i += 1 + continue + elif c == ')': + self.tokens.append(Token(self.TOKEN_PAREN_RIGHT)) + i += 1 + continue + elif c == '{': + self.tokens.append(Token(self.TOKEN_BRACE_LEFT)) + i += 1 + continue + elif c == '}': + self.tokens.append(Token(self.TOKEN_BRACE_RIGHT)) + i += 1 + continue + elif c == '[': + self.tokens.append(Token(self.TOKEN_BRACKET_LEFT)) + i += 1 + continue + elif c == ']': + self.tokens.append(Token(self.TOKEN_BRACKET_RIGHT)) + i += 1 + continue + elif c == '/': + if s[i + 1] == '/': + self.tokens.append(Token(self.TOKEN_LINE_CMNT_START)) + i += 2 # skip one character, as we have a two-char token '//' + continue + elif s[i + 1] == '*' and s[i + 2] != '*': + self.tokens.append(Token(self.TOKEN_COMMENT_START)) + i += 2 # skip one character, as we have a two-char token '/*' + continue + elif s[i + 1] == '*' and s[i + 2] == '*': + self.tokens.append(Token(self.TOKEN_DOXYGEN_CMNT_START)) + i += 3 # skip two characters, as we have a three-char token '/**' + continue + else: + t = Token(self.TOKEN_OTHER) + t.contents = '/' + self.tokens.append(t) + i += 1 + continue + elif c == '@': + self.tokens.append(Token(self.TOKEN_AT)) + i += 1 + continue + else: + t = Token(self.TOKEN_OTHER) + t.contents = c + self.tokens.append(t) + i += 1 + continue + + def read_comment(self, idx): + # idx is at '/*' or '/**' + + # Move until '*/' is found. + # We assume that comments have the closing '*/'. + t = self.tokens + while t[idx]._type != self.TOKEN_COMMENT_END: + idx += 1 + + # Move to the token after '*/'. + idx += 1 + + return idx + + def read_line_comment(self, idx): + # idx is at '//' + + # Move until newline or end of file is found. + t = self.tokens + while t[idx]._type != self.TOKEN_NEWLINE and idx < len(t) - 1: + idx += 1 + + # Move to the token after newline/eof. + # This is ok, because the loop in find_typedefs() will stop if token + # index is out of range. + idx += 1 + + return idx + + def is_callback_typedef(self, idx): + t = self.tokens + + # We need 3 non-newline tokens after 'typedef'. + # It's unlikely but possible that multi-line signature of a callback + # will include the 'typedef void (*' part split by newlines. + + nnt = [] # no newline tokens + i = idx + 1 + while len(nnt) < 3: + if t[i]._type != self.TOKEN_NEWLINE: + nnt.append(t[i]) + i += 1 + + return nnt[0]._type == self.TOKEN_WORD and \ + nnt[1]._type == self.TOKEN_PAREN_LEFT and \ + nnt[2]._type == self.TOKEN_ASTERISK + + # Also detects enums and unions. + # If we have a '{' in the definition, that means this is a struct/ + # enum/union. We look for it until we reach ';'. + def is_struct_typedef(self, idx): + t = self.tokens + i = idx + while t[i]._type != self.TOKEN_SEMICOLON: + # We could account for a newline between '}' and ';', but that + # doesn't occur in the API. + if t[i]._type == self.TOKEN_BRACE_LEFT: + return True + i += 1 + return False + + # In this method, if we have + # typedef void *handle_h; + # by "name" (handle name) we mean handle_h, and by "_type" (underlying type) + # we mean "void *". + def read_handle(self, idx): + t = self.tokens + _type = '' + i = idx + 1 # idx is at the word 'typedef', skip to start reading type + while t[i]._type != self.TOKEN_SEMICOLON: + if t[i + 1]._type == self.TOKEN_SEMICOLON: + # We are at the last token before ';' which means this is the name + # of the handle type and the underlying type was already read. + # We've found all we need, we add the handle to found handles. + name = t[i].word + self.handles[name] = _type.strip() + return + else: + # We are not at the handle name yet, this is part of the + # underlying type. + if t[i]._type == self.TOKEN_WORD: + _type += ' ' + _type += t[i].word + elif t[i]._type == self.TOKEN_ASTERISK: + if _type.endswith('*'): + _type += '*' + else: + _type += ' *' + i += 1 + + def find_typedefs(self): + t = self.tokens + i = 0 + while i < len(t): + _type = t[i]._type + if _type == self.TOKEN_LINE_CMNT_START: + i = self.read_line_comment(i) + continue + elif _type == self.TOKEN_COMMENT_START or _type == self.TOKEN_DOXYGEN_CMNT_START: + i = self.read_comment(i) + continue + elif t[i]._type != self.TOKEN_WORD: + i += 1 + continue + elif t[i].word != 'typedef': + i += 1 + continue + elif self.is_callback_typedef(i): + csr = CallbackSignatureReader(self, self.tokens) + cb_info = csr.read_signature(i) + self.callbacks.append(cb_info) + # If a typedef is not a callback, and is not a struct/enum/union type, + # then it's likely a definition we're interested in - a handle: + # typedef void *handle_h; + elif not self.is_struct_typedef(i): + self.read_handle(i) + + i += 1 + + +class CallbackDataCollector: + def __init__(self): + self.callbacks: Mapping[str, CallbackInfo] = {} + self.types = {} + self.no_user_data_callbacks = set() + self.versions = [] + self.version = None + self._used_type_mapping = None + self.loaded_headers = [] + self.allowed_names: Set[str] = [] + + def set_version(self, version): + self.version = version + if version not in self.versions: + self.versions.append(version) + + def enable_asserts(self): + self._used_type_mapping = set() + + def load_headers(self, headers): + cr = CodeReader() + for f in headers: + cr.read_file(f) + cr.tokenize() + cr.find_typedefs() + self.loaded_headers.append(f) + + for cb in cr.callbacks: + if cb.name in self.callbacks: + if not cb.compatible_signature(self.callbacks[cb.name]): + log.warn('Callback %s signature mismatch %s\n\t%s\n\t%s', + self.version, cb.name, repr(cb), repr(self.callbacks[cb.name])) + else: + self.callbacks[cb.name] = cb + + def preprocess_callbacks_data(self): + if self._used_type_mapping is not None: + callbacks_before_rewrite = copy.deepcopy(self.callbacks) + if self.allowed_names: + names = set(self.callbacks) + not_allowed_names = names.difference(self.allowed_names) + if not_allowed_names: + log.debug('Ignoring following names not found in bindings: %s', not_allowed_names) + for name in not_allowed_names: + del self.callbacks[name] + + for name, cb in self.callbacks.items(): + + patch = CB_PARAMETER_PATCHES.get(name) + if patch: + patch(cb) + + if name in CB_USER_DATA_OVERRIDES: + cb.override_has_user_data(True) + + if not cb.has_user_data: + self.no_user_data_callbacks.add(name) + + self.rewrite_types(cb) + + if self._used_type_mapping is not None: + for name, cb in self.callbacks.items(): + original_cb = callbacks_before_rewrite[name] + self._used_type_mapping.add((original_cb.ret_type, cb.ret_type)) + for param, original_param in zip(cb.params, original_cb.params): + self._used_type_mapping.add((original_param._type, param._type)) + + def get_type_mapping(self): + const_items = set( + item for item in self._used_type_mapping if item[0].startswith('const ')) + self._used_type_mapping.difference_update(const_items) + self._used_type_mapping.update( + set((item[0].replace('const ', ''), item[1].replace('const ', '')) + for item in const_items) + ) + if self._used_type_mapping is not None: + for item in sorted(self._used_type_mapping): + if item[0] == item[1] or item[0].replace(' ', '') == item[1].replace(' ', ''): + continue + + # FIXME: those exceptions are probably results of issue with paramter parsing + if item[0] == 'char * messages *': + yield 'char **', item[1] + elif item[0] == 'sensor_event_s events *': + yield 'sensor_event_s*', item[1] + else: + yield item + + def set_bindings_filter(self, bindings_file_paths: List[str]): + names = set() + for bindings_path in bindings_file_paths: + with open(bindings_path) as bindings_file: + for line in bindings_file: + if line.startswith('typedef '): + names.add(line.split()[1]) + + self.allowed_names = names + + @classmethod + def rewrite_types(class_, cb: CallbackInfo): + cb.ret_type = class_.type_substitute(cb.ret_type) + if cb.ret_type == 'void*': + cb.ret_type = 'void_pointer' + elif cb.ret_type.endswith('*'): + log.error( + 'Callback %s returns pointer: %s. Please add typedef for it.', cb.name, cb.ret_type) + for param in cb.params: + if param.name == 'void': + return + param.set_type(class_.type_substitute(param._type)) + + @classmethod + def type_substitute(class_, t): + t = t.strip().replace(' *', '*') + if t.startswith('const '): + inner = t[5:] + if inner in KNOWN_TYPES: + return t + else: + return 'const ' + class_.type_substitute(inner) + elif t in KNOWN_TYPES: + return t + elif t in SPECIAL_TYPES: + return SPECIAL_TYPES[t] + elif t.endswith('*') or t.endswith('_h'): + return 'void*' + elif t.endswith('_e'): + return 'some_enum' + log.error('Failed to map type `%s`.', t) + return t + + +class CallbackGenerator: + def __init__(self, callbacks): + self.filenames = [] + self.callbacks = callbacks + self.out = StringIO() + self.callback_id = 0 + self.no_user_data_callbacks = set() + self.map_entries = [] + + def writeln(self, *args): + print(*args, file=self.out) + + def write_reserved_callback_id(self, cb): + self.writeln(f'#define BASE_CALLBACK_ID_{cb.name} {self.callback_id}') + self.callback_id += PROXY_INSTANCES_COUNT + self.no_user_data_callbacks.add(cb.name) + + def generate_single_callback_code_non_blocking(self, cb: CallbackInfo): + if cb.has_user_data: + self.writeln(f'PROXY_GROUP_NON_BLOCKING({cb.name}{cb.param_list})') + else: + self.writeln( + f'PROXY_GROUP_NON_BLOCKING_NO_USER_DATA({cb.name}{cb.param_list})') + + self.map_entries.append((cb.name, f'platform_non_blocking_{cb.name}')) + + def generate_single_callback_code_blocking(self, cb: CallbackInfo): + if cb.ret_type == 'void': + if cb.has_user_data: + self.writeln(f'PROXY_GROUP_BLOCKING({cb.name}{cb.param_list})') + elif cb.param_list: + self.writeln( + f'PROXY_GROUP_BLOCKING_NO_USER_DATA({cb.name}{cb.param_list})') + else: + raise NotImplementedError( + 'NO return AND no params is not supported: ' + cb.name) + else: + if cb.has_user_data: + self.writeln( + f'PROXY_GROUP_RETURN({cb.name}, {cb.ret_type}{cb.param_list})') + elif cb.param_list: + self.writeln( + f'PROXY_GROUP_RETURN_NO_USER_DATA({cb.name}, {cb.ret_type}{cb.param_list})') + else: + self.writeln( + f'PROXY_GROUP_RETURN_NO_USER_DATA_NO_PARAM({cb.name}, {cb.ret_type})') + self.map_entries.append((cb.name, f'platform_blocking_{cb.name}')) + + def generate_single_callback_code(self, cb: CallbackInfo): + if not cb.has_user_data: + self.write_reserved_callback_id(cb) + self.writeln( + f'typedef {cb.ret_type} (*{cb.name})({cb.param_list.lstrip(", ")});') + + has_params = bool(cb.param_list) + if has_params: + self.writeln(f'#define CB_PARAMS_NAMES {cb.param_names}') + + if cb.allow_non_blocking: + self.generate_single_callback_code_non_blocking(cb) + self.generate_single_callback_code_blocking(cb) + + if has_params: + self.writeln('#undef CB_PARAMS_NAMES\n') + else: + self.writeln() + + def generate_callbacks(self): + for cb in sorted(self.callbacks, key=lambda cb: cb.name): + self.generate_single_callback_code(cb) + return self.out + + def process_files(self, filenames, headers_prepend={}): + self.filenames = filenames + + cr = CodeReader() + for f in filenames: + cr.read_file(f) + cr.tokenize() + cr.find_typedefs() + + self.callbacks = cr.callbacks + + if self.callbacks: + for f in sorted(self.filenames): + if 'rootstrap' in f and '/usr/include/' in f: + header = f[f.index('/usr/include/') + 13:] + if header in headers_prepend: + for h in headers_prepend[header]: + self.writeln('#include <%s>' % h) + self.writeln('#include <%s>\n' % header) + + return self.generate_callbacks() + + def generate_full_source(self, api): + generate_preamble(self.out) + print(f'static_assert(kProxyInstanceCount == {PROXY_INSTANCES_COUNT}, "Callbacks instances count mismatch");', + file=self.out) + print( + f'static constexpr int32_t kNoUserDataCallbackCount = {len(api.no_user_data_callbacks)};\n', file=self.out) + print( + 'uint32_t reserved_callback_ids[kProxyInstanceCount * kNoUserDataCallbackCount] = {};\n', file=self.out) + self.generate_callbacks() + print( + '\nstd::map multi_proxy_map = {', file=self.out) + for cb in sorted(self.callbacks, key=lambda cb: cb.name): + print( + f' MULTI_PROXY_MAP_ENTRY(platform_blocking_{cb.name})', file=self.out) + if cb.allow_non_blocking: + print( + f' MULTI_PROXY_MAP_ENTRY(platform_non_blocking_{cb.name})', file=self.out) + print('};\n', file=self.out) + print( + 'std::map reserved_base_id_map = {', file=self.out) + for cb in sorted(api.no_user_data_callbacks): + print(f' {{"{cb}", BASE_CALLBACK_ID_{cb}}},', file=self.out) + print('};', file=self.out) + log.info(f'Generated code for {len(api.callbacks)} callbacks.') + + @staticmethod + def generate_from_collector(api: CallbackDataCollector, output): + api.preprocess_callbacks_data() + cg = CallbackGenerator(list(api.callbacks.values())) + cg.out = output + cg.generate_full_source(api) + + @staticmethod + def generate_asserts_from_collector(api: CallbackDataCollector, output, args): + entrypoints = os.path.join(os.path.dirname(args.config[0]), 'entrypoints.h') + if not os.path.exists(entrypoints): + log.error('Entrypoints header not found (%s)', entrypoints) + sys.exit(3) + api.enable_asserts() + api.preprocess_callbacks_data() + cg = CallbackGenerator(list(api.callbacks.values())) + cg.out = output + generate_preamble(output) + output.write( + f'static constexpr int32_t kNoUserDataCallbackCount = {len(api.no_user_data_callbacks)};\n') + output.write( + 'int reserved_callback_ids[kProxyInstanceCount * kNoUserDataCallbackCount];\n') + output.write( + 'std::map multi_proxy_map;\n') + output.write('std::map reserved_base_id_map;\n\n') + output.write('#undef TIZEN_DEPRECATION\n#undef DEPRECATION_WARNING\n') + output.write(f'#include "{entrypoints}"\n') + output.write('\n') + for type1, type2 in api.get_type_mapping(): + output.write(f'static_assert(sizeof({type1}) == sizeof({type2}), "Wrong ' + f'type substitution - {type1} and {type2} have different sizes.");\n') + log.info(f'Generated asserts for {len(api.callbacks)} callbacks.') + + +def generate_preamble(output): + print('#include "tizen_interop_callbacks_plugin.h"\n', file=output) + print('#include ', file=output) + print('#include ', file=output) + print('#include \n', file=output) + print('#include "macros.h"', file=output) + print('#include "types.h"\n', file=output) + + +def find_headers_by_config(config_path): + log.info('Processing config file: %s', config_path) + root_dir = os.path.relpath(os.path.join( + os.path.dirname(config_path), os.pardir, os.pardir)) + log.debug('Root dir: %s', root_dir) + api_version = os.path.basename(os.path.dirname(os.path.abspath(config_path))) + log.debug('API version: %s', api_version) + rootstrap_include = os.path.join( + root_dir, 'rootstraps', api_version, 'usr', 'include') + if not os.path.isdir(rootstrap_include): + log.error('Rootstrap not found. There is no directory %s', rootstrap_include) + return + + with open(config_path) as ffigen_conf_file: + ffigen_config = yaml.safe_load(ffigen_conf_file) + + selected = ffigen_config['headers']['include-directives'] + files_to_find = set() + dirs_to_find = set() + for pattern in selected: + assert pattern.startswith('**/') + if pattern.endswith('/*.h'): + log.debug('DIR %s', pattern[3:-4]) + dirs_to_find.add('/' + pattern[3:-4]) + elif pattern.endswith('.h') and pattern.count('/') == 1: + log.debug('FILE %s', pattern[3:]) + files_to_find.add(pattern[3:]) + else: + raise NotImplementedError( + f'config include-directives `{pattern}` not supported') + + items = set() + + for directory, _, files in os.walk(rootstrap_include): + match = files_to_find.intersection(files) + if match: + log.debug('%s %d %d', match, len(match), len(files_to_find)) + items.update(os.path.join(directory, m) for m in match) + for p in dirs_to_find: + if directory.endswith(p): + log.debug('--- %s [%s] %s', directory, p, files) + items.add(os.path.join(directory, '*.h')) + break + return api_version, rootstrap_include, items + + +def process_configs(args): + config_paths = args.config + for config_path in config_paths: + file_is_missing = False + if not os.path.exists(config_path): + log.error('Config file does not exist: %s', config_path) + file_is_missing = True + if file_is_missing: + return + + api = CallbackDataCollector() + for config_path in config_paths: + res = find_headers_by_config(config_path) + if not res: + return + api_version, rootstrap_include, items = res + api.set_version(api_version) + for item in items: + api.load_headers(glob.glob(item)) + + if args.bindings: + api.set_bindings_filter(args.bindings) + if args.output: + output = open(args.output, 'w') + else: + output = sys.stdout + if args.asserts: + CallbackGenerator.generate_asserts_from_collector(api, output, args) + else: + CallbackGenerator.generate_from_collector(api, output) + if args.output: + output.close() + + +def main(argv): + parser = argparse.ArgumentParser() + parser.add_argument('-c', '--config', action='append', default=[]) + parser.add_argument('-o', '--output') + parser.add_argument('-v', '--verbose', action='store_true') + parser.add_argument('-a', '--asserts', + help='Generate asserts to verify type substitution') + parser.add_argument('-b', '--bindings', action='append', default=[], + help='Filter callbacks using generated bindings dart file(s)') + parser.add_argument('files', nargs='*') + args = parser.parse_args(argv) + logging.basicConfig(level=logging.DEBUG if args.verbose else logging.INFO) + if args.config: + process_configs(args) + elif args.files: + cg = CallbackGenerator([]) + if args.bindings: + cg.set_bindings_filter(args.bindings) + res = cg.process_files(args.files).getvalue() + print(res) + + +if __name__ == '__main__': + sys.exit(main(sys.argv[1:])) diff --git a/scripts/callbacks_generator/tests/__init__.py b/scripts/callbacks_generator/tests/__init__.py new file mode 100644 index 0000000..e69de29 diff --git a/scripts/callbacks_generator/tests/run_tests.py b/scripts/callbacks_generator/tests/run_tests.py new file mode 100755 index 0000000..81d4a2e --- /dev/null +++ b/scripts/callbacks_generator/tests/run_tests.py @@ -0,0 +1,9 @@ +#!/usr/bin/env python3 +# Copyright 2023 Samsung Electronics Co., Ltd. All rights reserved. +# Use of this source code is governed by a BSD-style license that can be +# found in the LICENSE file. + +import unittest + +if __name__ == '__main__': + unittest.main(module=None, buffer=True) diff --git a/scripts/callbacks_generator/tests/test_callbacksdata.py b/scripts/callbacks_generator/tests/test_callbacksdata.py new file mode 100644 index 0000000..fd36f57 --- /dev/null +++ b/scripts/callbacks_generator/tests/test_callbacksdata.py @@ -0,0 +1,17 @@ +# Copyright 2023 Samsung Electronics Co., Ltd. All rights reserved. +# Use of this source code is governed by a BSD-style license that can be +# found in the LICENSE file. + +import unittest +import gen_callbacks as gc + + +class TestCallbacksData(unittest.TestCase): + def test_empty_string(self): + callbacks = gc.CodeReader.read_callbacks_from_string( + 'typedef void (*cb)(int a, const char* b, some_h c, some_e d);') + cb = callbacks[0] + api = gc.CallbackDataCollector() + print(cb) + api.rewrite_types(cb) + print(cb) diff --git a/scripts/callbacks_generator/tests/test_tokenize.py b/scripts/callbacks_generator/tests/test_tokenize.py new file mode 100644 index 0000000..94ffe42 --- /dev/null +++ b/scripts/callbacks_generator/tests/test_tokenize.py @@ -0,0 +1,422 @@ +# Copyright 2023 Samsung Electronics Co., Ltd. All rights reserved. +# Use of this source code is governed by a BSD-style license that can be +# found in the LICENSE file. + +import unittest +import gen_callbacks as gc + + +class TestTokenize(unittest.TestCase): + def token_word(self, word): + cr = gc.CodeReader() + t = gc.Token(cr.TOKEN_WORD) + t.word = word + return t + + def token_other(self, contents): + cr = gc.CodeReader() + t = gc.Token(cr.TOKEN_OTHER) + t.contents = contents + return t + + def test_empty_string(self): + code = '' + + cr = gc.CodeReader() + cr.string = code + cr.tokenize() + + self.assertEqual(cr.tokens, []) + + def test_space(self): + code = ' ' + + cr = gc.CodeReader() + cr.string = code + cr.tokenize() + + self.assertEqual(cr.tokens, []) + + def test_three_spaces(self): + code = ' ' + + cr = gc.CodeReader() + cr.string = code + cr.tokenize() + + self.assertEqual(cr.tokens, []) + + def test_one_letter(self): + code = 'a' + + cr = gc.CodeReader() + cr.string = code + cr.tokenize() + + self.assertEqual(cr.tokens, [self.token_word('a')]) + + def test_one_word(self): + code = 'abc' + + cr = gc.CodeReader() + cr.string = code + cr.tokenize() + + self.assertEqual(cr.tokens, [self.token_word('abc')]) + + def test_two_words(self): + code = 'abc def' + + cr = gc.CodeReader() + cr.string = code + cr.tokenize() + + self.assertEqual(cr.tokens, [ + self.token_word('abc'), + self.token_word('def') + ]) + + def test_three_one_letter_words(self): + code = 'a b c' + + cr = gc.CodeReader() + cr.string = code + cr.tokenize() + + self.assertEqual(cr.tokens, [ + self.token_word('a'), + self.token_word('b'), + self.token_word('c') + ]) + + def test_alphanums_1(self): + code = 'a1 b2' + + cr = gc.CodeReader() + cr.string = code + cr.tokenize() + + self.assertEqual(cr.tokens, [ + self.token_word('a1'), + self.token_word('b2') + ]) + + def test_alphanums_2(self): + code = '1 2 3' + + cr = gc.CodeReader() + cr.string = code + cr.tokenize() + + self.assertEqual(cr.tokens, [ + self.token_other('1'), + self.token_other('2'), + self.token_other('3') + ]) + + # We're not testing string like '1abc', as they will not occur in the code + # as keywords or identifiers. We assume that the code compiles (i.e. is correct). + # They may appear as parts of strings or comments, but we're not interested in + # parsing those perfectly. + + def test_other_chars_1(self): + code = '+ - * /' + + cr = gc.CodeReader() + cr.string = code + cr.tokenize() + + self.assertEqual(cr.tokens, [ + self.token_other('+'), + self.token_other('-'), + gc.Token(cr.TOKEN_ASTERISK), + self.token_other('/') + ]) + + def test_other_chars_2(self): + code = '+a -b *c /d' + + cr = gc.CodeReader() + cr.string = code + cr.tokenize() + + self.assertEqual(cr.tokens, [ + self.token_other('+'), + self.token_word('a'), + self.token_other('-'), + self.token_word('b'), + gc.Token(cr.TOKEN_ASTERISK), + self.token_word('c'), + self.token_other('/'), + self.token_word('d') + ]) + + def test_other_chars_3(self): + code = '_a+_+_b_+' + + cr = gc.CodeReader() + cr.string = code + cr.tokenize() + + self.assertEqual(cr.tokens, [ + self.token_word('_a'), + self.token_other('+'), + self.token_word('_'), + self.token_other('+'), + self.token_word('_b_'), + self.token_other('+') + ]) + + def test_comment_start(self): + code = '/*' + + cr = gc.CodeReader() + cr.string = code + cr.tokenize() + + self.assertEqual(cr.tokens, [gc.Token(cr.TOKEN_COMMENT_START)]) + + def test_comment_start_end(self): + code = '/* */' + + cr = gc.CodeReader() + cr.string = code + cr.tokenize() + + self.assertEqual(cr.tokens, [ + gc.Token(cr.TOKEN_COMMENT_START), + gc.Token(cr.TOKEN_COMMENT_END) + ]) + + def test_comment_text(self): + code = '/* aaa bbb */' + + cr = gc.CodeReader() + cr.string = code + cr.tokenize() + + self.assertEqual(cr.tokens, [ + gc.Token(cr.TOKEN_COMMENT_START), + self.token_word('aaa'), + self.token_word('bbb'), + gc.Token(cr.TOKEN_COMMENT_END) + ]) + + def test_comment_asterisks(self): + code = '* /* * */ *' + + cr = gc.CodeReader() + cr.string = code + cr.tokenize() + + self.assertEqual(cr.tokens, [ + gc.Token(cr.TOKEN_ASTERISK), + gc.Token(cr.TOKEN_COMMENT_START), + gc.Token(cr.TOKEN_ASTERISK), + gc.Token(cr.TOKEN_COMMENT_END), + gc.Token(cr.TOKEN_ASTERISK) + ]) + + def test_doxygen_comment_start(self): + code = '/**' + + cr = gc.CodeReader() + cr.string = code + cr.tokenize() + + self.assertEqual(cr.tokens, [gc.Token(cr.TOKEN_DOXYGEN_CMNT_START)]) + + def test_doxygen_comment_start_end(self): + code = '/** */' + + cr = gc.CodeReader() + cr.string = code + cr.tokenize() + + self.assertEqual(cr.tokens, [ + gc.Token(cr.TOKEN_DOXYGEN_CMNT_START), + gc.Token(cr.TOKEN_COMMENT_END) + ]) + + def test_doxygen_comment_text(self): + code = '/** aaa bbb */' + + cr = gc.CodeReader() + cr.string = code + cr.tokenize() + + self.assertEqual(cr.tokens, [ + gc.Token(cr.TOKEN_DOXYGEN_CMNT_START), + self.token_word('aaa'), + self.token_word('bbb'), + gc.Token(cr.TOKEN_COMMENT_END) + ]) + + def test_doxygen_comment_asterisks(self): + code = '* /** * */ *' + + cr = gc.CodeReader() + cr.string = code + cr.tokenize() + + self.assertEqual(cr.tokens, [ + gc.Token(cr.TOKEN_ASTERISK), + gc.Token(cr.TOKEN_DOXYGEN_CMNT_START), + gc.Token(cr.TOKEN_ASTERISK), + gc.Token(cr.TOKEN_COMMENT_END), + gc.Token(cr.TOKEN_ASTERISK) + ]) + + def test_typedef_handle(self): + code = 'typedef void *handle_h;\n' + + cr = gc.CodeReader() + cr.string = code + cr.tokenize() + + self.assertEqual(cr.tokens, [ + self.token_word('typedef'), + self.token_word('void'), + gc.Token(cr.TOKEN_ASTERISK), + self.token_word('handle_h'), + gc.Token(cr.TOKEN_SEMICOLON), + gc.Token(cr.TOKEN_NEWLINE) + ]) + + def test_typedef_callback_no_params(self): + code = 'typedef void (*done_cb)();\n' + + cr = gc.CodeReader() + cr.string = code + cr.tokenize() + + self.assertEqual(cr.tokens, [ + self.token_word('typedef'), + self.token_word('void'), + gc.Token(cr.TOKEN_PAREN_LEFT), + gc.Token(cr.TOKEN_ASTERISK), + self.token_word('done_cb'), + gc.Token(cr.TOKEN_PAREN_RIGHT), + gc.Token(cr.TOKEN_PAREN_LEFT), + gc.Token(cr.TOKEN_PAREN_RIGHT), + gc.Token(cr.TOKEN_SEMICOLON), + gc.Token(cr.TOKEN_NEWLINE) + ]) + + def test_typedef_callback_one_param(self): + code = 'typedef void (*done_cb)(int id);\n' + + cr = gc.CodeReader() + cr.string = code + cr.tokenize() + + self.assertEqual(cr.tokens, [ + self.token_word('typedef'), + self.token_word('void'), + gc.Token(cr.TOKEN_PAREN_LEFT), + gc.Token(cr.TOKEN_ASTERISK), + self.token_word('done_cb'), + gc.Token(cr.TOKEN_PAREN_RIGHT), + gc.Token(cr.TOKEN_PAREN_LEFT), + self.token_word('int'), + self.token_word('id'), + gc.Token(cr.TOKEN_PAREN_RIGHT), + gc.Token(cr.TOKEN_SEMICOLON), + gc.Token(cr.TOKEN_NEWLINE) + ]) + + def test_typedef_callback_two_params(self): + code = 'typedef void (*done_cb)(int id, void *user_data);\n' + + cr = gc.CodeReader() + cr.string = code + cr.tokenize() + + self.assertEqual(cr.tokens, [ + self.token_word('typedef'), + self.token_word('void'), + gc.Token(cr.TOKEN_PAREN_LEFT), + gc.Token(cr.TOKEN_ASTERISK), + self.token_word('done_cb'), + gc.Token(cr.TOKEN_PAREN_RIGHT), + gc.Token(cr.TOKEN_PAREN_LEFT), + self.token_word('int'), + self.token_word('id'), + gc.Token(cr.TOKEN_COMMA), + self.token_word('void'), + gc.Token(cr.TOKEN_ASTERISK), + self.token_word('user_data'), + gc.Token(cr.TOKEN_PAREN_RIGHT), + gc.Token(cr.TOKEN_SEMICOLON), + gc.Token(cr.TOKEN_NEWLINE) + ]) + + def test_doxygen_comment_brief(self): + code = ''' +/** + * @brief Gets ID. + */ +''' + + cr = gc.CodeReader() + cr.string = code + cr.tokenize() + + self.assertEqual(cr.tokens, [ + gc.Token(cr.TOKEN_NEWLINE), + gc.Token(cr.TOKEN_DOXYGEN_CMNT_START), + gc.Token(cr.TOKEN_NEWLINE), + gc.Token(cr.TOKEN_ASTERISK), + gc.Token(cr.TOKEN_AT), + self.token_word('brief'), + self.token_word('Gets'), + self.token_word('ID'), + gc.Token(cr.TOKEN_PERIOD), + gc.Token(cr.TOKEN_NEWLINE), + gc.Token(cr.TOKEN_COMMENT_END), + gc.Token(cr.TOKEN_NEWLINE) + ]) + + def test_doxygen_comment_many_tags(self): + code = ''' +/** + * @brief + * @param[in] + * @param[out] + * @see + */ +''' + + cr = gc.CodeReader() + cr.string = code + cr.tokenize() + + self.assertEqual(cr.tokens, [ + gc.Token(cr.TOKEN_NEWLINE), + gc.Token(cr.TOKEN_DOXYGEN_CMNT_START), + gc.Token(cr.TOKEN_NEWLINE), + gc.Token(cr.TOKEN_ASTERISK), + gc.Token(cr.TOKEN_AT), + self.token_word('brief'), + gc.Token(cr.TOKEN_NEWLINE), + gc.Token(cr.TOKEN_ASTERISK), + gc.Token(cr.TOKEN_AT), + self.token_word('param'), + gc.Token(cr.TOKEN_BRACKET_LEFT), + self.token_word('in'), + gc.Token(cr.TOKEN_BRACKET_RIGHT), + gc.Token(cr.TOKEN_NEWLINE), + gc.Token(cr.TOKEN_ASTERISK), + gc.Token(cr.TOKEN_AT), + self.token_word('param'), + gc.Token(cr.TOKEN_BRACKET_LEFT), + self.token_word('out'), + gc.Token(cr.TOKEN_BRACKET_RIGHT), + gc.Token(cr.TOKEN_NEWLINE), + gc.Token(cr.TOKEN_ASTERISK), + gc.Token(cr.TOKEN_AT), + self.token_word('see'), + gc.Token(cr.TOKEN_NEWLINE), + gc.Token(cr.TOKEN_COMMENT_END), + gc.Token(cr.TOKEN_NEWLINE) + ]) diff --git a/scripts/callbacks_generator/tests/test_typedef_reading.py b/scripts/callbacks_generator/tests/test_typedef_reading.py new file mode 100644 index 0000000..bb22759 --- /dev/null +++ b/scripts/callbacks_generator/tests/test_typedef_reading.py @@ -0,0 +1,760 @@ +# Copyright 2023 Samsung Electronics Co., Ltd. All rights reserved. +# Use of this source code is governed by a BSD-style license that can be +# found in the LICENSE file. + +import unittest +import gen_callbacks as gc + + +class TestHandlefReading(unittest.TestCase): + def test_handle_1(self): + code = 'typedef void *handle_h;' + + cr = gc.CodeReader() + cr.string = code + cr.tokenize() + cr.find_typedefs() + + self.assertEqual(cr.handles, {'handle_h': 'void *'}) + + def test_handle_2(self): + code = 'typedef void* handle_h;' + + cr = gc.CodeReader() + cr.string = code + cr.tokenize() + cr.find_typedefs() + + self.assertEqual(cr.handles, {'handle_h': 'void *'}) + + def test_handle_3(self): + code = 'typedef int handle_h;' + + cr = gc.CodeReader() + cr.string = code + cr.tokenize() + cr.find_typedefs() + + self.assertEqual(cr.handles, {'handle_h': 'int'}) + + def test_handle_4(self): + code = ''' +typedef void *handle_1_h; +typedef void* handle_2_h; +typedef void * handle_3_h; +typedef int handle_4_h; +''' + + cr = gc.CodeReader() + cr.string = code + cr.tokenize() + cr.find_typedefs() + + self.assertEqual(cr.handles, { + 'handle_1_h': 'void *', + 'handle_2_h': 'void *', + 'handle_3_h': 'void *', + 'handle_4_h': 'int' + }) + + def test_handle_5(self): + code = ''' +/** + * @brief Handle 1. + * @since_tizen 6.5 + */ +typedef void *handle_1_h; + +/** + * @brief Handle 2. + * @since_tizen 6.5 + */ +typedef void* handle_2_h; + +/** + * @brief Handle 3. + * @since_tizen 6.5 + */ +typedef void * handle_3_h; + +/** + * @brief Handle 4. + * @since_tizen 6.5 + */ +typedef int handle_4_h; +''' + + cr = gc.CodeReader() + cr.string = code + cr.tokenize() + cr.find_typedefs() + + self.assertEqual(cr.handles, { + 'handle_1_h': 'void *', + 'handle_2_h': 'void *', + 'handle_3_h': 'void *', + 'handle_4_h': 'int' + }) + + # typedefs in comments should be ignored. + def test_handle_in_comment_1(self): + code = '/* typedef void *handle_h; */' + + cr = gc.CodeReader() + cr.string = code + cr.tokenize() + cr.find_typedefs() + + self.assertEqual(cr.handles, {}) + + def test_handle_in_comment_2(self): + code = '/** typedef void *handle_h; */' + + cr = gc.CodeReader() + cr.string = code + cr.tokenize() + cr.find_typedefs() + + self.assertEqual(cr.handles, {}) + + def test_handle_in_comment_3(self): + code = ''' +/* + * typedef void *handle_h; + */ +''' + + cr = gc.CodeReader() + cr.string = code + cr.tokenize() + cr.find_typedefs() + + self.assertEqual(cr.handles, {}) + + def test_handle_in_comment_4(self): + code = ''' +/** + * typedef void *handle_h; + */ +''' + + cr = gc.CodeReader() + cr.string = code + cr.tokenize() + cr.find_typedefs() + + self.assertEqual(cr.handles, {}) + + # Handle typedef in line comment without newline at the end. + def test_handle_in_line_comment_1(self): + code = '// typedef void *handle_h;' + + cr = gc.CodeReader() + cr.string = code + cr.tokenize() + cr.find_typedefs() + + self.assertEqual(cr.handles, {}) + + # Handle typedef in line comment with newline at the end. + def test_handle_in_line_comment_2(self): + code = ''' +// +// typedef void *handle_h; +// +''' + + cr = gc.CodeReader() + cr.string = code + cr.tokenize() + cr.find_typedefs() + + self.assertEqual(cr.handles, {}) + + +class TestCallbackReading(unittest.TestCase): + def test_void_cb_no_params(self): + code = 'typedef void (*scan_completed_cb)();' + + cr = gc.CodeReader() + cr.string = code + cr.tokenize() + cr.find_typedefs() + + cb = gc.CallbackInfo() + cb.ret_type = 'void' + cb.name = 'scan_completed_cb' + cb.params = [] + + self.assertEqual(cr.callbacks, [cb]) + + def test_int_cb_no_params(self): + code = 'typedef int (*scan_completed_cb)();' + + cr = gc.CodeReader() + cr.string = code + cr.tokenize() + cr.find_typedefs() + + cb = gc.CallbackInfo() + cb.ret_type = 'int' + cb.name = 'scan_completed_cb' + cb.params = [] + + self.assertEqual(cr.callbacks, [cb]) + + def test_cb_one_param(self): + code = 'typedef void (*scan_completed_cb)(int result);' + + cr = gc.CodeReader() + cr.string = code + cr.tokenize() + cr.find_typedefs() + + cb = gc.CallbackInfo() + cb.ret_type = 'void' + cb.name = 'scan_completed_cb' + cb.params = [gc.ParamInfo('int', 'result')] + + self.assertEqual(cr.callbacks, [cb]) + + def test_cb_two_params(self): + code = 'typedef void (*scan_completed_cb)(int result, void *user_data);' + + cr = gc.CodeReader() + cr.string = code + cr.tokenize() + cr.find_typedefs() + + cb = gc.CallbackInfo() + cb.ret_type = 'void' + cb.name = 'scan_completed_cb' + cb.params = [ + gc.ParamInfo('int', 'result'), + gc.ParamInfo('void *', 'user_data'), + ] + + self.assertEqual(cr.callbacks, [cb]) + + def test_cb_three_params(self): + code = 'typedef void (*scan_completed_cb)(int result, char **name, void *user_data);' + + cr = gc.CodeReader() + cr.string = code + cr.tokenize() + cr.find_typedefs() + + cb = gc.CallbackInfo() + cb.ret_type = 'void' + cb.name = 'scan_completed_cb' + cb.params = [ + gc.ParamInfo('int', 'result'), + gc.ParamInfo('char **', 'name'), + gc.ParamInfo('void *', 'user_data'), + ] + + self.assertEqual(cr.callbacks, [cb]) + + def test_cb_multi_line_1(self): + code = ''' +typedef void (*scan_completed_cb)( + int result, + char **name, + void *user_data); +''' + + cr = gc.CodeReader() + cr.string = code + cr.tokenize() + cr.find_typedefs() + + cb = gc.CallbackInfo() + cb.ret_type = 'void' + cb.name = 'scan_completed_cb' + cb.params = [ + gc.ParamInfo('int', 'result'), + gc.ParamInfo('char **', 'name'), + gc.ParamInfo('void *', 'user_data'), + ] + + self.assertEqual(cr.callbacks, [cb]) + + def test_cb_multi_line_2(self): + code = ''' +typedef +void +( +* +scan_completed_cb +) +( +int +result +, +char +* +* +name +, +void +* +user_data +) +; +''' + + cr = gc.CodeReader() + cr.string = code + cr.tokenize() + cr.find_typedefs() + + cb = gc.CallbackInfo() + cb.ret_type = 'void' + cb.name = 'scan_completed_cb' + cb.params = [ + gc.ParamInfo('int', 'result'), + gc.ParamInfo('char **', 'name'), + gc.ParamInfo('void *', 'user_data'), + ] + + self.assertEqual(cr.callbacks, [cb]) + + def test_three_callbacks(self): + code = ''' +/** + * @brief Called when ... + * @details ... + * @param[out] result ... + * @param[out] name ... + * @param[out] user_data ... + */ +typedef void (*scan_completed_cb)(int result, char **name, void *user_data); + +/** + * @brief Called when ... + * @details ... + * @param[out] user_data ... + */ +typedef int (*completed_cb)(void *user_data); + +/** + * @brief Called when ... + * @details ... + */ +typedef void (*done_cb)(); +''' + + cr = gc.CodeReader() + cr.string = code + cr.tokenize() + cr.find_typedefs() + + cb1 = gc.CallbackInfo() + cb1.ret_type = 'void' + cb1.name = 'scan_completed_cb' + cb1.params = [ + gc.ParamInfo('int', 'result'), + gc.ParamInfo('char **', 'name'), + gc.ParamInfo('void *', 'user_data'), + ] + + cb2 = gc.CallbackInfo() + cb2.ret_type = 'int' + cb2.name = 'completed_cb' + cb2.params = [ + gc.ParamInfo('void *', 'user_data'), + ] + + cb3 = gc.CallbackInfo() + cb3.ret_type = 'void' + cb3.name = 'done_cb' + cb3.params = [] + + self.assertEqual(cr.callbacks, [cb1, cb2, cb3]) + + # typedefs in comments should be ignored. + def test_cb_in_comments_1(self): + code = '/* typedef void (*scan_completed_cb)(int result, void *user_data); */' + + cr = gc.CodeReader() + cr.string = code + cr.tokenize() + cr.find_typedefs() + + self.assertEqual(cr.callbacks, []) + + def test_cb_in_comments_2(self): + code = ''' +/* + * typedef void (*scan_completed_cb)(int result, void *user_data); + */ +''' + + cr = gc.CodeReader() + cr.string = code + cr.tokenize() + cr.find_typedefs() + + self.assertEqual(cr.callbacks, []) + + def test_cb_in_comments_3(self): + code = '/** typedef void (*scan_completed_cb)(int result, void *user_data); */' + + cr = gc.CodeReader() + cr.string = code + cr.tokenize() + cr.find_typedefs() + + self.assertEqual(cr.callbacks, []) + + def test_cb_in_comments_4(self): + code = ''' +/** + * typedef void (*scan_completed_cb)(int result, void *user_data); + */ +''' + + cr = gc.CodeReader() + cr.string = code + cr.tokenize() + cr.find_typedefs() + + self.assertEqual(cr.callbacks, []) + + # Callback typedef in line comment without newline at the end. + def test_cb_in_line_comments_1(self): + code = '// typedef void (*scan_completed_cb)(int result, void *user_data);' + + cr = gc.CodeReader() + cr.string = code + cr.tokenize() + cr.find_typedefs() + + self.assertEqual(cr.callbacks, []) + + # Callback typedef in line comment with newline at the end. + def test_cb_in_line_comments_2(self): + code = ''' +// +// typedef void (*scan_completed_cb)(int result, void *user_data); +// +''' + + cr = gc.CodeReader() + cr.string = code + cr.tokenize() + cr.find_typedefs() + + self.assertEqual(cr.callbacks, []) + + def test_cb_with_example_1(self): + # In the example code another function pointer type is defined, + # It should not be considered as an actual typedef. + # Only the typedef should be recognized. + code = ''' +/** + * @brief Called when ... + * @details ... + * @code Example: + * ... + * typedef void (*some_other_cb)(int result, void *user_data); + * ... + * @endcode + */ +typedef void (*scan_completed_cb)(int result, void *user_data); +''' + + cr = gc.CodeReader() + cr.string = code + cr.tokenize() + cr.find_typedefs() + + cb = gc.CallbackInfo() + cb.ret_type = 'void' + cb.name = 'scan_completed_cb' + cb.params = [ + gc.ParamInfo('int', 'result'), + gc.ParamInfo('void *', 'user_data') + ] + + self.assertEqual(cr.callbacks, [cb]) + + def test_cb_with_example_2(self): + # As above, with multiple typedefs. + code = ''' +// +// typedef void (*some_other_cb)(int result, void *user_data); +// +/** + * @brief Called when ... + * @details ... + * @code Example: + * // ... + * // typedef void (*some_other_cb)(int result, void *user_data); + * // ... + * ... + * typedef void (*some_other_cb)(int result, void *user_data); + * ... + * @endcode + */ +typedef void (*scan_completed_cb)(int result, void *user_data); +''' + + cr = gc.CodeReader() + cr.string = code + cr.tokenize() + cr.find_typedefs() + + cb = gc.CallbackInfo() + cb.ret_type = 'void' + cb.name = 'scan_completed_cb' + cb.params = [ + gc.ParamInfo('int', 'result'), + gc.ParamInfo('void *', 'user_data') + ] + + self.assertEqual(cr.callbacks, [cb]) + + +class TestMultipleApiElements(unittest.TestCase): + def test_handles_and_callbacks(self): + code = ''' +/** + * @brief Data handle + * @since_tizen 6.5 + */ +typedef void *data_h; + +/** + * @brief Service handle + * @since_tizen 6.5 + */ +typedef int service_h; + +/** + * @brief Called when ... + * @details ... + * @param[out] result ... + * @param[out] name ... + * @param[out] user_data ... + */ +typedef void (*scan_completed_cb)(int result, char **name, void *user_data); + +/** + * @brief Called when ... + * @details ... + * @param[out] user_data ... + */ +typedef int (*completed_cb)(void *user_data); +''' + + cr = gc.CodeReader() + cr.string = code + cr.tokenize() + cr.find_typedefs() + + cb1 = gc.CallbackInfo() + cb1.ret_type = 'void' + cb1.name = 'scan_completed_cb' + cb1.params = [ + gc.ParamInfo('int', 'result'), + gc.ParamInfo('char **', 'name'), + gc.ParamInfo('void *', 'user_data') + ] + + cb2 = gc.CallbackInfo() + cb2.ret_type = 'int' + cb2.name = 'completed_cb' + cb2.params = [ + gc.ParamInfo('void *', 'user_data'), + ] + + self.assertEqual(cr.callbacks, [cb1, cb2]) + self.assertEqual(cr.handles, { + 'data_h': 'void *', + 'service_h': 'int' + }) + + def test_handles_callbacks_funcs(self): + code = ''' +/* + * License + */ + +/** + * @brief Data handle + * @since_tizen 6.5 + */ +typedef void *data_h; + +/** + * @brief Service handle + * @since_tizen 6.5 + */ +typedef int service_h; + +/** + * @brief Starts scanning. + * @since_tizen 6.5 + * @param[in] service ... + * @param[in] filter ... + * @returns ... + * @retval ... + * @retval ... + */ +int start_scan(service_h service, filter_h filter); + +/** + * @brief Called when ... + * @details ... + * @param[out] result ... + * @param[out] name ... + * @param[out] user_data ... + */ +typedef void (*scan_completed_cb)(int result, char **name, void *user_data); + +/** + * @brief Starts the service. + * @since_tizen 6.5 + * @param[in] service ... + * @returns ... + * @retval ... + * @retval ... + */ +int service_start(service_h service); + +/** + * @brief Called when ... + * @details ... + * @param[out] user_data ... + */ +typedef int (*completed_cb)(void *user_data); +''' + + cr = gc.CodeReader() + cr.string = code + cr.tokenize() + cr.find_typedefs() + + cb1 = gc.CallbackInfo() + cb1.ret_type = 'void' + cb1.name = 'scan_completed_cb' + cb1.params = [ + gc.ParamInfo('int', 'result'), + gc.ParamInfo('char **', 'name'), + gc.ParamInfo('void *', 'user_data') + ] + + cb2 = gc.CallbackInfo() + cb2.ret_type = 'int' + cb2.name = 'completed_cb' + cb2.params = [ + gc.ParamInfo('void *', 'user_data'), + ] + + self.assertEqual(cr.callbacks, [cb1, cb2]) + self.assertEqual(cr.handles, { + 'data_h': 'void *', + 'service_h': 'int' + }) + + def test_handle_cbs_struct_enum(self): + code = ''' +/* + * License + */ + +/** + * @brief Service handle + * @since_tizen 6.5 + */ +typedef int service_h; + +/** + * @brief Data struct + * @since_tizen 6.5 + */ +typedef struct { + /** + * Id + */ + int id; + + /** + * Name + */ + char *name; +} data_s; + +/** + * @brief Starts scanning. + * @since_tizen 6.5 + * @param[in] service ... + * @param[in] filter ... + * @returns ... + * @retval ... + * @retval ... + */ +int start_scan(service_h service, filter_h filter); + +/** + * @brief Called when ... + * @details ... + * @param[out] result ... + * @param[out] name ... + * @param[out] user_data ... + */ +typedef void (*scan_completed_cb)(int result, char **name, void *user_data); + +/** + * @brief State enum + * @since_tizen 6.5 + */ +typedef enum { + STATE_ACTIVE = 0, /**< Active */ + STATE_INACTIVE = 1 /**< Inactive */ +} state_e; + +/** + * @brief Starts the service. + * @since_tizen 6.5 + * @param[in] service ... + * @returns ... + * @retval ... + * @retval ... + */ +int service_start(service_h service); + +/** + * @brief Called when ... + * @details ... + * @param[out] user_data ... + */ +typedef int (*completed_cb)(void *user_data); +''' + + cr = gc.CodeReader() + cr.string = code + cr.tokenize() + cr.find_typedefs() + + cb1 = gc.CallbackInfo() + cb1.ret_type = 'void' + cb1.name = 'scan_completed_cb' + cb1.params = [ + gc.ParamInfo('int', 'result'), + gc.ParamInfo('char **', 'name'), + gc.ParamInfo('void *', 'user_data') + ] + + cb2 = gc.CallbackInfo() + cb2.ret_type = 'int' + cb2.name = 'completed_cb' + cb2.params = [ + gc.ParamInfo('void *', 'user_data') + ] + + self.assertEqual(cr.callbacks, [cb1, cb2]) + self.assertEqual(cr.handles, { + 'service_h': 'int' + }) diff --git a/scripts/callbacks_generator/tests/test_typedef_recognition.py b/scripts/callbacks_generator/tests/test_typedef_recognition.py new file mode 100644 index 0000000..71f942c --- /dev/null +++ b/scripts/callbacks_generator/tests/test_typedef_recognition.py @@ -0,0 +1,271 @@ +# Copyright 2023 Samsung Electronics Co., Ltd. All rights reserved. +# Use of this source code is governed by a BSD-style license that can be +# found in the LICENSE file. + +import unittest +import gen_callbacks as gc + + +class TestTypedefRecognition(unittest.TestCase): + def test_handle_1(self): + code = 'typedef void *handle_h;' + + cr = gc.CodeReader() + cr.string = code + cr.tokenize() + + self.assertEqual(cr.is_callback_typedef(0), False) + self.assertEqual(cr.is_struct_typedef(0), False) + + def test_handle_2(self): + code = 'typedef void* handle_h;' + + cr = gc.CodeReader() + cr.string = code + cr.tokenize() + + self.assertEqual(cr.is_callback_typedef(0), False) + self.assertEqual(cr.is_struct_typedef(0), False) + + def test_handle_3(self): + code = 'typedef int handle_h;' + + cr = gc.CodeReader() + cr.string = code + cr.tokenize() + + self.assertEqual(cr.is_callback_typedef(0), False) + self.assertEqual(cr.is_struct_typedef(0), False) + + def test_callback_1(self): + code = 'typedef void (*done_cb)();' + + cr = gc.CodeReader() + cr.string = code + cr.tokenize() + + self.assertEqual(cr.is_callback_typedef(0), True) + self.assertEqual(cr.is_struct_typedef(0), False) + + def test_callback_2(self): + code = 'typedef void (*done_cb)(int a);' + + cr = gc.CodeReader() + cr.string = code + cr.tokenize() + + self.assertEqual(cr.is_callback_typedef(0), True) + self.assertEqual(cr.is_struct_typedef(0), False) + + def test_callback_3(self): + code = 'typedef void (*done_cb)(int a, void *user_data);' + + cr = gc.CodeReader() + cr.string = code + cr.tokenize() + + self.assertEqual(cr.is_callback_typedef(0), True) + self.assertEqual(cr.is_struct_typedef(0), False) + + def test_callback_4(self): + code = ''' +typedef void (*done_cb)( + int a, + void *user_data); +''' + + cr = gc.CodeReader() + cr.string = code + cr.tokenize() + + # We check at position 1 because the first token is \n. + self.assertEqual(cr.is_callback_typedef(1), True) + self.assertEqual(cr.is_struct_typedef(1), False) + + def test_struct_1(self): + code = 'typedef struct { int x; } struct_s;' + + cr = gc.CodeReader() + cr.string = code + cr.tokenize() + + self.assertEqual(cr.is_callback_typedef(0), False) + self.assertEqual(cr.is_struct_typedef(0), True) + + def test_struct_2(self): + code = 'typedef struct _tag1 { int x; } struct_s;' + + cr = gc.CodeReader() + cr.string = code + cr.tokenize() + + self.assertEqual(cr.is_callback_typedef(0), False) + self.assertEqual(cr.is_struct_typedef(0), True) + + def test_struct_3(self): + code = ''' +typedef struct { + int x; + int y; + char *s; +} struct_s;' +''' + + cr = gc.CodeReader() + cr.string = code + cr.tokenize() + + self.assertEqual(cr.is_callback_typedef(0), False) + self.assertEqual(cr.is_struct_typedef(0), True) + + def test_struct_4(self): + code = ''' +typedef struct _tag1 { + int x; + int y; + char *s; +} struct_s;' +''' + + cr = gc.CodeReader() + cr.string = code + cr.tokenize() + + self.assertEqual(cr.is_callback_typedef(0), False) + self.assertEqual(cr.is_struct_typedef(0), True) + + def test_struct_5(self): + code = ''' +typedef struct _tag1 { + /** + * X + */ + int x; + /** + * Y + */ + int y; + /** + * S + */ + char *s; + /** + * Substruct + */ + struct sub1 { + int a; + int b; + }; +} struct_s;' +''' + + cr = gc.CodeReader() + cr.string = code + cr.tokenize() + + self.assertEqual(cr.is_callback_typedef(0), False) + self.assertEqual(cr.is_struct_typedef(0), True) + + def test_struct_6(self): + code = ''' +typedef struct _tag1 { + int x; /**< X */ + int y; /**< Y */ + char *s; /**< S */ + struct sub1 { + int a; /**< A */ + int b; /**< B */ + }; /**< Substruct */ +} struct_s;' +''' + + cr = gc.CodeReader() + cr.string = code + cr.tokenize() + + self.assertEqual(cr.is_callback_typedef(0), False) + self.assertEqual(cr.is_struct_typedef(0), True) + + def test_enum_1(self): + code = ''' +typedef enum _tag1 { + ENUM_VAL_1, + ENUM_VAL_2, + ENUM_VAL_3 +} enum_e;' +''' + + cr = gc.CodeReader() + cr.string = code + cr.tokenize() + + self.assertEqual(cr.is_callback_typedef(0), False) + self.assertEqual(cr.is_struct_typedef(0), True) + + def test_enum_2(self): + code = ''' +typedef enum _tag1 { + ENUM_VAL_1, /**< Val 1 */ + ENUM_VAL_2, /**< Val 2 */ + ENUM_VAL_3 /**< Val 3 */ +} enum_e;' +''' + + cr = gc.CodeReader() + cr.string = code + cr.tokenize() + + self.assertEqual(cr.is_callback_typedef(0), False) + self.assertEqual(cr.is_struct_typedef(0), True) + + def test_union_1(self): + code = ''' +typedef union _tag1 { + /** + * X + */ + int x; + /** + * Y + */ + int y; + /** + * S + */ + char *s; + /** + * Substruct + */ + struct sub1 { + int a; + int b; + }; +} struct_s;' +''' + + cr = gc.CodeReader() + cr.string = code + cr.tokenize() + + self.assertEqual(cr.is_callback_typedef(0), False) + self.assertEqual(cr.is_struct_typedef(0), True) + + def test_union_2(self): + code = ''' +typedef union _tag1 { + int x; /**< X */ + int y; /**< Y */ + char *s; /**< S */ + struct sub1 { + int a; /**< A */ + int b; /**< B */ + }; /**< Substruct */ +} struct_s;' +''' + + cr = gc.CodeReader() + cr.string = code + cr.tokenize() + + self.assertEqual(cr.is_callback_typedef(0), False) + self.assertEqual(cr.is_struct_typedef(0), True) diff --git a/scripts/generate_callbacks.sh b/scripts/generate_callbacks.sh new file mode 100755 index 0000000..02211f2 --- /dev/null +++ b/scripts/generate_callbacks.sh @@ -0,0 +1,90 @@ +#!/usr/bin/env bash +# Copyright 2023 Samsung Electronics Co., Ltd. All rights reserved. +# Use of this source code is governed by a BSD-style license that can be +# found in the LICENSE file. + +set -e + +SCRIPT_DIR=$(dirname $(readlink -f $0)) +GENERATOR_ROOT="$SCRIPT_DIR/callbacks_generator" +ROOTSTRAPS="$SCRIPT_DIR/../rootstraps" +FOUND_COUNT=0 +TARGET="$SCRIPT_DIR/../packages/tizen_interop_callbacks/tizen/src/generated_callbacks.cc" + +if [ "$1" == "-h" -o "$1" = "help" -o "$1" = "--help" ]; then + echo "$0 - generates callbacks based on ffigen.yaml config files" + echo "$0 verify - check type substitution, see this script source for more info" + exit 0 +elif [ "$1" = "verify" ]; then + # The generator can output a compile time asserts to test if types we are substituting for + # Tizen API types are of the same type - i.e. that our signatures are compatible with original + # callbacks signatures. + # When asserts are generated, the code is only useful for verification, not for calling callbacks. + # Just the fact that the app with asserts is building means the signatures match. + # Many combinations of profile and platform version cause issues with Tizen headers, + # as not every header is available there, or they need to be included in specific order, etc. + # Because of that a failing build does not always mean that our type substitution is wrong. + VERIFY=yes + ARCHS="${ARCHS:-arm arm64}" # arm64 x86 + PROFILES="${PROFILES:-common}" # mobile, wearable, tv + declare -A SKIP_VERIFY_VERSIONS + EXAMPLE_DIR="$SCRIPT_DIR/../packages/tizen_interop_callbacks/example" + (cd "$EXAMPLE_DIR"; flutter-tizen pub get) +fi + +if [ ! -d $ROOTSTRAPS ]; then + echo "ERROR: Rootstraps directory not found." + exit 1 +fi + +CONFIGS="" +declare -a VERIFY_RESULT +for C in "$SCRIPT_DIR"/../configs/*/ffigen.yaml; do + echo $C + VERSION="${C%/ffigen.yaml}" + VERSION="${VERSION##*/}" + echo "==== Found Tizen $VERSION config" + D="$ROOTSTRAPS/$VERSION" + if [ -d "$D" ]; then + if [ "$VERIFY" = "yes" ]; then + if [ -n "${SKIP_VERIFY_VERSIONS[$VERSION]}" ]; then + VERIFY_RESULT[${#VERIFY_RESULT[@]}]="all - $VERSION skip" + continue + fi + "$GENERATOR_ROOT/gen_callbacks.py" --asserts="$VERSION" -c $SCRIPT_DIR/../configs/$VERSION/ffigen.yaml -b $SCRIPT_DIR/../lib/src/bindings/$VERSION/generated_bindings.dart -o "$TARGET" + sed -i '/manifest/ s/api-version="[0-9.]*"/api-version="'$VERSION'"/' "$EXAMPLE_DIR/tizen/tizen-manifest.xml" + for PROFILE in $PROFILES; do + for ARCH in $ARCHS; do + echo -e "\e[32m$VERSION> flutter-tizen build tpk --device-profile $PROFILE --target-arch $ARCH\e[0m" + LOGFILE="/tmp/tzincb-$PROFILE-$ARCH-$VERSION.log" + (cd "$EXAMPLE_DIR"; flutter-tizen build tpk --device-profile $PROFILE --target-arch $ARCH --debug 2>&1 \ + | tee $LOGFILE) + if grep -q "use of undeclared identifier" "$LOGFILE"; then + RESULT="undeclared identifiers" + elif grep -q "Wrong type substitution" "$LOGFILE"; then + RESULT="ASSERTs failed" + elif grep -q "Built.*callbacks_example.*.tpk" "$LOGFILE" ; then + RESULT="ok" + else + RESULT="failed" + fi + VERIFY_RESULT[${#VERIFY_RESULT[@]}]="$PROFILE $ARCH $VERSION $RESULT" + done + done + else + CONFIGS="-c $SCRIPT_DIR/../configs/$VERSION/ffigen.yaml -b $SCRIPT_DIR/../lib/src/bindings/$VERSION/generated_bindings.dart $CONFIGS" + fi + else + echo "ERROR: Rootstrap $ROOTSTRAPS/$VERSION not found." + exit 1 + fi +done +if [ "$VERIFY" == "yes" ]; then + echo "======== Results of the verification" + for x in "${!VERIFY_RESULT[@]}"; do printf " %s\n" "${VERIFY_RESULT[$x]}" ; done + exit +elif [ -z "$CONFIGS" ]; then + echo "ERROR: No rootstrap found. Run copy_rootstrap.sh first." + exit 1 +fi +"$GENERATOR_ROOT/gen_callbacks.py" $CONFIGS -o "$TARGET"