debug logs

2025-10-23 23:17:41 +08:00 · 2025-10-23 23:01:30 +08:00 · 2025-10-23 22:39:33 +08:00 · 2025-10-18 14:56:12 +08:00 · 2025-10-18 13:49:55 +08:00 · 2025-10-17 23:50:44 +08:00
34 changed files with 2454 additions and 431 deletions
--- a/6
+++ b/6
@@ -23,8 +23,8 @@ all: debug release pkgconfig
 #

 VERSION_MAJOR = 1
-VERSION_MINOR = 5
-VERSION_RELEASE = 4
+VERSION_MINOR = 6
+VERSION_RELEASE = 0

 # Version for pkg-config
 PCVERSION = $(VERSION_MAJOR).$(VERSION_MINOR).$(VERSION_RELEASE)
@@ -238,7 +238,7 @@ INSTALL_PKGCONFIG_DIR = $(DESTDIR)$(ABS_LIBDIR)/pkgconfig
 install: $(INSTALL_LIB_DIR)
 	$(INSTALL) -m 755 $(RELEASE_SO) $(INSTALL_LIB_DIR)
 	ln -sf $(LIB_SO) $(INSTALL_LIB_DIR)/$(LIB_SYMLINK2)
-	ln -sf $(LIB_SYMLINK2) $(INSTALL_LIB_DIR)/$(LIB_SYMLINK1)
+	ln -sf $(LIB_SO) $(INSTALL_LIB_DIR)/$(LIB_SYMLINK1)

 install-dev: install $(INSTALL_INCLUDE_DIR) $(INSTALL_PKGCONFIG_DIR)
 	$(INSTALL_FILES) $(INCLUDE_DIR)/*.h $(INSTALL_INCLUDE_DIR)
--- a/debian/Jenkinsfile
+++ b/debian/Jenkinsfile
@@ -0,0 +1,10 @@
+@Library('ubports-build-tools') _
+
+buildAndProvideDebianPackage()
+
+// Or if the package consists entirely of arch-independent packages:
+// (optional optimization, will confuse BlueOcean's live view at build stage)
+// buildAndProvideDebianPackage(/* isArchIndependent */ true)
+
+// Optionally, to skip building on some architectures (amd64 is always built):
+// buildAndProvideDebianPackage(false, /* ignoredArchs */ ['arm64'])
--- a/debian/changelog
+++ b/debian/changelog
@@ -1,183 +1,49 @@
-libgbinder-radio (1.5.5) unstable; urgency=medium
+libgbinder-radio (1.6.0-0ubports1) UNRELEASED; urgency=unknown

-  * Fix RADIO_CELL_IDENTITY_TYPE_1_5 enum values
-  * Add missing radio indication filter enum values for IRadio@1.5 interface
-  * Add missing RadioAppStatus_1_5 struct
+  * New upstream release v1.6.0 

- -- Matti Lehtimäki <matti.lehtimaki@jolla.com>  Fri, 14 Apr 2023 22:42:38 +0300
+ -- UBports package upgrader bot <dev@ubports.com>  Fri, 13 Dec 2024 04:07:25 +0000

-libgbinder-radio (1.5.4) unstable; urgency=medium
+libgbinder-radio (1.5.6-0ubports1) UNRELEASED; urgency=unknown

-  * Added NR specific types
+  * New upstream release v1.5.6 

- -- Slava Monich <slava.monich@jolla.com>  Wed, 30 Nov 2022 19:14:38 +0200
+ -- UBports package upgrader bot <dev@ubports.com>  Thu, 09 Nov 2023 00:27:17 +0000

-libgbinder-radio (1.5.3) unstable; urgency=medium
+libgbinder-radio (1.5.4-0ubports1) focal; urgency=medium

-  * Added RADIO_ACCESS_NETWORKS enum
+  * Update from upstream

- -- Slava Monich <slava.monich@jolla.com>  Sat, 19 Nov 2022 17:48:38 +0200
+ -- Lionel Duboeuf <lduboeuf@ouvaton.org>  Wed, 08 Jan 2023 10:52:34 +0100

-libgbinder-radio (1.5.2) unstable; urgency=medium
+libgbinder-radio (1.4.2-0ubports4) focal; urgency=medium

-  * Added network scan related types
+  * Rename libgbinder-radio-dev to libgbinder-radio1-dev
+  * Generate install files correctly again

- -- Slava Monich <slava.monich@jolla.com>  Thu, 17 Nov 2022 03:12:02 +0200
+ -- Guido Berhoerster <guido+gitlab.com@berhoerster.name>  Wed, 24 Nov 2021 10:52:34 +0100

-libgbinder-radio (1.5.1) unstable; urgency=medium
+libgbinder-radio (1.4.2-0ubports3) focal; urgency=medium

-  * Fixed names of IRadio 1.4 and 1.5 responses
+  * Switch to dh version 12
+  * Fix lintian warnings and errors
+    * Add fix-library-symlink.patch: fix symlink according to Debian policy
+    * Rename library package based on soname
+    * Add long description, improve short description
+    * Use static install files
+    * Add section to source package
+    * Specify homepage and VCS

- -- Slava Monich <slava.monich@jolla.com>  Mon, 14 Nov 2022 22:34:08 +0200
+ -- Guido Berhoerster <guido+gitlab.com@berhoerster.name>  Mon, 15 Nov 2021 15:02:18 +0100

-libgbinder-radio (1.5.0) unstable; urgency=medium
+libgbinder-radio (1.4.2-0ubports2) focal; urgency=medium

-  * Added support for IRadio@1.5
-  * Added support for IRadioConfig@1.2
+  * Bump version, no changes.

- -- Slava Monich <slava.monich@jolla.com>  Fri, 16 Sep 2022 14:13:04 +0300
+ -- Guido Berhoerster <guido+gitlab.com@berhoerster.name>  Thu, 11 Nov 2021 15:02:07 +0100

-libgbinder-radio (1.4.12) unstable; urgency=medium
+libgbinder-radio (1.4.2-0ubports1) focal; urgency=medium

-  * Fixed RadioDataRegStateResult_1_4
+  * Initial packaging for UBPorts

- -- Slava Monich <slava.monich@jolla.com>  Sun, 11 Sep 2022 21:37:23 +0300
-
-libgbinder-radio (1.4.11) unstable; urgency=medium
-
-  * Added radio_request_user_data()
-
- -- Slava Monich <slava.monich@jolla.com>  Wed, 31 Aug 2022 19:10:49 +0300
-
-libgbinder-radio (1.4.10) unstable; urgency=medium
-
-  * Tweaked completion callback criteria
-
- -- Slava Monich <slava.monich@jolla.com>  Fri, 15 Apr 2022 21:58:17 +0300
-
-libgbinder-radio (1.4.9) unstable; urgency=medium
-
-  * Added IMS types
-
- -- Slava Monich <slava.monich@jolla.com>  Thu, 17 Feb 2022 01:47:27 +0200
-
-libgbinder-radio (1.4.8) unstable; urgency=medium
-
-  * Fixed retries of blocking requests
-
- -- Slava Monich <slava.monich@jolla.com>  Wed, 19 Jan 2022 03:32:30 +0200
-
-libgbinder-radio (1.4.7) unstable; urgency=medium
-
-  * Fixed owner queue logic
-
- -- Slava Monich <slava.monich@jolla.com>  Mon, 10 Jan 2022 01:03:28 +0200
-
-libgbinder-radio (1.4.6) unstable; urgency=medium
-
-  * Added RadioConfig API
-
- -- Slava Monich <slava.monich@jolla.com>  Sat, 08 Jan 2022 20:58:06 +0200
-
-libgbinder-radio (1.4.5) unstable; urgency=medium
-
-  * Added radio_req_resp2()
-
- -- Slava Monich <slava.monich@jolla.com>  Thu, 16 Dec 2021 01:18:54 +0200
-
-libgbinder-radio (1.4.4) unstable; urgency=medium
-
-  * Added IRadio@1.2 IndicationFilter bits
-
- -- Slava Monich <slava.monich@jolla.com>  Tue, 14 Dec 2021 18:01:43 +0200
-
-libgbinder-radio (1.4.3) unstable; urgency=medium
-
-  * Added RadioClient and related APIs
-
- -- Slava Monich <slava.monich@jolla.com>  Thu, 02 Dec 2021 19:08:47 +0200
-
-libgbinder-radio (1.4.2) unstable; urgency=medium
-
-  * Don't assume that GBinderServiceManager is a GObject
-  * Added unit tests
-
- -- Slava Monich <slava.monich@jolla.com>  Sun, 12 Sep 2021 18:05:19 +0300
-
-libgbinder-radio (1.4.1) unstable; urgency=medium
-
-  * Added RADIO_CELL_INFO_TYPE_1_4 enum
-
- -- Slava Monich <slava.monich@jolla.com>  Thu, 20 May 2021 16:32:16 +0300
-
-libgbinder-radio (1.4.0) unstable; urgency=medium
-
-  * Support for radio@1.4 interfaces
-  * Fixed RadioCellInfo_1_4 definition
-
- -- Slava Monich <slava.monich@jolla.com>  Tue, 18 May 2021 18:54:52 +0300
-
-libgbinder-radio (1.2.6) unstable; urgency=medium
-
-  * Added RadioSimApdu type
-
- -- Slava Monich <slava.monich@jolla.com>  Sun, 25 Apr 2021 14:41:32 +0300
-
-libgbinder-radio (1.2.5) unstable; urgency=medium
-
-  * Added radio@1.3 types
-  * Added radio@1.4 types
-
- -- Slava Monich <slava.monich@jolla.com>  Thu, 25 Mar 2021 20:13:08 +0200
-
-libgbinder-radio (1.2.4) unstable; urgency=medium
-
-  * Added more radio@1.2 types
-
- -- Slava Monich <slava.monich@jolla.com>  Sat, 20 Mar 2021 02:41:07 +0200
-
-libgbinder-radio (1.2.3) unstable; urgency=medium
-
-  * Reformatted radio@1.2 types
-
- -- Slava Monich <slava.monich@jolla.com>  Fri, 19 Mar 2021 05:21:52 +0200
-
-libgbinder-radio (1.2.2) unstable; urgency=medium
-
-  * Added radio_instance_get_with_version()
-
- -- Slava Monich <slava.monich@jolla.com>  Fri, 05 Mar 2021 14:00:20 +0200
-
-libgbinder-radio (1.2.1) unstable; urgency=medium
-
-  * Fixed backward compatibility with radio@1.0
-
- -- Slava Monich <slava.monich@jolla.com>  Fri, 05 Mar 2021 12:33:50 +0200
-
-libgbinder-radio (1.2.0) unstable; urgency=medium
-
-  * Support for radio@1.2 interfaces
-
- -- Slava Monich <slava.monich@jolla.com>  Thu, 04 Mar 2021 13:36:51 +0200
-
-libgbinder-radio (1.0.11) unstable; urgency=medium
-
-  * Make library executable on RPM based systems
-  * Added req => resp mapping for radio@1.1 calls
-
- -- Slava Monich <slava.monich@jolla.com>  Thu, 01 Oct 2020 21:04:59 +0300
-
-libgbinder-radio (1.0.10) unstable; urgency=medium
-
-  * Hide internal symbols
-  * Respect arch specific lib dir
-  * Ignore GLib deprecation warnings
-  * Added constants for android.hardware.radio@1.1 interfaces
-
- -- Slava Monich <slava.monich@jolla.com>  Wed, 03 Jun 2020 15:24:17 +0300
-
-libgbinder-radio (1.0.9) unstable; urgency=medium
-
-  * Added packaging for Debian-based distros.
-
- -- Danct12 <danct12@disroot.org>  Tue, 24 Mar 2020 02:55:50 +0700
+ -- Guido Berhoerster <guido+gitlab.com@berhoerster.name>  Mon, 11 Oct 2021 16:38:02 +0200
--- a/debian/compat
+++ b/debian/compat
@@ -1 +0,0 @@
-9
--- a/debian/control
+++ b/debian/control
@@ -1,17 +1,31 @@
 Source: libgbinder-radio
 Priority: optional
-Maintainer: Danct12 <danct12@disroot.org>
-Build-Depends: debhelper (>=9), libgbinder-dev (>= 1.1.14), libglibutil-dev (>= 1.0.49)
+Maintainer: UBports developers <devs@ubports.com>
+Build-Depends: debhelper-compat (= 12),
+               libgbinder-dev (>= 1.1.14),
+               libglib2.0-dev,
+               libglibutil-dev,
 Standards-Version: 3.9.6
+Section: libs
+Homepage: https://github.com/mer-hybris/libgbinder-radio
+Vcs-Git: https://github.com/mer-hybris/libgbinder-radio.git
+Vcs-Browser: https://github.com/mer-hybris/libgbinder-radio

-Package: libgbinder-radio-dev
+Package: libgbinder-radio1-dev
 Section: libdevel
 Architecture: any
-Depends: libgbinder-radio (= ${binary:Version}), ${misc:Depends}
-Description: Development files for libgbinder-radio
+Depends: libgbinder-radio1 (= ${binary:Version}),
+         ${misc:Depends}
+Description: Client library for Android radio interfaces (development files)
+ A helper library based on glib which allows communicating with Android radio
+ interfaces via Binder.

-Package: libgbinder-radio
+Package: libgbinder-radio1
 Section: libs
 Architecture: any
-Depends: libgbinder (>= 1.1.14), libglibutil (>= 1.0.49), ${shlibs:Depends}, ${misc:Depends}
-Description: Binder client library for Android radio interfaces
+Depends: libgbinder (>= 1.0.9),
+         ${shlibs:Depends},
+         ${misc:Depends}
+Description: Client library for Android radio interfaces
+ A helper library based on glib which allows communicating with Android radio
+ interfaces via Binder.
--- a/debian/copyright
+++ b/debian/copyright
@@ -1,5 +1,5 @@
-Copyright (C) 2018-2022 Jolla Ltd.
-Copyright (C) 2018-2022 Slava Monich <slava.monich@jolla.com>
+Copyright (C) 2018-2021 Jolla Ltd.
+Copyright (C) 2018-2021 Slava Monich <slava.monich@jolla.com>

 You may use this file under the terms of the BSD license as follows:

--- a/debian/libgbinder-radio1-dev.install.in
+++ b/debian/libgbinder-radio1-dev.install.in
@@ -0,0 +1,3 @@
+debian/tmp/@LIBDIR@/libgbinder-radio.so @LIBDIR@
+debian/tmp/@LIBDIR@/pkgconfig/libgbinder-radio.pc @LIBDIR@/pkgconfig
+debian/tmp/usr/include/* usr/include
--- a/debian/libgbinder-radio1.install.in
+++ b/debian/libgbinder-radio1.install.in
@@ -0,0 +1 @@
+debian/tmp/@LIBDIR@/libgbinder-radio.so.* @LIBDIR@
--- a/debian/rules
+++ b/debian/rules
@@ -1,11 +1,12 @@
 #!/usr/bin/make -f
 # Uncomment to enable verbose build
 #export DH_VERBOSE = 1
+export DEB_BUILD_OPTIONS='nostrip debug'

 LIBDIR=usr/lib/$(shell dpkg-architecture -qDEB_HOST_MULTIARCH)

 override_dh_auto_build:
-	dh_auto_build -- LIBDIR=$(LIBDIR) release pkgconfig debian/libgbinder-radio.install debian/libgbinder-radio-dev.install
+	dh_auto_build -- LIBDIR=$(LIBDIR) release pkgconfig debian/libgbinder-radio1.install debian/libgbinder-radio1-dev.install

 override_dh_auto_install:
 	dh_auto_install -- LIBDIR=$(LIBDIR) install-dev
--- a/include/radio_client.h
+++ b/include/radio_client.h
@@ -74,6 +74,10 @@ RADIO_INTERFACE
 radio_client_interface(
    RadioClient* client);

+RADIO_AIDL_INTERFACE
+radio_client_aidl_interface(
+    RadioClient* client); /* Since 1.6.0 */
+
 const char*
 radio_client_slot(
    RadioClient* client);
--- a/include/radio_config.h
+++ b/include/radio_config.h
@@ -40,6 +40,7 @@
 /* This API exists since 1.4.6 */

 #include <radio_config_types.h>
+#include <radio_config_aidl_types.h>

 G_BEGIN_DECLS

@@ -83,6 +84,12 @@ radio_config_new_with_version(
    RADIO_CONFIG_INTERFACE max_version)
    G_GNUC_WARN_UNUSED_RESULT;

+RadioConfig*
+radio_config_new_with_version_and_interface_type(
+    RADIO_CONFIG_INTERFACE max_version,
+    RADIO_INTERFACE_TYPE interface_type)
+    G_GNUC_WARN_UNUSED_RESULT; /* Since 1.6.0 */
+
 RadioConfig*
 radio_config_ref(
    RadioConfig* config);
@@ -95,6 +102,10 @@ gboolean
 radio_config_dead(
    RadioConfig* config);

+RADIO_INTERFACE_TYPE
+radio_config_interface_type(
+    RadioConfig* self); /* Since 1.6.0 */
+
 RADIO_CONFIG_INTERFACE
 radio_config_interface(
    RadioConfig* config);
--- a/include/radio_config_aidl_types.h
+++ b/include/radio_config_aidl_types.h
@@ -0,0 +1,161 @@
+/*
+ * Copyright (C) 2024 Jollyboys Ltd
+ *
+ * You may use this file under the terms of the BSD license as follows:
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ *   1. Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *   2. 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.
+ *   3. Neither the names of the copyright holders nor the names of its
+ *      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 HOLDERS 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.
+ *
+ * The views and conclusions contained in the software and documentation
+ * are those of the authors and should not be interpreted as representing
+ * any official policies, either expressed or implied.
+ */
+
+#ifndef RADIO_CONFIG_AIDL_TYPES_H
+#define RADIO_CONFIG_AIDL_TYPES_H
+
+#include <radio_types.h>
+
+G_BEGIN_DECLS
+
+typedef enum radio_config_aidl_interface {
+    RADIO_CONFIG_AIDL_INTERFACE_NONE = -1,
+    RADIO_CONFIG_AIDL_INTERFACE_1,
+    RADIO_CONFIG_AIDL_INTERFACE_COUNT
+} RADIO_CONFIG_AIDL_INTERFACE;
+
+#define RADIO_CONFIG_AIDL_INTERFACE_MAX (RADIO_CONFIG_AIDL_INTERFACE_COUNT - 1)
+
+#define RADIO_CONFIG_AIDL_INSTANCE         "default"
+#define RADIO_CONFIG_AIDL_IFACE_PREFIX     "android.hardware.radio.config."
+#define RADIO_CONFIG_AIDL_IFACE            "IRadioConfig"
+#define RADIO_CONFIG_AIDL_RESPONSE_IFACE   "IRadioConfigResponse"
+#define RADIO_CONFIG_AIDL_INDICATION_IFACE "IRadioConfigIndication"
+#define RADIO_CONFIG_AIDL                  RADIO_CONFIG_AIDL_IFACE_PREFIX RADIO_CONFIG_AIDL_IFACE
+#define RADIO_CONFIG_AIDL_FQNAME           RADIO_CONFIG_AIDL "/" RADIO_CONFIG_AIDL_INSTANCE
+#define RADIO_CONFIG_AIDL_RESPONSE         RADIO_CONFIG_AIDL_IFACE_PREFIX RADIO_CONFIG_AIDL_RESPONSE_IFACE
+#define RADIO_CONFIG_AIDL_INDICATION       RADIO_CONFIG_AIDL_IFACE_PREFIX RADIO_CONFIG_AIDL_INDICATION_IFACE
+
+/* Types defined in android.hardware.radio.config package */
+
+/* PhoneCapability */
+typedef struct radio_aidl_phone_capability {
+    guint8 maxActiveData RADIO_ALIGNED(4);
+    guint8 maxActiveInternetData RADIO_ALIGNED(4);
+    guint8 isInternetLingeringSupported RADIO_ALIGNED(4);
+    struct {
+        guint32 length;
+        guint8 data[];
+    } logicalModemList;
+} RadioAidlPhoneCapability;
+
+/* SimPortInfo */
+typedef struct radio_aidl_sim_port_info {
+    struct {
+        guint32 length;
+        gchar data[];
+    } iccId;
+    gint32 logicalSlotId;
+    gboolean portActive;
+} RadioAidlSimPortInfo;
+
+/* SimSlotStatus */
+typedef struct radio_aidl_sim_slot_status {
+    RADIO_CARD_STATE cardState;
+    GString* atr;
+    GString* eid;
+    struct {
+        guint32 length;
+        RadioAidlSimPortInfo data[];
+    } portInfo;
+} RadioAidlSimSlotStatus;
+
+/* Transaction codes */
+
+/* c(req,resp,Name,CALL_NAME) */
+#define RADIO_CONFIG_AIDL_CALL_1(c) \
+    c(1,1,getHalDeviceCapabilities,GET_HAL_DEVICE_CAPABILITIES) \
+    c(2,2,getNumOfLiveModems,GET_NUM_OF_LIVE_MODEMS) \
+    c(3,3,getPhoneCapability,GET_PHONE_CAPABILITY) \
+    c(4,4,getSimSlotsStatus,GET_SIM_SLOTS_STATUS) \
+    c(5,5,setNumOfLiveModems,SET_NUM_OF_LIVE_MODEMS) \
+    c(6,6,setPreferredDataModem,SET_PREFERRED_DATA_MODEM) \
+    c(8,7,setSimSlotsMapping,SET_SIM_SLOTS_MAPPING) \
+
+/* i(code,Name,IND_NAME) */
+#define RADIO_CONFIG_AIDL_IND_1(i) \
+    i(1,simSlotsStatusChanged,SIM_SLOTS_STATUS_CHANGED) \
+
+typedef enum radio_aidl_config_req {
+    RADIO_CONFIG_AIDL_REQ_ANY = 0,
+    RADIO_CONFIG_AIDL_REQ_NONE = 0,
+#define RADIO_CONFIG_AIDL_REQ_(req,resp,Name,NAME) RADIO_CONFIG_AIDL_REQ_##NAME = req,
+
+    /* android.hardware.radio.config.IRadioConfig v1 */
+    RADIO_CONFIG_AIDL_REQ_SET_RESPONSE_FUNCTIONS = 7, /* setResponseFunctions */
+    RADIO_CONFIG_AIDL_CALL_1(RADIO_CONFIG_AIDL_REQ_)
+    RADIO_CONFIG_AIDL_1_REQ_LAST = RADIO_CONFIG_AIDL_REQ_SET_SIM_SLOTS_MAPPING,
+
+#undef RADIO_CONFIG_AIDL_REQ_
+} RADIO_CONFIG_AIDL_REQ;
+G_STATIC_ASSERT(sizeof(RADIO_CONFIG_AIDL_REQ) == 4);
+
+typedef enum radio_aidl_config_resp {
+    RADIO_CONFIG_AIDL_RESP_ANY = 0,
+    RADIO_CONFIG_AIDL_RESP_NONE = 0,
+#define RADIO_CONFIG_AIDL_RESP_(req,resp,Name,NAME) RADIO_CONFIG_AIDL_RESP_##NAME = resp,
+
+    /* android.hardware.radio.config.IRadioConfigResponse v1 */
+    RADIO_CONFIG_AIDL_CALL_1(RADIO_CONFIG_AIDL_RESP_)
+    RADIO_CONFIG_AIDL_1_RESP_LAST = RADIO_CONFIG_AIDL_RESP_SET_SIM_SLOTS_MAPPING,
+
+#undef RADIO_CONFIG_AIDL_RESP_
+} RADIO_CONFIG_AIDL_RESP;
+G_STATIC_ASSERT(sizeof(RADIO_CONFIG_AIDL_RESP) == 4);
+
+typedef enum radio_aidl_config_ind {
+    RADIO_CONFIG_AIDL_IND_ANY = 0,
+    RADIO_CONFIG_AIDL_IND_NONE = 0,
+#define RADIO_CONFIG_AIDL_IND_(code,Name,NAME) RADIO_CONFIG_AIDL_IND_##NAME = code,
+
+    /* android.hardware.radio.config.IRadioConfigIndication v1 */
+    RADIO_CONFIG_AIDL_IND_1(RADIO_CONFIG_AIDL_IND_)
+    RADIO_CONFIG_AIDL_1_IND_LAST = RADIO_CONFIG_AIDL_IND_SIM_SLOTS_STATUS_CHANGED,
+
+#undef RADIO_CONFIG_AIDL_IND_
+} RADIO_CONFIG_AIDL_IND;
+G_STATIC_ASSERT(sizeof(RADIO_CONFIG_AIDL_IND) == 4);
+
+G_END_DECLS
+
+#endif /* RADIO_CONFIG_AIDL_TYPES_H */
+
+/*
+ * Local Variables:
+ * mode: C
+ * c-basic-offset: 4
+ * indent-tabs-mode: nil
+ * End:
+ */
--- a/include/radio_data_types.h
+++ b/include/radio_data_types.h
@@ -0,0 +1,134 @@
+/*
+ * Copyright (C) 2024 Jollyboys Ltd
+ *
+ * You may use this file under the terms of the BSD license as follows:
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ *   1. Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *   2. 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.
+ *   3. Neither the names of the copyright holders nor the names of its
+ *      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 HOLDERS 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.
+ *
+ * The views and conclusions contained in the software and documentation
+ * are those of the authors and should not be interpreted as representing
+ * any official policies, either expressed or implied.
+ */
+
+#ifndef RADIO_DATA_TYPES_H
+#define RADIO_DATA_TYPES_H
+
+#include <gbinder_types.h>
+
+G_BEGIN_DECLS
+
+#define RADIO_DATA_INTERFACE_MAX (RADIO_DATA_INTERFACE_COUNT - 1)
+
+#define RADIO_DATA_INSTANCE         "default"
+#define RADIO_DATA_IFACE_PREFIX     "android.hardware.radio.data."
+#define RADIO_DATA_IFACE            "IRadioData"
+#define RADIO_DATA_RESPONSE_IFACE   "IRadioDataResponse"
+#define RADIO_DATA_INDICATION_IFACE "IRadioDataIndication"
+#define RADIO_DATA                  RADIO_DATA_IFACE_PREFIX RADIO_DATA_IFACE
+#define RADIO_DATA_FQNAME           RADIO_DATA "/" RADIO_DATA_INSTANCE
+#define RADIO_DATA_RESPONSE         RADIO_DATA_IFACE_PREFIX RADIO_DATA_RESPONSE_IFACE
+#define RADIO_DATA_INDICATION       RADIO_DATA_IFACE_PREFIX RADIO_DATA_INDICATION_IFACE
+
+/* Transaction codes */
+
+/* c(req,resp,Name,CALL_NAME) */
+#define RADIO_DATA_CALL_1(c) \
+    c(1,2,allocatePduSessionId,ALLOCATE_PDU_SESSION_ID) \
+    c(2,3,cancelHandover,CANCEL_HANDOVER) \
+    c(3,4,deactivateDataCall,DEACTIVATE_DATA_CALL) \
+    c(4,5,getDataCallList,GET_DATA_CALL_LIST) \
+    c(5,6,getSlicingConfig,GET_SLICING_CONFIG) \
+    c(6,7,releasePduSessionId,RELEASE_PDU_SESSION_ID) \
+    c(8,8,setDataAllowed,SET_DATA_ALLOWED) \
+    c(9,9,setDataProfile,SET_DATA_PROFILE) \
+    c(10,10,setDataThrottling,SET_DATA_THROTTLING) \
+    c(11,11,setInitialAttachApn,SET_INITIAL_ATTACH_APN) \
+    c(13,12,setupDataCall,SETUP_DATA_CALL) \
+    c(14,13,startHandover,START_HANDOVER) \
+    c(15,14,startKeepalive,START_KEEPALIVE) \
+    c(16,15,stopKeepalive,STOP_KEEPALIVE) \
+
+/* i(code,Name,IND_NAME) */
+#define RADIO_DATA_IND_1(i) \
+    i(1,dataCallListChanged,DATA_CALL_LIST_CHANGED) \
+    i(2,keepaliveStatus,KEEPALIVE_STATUS) \
+    i(3,pcoData,PCO_DATA) \
+    i(4,unthrottleApn,UNTHROTTLE_APN) \
+    i(5,slicingConfigChanged,SLICING_CONFIG_CHANGED) \
+
+typedef enum radio_data_req {
+    RADIO_DATA_REQ_ANY = 0,
+    RADIO_DATA_REQ_NONE = 0,
+#define RADIO_DATA_REQ_(req,resp,Name,NAME) RADIO_DATA_REQ_##NAME = req,
+
+    /* android.hardware.radio.data.IRadioData v1 */
+    RADIO_DATA_CALL_1(RADIO_DATA_REQ_)
+    RADIO_DATA_REQ_RESPONSE_ACKNOWLEDGEMENT = 7, /* responseAcknowledgement */
+    RADIO_DATA_REQ_SET_RESPONSE_FUNCTIONS = 12, /* setResponseFunctions */
+    RADIO_DATA_1_REQ_LAST = RADIO_DATA_REQ_STOP_KEEPALIVE,
+
+#undef RADIO_DATA_REQ_
+} RADIO_DATA_REQ;
+G_STATIC_ASSERT(sizeof(RADIO_DATA_REQ) == 4);
+
+typedef enum radio_data_resp {
+    RADIO_DATA_RESP_ANY = 0,
+    RADIO_DATA_RESP_NONE = 0,
+#define RADIO_DATA_RESP_(req,resp,Name,NAME) RADIO_DATA_RESP_##NAME = resp,
+
+    /* android.hardware.radio.data.IRadioDataResponse v1 */
+    RADIO_DATA_CALL_1(RADIO_DATA_RESP_)
+    RADIO_DATA_RESP_ACKNOWLEDGE_REQUEST = 1, /* acknowledgeRequest */
+    RADIO_DATA_1_RESP_LAST = RADIO_DATA_RESP_STOP_KEEPALIVE,
+
+#undef RADIO_DATA_RESP_
+} RADIO_DATA_RESP;
+G_STATIC_ASSERT(sizeof(RADIO_DATA_RESP) == 4);
+
+typedef enum radio_data_ind {
+    RADIO_DATA_IND_ANY = 0,
+    RADIO_DATA_IND_NONE = 0,
+#define RADIO_DATA_IND_(code,Name,NAME) RADIO_DATA_IND_##NAME = code,
+
+    /* android.hardware.radio.data.IRadioDataIndication v1 */
+    RADIO_DATA_IND_1(RADIO_DATA_IND_)
+    RADIO_DATA_1_IND_LAST = RADIO_DATA_IND_SLICING_CONFIG_CHANGED,
+
+#undef RADIO_DATA_IND_
+} RADIO_DATA_IND;
+G_STATIC_ASSERT(sizeof(RADIO_DATA_IND) == 4);
+
+G_END_DECLS
+
+#endif /* RADIO_DATA_TYPES_H */
+
+/*
+ * Local Variables:
+ * mode: C
+ * c-basic-offset: 4
+ * indent-tabs-mode: nil
+ * End:
+ */
--- a/include/radio_ims_types.h
+++ b/include/radio_ims_types.h
@@ -0,0 +1,123 @@
+/*
+ * Copyright (C) 2024 Jollyboys Ltd
+ *
+ * You may use this file under the terms of the BSD license as follows:
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ *   1. Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *   2. 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.
+ *   3. Neither the names of the copyright holders nor the names of its
+ *      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 HOLDERS 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.
+ *
+ * The views and conclusions contained in the software and documentation
+ * are those of the authors and should not be interpreted as representing
+ * any official policies, either expressed or implied.
+ */
+
+#ifndef RADIO_IMS_TYPES_H
+#define RADIO_IMS_TYPES_H
+
+#include <gbinder_types.h>
+
+G_BEGIN_DECLS
+
+#define RADIO_IMS_INTERFACE_MAX (RADIO_IMS_INTERFACE_COUNT - 1)
+
+#define RADIO_IMS_INSTANCE         "default"
+#define RADIO_IMS_IFACE_PREFIX     "android.hardware.radio.ims."
+#define RADIO_IMS_IFACE            "IRadioIms"
+#define RADIO_IMS_RESPONSE_IFACE   "IRadioImsResponse"
+#define RADIO_IMS_INDICATION_IFACE "IRadioImsIndication"
+#define RADIO_IMS                  RADIO_IMS_IFACE_PREFIX RADIO_IMS_IFACE
+#define RADIO_IMS_FQNAME           RADIO_IMS "/" RADIO_IMS_INSTANCE
+#define RADIO_IMS_RESPONSE         RADIO_IMS_IFACE_PREFIX RADIO_IMS_RESPONSE_IFACE
+#define RADIO_IMS_INDICATION       RADIO_IMS_IFACE_PREFIX RADIO_IMS_INDICATION_IFACE
+
+/* Transaction codes */
+
+/* c(req,resp,Name,CALL_NAME) */
+#define RADIO_IMS_CALL_1(c) \
+    c(1,1,setSrvccCallInfo,SET_SRVCC_CALL_INFO) \
+    c(2,2,updateImsRegistrationInfo,UPDATE_IMS_REGISTRATION_INFO) \
+    c(3,3,startImsTraffic,START_IMS_TRAFFIC) \
+    c(4,4,stopImsTraffic,STOP_IMS_TRAFFIC) \
+    c(5,5,triggerEpsFallback,TRIGGER_EPS_FALLBACK) \
+    c(7,6,sendAnbrQuery,SEND_ANBR_QUERY) \
+    c(8,7,updateImsCallStatus,UPDATE_IMS_CALL_STATUS) \
+
+/* i(code,Name,IND_NAME) */
+#define RADIO_IMS_IND_1(i) \
+    i(1,onConnectionSetupFailure,ON_CONNECTION_SETUP_FAILURE) \
+    i(2,notifyAnbr,NOTIFY_ANBR) \
+    i(3,triggerImsDeregistration,TRIGGER_IMS_DEREGISTRATION) \
+
+typedef enum radio_ims_req {
+    RADIO_IMS_REQ_ANY = 0,
+    RADIO_IMS_REQ_NONE = 0,
+#define RADIO_IMS_REQ_(req,resp,Name,NAME) RADIO_IMS_REQ_##NAME = req,
+
+    /* android.hardware.radio.ims.IRadioIms v1 */
+    RADIO_IMS_CALL_1(RADIO_IMS_REQ_)
+    RADIO_IMS_REQ_SET_RESPONSE_FUNCTIONS = 6, /* setResponseFunctions */
+    RADIO_IMS_1_REQ_LAST = RADIO_IMS_REQ_UPDATE_IMS_CALL_STATUS,
+
+#undef RADIO_IMS_REQ_
+} RADIO_IMS_REQ;
+G_STATIC_ASSERT(sizeof(RADIO_IMS_REQ) == 4);
+
+typedef enum radio_ims_resp {
+    RADIO_IMS_RESP_ANY = 0,
+    RADIO_IMS_RESP_NONE = 0,
+#define RADIO_IMS_RESP_(req,resp,Name,NAME) RADIO_IMS_RESP_##NAME = resp,
+
+    /* android.hardware.radio.ims.IRadioImsResponse v1 */
+    RADIO_IMS_CALL_1(RADIO_IMS_RESP_)
+    RADIO_IMS_1_RESP_LAST = RADIO_IMS_RESP_UPDATE_IMS_CALL_STATUS,
+
+#undef RADIO_IMS_RESP_
+} RADIO_IMS_RESP;
+G_STATIC_ASSERT(sizeof(RADIO_IMS_RESP) == 4);
+
+typedef enum radio_ims_ind {
+    RADIO_IMS_IND_ANY = 0,
+    RADIO_IMS_IND_NONE = 0,
+#define RADIO_IMS_IND_(code,Name,NAME) RADIO_IMS_IND_##NAME = code,
+
+    /* android.hardware.radio.ims.IRadioImsIndication v1 */
+    RADIO_IMS_IND_1(RADIO_IMS_IND_)
+    RADIO_IMS_1_IND_LAST = RADIO_IMS_IND_TRIGGER_IMS_DEREGISTRATION,
+
+#undef RADIO_IMS_IND_
+} RADIO_IMS_IND;
+G_STATIC_ASSERT(sizeof(RADIO_IMS_IND) == 4);
+
+G_END_DECLS
+
+#endif /* RADIO_IMS_TYPES_H */
+
+/*
+ * Local Variables:
+ * mode: C
+ * c-basic-offset: 4
+ * indent-tabs-mode: nil
+ * End:
+ */
--- a/include/radio_instance.h
+++ b/include/radio_instance.h
@@ -38,6 +38,13 @@
 #define RADIO_INSTANCE_H

 #include <radio_types.h>
+#include <radio_data_types.h>
+#include <radio_ims_types.h>
+#include <radio_messaging_types.h>
+#include <radio_modem_types.h>
+#include <radio_network_types.h>
+#include <radio_sim_types.h>
+#include <radio_voice_types.h>

 #include <glib-object.h>

@@ -60,6 +67,9 @@ struct radio_instance {
    RADIO_INTERFACE version;
    /* Since 1.4.3 */
    gboolean connected; /* rilConnected received */
+    /* Since 1.6.0 */
+    RADIO_INTERFACE_TYPE interface_type;
+    RADIO_AIDL_INTERFACE interface_aidl;
 };

 /* These were introduced in 1.4.3 and then renamed in 1.4.6 */
@@ -156,6 +166,15 @@ radio_instance_new_with_modem_slot_and_version(
    int slot_index,
    RADIO_INTERFACE version); /* Since 1.2.1 */

+RadioInstance*
+radio_instance_new_with_modem_slot_version_and_interface(
+    const char* dev,
+    const char* name,
+    const char* modem,
+    int slot,
+    RADIO_INTERFACE version,
+    RADIO_AIDL_INTERFACE aidl_interface); /* Since 1.6.0 */
+
 RadioInstance*
 radio_instance_get(
    const char* dev,
--- a/include/radio_messaging_types.h
+++ b/include/radio_messaging_types.h
@@ -0,0 +1,143 @@
+/*
+ * Copyright (C) 2024 Jollyboys Ltd
+ *
+ * You may use this file under the terms of the BSD license as follows:
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ *   1. Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *   2. 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.
+ *   3. Neither the names of the copyright holders nor the names of its
+ *      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 HOLDERS 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.
+ *
+ * The views and conclusions contained in the software and documentation
+ * are those of the authors and should not be interpreted as representing
+ * any official policies, either expressed or implied.
+ */
+
+#ifndef RADIO_MESSAGING_TYPES_H
+#define RADIO_MESSAGING_TYPES_H
+
+#include <gbinder_types.h>
+
+G_BEGIN_DECLS
+
+#define RADIO_MESSAGING_INTERFACE_MAX (RADIO_MESSAGING_INTERFACE_COUNT - 1)
+
+#define RADIO_MESSAGING_INSTANCE         "default"
+#define RADIO_MESSAGING_IFACE_PREFIX     "android.hardware.radio.messaging."
+#define RADIO_MESSAGING_IFACE            "IRadioMessaging"
+#define RADIO_MESSAGING_RESPONSE_IFACE   "IRadioMessagingResponse"
+#define RADIO_MESSAGING_INDICATION_IFACE "IRadioMessagingIndication"
+#define RADIO_MESSAGING                  RADIO_MESSAGING_IFACE_PREFIX RADIO_MESSAGING_IFACE
+#define RADIO_MESSAGING_FQNAME           RADIO_MESSAGING "/" RADIO_MESSAGING_INSTANCE
+#define RADIO_MESSAGING_RESPONSE         RADIO_MESSAGING_IFACE_PREFIX RADIO_MESSAGING_RESPONSE_IFACE
+#define RADIO_MESSAGING_INDICATION       RADIO_MESSAGING_IFACE_PREFIX RADIO_MESSAGING_INDICATION_IFACE
+
+/* Transaction codes */
+
+/* c(req,resp,Name,CALL_NAME) */
+#define RADIO_MESSAGING_CALL_1(c) \
+    c(1,1,acknowledgeIncomingGsmSmsWithPdu,ACKNOWLEDGE_INCOMING_GSM_SMS_WITH_PDU) \
+    c(2,2,acknowledgeLastIncomingCdmaSms,ACKNOWLEDGE_LAST_INCOMING_CDMA_SMS) \
+    c(3,3,acknowledgeLastIncomingGsmSms,ACKNOWLEDGE_LAST_INCOMING_GSM_SMS) \
+    c(4,5,deleteSmsOnRuim,DELETE_SMS_ON_RUIM) \
+    c(5,6,deleteSmsOnSim,DELETE_SMS_ON_SIM) \
+    c(6,7,getCdmaBroadcastConfig,GET_CDMA_BROADCAST_CONFIG) \
+    c(7,8,getGsmBroadcastConfig,GET_GSM_BROADCAST_CONFIG) \
+    c(8,9,getSmscAddress,GET_SMSC_ADDRESS) \
+    c(9,10,reportSmsMemoryStatus,REPORT_SMS_MEMORY_STATUS) \
+    c(11,12,sendCdmaSms,SEND_CDMA_SMS) \
+    c(12,11,sendCdmaSmsExpectMore,SEND_CDMA_SMS_EXPECT_MORE) \
+    c(13,13,sendImsSms,SEND_IMS_SMS) \
+    c(14,15,sendSms,SEND_SMS) \
+    c(15,14,sendSmsExpectMore,SEND_SMS_EXPECT_MORE) \
+    c(16,16,setCdmaBroadcastActivation,SET_CDMA_BROADCAST_ACTIVATION) \
+    c(17,17,setCdmaBroadcastConfig,SET_CDMA_BROADCAST_CONFIG) \
+    c(18,18,setGsmBroadcastActivation,SET_GSM_BROADCAST_ACTIVATION) \
+    c(19,19,setGsmBroadcastConfig,SET_GSM_BROADCAST_CONFIG) \
+    c(21,20,setSmscAddress,SET_SMSC_ADDRESS) \
+    c(22,21,writeSmsToRuim,WRITE_SMS_TO_RUIM) \
+    c(23,22,writeSmsToSim,WRITE_SMS_TO_SIM) \
+
+/* i(code,Name,IND_NAME) */
+#define RADIO_MESSAGING_IND_1(i) \
+    i(1,cdmaNewSms,CDMA_NEW_SMS) \
+    i(2,cdmaRuimSmsStorageFull,CDMA_RUIM_SMS_STORAGE_FULL) \
+    i(3,newBroadcastSms,NEW_BROADCAST_SMS) \
+    i(4,newSms,NEW_SMS) \
+    i(5,newSmsOnSim,NEW_SMS_ON_SIM) \
+    i(6,newSmsStatusReport,NEW_SMS_STATUS_REPORT) \
+    i(7,simSmsStorageFull,SIM_SMS_STORAGE_FULL) \
+
+typedef enum radio_messaging_req {
+    RADIO_MESSAGING_REQ_ANY = 0,
+    RADIO_MESSAGING_REQ_NONE = 0,
+#define RADIO_MESSAGING_REQ_(req,resp,Name,NAME) RADIO_MESSAGING_REQ_##NAME = req,
+
+    /* android.hardware.radio.messaging.IRadioMessaging v1 */
+    RADIO_MESSAGING_CALL_1(RADIO_MESSAGING_REQ_)
+    RADIO_MESSAGING_REQ_RESPONSE_ACKNOWLEDGEMENT = 10, /* responseAcknowledgement */
+    RADIO_MESSAGING_REQ_SET_RESPONSE_FUNCTIONS = 20, /* setResponseFunctions */
+    RADIO_MESSAGING_1_REQ_LAST = RADIO_MESSAGING_REQ_WRITE_SMS_TO_SIM,
+
+#undef RADIO_MESSAGING_REQ_
+} RADIO_MESSAGING_REQ;
+G_STATIC_ASSERT(sizeof(RADIO_MESSAGING_REQ) == 4);
+
+typedef enum radio_messaging_resp {
+    RADIO_MESSAGING_RESP_ANY = 0,
+    RADIO_MESSAGING_RESP_NONE = 0,
+#define RADIO_MESSAGING_RESP_(req,resp,Name,NAME) RADIO_MESSAGING_RESP_##NAME = resp,
+
+    /* android.hardware.radio.messaging.IRadioMessagingResponse v1 */
+    RADIO_MESSAGING_CALL_1(RADIO_MESSAGING_RESP_)
+    RADIO_MESSAGING_RESP_ACKNOWLEDGE_REQUEST = 4, /* acknowledgeRequest */
+    RADIO_MESSAGING_1_RESP_LAST = RADIO_MESSAGING_RESP_WRITE_SMS_TO_SIM,
+
+#undef RADIO_MESSAGING_RESP_
+} RADIO_MESSAGING_RESP;
+G_STATIC_ASSERT(sizeof(RADIO_MESSAGING_RESP) == 4);
+
+typedef enum radio_messaging_ind {
+    RADIO_MESSAGING_IND_ANY = 0,
+    RADIO_MESSAGING_IND_NONE = 0,
+#define RADIO_MESSAGING_IND_(code,Name,NAME) RADIO_MESSAGING_IND_##NAME = code,
+
+    /* android.hardware.radio.messaging.IRadioMessagingIndication v1 */
+    RADIO_MESSAGING_IND_1(RADIO_MESSAGING_IND_)
+    RADIO_MESSAGING_1_IND_LAST = RADIO_MESSAGING_IND_SIM_SMS_STORAGE_FULL,
+
+#undef RADIO_MESSAGING_IND_
+} RADIO_MESSAGING_IND;
+G_STATIC_ASSERT(sizeof(RADIO_MESSAGING_IND) == 4);
+
+G_END_DECLS
+
+#endif /* RADIO_MESSAGING_TYPES_H */
+
+/*
+ * Local Variables:
+ * mode: C
+ * c-basic-offset: 4
+ * indent-tabs-mode: nil
+ * End:
+ */
--- a/include/radio_modem_types.h
+++ b/include/radio_modem_types.h
@@ -0,0 +1,135 @@
+/*
+ * Copyright (C) 2024 Jollyboys Ltd
+ *
+ * You may use this file under the terms of the BSD license as follows:
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ *   1. Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *   2. 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.
+ *   3. Neither the names of the copyright holders nor the names of its
+ *      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 HOLDERS 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.
+ *
+ * The views and conclusions contained in the software and documentation
+ * are those of the authors and should not be interpreted as representing
+ * any official policies, either expressed or implied.
+ */
+
+#ifndef RADIO_MODEM_TYPES_H
+#define RADIO_MODEM_TYPES_H
+
+#include <gbinder_types.h>
+
+G_BEGIN_DECLS
+
+#define RADIO_MODEM_INTERFACE_MAX (RADIO_MODEM_INTERFACE_COUNT - 1)
+
+#define RADIO_MODEM_INSTANCE         "default"
+#define RADIO_MODEM_IFACE_PREFIX     "android.hardware.radio.modem."
+#define RADIO_MODEM_IFACE            "IRadioModem"
+#define RADIO_MODEM_RESPONSE_IFACE   "IRadioModemResponse"
+#define RADIO_MODEM_INDICATION_IFACE "IRadioModemIndication"
+#define RADIO_MODEM                  RADIO_MODEM_IFACE_PREFIX RADIO_MODEM_IFACE
+#define RADIO_MODEM_FQNAME           RADIO_MODEM "/" RADIO_MODEM_INSTANCE
+#define RADIO_MODEM_RESPONSE         RADIO_MODEM_IFACE_PREFIX RADIO_MODEM_RESPONSE_IFACE
+#define RADIO_MODEM_INDICATION       RADIO_MODEM_IFACE_PREFIX RADIO_MODEM_INDICATION_IFACE
+
+/* Transaction codes */
+
+/* c(req,resp,Name,CALL_NAME) */
+#define RADIO_MODEM_CALL_1(c) \
+    c(1,2,enableModem,ENABLE_MODEM) \
+    c(2,3,getBasebandVersion,GET_BASEBAND_VERSION) \
+    c(3,4,getDeviceIdentity,GET_DEVICE_IDENTITY) \
+    c(4,5,getHardwareConfig,GET_HARDWARE_CONFIG) \
+    c(5,6,getModemActivityInfo,GET_MODEM_ACTIVITY_INFO) \
+    c(6,7,getModemStackStatus,GET_MODEM_STACK_STATUS) \
+    c(7,8,getRadioCapability,GET_RADIO_CAPABILITY) \
+    c(8,9,nvReadItem,NV_READ_ITEM) \
+    c(9,10,nvResetConfig,NV_RESET_CONFIG) \
+    c(10,11,nvWriteCdmaPrl,NV_WRITE_CDMA_PRL) \
+    c(11,12,nvWriteItem,NV_WRITE_ITEM) \
+    c(12,13,requestShutdown,REQUEST_SHUTDOWN) \
+    c(14,14,sendDeviceState,SEND_DEVICE_STATE) \
+    c(15,15,setRadioCapability,SET_RADIO_CAPABILITY) \
+    c(16,16,setRadioPower,SET_RADIO_POWER) \
+
+/* i(code,Name,IND_NAME) */
+#define RADIO_MODEM_IND_1(i) \
+    i(1,hardwareConfigChanged,HARDWARE_CONFIG_CHANGED) \
+    i(2,modemReset,MODEM_RESET) \
+    i(3,radioCapabilityIndication,RADIO_CAPABILITY_INDICATION) \
+    i(4,radioStateChanged,RADIO_STATE_CHANGED) \
+    i(5,rilConnected,RIL_CONNECTED) \
+
+typedef enum radio_modem_req {
+    RADIO_MODEM_REQ_ANY = 0,
+    RADIO_MODEM_REQ_NONE = 0,
+#define RADIO_MODEM_REQ_(req,resp,Name,NAME) RADIO_MODEM_REQ_##NAME = req,
+
+    /* android.hardware.radio.modem.IRadioModem v1 */
+    RADIO_MODEM_CALL_1(RADIO_MODEM_REQ_)
+    RADIO_MODEM_REQ_RESPONSE_ACKNOWLEDGEMENT = 13, /* responseAcknowledgement */
+    RADIO_MODEM_REQ_SET_RESPONSE_FUNCTIONS = 17, /* setResponseFunctions */
+    RADIO_MODEM_1_REQ_LAST = RADIO_MODEM_REQ_SET_RESPONSE_FUNCTIONS,
+
+#undef RADIO_MODEM_REQ_
+} RADIO_MODEM_REQ;
+G_STATIC_ASSERT(sizeof(RADIO_MODEM_REQ) == 4);
+
+typedef enum radio_modem_resp {
+    RADIO_MODEM_RESP_ANY = 0,
+    RADIO_MODEM_RESP_NONE = 0,
+#define RADIO_MODEM_RESP_(req,resp,Name,NAME) RADIO_MODEM_RESP_##NAME = resp,
+
+    /* android.hardware.radio.modem.IRadioModemResponse v1 */
+    RADIO_MODEM_CALL_1(RADIO_MODEM_RESP_)
+    RADIO_MODEM_RESP_ACKNOWLEDGE_REQUEST = 1, /* acknowledgeRequest */
+    RADIO_MODEM_1_RESP_LAST = RADIO_MODEM_RESP_SET_RADIO_POWER,
+
+#undef RADIO_MODEM_RESP_
+} RADIO_MODEM_RESP;
+G_STATIC_ASSERT(sizeof(RADIO_MODEM_RESP) == 4);
+
+typedef enum radio_modem_ind {
+    RADIO_MODEM_IND_ANY = 0,
+    RADIO_MODEM_IND_NONE = 0,
+#define RADIO_MODEM_IND_(code,Name,NAME) RADIO_MODEM_IND_##NAME = code,
+
+    /* android.hardware.radio.modem.IRadioModemIndication v1 */
+    RADIO_MODEM_IND_1(RADIO_MODEM_IND_)
+    RADIO_MODEM_1_IND_LAST = RADIO_MODEM_IND_RIL_CONNECTED,
+
+#undef RADIO_MODEM_IND_
+} RADIO_MODEM_IND;
+G_STATIC_ASSERT(sizeof(RADIO_MODEM_IND) == 4);
+
+G_END_DECLS
+
+#endif /* RADIO_MODEM_TYPES_H */
+
+/*
+ * Local Variables:
+ * mode: C
+ * c-basic-offset: 4
+ * indent-tabs-mode: nil
+ * End:
+ */
--- a/include/radio_network_types.h
+++ b/include/radio_network_types.h
@@ -0,0 +1,163 @@
+/*
+ * Copyright (C) 2024 Jollyboys Ltd
+ *
+ * You may use this file under the terms of the BSD license as follows:
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ *   1. Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *   2. 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.
+ *   3. Neither the names of the copyright holders nor the names of its
+ *      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 HOLDERS 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.
+ *
+ * The views and conclusions contained in the software and documentation
+ * are those of the authors and should not be interpreted as representing
+ * any official policies, either expressed or implied.
+ */
+
+#ifndef RADIO_NETWORK_TYPES_H
+#define RADIO_NETWORK_TYPES_H
+
+#include <gbinder_types.h>
+
+G_BEGIN_DECLS
+
+#define RADIO_NETWORK_INTERFACE_MAX (RADIO_NETWORK_INTERFACE_COUNT - 1)
+
+#define RADIO_NETWORK_INSTANCE         "default"
+#define RADIO_NETWORK_IFACE_PREFIX     "android.hardware.radio.network."
+#define RADIO_NETWORK_IFACE            "IRadioNetwork"
+#define RADIO_NETWORK_RESPONSE_IFACE   "IRadioNetworkResponse"
+#define RADIO_NETWORK_INDICATION_IFACE "IRadioNetworkIndication"
+#define RADIO_NETWORK                  RADIO_NETWORK_IFACE_PREFIX RADIO_NETWORK_IFACE
+#define RADIO_NETWORK_FQNAME           RADIO_NETWORK "/" RADIO_NETWORK_INSTANCE
+#define RADIO_NETWORK_RESPONSE         RADIO_NETWORK_IFACE_PREFIX RADIO_NETWORK_RESPONSE_IFACE
+#define RADIO_NETWORK_INDICATION       RADIO_NETWORK_IFACE_PREFIX RADIO_NETWORK_INDICATION_IFACE
+
+/* Transaction codes */
+
+/* c(req,resp,Name,CALL_NAME) */
+#define RADIO_NETWORK_CALL_1(c) \
+    c(1,2,getAllowedNetworkTypesBitmap,GET_ALLOWED_NETWORK_TYPES_BITMAP) \
+    c(2,3,getAvailableBandModes,GET_AVAILABLE_BAND_MODES) \
+    c(3,4,getAvailableNetworks,GET_AVAILABLE_NETWORKS) \
+    c(4,5,getBarringInfo,GET_BARRING_INFO) \
+    c(5,6,getCdmaRoamingPreference,GET_CDMA_ROAMING_PREFERENCE) \
+    c(6,7,getCellInfoList,GET_CELL_INFO_LIST) \
+    c(7,8,getDataRegistrationState,GET_DATA_REGISTRATION_STATE) \
+    c(8,9,getImsRegistrationState,GET_IMS_REGISTRATION_STATE) \
+    c(9,10,getNetworkSelectionMode,GET_NETWORK_SELECTION_MODE) \
+    c(10,11,getOperator,GET_OPERATOR) \
+    c(11,12,getSignalStrength,GET_SIGNAL_STRENGTH) \
+    c(12,13,getSystemSelectionChannels,GET_SYSTEM_SELECTION_CHANNELS) \
+    c(13,14,getVoiceRadioTechnology,GET_VOICE_RADIO_TECHNOLOGY) \
+    c(14,15,getVoiceRegistrationState,GET_VOICE_REGISTRATION_STATE) \
+    c(15,16,isNrDualConnectivityEnabled,IS_NR_DUAL_CONNECTIVITY_ENABLED) \
+    c(17,17,setAllowedNetworkTypesBitmap,SET_ALLOWED_NETWORK_TYPES_BITMAP) \
+    c(18,18,setBandMode,SET_BAND_MODE) \
+    c(19,19,setBarringPassword,SET_BARRING_PASSWORD) \
+    c(20,20,setCdmaRoamingPreference,SET_CDMA_ROAMING_PREFERENCE) \
+    c(21,21,setCellInfoListRate,SET_CELL_INFO_LIST_RATE) \
+    c(22,22,setIndicationFilter,SET_INDICATION_FILTER) \
+    c(23,23,setLinkCapacityReportingCriteria,SET_LINK_CAPACITY_REPORTING_CRITERIA) \
+    c(24,24,setLocationUpdates,SET_LOCATION_UPDATES) \
+    c(25,25,setNetworkSelectionModeAutomatic,SET_NETWORK_SELECTION_MODE_AUTOMATIC) \
+    c(26,26,setNetworkSelectionModeManual,SET_NETWORK_SELECTION_MODE_MANUAL) \
+    c(27,27,setNrDualConnectivityState,SET_NR_DUAL_CONNECTIVITY_STATE) \
+    c(29,28,setSignalStrengthReportingCriteria,SET_SIGNAL_STRENGTH_REPORTING_CRITERIA) \
+    c(30,29,setSuppServiceNotifications,SET_SUPP_SERVICE_NOTIFICATIONS) \
+    c(31,30,setSystemSelectionChannels,SET_SYSTEM_SELECTION_CHANNELS) \
+    c(32,31,startNetworkScan,START_NETWORK_SCAN) \
+    c(33,32,stopNetworkScan,STOP_NETWORK_SCAN) \
+    c(34,33,supplyNetworkDepersonalization,SUPPLY_NETWORK_DEPERSONALIZATION) \
+    c(35,34,setUsageSetting,SET_USAGE_SETTING) \
+    c(36,35,getUsageSetting,GET_USAGE_SETTING) \
+
+/* i(code,Name,IND_NAME) */
+#define RADIO_NETWORK_IND_1(i) \
+    i(1,barringInfoChanged,BARRING_INFO_CHANGED) \
+    i(2,cdmaPrlChanged,CDMA_PRL_CHANGED) \
+    i(3,cellInfoList,CELL_INFO_LIST) \
+    i(4,currentLinkCapacityEstimate,CURRENT_LINK_CAPACITY_ESTIMATE) \
+    i(5,currentPhysicalChannelConfigs,CURRENT_PHYSICAL_CHANNEL_CONFIGS) \
+    i(6,currentSignalStrength,CURRENT_SIGNAL_STRENGTH) \
+    i(7,imsNetworkStateChanged,IMS_NETWORK_STATE_CHANGED) \
+    i(8,networkScanResult,NETWORK_SCAN_RESULT) \
+    i(9,networkStateChanged,NETWORK_STATE_CHANGED) \
+    i(10,nitzTimeReceived,NITZ_TIME_RECEIVED) \
+    i(11,registrationFailed,REGISTRATION_FAILED) \
+    i(12,restrictedStateChanged,RESTRICTED_STATE_CHANGED) \
+    i(13,suppSvcNotify,SUPP_SVC_NOTIFY) \
+    i(14,voiceRadioTechChanged,VOICE_RADIO_TECH_CHANGED) \
+
+typedef enum radio_network_req {
+    RADIO_NETWORK_REQ_ANY = 0,
+    RADIO_NETWORK_REQ_NONE = 0,
+#define RADIO_NETWORK_REQ_(req,resp,Name,NAME) RADIO_NETWORK_REQ_##NAME = req,
+
+    /* android.hardware.radio.network.IRadioNetwork v1 */
+    RADIO_NETWORK_CALL_1(RADIO_NETWORK_REQ_)
+    RADIO_NETWORK_REQ_RESPONSE_ACKNOWLEDGEMENT = 16, /* responseAcknowledgement */
+    RADIO_NETWORK_REQ_SET_RESPONSE_FUNCTIONS = 28, /* setResponseFunctions */
+    RADIO_NETWORK_1_REQ_LAST = RADIO_NETWORK_REQ_GET_USAGE_SETTING,
+
+#undef RADIO_NETWORK_REQ_
+} RADIO_NETWORK_REQ;
+G_STATIC_ASSERT(sizeof(RADIO_NETWORK_REQ) == 4);
+
+typedef enum radio_network_resp {
+    RADIO_NETWORK_RESP_ANY = 0,
+    RADIO_NETWORK_RESP_NONE = 0,
+#define RADIO_NETWORK_RESP_(req,resp,Name,NAME) RADIO_NETWORK_RESP_##NAME = resp,
+
+    /* android.hardware.radio.network.IRadioNetworkResponse v1 */
+    RADIO_NETWORK_CALL_1(RADIO_NETWORK_RESP_)
+    RADIO_NETWORK_RESP_ACKNOWLEDGE_REQUEST = 1, /* acknowledgeRequest */
+    RADIO_NETWORK_1_RESP_LAST = RADIO_NETWORK_RESP_GET_USAGE_SETTING,
+
+#undef RADIO_NETWORK_RESP_
+} RADIO_NETWORK_RESP;
+G_STATIC_ASSERT(sizeof(RADIO_NETWORK_RESP) == 4);
+
+typedef enum radio_network_ind {
+    RADIO_NETWORK_IND_ANY = 0,
+    RADIO_NETWORK_IND_NONE = 0,
+#define RADIO_NETWORK_IND_(code,Name,NAME) RADIO_NETWORK_IND_##NAME = code,
+
+    /* android.hardware.radio.network.IRadioNetworkIndication v1 */
+    RADIO_NETWORK_IND_1(RADIO_NETWORK_IND_)
+    RADIO_NETWORK_1_IND_LAST = RADIO_NETWORK_IND_VOICE_RADIO_TECH_CHANGED,
+
+#undef RADIO_NETWORK_IND_
+} RADIO_NETWORK_IND;
+G_STATIC_ASSERT(sizeof(RADIO_NETWORK_IND) == 4);
+
+G_END_DECLS
+
+#endif /* RADIO_NETWORK_TYPES_H */
+
+/*
+ * Local Variables:
+ * mode: C
+ * c-basic-offset: 4
+ * indent-tabs-mode: nil
+ * End:
+ */
--- a/include/radio_sim_types.h
+++ b/include/radio_sim_types.h
@@ -0,0 +1,160 @@
+/*
+ * Copyright (C) 2024 Jollyboys Ltd
+ *
+ * You may use this file under the terms of the BSD license as follows:
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ *   1. Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *   2. 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.
+ *   3. Neither the names of the copyright holders nor the names of its
+ *      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 HOLDERS 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.
+ *
+ * The views and conclusions contained in the software and documentation
+ * are those of the authors and should not be interpreted as representing
+ * any official policies, either expressed or implied.
+ */
+
+#ifndef RADIO_SIM_TYPES_H
+#define RADIO_SIM_TYPES_H
+
+#include <gbinder_types.h>
+
+G_BEGIN_DECLS
+
+#define RADIO_SIM_INTERFACE_MAX (RADIO_SIM_INTERFACE_COUNT - 1)
+
+#define RADIO_SIM_INSTANCE         "default"
+#define RADIO_SIM_IFACE_PREFIX     "android.hardware.radio.sim."
+#define RADIO_SIM_IFACE            "IRadioSim"
+#define RADIO_SIM_RESPONSE_IFACE   "IRadioSimResponse"
+#define RADIO_SIM_INDICATION_IFACE "IRadioSimIndication"
+#define RADIO_SIM                  RADIO_SIM_IFACE_PREFIX RADIO_SIM_IFACE
+#define RADIO_SIM_FQNAME           RADIO_SIM "/" RADIO_SIM_INSTANCE
+#define RADIO_SIM_RESPONSE         RADIO_SIM_IFACE_PREFIX RADIO_SIM_RESPONSE_IFACE
+#define RADIO_SIM_INDICATION       RADIO_SIM_IFACE_PREFIX RADIO_SIM_INDICATION_IFACE
+
+/* Transaction codes */
+
+/* c(req,resp,Name,CALL_NAME) */
+#define RADIO_SIM_CALL_1(c) \
+    c(1,2,areUiccApplicationsEnabled,ARE_UICC_APPLICATIONS_ENABLED) \
+    c(2,3,changeIccPin2ForApp,CHANGE_ICC_PIN2_FOR_APP) \
+    c(3,4,changeIccPinForApp,CHANGE_ICC_PIN_FOR_APP) \
+    c(4,5,enableUiccApplications,ENABLE_UICC_APPLICATIONS) \
+    c(5,6,getAllowedCarriers,GET_ALLOWED_CARRIERS) \
+    c(6,7,getCdmaSubscription,GET_CDMA_SUBSCRIPTION) \
+    c(7,8,getCdmaSubscriptionSource,GET_CDMA_SUBSCRIPTION_SOURCE) \
+    c(8,9,getFacilityLockForApp,GET_FACILITY_LOCK_FOR_APP) \
+    c(9,10,getIccCardStatus,GET_ICC_CARD_STATUS) \
+    c(10,11,getImsiForApp,GET_IMSI_FOR_APP) \
+    c(11,12,getSimPhonebookCapacity,GET_SIM_PHONEBOOK_CAPACITY) \
+    c(12,13,getSimPhonebookRecords,GET_SIM_PHONEBOOK_RECORDS) \
+    c(13,14,iccCloseLogicalChannel,ICC_CLOSE_LOGICAL_CHANNEL) \
+    c(14,15,iccIoForApp,ICC_IO_FOR_APP) \
+    c(15,16,iccOpenLogicalChannel,ICC_OPEN_LOGICAL_CHANNEL) \
+    c(16,17,iccTransmitApduBasicChannel,ICC_TRANSMIT_APDU_BASIC_CHANNEL) \
+    c(17,18,iccTransmitApduLogicalChannel,ICC_TRANSMIT_APDU_LOGICAL_CHANNEL) \
+    c(18,19,reportStkServiceIsRunning,REPORT_STK_SERVICE_IS_RUNNING) \
+    c(19,20,requestIccSimAuthentication,REQUEST_ICC_SIM_AUTHENTICATION) \
+    c(21,21,sendEnvelope,SEND_ENVELOPE) \
+    c(22,22,sendEnvelopeWithStatus,SEND_ENVELOPE_WITH_STATUS) \
+    c(23,23,sendTerminalResponseToSim,SEND_TERMINAL_RESPONSE_TO_SIM) \
+    c(24,24,setAllowedCarriers,SET_ALLOWED_CARRIERS) \
+    c(25,25,setCarrierInfoForImsiEncryption,SET_CARRIER_INFO_FOR_IMSI_ENCRYPTION) \
+    c(26,26,setCdmaSubscriptionSource,SET_CDMA_SUBSCRIPTION_SOURCE) \
+    c(27,27,setFacilityLockForApp,SET_FACILITY_LOCK_FOR_APP) \
+    c(29,28,setSimCardPower,SET_SIM_CARD_POWER) \
+    c(30,29,setUiccSubscription,SET_UICC_SUBSCRIPTION) \
+    c(31,30,supplyIccPin2ForApp,SUPPLY_ICC_PIN2_FOR_APP) \
+    c(32,31,supplyIccPinForApp,SUPPLY_ICC_PIN_FOR_APP) \
+    c(33,32,supplyIccPuk2ForApp,SUPPLY_ICC_PUK2_FOR_APP) \
+    c(34,33,supplyIccPukForApp,SUPPLY_ICC_PUK_FOR_APP) \
+    c(35,34,supplySimDepersonalization,SUPPLY_SIM_DEPERSONALIZATION) \
+    c(36,35,updateSimPhonebookRecords,UPDATE_SIM_PHONEBOOK_RECORDS) \
+
+/* i(code,Name,IND_NAME) */
+#define RADIO_SIM_IND_1(i) \
+    i(1,carrierInfoForImsiEncryption,CARRIER_INFO_FOR_IMSI_ENCRYPTION) \
+    i(2,cdmaSubscriptionSourceChanged,CDMA_SUBSCRIPTION_SOURCE_CHANGED) \
+    i(3,simPhonebookChanged,SIM_PHONEBOOK_CHANGED) \
+    i(4,simPhonebookRecordsReceived,SIM_PHONEBOOK_RECORDS_RECEIVED) \
+    i(5,simRefresh,SIM_REFRESH) \
+    i(6,simStatusChanged,SIM_STATUS_CHANGED) \
+    i(7,stkEventNotify,STK_EVENT_NOTIFY) \
+    i(8,stkProactiveCommand,STK_PROACTIVE_COMMAND) \
+    i(9,stkSessionEnd,STK_SESSION_END) \
+    i(10,subscriptionStatusChanged,SUBSCRIPTION_STATUS_CHANGED) \
+    i(11,uiccApplicationsEnablementChanged,UICC_APPLICATIONS_ENABLEMENT_CHANGED) \
+
+typedef enum radio_sim_req {
+    RADIO_SIM_REQ_ANY = 0,
+    RADIO_SIM_REQ_NONE = 0,
+#define RADIO_SIM_REQ_(req,resp,Name,NAME) RADIO_SIM_REQ_##NAME = req,
+
+    /* android.hardware.radio.sim.IRadioSim v1 */
+    RADIO_SIM_CALL_1(RADIO_SIM_REQ_)
+    RADIO_SIM_REQ_RESPONSE_ACKNOWLEDGEMENT = 20, /* responseAcknowledgement */
+    RADIO_SIM_REQ_SET_RESPONSE_FUNCTIONS = 28, /* setResponseFunctions */
+    RADIO_SIM_1_REQ_LAST = RADIO_SIM_REQ_UPDATE_SIM_PHONEBOOK_RECORDS,
+
+#undef RADIO_SIM_REQ_
+} RADIO_SIM_REQ;
+G_STATIC_ASSERT(sizeof(RADIO_SIM_REQ) == 4);
+
+typedef enum radio_sim_resp {
+    RADIO_SIM_RESP_ANY = 0,
+    RADIO_SIM_RESP_NONE = 0,
+#define RADIO_SIM_RESP_(req,resp,Name,NAME) RADIO_SIM_RESP_##NAME = resp,
+
+    /* android.hardware.radio.sim.IRadioSimResponse v1 */
+    RADIO_SIM_CALL_1(RADIO_SIM_RESP_)
+    RADIO_SIM_RESP_ACKNOWLEDGE_REQUEST = 1, /* acknowledgeRequest */
+    RADIO_SIM_1_RESP_LAST = RADIO_SIM_RESP_UPDATE_SIM_PHONEBOOK_RECORDS,
+
+#undef RADIO_SIM_RESP_
+} RADIO_SIM_RESP;
+G_STATIC_ASSERT(sizeof(RADIO_SIM_RESP) == 4);
+
+typedef enum radio_sim_ind {
+    RADIO_SIM_IND_ANY = 0,
+    RADIO_SIM_IND_NONE = 0,
+#define RADIO_SIM_IND_(code,Name,NAME) RADIO_SIM_IND_##NAME = code,
+
+    /* android.hardware.radio.sim.IRadioSimIndication v1 */
+    RADIO_SIM_IND_1(RADIO_SIM_IND_)
+    RADIO_SIM_1_IND_LAST = RADIO_SIM_IND_UICC_APPLICATIONS_ENABLEMENT_CHANGED,
+
+#undef RADIO_SIM_IND_
+} RADIO_SIM_IND;
+G_STATIC_ASSERT(sizeof(RADIO_SIM_IND) == 4);
+
+G_END_DECLS
+
+#endif /* RADIO_SIM_TYPES_H */
+
+/*
+ * Local Variables:
+ * mode: C
+ * c-basic-offset: 4
+ * indent-tabs-mode: nil
+ * End:
+ */
--- a/include/radio_types.h
+++ b/include/radio_types.h
@@ -66,6 +66,24 @@ typedef enum radio_interface {
    RADIO_INTERFACE_COUNT
 } RADIO_INTERFACE; /* Since 1.2.0 */

+typedef enum radio_aidl_interface {
+    RADIO_AIDL_INTERFACE_NONE = -1,
+    RADIO_DATA_INTERFACE,
+    RADIO_IMS_INTERFACE,
+    RADIO_MESSAGING_INTERFACE,
+    RADIO_MODEM_INTERFACE,
+    RADIO_NETWORK_INTERFACE,
+    RADIO_SIM_INTERFACE,
+    RADIO_VOICE_INTERFACE,
+    RADIO_AIDL_INTERFACE_COUNT
+} RADIO_AIDL_INTERFACE; /* Since 1.6.0 */
+
+typedef enum radio_interface_type {
+    RADIO_INTERFACE_TYPE_NONE,
+    RADIO_INTERFACE_TYPE_HIDL,
+    RADIO_INTERFACE_TYPE_AIDL,
+} RADIO_INTERFACE_TYPE; /* Since 1.6.0 */
+
 typedef enum radio_observer_priority {
    RADIO_OBSERVER_PRIORITY_LOWEST,
    RADIO_OBSERVER_PRIORITY_DEFAULT = 2,
--- a/include/radio_util.h
+++ b/include/radio_util.h
@@ -45,14 +45,29 @@ const char*
 radio_req_name(
    RADIO_REQ req);

+const char*
+radio_req_name2(
+    RadioInstance* instance,
+    RADIO_REQ req); /* Since 1.6.0 */
+
 const char*
 radio_resp_name(
    RADIO_RESP resp);

+const char*
+radio_resp_name2(
+    RadioInstance* instance,
+    RADIO_RESP resp); /* Since 1.6.0 */
+
 const char*
 radio_ind_name(
    RADIO_IND ind);

+const char*
+radio_ind_name2(
+    RadioInstance* instance,
+    RADIO_IND ind); /* Since 1.6.0 */
+
 RADIO_RESP
 radio_req_resp(
    RADIO_REQ req)
--- a/include/radio_voice_types.h
+++ b/include/radio_voice_types.h
@@ -0,0 +1,168 @@
+/*
+ * Copyright (C) 2024 Jollyboys Ltd
+ *
+ * You may use this file under the terms of the BSD license as follows:
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions
+ * are met:
+ *
+ *   1. Redistributions of source code must retain the above copyright
+ *      notice, this list of conditions and the following disclaimer.
+ *   2. 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.
+ *   3. Neither the names of the copyright holders nor the names of its
+ *      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 HOLDERS 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.
+ *
+ * The views and conclusions contained in the software and documentation
+ * are those of the authors and should not be interpreted as representing
+ * any official policies, either expressed or implied.
+ */
+
+#ifndef RADIO_VOICE_TYPES_H
+#define RADIO_VOICE_TYPES_H
+
+#include <gbinder_types.h>
+
+G_BEGIN_DECLS
+
+#define RADIO_VOICE_INTERFACE_MAX (RADIO_VOICE_INTERFACE_COUNT - 1)
+
+#define RADIO_VOICE_INSTANCE         "default"
+#define RADIO_VOICE_IFACE_PREFIX     "android.hardware.radio.voice."
+#define RADIO_VOICE_IFACE            "IRadioVoice"
+#define RADIO_VOICE_RESPONSE_IFACE   "IRadioVoiceResponse"
+#define RADIO_VOICE_INDICATION_IFACE "IRadioVoiceIndication"
+#define RADIO_VOICE                  RADIO_VOICE_IFACE_PREFIX RADIO_VOICE_IFACE
+#define RADIO_VOICE_FQNAME           RADIO_VOICE "/" RADIO_VOICE_INSTANCE
+#define RADIO_VOICE_RESPONSE         RADIO_VOICE_IFACE_PREFIX RADIO_VOICE_RESPONSE_IFACE
+#define RADIO_VOICE_INDICATION       RADIO_VOICE_IFACE_PREFIX RADIO_VOICE_INDICATION_IFACE
+
+/* Transaction codes */
+
+/* c(req,resp,Name,CALL_NAME) */
+#define RADIO_VOICE_CALL_1(c) \
+    c(1,1,acceptCall,ACCEPT_CALL) \
+    c(2,3,cancelPendingUssd,CANCEL_PENDING_USSD) \
+    c(3,4,conference,CONFERENCE) \
+    c(4,5,dial,DIAL) \
+    c(5,6,emergencyDial,EMERGENCY_DIAL) \
+    c(6,7,exitEmergencyCallbackMode,EXIT_EMERGENCY_CALLBACK_MODE) \
+    c(7,8,explicitCallTransfer,EXPLICIT_CALL_TRANSFER) \
+    c(8,9,getCallForwardStatus,GET_CALL_FORWARD_STATUS) \
+    c(9,10,getCallWaiting,GET_CALL_WAITING) \
+    c(10,11,getClip,GET_CLIP) \
+    c(11,12,getClir,GET_CLIR) \
+    c(12,13,getCurrentCalls,GET_CURRENT_CALLS) \
+    c(13,14,getLastCallFailCause,GET_LAST_CALL_FAIL_CAUSE) \
+    c(14,15,getMute,GET_MUTE) \
+    c(15,16,getPreferredVoicePrivacy,GET_PREFERRED_VOICE_PRIVACY) \
+    c(16,17,getTtyMode,GET_TTY_MODE) \
+    c(17,18,handleStkCallSetupRequestFromSim,HANDLE_STK_CALL_SETUP_REQUEST_FROM_SIM) \
+    c(19,20,hangupForegroundResumeBackground,HANGUP_FOREGROUND_RESUME_BACKGROUND) \
+    c(20,21,hangupWaitingOrBackground,HANGUP_WAITING_OR_BACKGROUND) \
+    c(21,22,isVoNrEnabled,IS_VO_NR_ENABLED) \
+    c(22,23,rejectCall,REJECT_CALL) \
+    c(24,24,sendBurstDtmf,SEND_BURST_DTMF) \
+    c(25,25,sendCdmaFeatureCode,SEND_CDMA_FEATURE_CODE) \
+    c(26,26,sendDtmf,SEND_DTMF) \
+    c(27,27,sendUssd,SEND_USSD) \
+    c(28,28,separateConnection,SEPARATE_CONNECTION) \
+    c(29,29,setCallForward,SET_CALL_FORWARD) \
+    c(30,30,setCallWaiting,SET_CALL_WAITING) \
+    c(31,31,setClir,SET_CLIR) \
+    c(32,32,setMute,SET_MUTE) \
+    c(33,33,setPreferredVoicePrivacy,SET_PREFERRED_VOICE_PRIVACY) \
+    c(35,34,setTtyMode,SET_TTY_MODE) \
+    c(36,35,setVoNrEnabled,SET_VO_NR_ENABLED) \
+    c(37,36,startDtmf,START_DTMF) \
+    c(38,37,stopDtmf,STOP_DTMF) \
+    c(39,38,switchWaitingOrHoldingAndActive,SWITCH_WAITING_OR_HOLDING_AND_ACTIVE) \
+
+/* i(code,Name,IND_NAME) */
+#define RADIO_VOICE_IND_1(i) \
+    i(1,callRing,CALL_RING) \
+    i(2,callStateChanged,CALL_STATE_CHANGED) \
+    i(3,cdmaCallWaiting,CDMA_CALL_WAITING) \
+    i(4,cdmaInfoRec,CDMA_INFO_REC) \
+    i(5,cdmaOtaProvisionStatus,CDMA_OTA_PROVISION_STATUS) \
+    i(6,currentEmergencyNumberList,CURRENT_EMERGENCY_NUMBER_LIST) \
+    i(7,enterEmergencyCallbackMode,ENTER_EMERGENCY_CALLBACK_MODE) \
+    i(8,exitEmergencyCallbackMode,EXIT_EMERGENCY_CALLBACK_MODE) \
+    i(9,indicateRingbackTone,INDICATE_RINGBACK_TONE) \
+    i(10,onSupplementaryServiceIndication,ON_SUPPLEMENTARY_SERVICE_INDICATION) \
+    i(11,onUssd,ON_USSD) \
+    i(12,resendIncallMute,RESEND_INCALL_MUTE) \
+    i(13,srvccStateNotify,SRVCC_STATE_NOTIFY) \
+    i(14,stkCallControlAlphaNotify,STK_CALL_CONTROL_ALPHA_NOTIFY) \
+    i(15,stkCallSetup,STK_CALL_SETUP) \
+
+typedef enum radio_voice_req {
+    RADIO_VOICE_REQ_ANY = 0,
+    RADIO_VOICE_REQ_NONE = 0,
+#define RADIO_VOICE_REQ_(req,resp,Name,NAME) RADIO_VOICE_REQ_##NAME = req,
+
+    /* android.hardware.radio.voice.IRadioVoice v1 */
+    RADIO_VOICE_CALL_1(RADIO_VOICE_REQ_)
+    RADIO_VOICE_REQ_HANGUP = 18, /* hangup */
+    RADIO_VOICE_REQ_RESPONSE_ACKNOWLEDGEMENT = 23, /* responseAcknowledgement */
+    RADIO_VOICE_REQ_SET_RESPONSE_FUNCTIONS = 34, /* setResponseFunctions */
+    RADIO_VOICE_1_REQ_LAST = RADIO_VOICE_REQ_SWITCH_WAITING_OR_HOLDING_AND_ACTIVE,
+
+#undef RADIO_VOICE_REQ_
+} RADIO_VOICE_REQ;
+G_STATIC_ASSERT(sizeof(RADIO_VOICE_REQ) == 4);
+
+typedef enum radio_voice_resp {
+    RADIO_VOICE_RESP_ANY = 0,
+    RADIO_VOICE_RESP_NONE = 0,
+#define RADIO_VOICE_RESP_(req,resp,Name,NAME) RADIO_VOICE_RESP_##NAME = resp,
+
+    /* android.hardware.radio.voice.IRadioVoiceResponse v1 */
+    RADIO_VOICE_CALL_1(RADIO_VOICE_RESP_)
+    RADIO_VOICE_RESP_ACKNOWLEDGE_REQUEST = 2, /* acknowledgeRequest */
+    RADIO_VOICE_RESP_HANGUP_CONNECTION_RESPONSE = 19, /* hangupConnectionResponse */
+    RADIO_VOICE_1_RESP_LAST = RADIO_VOICE_RESP_SWITCH_WAITING_OR_HOLDING_AND_ACTIVE,
+
+#undef RADIO_VOICE_RESP_
+} RADIO_VOICE_RESP;
+G_STATIC_ASSERT(sizeof(RADIO_VOICE_RESP) == 4);
+
+typedef enum radio_voice_ind {
+    RADIO_VOICE_IND_ANY = 0,
+    RADIO_VOICE_IND_NONE = 0,
+#define RADIO_VOICE_IND_(code,Name,NAME) RADIO_VOICE_IND_##NAME = code,
+
+    /* android.hardware.radio.voice.IRadioVoiceIndication v1 */
+    RADIO_VOICE_IND_1(RADIO_VOICE_IND_)
+    RADIO_VOICE_1_IND_LAST = RADIO_VOICE_IND_STK_CALL_SETUP,
+
+#undef RADIO_VOICE_IND_
+} RADIO_VOICE_IND;
+G_STATIC_ASSERT(sizeof(RADIO_VOICE_IND) == 4);
+
+G_END_DECLS
+
+#endif /* RADIO_VOICE_TYPES_H */
+
+/*
+ * Local Variables:
+ * mode: C
+ * c-basic-offset: 4
+ * indent-tabs-mode: nil
+ * End:
+ */
--- a/rpm/libgbinder-radio.spec
+++ b/rpm/libgbinder-radio.spec
@@ -1,6 +1,6 @@
 Name: libgbinder-radio

-Version: 1.5.5
+Version: 1.6.0
 Release: 0
 Summary: Binder client library for Android radio interfaces
 License: BSD
--- a/src/radio_base.c
+++ b/src/radio_base.c
@@ -92,6 +92,7 @@ guint32
 radio_base_reserve_serial(
    RadioBase* self)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    /*
     * Using a static counter practically guarantees that different
     * serials would never be in use simultanously by different
@@ -114,6 +115,7 @@ radio_base_unlink_request(
    RadioRequest* req,
    RadioRequest* prev)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    RadioRequest* next = req->queue_next;

    if (prev) {
@@ -134,6 +136,7 @@ radio_base_dequeue_request(
    RadioBasePriv* q,
    RadioRequest* req)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    RadioRequest* ptr = q->queue_first;
    RadioRequest* prev = NULL;

@@ -154,6 +157,7 @@ radio_base_deactivate_request(
    RadioBase* self,
    RadioRequest* req)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    RadioBasePriv* priv = self->priv;

    g_hash_table_remove(priv->pending, KEY(req->serial2));
@@ -177,6 +181,7 @@ radio_base_drop_req(
    RadioBase* self,
    RadioRequest* req)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    radio_base_cancel_request(self, req);
    radio_base_deactivate_request(self, req);
    radio_base_reset_timeout(self);
@@ -192,6 +197,7 @@ radio_base_detach_req(
    gpointer value,
    gpointer user_data)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    RadioRequest* req = value;

    radio_base_cancel_request(THIS(user_data), req);
@@ -206,6 +212,7 @@ radio_base_fail_request(
    RADIO_REQUEST_STATE state,
    RADIO_TX_STATUS status)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    radio_request_ref(req);
    req->state = state;
    if (req->complete) {
@@ -225,6 +232,7 @@ radio_base_request_failed(
    RadioBase* self,
    RadioRequest* req)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    radio_base_fail_request(self, req,
        RADIO_REQUEST_STATE_FAILED,
        RADIO_TX_STATUS_FAILED);
@@ -237,6 +245,7 @@ radio_base_request_sent(
    RadioRequest* req,
    int status)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    req->tx_id = 0;
    if (status != GBINDER_STATUS_OK) {
        g_object_ref(self);
@@ -251,6 +260,7 @@ radio_base_submit_transaction(
    RadioBase* self,
    RadioRequest* req)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    RadioBasePriv* priv = self->priv;

    if (req->serial2) {
@@ -300,6 +310,7 @@ radio_base_can_set_owner(
    RadioBasePriv* priv,
    RadioRequestGroup* group)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    /*
     * Caller has verified that the group isn't already the owner.
     * It's also been checked that either the owner queue is empty,
@@ -340,6 +351,7 @@ void
 radio_base_move_owner_queue(
    RadioBase* self)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    RadioBasePriv* priv = self->priv;

    if (!priv->owner && priv->owner_queue) {
@@ -362,6 +374,7 @@ radio_base_can_submit_request(
    RadioBasePriv* priv,
    RadioRequest* req)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    if (priv->block_req) {
        /* The current blocker can be resubmitted */
        return priv->block_req == req;
@@ -401,6 +414,7 @@ radio_base_queue_request(
    RadioBasePriv* priv,
    RadioRequest* req)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    req->state = RADIO_REQUEST_STATE_QUEUED;
    if (priv->queue_last) {
        priv->queue_last->queue_next = req;
@@ -415,6 +429,7 @@ guint
 radio_base_submit_queued_requests(
    RadioBase* self)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    RadioBasePriv* priv = self->priv;
    guint submitted = 0;

@@ -461,6 +476,7 @@ gboolean
 radio_base_timeout(
    gpointer user_data)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    RadioBase* self = THIS(user_data);
    RadioBasePriv* priv = self->priv;
    const gint64 now = g_get_monotonic_time();
@@ -529,6 +545,7 @@ void
 radio_base_initialize(
    RadioBase* self)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
 }

 void
@@ -536,6 +553,7 @@ radio_base_register_request(
    RadioBase* self,
    RadioRequest* req)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    /* Caller makes sure that both arguments are not NULL */
    RadioBasePriv* priv = self->priv;

@@ -549,6 +567,7 @@ radio_base_unregister_request(
    RadioBase* self,
    RadioRequest* req)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    /* Caller doesn't check base for NULL */
    if (G_LIKELY(self)) {
        RadioBasePriv* priv = self->priv;
@@ -566,6 +585,7 @@ radio_base_submit_request(
    RadioBase* self,
    RadioRequest* req)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    /*
     * Caller makes sure that both arguments are not NULL. Note that if the
     * base is dead, request stays in the NEW state and can be resubmitted
@@ -603,6 +623,7 @@ radio_base_retry_request(
    RadioBase* self,
    RadioRequest* req)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    /* Caller makes sure that both arguments are not NULL */
    if (req->state == RADIO_REQUEST_STATE_PENDING &&
        radio_base_can_retry(req)) {
@@ -627,6 +648,7 @@ void
 radio_base_request_dropped(
    RadioRequest* req)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    if (req->object) {
        radio_base_drop_req(req->object, req);
    }
@@ -637,6 +659,7 @@ radio_base_timeout_ms(
    RadioBase* self,
    RadioRequest* req)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    /* Caller checks object pointer for NULL */
    return req->timeout_ms ? req->timeout_ms : self->priv->default_timeout_ms;
 }
@@ -645,6 +668,7 @@ void
 radio_base_reset_timeout(
    RadioBase* self)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    RadioBasePriv* priv = self->priv;

    if (g_hash_table_size(priv->active)) {
@@ -707,6 +731,7 @@ radio_base_block_status(
    RadioBase* self,
    RadioRequestGroup* group)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    RadioBasePriv* priv = self->priv;

    /* Caller checks object pointer for NULL */
@@ -724,6 +749,7 @@ radio_base_block(
    RadioBase* self,
    RadioRequestGroup* group)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    RadioBasePriv* priv = self->priv;

    /* Caller checks object pointer for NULL */
@@ -750,6 +776,7 @@ radio_base_unblock(
    RadioBase* self,
    RadioRequestGroup* group)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    /* Parameters are checked by the caller */
    RadioBasePriv* priv = self->priv;

@@ -778,6 +805,7 @@ radio_base_handle_resp(
    const RadioResponseInfo* info,
    const GBinderReader* reader)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    RadioBasePriv* priv = self->priv;
    RadioRequest* req = g_hash_table_lookup(priv->active, KEY(info->serial));

@@ -829,6 +857,7 @@ radio_base_handle_ack(
    RadioBase* self,
    guint32 serial)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    RadioBasePriv* priv = self->priv;
    RadioRequest* req = g_hash_table_lookup(priv->active, KEY(serial));

@@ -844,6 +873,7 @@ void
 radio_base_handle_death(
    RadioBase* self)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    RadioBasePriv* priv = self->priv;
    RadioRequest* dead = NULL;
    RadioRequest* req;
@@ -890,6 +920,7 @@ void
 radio_base_submit_requests(
    RadioBase* self)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    if (radio_base_submit_queued_requests(self)) {
        radio_base_reset_timeout(self);
    }
@@ -900,6 +931,7 @@ radio_base_cancel_request(
    RadioBase* self,
    RadioRequest* req)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    req->scheduled = 0;
    if (req->tx_id) {
        RADIO_BASE_GET_CLASS(self)->cancel_request(self, req->tx_id);
@@ -912,6 +944,7 @@ radio_base_set_default_timeout(
    RadioBase* self,
    int ms)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    /* Caller checks object pointer for NULL */
    RadioBasePriv* priv = self->priv;

@@ -948,6 +981,7 @@ radio_base_add_owner_changed_handler(
    RadioBaseFunc fn,
    gpointer user_data)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    /* Caller checks object pointer for NULL */
    return G_LIKELY(fn) ?
        g_signal_connect_closure_by_id(self, radio_base_signals[SIGNAL_OWNER],
@@ -963,6 +997,7 @@ void
 radio_base_init(
    RadioBase* self)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    RadioBasePriv* priv = G_TYPE_INSTANCE_GET_PRIVATE(self, RADIO_TYPE_BASE,
        RadioBasePriv);

@@ -980,6 +1015,7 @@ void
 radio_base_object_finalize(
    GObject* object)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    RadioBase* self = THIS(object);
    RadioBasePriv* priv = self->priv;

@@ -998,6 +1034,7 @@ void
 radio_base_class_init(
    RadioBaseClass* klass)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    g_type_class_add_private(klass, sizeof(RadioBasePriv));
    G_OBJECT_CLASS(klass)->finalize = radio_base_object_finalize;
    radio_base_signals[SIGNAL_OWNER] = g_signal_new(SIGNAL_OWNER_NAME,
--- a/src/radio_client.c
+++ b/src/radio_client.c
@@ -96,6 +96,7 @@ void
 radio_client_call_free(
    RadioClientCall* call)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    radio_request_unref(call->req);
    gutil_slice_free(call);
 }
@@ -106,6 +107,7 @@ radio_client_call_destroy(
    void* user_data1,
    void* user_data2)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    radio_client_call_free(user_data2);
 }

@@ -118,6 +120,7 @@ radio_client_call_complete(
    void* user_data1,
    void* user_data2)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    RadioClientCall* call = user_data2;

    call->callback(RADIO_BASE(user_data1), call->req, status);
@@ -129,6 +132,7 @@ radio_client_handle_death(
    RadioInstance* instance,
    gpointer user_data)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    RadioBase* base = RADIO_BASE(user_data);

    g_object_ref(base);
@@ -143,6 +147,7 @@ radio_client_handle_connected(
    RadioInstance* instance,
    gpointer user_data)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    g_signal_emit(THIS(user_data), radio_client_signals[SIGNAL_CONNECTED], 0);
    radio_base_submit_requests(RADIO_BASE(user_data));
 }
@@ -154,6 +159,7 @@ radio_client_handle_ack(
    guint32 serial,
    gpointer user_data)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    radio_base_handle_ack(RADIO_BASE(user_data), serial);
 }

@@ -166,6 +172,7 @@ radio_client_handle_ind(
    const GBinderReader* reader,
    gpointer user_data)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    g_signal_emit(THIS(user_data), radio_client_signals[SIGNAL_INDICATION],
        radio_instance_ind_quark(instance, code), code, reader);
 }
@@ -179,8 +186,9 @@ radio_client_handle_resp(
    const GBinderReader* reader,
    gpointer user_data)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    if (!radio_base_handle_resp(RADIO_BASE(user_data), code, info, reader)) {
-        const char* name = radio_resp_name(code);
+        const char* name = radio_resp_name2(instance, code);

        /* Most likely this is a response to a cancelled request */
        GDEBUG("Ignoring IRadio response [%08x] %u %s", info->serial, code,
@@ -196,6 +204,7 @@ radio_client_add_handler(
    RadioClientFunc fn,
    gpointer user_data)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    return (G_LIKELY(self) && G_LIKELY(fn)) ?
        g_signal_connect_closure_by_id(self, radio_client_signals[sig], 0,
             g_cclosure_new(G_CALLBACK(fn), user_data, NULL), FALSE) : 0;
@@ -209,6 +218,7 @@ RadioClient*
 radio_client_new(
    RadioInstance* instance)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    RadioClient* self = NULL;

    if (G_LIKELY(instance)) {
@@ -238,6 +248,7 @@ RadioClient*
 radio_client_ref(
    RadioClient* self)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    if (G_LIKELY(self)) {
        g_object_ref(self);
    }
@@ -248,6 +259,7 @@ void
 radio_client_unref(
    RadioClient* self)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    if (G_LIKELY(self)) {
        g_object_unref(self);
    }
@@ -257,6 +269,7 @@ const char*
 radio_client_slot(
    RadioClient* self)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    return G_LIKELY(self) ? self->instance->slot : NULL;
 }

@@ -264,6 +277,7 @@ gboolean
 radio_client_dead(
    RadioClient* self)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    return !self || self->instance->dead;
 }

@@ -271,6 +285,7 @@ gboolean
 radio_client_connected(
    RadioClient* self)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    return self && self->instance->connected;
 }

@@ -278,14 +293,24 @@ RADIO_INTERFACE
 radio_client_interface(
    RadioClient* self)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    return G_LIKELY(self) ? self->instance->version : RADIO_INTERFACE_NONE;
 }

+RADIO_AIDL_INTERFACE
+radio_client_aidl_interface(
+    RadioClient* self)
+{
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
+    return G_LIKELY(self) ? self->instance->interface_aidl : RADIO_AIDL_INTERFACE_NONE;
+}
+
 void
 radio_client_set_default_timeout(
    RadioClient* self,
    int milliseconds)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    if (G_LIKELY(self)) {
        radio_base_set_default_timeout(&self->base, milliseconds);
    }
@@ -298,6 +323,7 @@ radio_client_add_indication_handler(
    RadioClientIndicationFunc fn,
    gpointer user_data)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    return (G_LIKELY(self) && G_LIKELY(fn)) ?
        g_signal_connect_closure_by_id(self,
            radio_client_signals[SIGNAL_INDICATION],
@@ -311,6 +337,7 @@ radio_client_add_owner_changed_handler(
    RadioClientFunc fn,
    gpointer user_data)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    return self ? radio_base_add_owner_changed_handler(&self->base,
        (RadioBaseFunc) fn, user_data) : 0;
 }
@@ -321,6 +348,7 @@ radio_client_add_death_handler(
    RadioClientFunc fn,
    gpointer user_data)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    return radio_client_add_handler(self, SIGNAL_DEATH, fn, user_data);
 }

@@ -330,6 +358,7 @@ radio_client_add_connected_handler(
    RadioClientFunc fn,
    gpointer user_data)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    return radio_client_add_handler(self, SIGNAL_CONNECTED, fn, user_data);
 }

@@ -338,6 +367,7 @@ radio_client_remove_handler(
    RadioClient* self,
    gulong id)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    if (G_LIKELY(id) && G_LIKELY(self)) {
        g_signal_handler_disconnect(self, id);
    }
@@ -349,6 +379,7 @@ radio_client_remove_handlers(
    gulong* ids,
    int count)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    gutil_disconnect_handlers(self, ids, count);
 }

@@ -361,6 +392,7 @@ gboolean
 radio_client_is_dead(
    RadioBase* base)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    return THIS(base)->instance->dead;
 }

@@ -369,6 +401,7 @@ gboolean
 radio_client_can_submit_requests(
    RadioBase* base)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    return THIS(base)->instance->connected;
 }

@@ -378,6 +411,7 @@ radio_client_new_request(
    RadioBase* base,
    guint32 code)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    return radio_instance_new_request(THIS(base)->instance, code);
 }

@@ -388,6 +422,7 @@ radio_client_send_request(
    RadioRequest* req,
    RadioBaseRequestSentFunc callback)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    RadioClientCall* call = g_slice_new(RadioClientCall);
    gulong tx_id;

@@ -410,6 +445,7 @@ radio_client_cancel_request(
    RadioBase* base,
    gulong id)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    radio_instance_cancel_request(THIS(base)->instance, id);
 }

@@ -422,6 +458,7 @@ void
 radio_client_init(
    RadioClient* self)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
 }

 static
@@ -429,6 +466,7 @@ void
 radio_client_finalize(
    GObject* object)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    RadioClient* self = THIS(object);

    radio_instance_remove_all_handlers(self->instance, self->event_ids);
@@ -441,6 +479,7 @@ void
 radio_client_class_init(
    RadioClientClass* klass)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    RadioBaseClass* base_class = RADIO_BASE_CLASS(klass);
    GObjectClass* object_class = G_OBJECT_CLASS(klass);
    GType type = G_OBJECT_CLASS_TYPE(klass);
--- a/src/radio_config.c
+++ b/src/radio_config.c
@@ -56,6 +56,7 @@ typedef struct radio_config {
    GBinderRemoteObject* remote;
    GBinderLocalObject* response;
    GBinderLocalObject* indication;
+    RADIO_INTERFACE_TYPE interface_type;
    RADIO_CONFIG_INTERFACE version;
    GHashTable* req_quarks;
    GHashTable* resp_quarks;
@@ -121,6 +122,12 @@ static const GBinderClientIfaceInfo radio_config_iface_info[] = {
 G_STATIC_ASSERT(G_N_ELEMENTS(radio_config_iface_info) ==
    RADIO_CONFIG_INTERFACE_COUNT);

+static const GBinderClientIfaceInfo radio_config_aidl_iface_info[] = {
+    {RADIO_CONFIG_AIDL, RADIO_CONFIG_1_1_REQ_LAST }
+};
+G_STATIC_ASSERT(G_N_ELEMENTS(radio_config_aidl_iface_info) ==
+    RADIO_CONFIG_AIDL_INTERFACE_COUNT);
+
 static const char* const radio_config_indication_ifaces[] = {
    RADIO_CONFIG_INDICATION_1_2,
    RADIO_CONFIG_INDICATION_1_1,
@@ -130,6 +137,13 @@ static const char* const radio_config_indication_ifaces[] = {
 G_STATIC_ASSERT(G_N_ELEMENTS(radio_config_indication_ifaces) ==
    RADIO_CONFIG_INTERFACE_COUNT + 1);

+static const char* const radio_config_aidl_indication_ifaces[] = {
+    RADIO_CONFIG_AIDL_INDICATION,
+    NULL
+};
+G_STATIC_ASSERT(G_N_ELEMENTS(radio_config_aidl_indication_ifaces) ==
+    RADIO_CONFIG_AIDL_INTERFACE_COUNT + 1);
+
 static const char* const radio_config_response_ifaces[] = {
    RADIO_CONFIG_RESPONSE_1_2,
    RADIO_CONFIG_RESPONSE_1_1,
@@ -139,7 +153,15 @@ static const char* const radio_config_response_ifaces[] = {
 G_STATIC_ASSERT(G_N_ELEMENTS(radio_config_response_ifaces) ==
    RADIO_CONFIG_INTERFACE_COUNT + 1);

+static const char* const radio_config_aidl_response_ifaces[] = {
+    RADIO_CONFIG_AIDL_RESPONSE,
+    NULL
+};
+G_STATIC_ASSERT(G_N_ELEMENTS(radio_config_aidl_response_ifaces) ==
+    RADIO_CONFIG_AIDL_INTERFACE_COUNT + 1);
+
 typedef struct radio_config_interface_desc {
+    RADIO_INTERFACE_TYPE interface_type;
    RADIO_CONFIG_INTERFACE version;
    const char* fqname;
    const char* radio_iface;
@@ -150,6 +172,7 @@ typedef struct radio_config_interface_desc {
 #define RADIO_CONFIG_INTERFACE_INDEX(x) (RADIO_CONFIG_INTERFACE_COUNT - x - 1)

 #define RADIO_CONFIG_INTERFACE_DESC(v) \
+        RADIO_INTERFACE_TYPE_HIDL, \
        RADIO_CONFIG_INTERFACE_##v, \
        RADIO_CONFIG_##v##_FQNAME, \
        RADIO_CONFIG_##v, \
@@ -166,9 +189,24 @@ static const RadioConfigInterfaceDesc radio_config_interfaces[] = {
 G_STATIC_ASSERT(G_N_ELEMENTS(radio_config_interfaces) ==
    RADIO_CONFIG_INTERFACE_COUNT);

+static const RadioConfigInterfaceDesc radio_config_aidl_interfaces[] = {
+    {
+        RADIO_INTERFACE_TYPE_AIDL,
+        RADIO_CONFIG_AIDL_INTERFACE_1,
+        RADIO_CONFIG_AIDL_FQNAME,
+        RADIO_CONFIG_AIDL,
+        radio_config_aidl_indication_ifaces,
+        radio_config_aidl_response_ifaces,
+    }
+};
+G_STATIC_ASSERT(G_N_ELEMENTS(radio_config_aidl_interfaces) ==
+    RADIO_CONFIG_AIDL_INTERFACE_COUNT);
+
 /* Must have a separate instance for each interface version */
 static RadioConfig* radio_config_instance[RADIO_CONFIG_INTERFACE_COUNT] =
    { NULL };
+static RadioConfig* radio_config_aidl_instance[RADIO_CONFIG_AIDL_INTERFACE_COUNT] =
+    { NULL };

 typedef struct radio_config_call {
    RadioRequest* req;
@@ -185,6 +223,7 @@ void
 radio_config_call_free(
    RadioConfigCall* call)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    radio_request_unref(call->req);
    gutil_slice_free(call);
 }
@@ -197,6 +236,7 @@ radio_config_call_complete(
    int status,
    void* user_data)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    RadioConfigCall* call = user_data;

    call->callback(call->object, call->req, status);
@@ -205,18 +245,32 @@ radio_config_call_complete(
 static
 const char*
 radio_config_known_req_name(
+    RadioConfig* self,
    RADIO_CONFIG_REQ req)
 {
-    switch (req) {
-    case RADIO_CONFIG_REQ_SET_RESPONSE_FUNCTIONS: return "setResponseFunctions";
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
+    if (!G_LIKELY(self) || self->interface_type == RADIO_INTERFACE_TYPE_HIDL) {
+        switch (req) {
+        case RADIO_CONFIG_REQ_SET_RESPONSE_FUNCTIONS: return "setResponseFunctions";
 #define RADIO_CONFIG_REQ_(req,resp,Name,NAME) \
-    case RADIO_CONFIG_REQ_##NAME: return #Name;
-    RADIO_CONFIG_CALL_1_0(RADIO_CONFIG_REQ_)
-    RADIO_CONFIG_CALL_1_1(RADIO_CONFIG_REQ_)
-    /* 1.2 defines no new requests */
+        case RADIO_CONFIG_REQ_##NAME: return #Name;
+        RADIO_CONFIG_CALL_1_0(RADIO_CONFIG_REQ_)
+        RADIO_CONFIG_CALL_1_1(RADIO_CONFIG_REQ_)
+        /* 1.2 defines no new requests */
 #undef RADIO_CONFIG_REQ_
-    case RADIO_CONFIG_REQ_ANY:
-        break;
+        case RADIO_CONFIG_REQ_ANY:
+            break;
+        }
+    } else if (self->interface_type == RADIO_INTERFACE_TYPE_AIDL) {
+        switch ((RADIO_CONFIG_AIDL_REQ)req) {
+        case RADIO_CONFIG_AIDL_REQ_SET_RESPONSE_FUNCTIONS: return "setResponseFunctions";
+#define RADIO_CONFIG_AIDL_REQ_(req,resp,Name,NAME) \
+        case RADIO_CONFIG_AIDL_REQ_##NAME: return #Name;
+        RADIO_CONFIG_AIDL_CALL_1(RADIO_CONFIG_AIDL_REQ_)
+#undef RADIO_CONFIG_AIDL_REQ_
+        case RADIO_CONFIG_AIDL_REQ_ANY:
+            break;
+        }
    }
    return NULL;
 }
@@ -224,18 +278,31 @@ radio_config_known_req_name(
 static
 const char*
 radio_config_known_resp_name(
+    RadioConfig* self,
    RADIO_CONFIG_RESP resp)
 {
-    switch (resp) {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
+    if (!G_LIKELY(self) || self->interface_type == RADIO_INTERFACE_TYPE_HIDL) {
+        switch (resp) {
 #define RADIO_CONFIG_RESP_(req,resp,Name,NAME) \
-    case RADIO_CONFIG_RESP_##NAME: return #Name "Response";
-    RADIO_CONFIG_CALL_1_0(RADIO_CONFIG_RESP_)
-    RADIO_CONFIG_CALL_1_1(RADIO_CONFIG_RESP_)
+        case RADIO_CONFIG_RESP_##NAME: return #Name "Response";
+        RADIO_CONFIG_CALL_1_0(RADIO_CONFIG_RESP_)
+        RADIO_CONFIG_CALL_1_1(RADIO_CONFIG_RESP_)
 #undef RADIO_CONFIG_RESP_
-    case RADIO_CONFIG_RESP_GET_SIM_SLOTS_STATUS_1_2:
-        return "getSimSlotsStatusResponse_1_2";
-    case RADIO_CONFIG_RESP_ANY:
-        break;
+        case RADIO_CONFIG_RESP_GET_SIM_SLOTS_STATUS_1_2:
+            return "getSimSlotsStatusResponse_1_2";
+        case RADIO_CONFIG_RESP_ANY:
+            break;
+        }
+    } else if (self->interface_type == RADIO_INTERFACE_TYPE_AIDL) {
+        switch ((RADIO_CONFIG_AIDL_RESP)resp) {
+#define RADIO_CONFIG_AIDL_RESP_(req,resp,Name,NAME) \
+        case RADIO_CONFIG_AIDL_RESP_##NAME: return #Name "Response";
+        RADIO_CONFIG_AIDL_CALL_1(RADIO_CONFIG_AIDL_RESP_)
+#undef RADIO_CONFIG_AIDL_RESP_
+        case RADIO_CONFIG_AIDL_RESP_ANY:
+            break;
+        }
    }
    return NULL;
 }
@@ -243,17 +310,30 @@ radio_config_known_resp_name(
 static
 const char*
 radio_config_known_ind_name(
+    RadioConfig* self,
    RADIO_CONFIG_IND ind)
 {
-    switch (ind) {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
+    if (!G_LIKELY(self) || self->interface_type == RADIO_INTERFACE_TYPE_HIDL) {
+        switch (ind) {
 #define RADIO_CONFIG_IND_(code,Name,NAME) \
-    case RADIO_CONFIG_IND_##NAME: return #Name;
-    RADIO_CONFIG_IND_1_0(RADIO_CONFIG_IND_)
-    /* 1.1 defines no new indications */
-    RADIO_CONFIG_IND_1_2(RADIO_CONFIG_IND_)
+        case RADIO_CONFIG_IND_##NAME: return #Name;
+        RADIO_CONFIG_IND_1_0(RADIO_CONFIG_IND_)
+        /* 1.1 defines no new indications */
+        RADIO_CONFIG_IND_1_2(RADIO_CONFIG_IND_)
 #undef RADIO_CONFIG_IND_
-    case RADIO_CONFIG_IND_ANY:
-        break;
+        case RADIO_CONFIG_IND_ANY:
+            break;
+        }
+    } else if (self->interface_type == RADIO_INTERFACE_TYPE_AIDL) {
+        switch ((RADIO_CONFIG_AIDL_IND)ind) {
+#define RADIO_CONFIG_AIDL_IND_(code,Name,NAME) \
+        case RADIO_CONFIG_AIDL_IND_##NAME: return #Name;
+        RADIO_CONFIG_AIDL_IND_1(RADIO_CONFIG_AIDL_IND_)
+#undef RADIO_CONFIG_AIDL_IND_
+        case RADIO_CONFIG_AIDL_IND_ANY:
+            break;
+        }
    }
    return NULL;
 }
@@ -264,6 +344,7 @@ radio_config_req_quark(
    RadioConfig* self,
    RADIO_CONFIG_REQ req)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    GQuark q = 0;

    if (req != RADIO_CONFIG_REQ_ANY) {
@@ -271,7 +352,7 @@ radio_config_req_quark(

        q = GPOINTER_TO_UINT(g_hash_table_lookup(self->req_quarks, key));
        if (!q) {
-            const char* known = radio_config_known_req_name(req);
+            const char* known = radio_config_known_req_name(self, req);

            if (known) {
                q = g_quark_from_static_string(known);
@@ -290,6 +371,7 @@ radio_config_resp_quark(
    RadioConfig* self,
    RADIO_CONFIG_RESP resp)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    GQuark q = 0;

    if (resp != RADIO_CONFIG_RESP_ANY) {
@@ -297,7 +379,7 @@ radio_config_resp_quark(

        q = GPOINTER_TO_UINT(g_hash_table_lookup(self->resp_quarks, key));
        if (!q) {
-            const char* known = radio_config_known_resp_name(resp);
+            const char* known = radio_config_known_resp_name(self, resp);

            if (known) {
                q = g_quark_from_static_string(known);
@@ -316,6 +398,7 @@ radio_config_ind_quark(
    RadioConfig* self,
    RADIO_CONFIG_IND ind)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    GQuark q = 0;

    if (ind != RADIO_CONFIG_IND_ANY) {
@@ -323,7 +406,7 @@ radio_config_ind_quark(

        q = GPOINTER_TO_UINT(g_hash_table_lookup(self->ind_quarks, key));
        if (!q) {
-            const char* known = radio_config_known_ind_name(ind);
+            const char* known = radio_config_known_ind_name(self, ind);

            if (known) {
                q = g_quark_from_static_string(known);
@@ -346,6 +429,7 @@ radio_config_indication(
    int* status,
    void* user_data)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    RadioConfig* self = THIS(user_data);
    const char* iface = gbinder_remote_request_interface(req);

@@ -391,55 +475,67 @@ radio_config_response(
    int* status,
    void* user_data)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    RadioConfig* self = THIS(user_data);
    const char* iface = gbinder_remote_request_interface(req);
+    const RadioResponseInfo* info = NULL;
+    GBinderReader args;
+
+    gbinder_remote_request_init_reader(req, &args);

    if (gutil_strv_contains((GStrV*)radio_config_response_ifaces, iface)) {
-        GBinderReader args;
-        const RadioResponseInfo* info;
-
        /* All responses must be one-way and have RadioResponseInfo */
-        gbinder_remote_request_init_reader(req, &args);
        info = gbinder_reader_read_hidl_struct(&args, RadioResponseInfo);
-        GASSERT(flags & GBINDER_TX_FLAG_ONEWAY);
-        if (info) {
-            int p = RADIO_OBSERVER_PRIORITY_HIGHEST;
-            const GQuark quark = radio_config_resp_quark(self, code);
-            const guint* signals = radio_config_signals +
-                SIGNAL_OBSERVE_RESPONSE_0;
-
-            radio_config_ref(self);
-
-            /* High-priority observers get notified first */
-            for (; p > RADIO_OBSERVER_PRIORITY_DEFAULT; p--) {
-                const int i = RADIO_OBSERVER_PRIORITY_INDEX(p);
-
-                if (signals[i]) {
-                    g_signal_emit(self, signals[i], quark, code, info, &args);
-                }
-            }
-
-            /* Then the response is actually processed */
-            if (!radio_base_handle_resp(&self->base, code, info, &args)) {
-                const char* name = radio_config_known_resp_name(code);
-
-                /* Most likely this is a response to a cancelled request */
-                GDEBUG("Ignoring IRadioConfig response [%08x] %u %s",
-                    info->serial, code, name ? name : "");
-            }
-
-            /* Followed by the remaining observers in their priority order */
-            for (; p >= RADIO_OBSERVER_PRIORITY_LOWEST; p--) {
-                const int i = RADIO_OBSERVER_PRIORITY_INDEX(p);
-
-                if (signals[i]) {
-                    g_signal_emit(self, signals[i], quark, code, info, &args);
-                }
-            }
-            radio_config_unref(self);
-            *status = GBINDER_STATUS_OK;
-        }
+    } else if (gutil_strv_contains((GStrV*)radio_config_aidl_response_ifaces, iface)) {
+        /* RadioResponseInfo has the same fields/padding between HIDL and AIDL */
+        gsize out_size;
+        info = gbinder_reader_read_parcelable(&args, &out_size);
+        GASSERT(out_size == sizeof(RadioResponseInfo));
+    } else {
+        GDEBUG("radio_config_response called on unknown interface %s", iface);
+        return NULL;
    }
+
+    GASSERT(flags & GBINDER_TX_FLAG_ONEWAY);
+
+    if (info) {
+        int p = RADIO_OBSERVER_PRIORITY_HIGHEST;
+        const GQuark quark = radio_config_resp_quark(self, code);
+        const guint* signals = radio_config_signals +
+            SIGNAL_OBSERVE_RESPONSE_0;
+
+        radio_config_ref(self);
+
+        /* High-priority observers get notified first */
+        for (; p > RADIO_OBSERVER_PRIORITY_DEFAULT; p--) {
+            const int i = RADIO_OBSERVER_PRIORITY_INDEX(p);
+
+            if (signals[i]) {
+                g_signal_emit(self, signals[i], quark, code, info, &args);
+            }
+        }
+
+        /* Then the response is actually processed */
+        if (!radio_base_handle_resp(&self->base, code, info, &args)) {
+            const char* name = radio_config_known_resp_name(self, code);
+
+            /* Most likely this is a response to a cancelled request */
+            GDEBUG("Ignoring IRadioConfig response [%08x] %u %s",
+                info->serial, code, name ? name : "");
+        }
+
+        /* Followed by the remaining observers in their priority order */
+        for (; p >= RADIO_OBSERVER_PRIORITY_LOWEST; p--) {
+            const int i = RADIO_OBSERVER_PRIORITY_INDEX(p);
+
+            if (signals[i]) {
+                g_signal_emit(self, signals[i], quark, code, info, &args);
+            }
+        }
+        radio_config_unref(self);
+        *status = GBINDER_STATUS_OK;
+    }
+
    return NULL;
 }

@@ -448,6 +544,7 @@ void
 radio_config_drop_binder(
    RadioConfig* self)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    if (self->indication) {
        gbinder_local_object_drop(self->indication);
        self->indication = NULL;
@@ -470,6 +567,7 @@ radio_config_died(
    GBinderRemoteObject* obj,
    void* user_data)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    RadioConfig* self = THIS(user_data);

    GWARN("IRadioConfig died");
@@ -490,6 +588,7 @@ radio_config_gone(
    gpointer user_data,
    GObject* dead)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    GObject** shared_instance = user_data;

    if (*shared_instance == dead) {
@@ -505,16 +604,17 @@ radio_config_create(
    GBinderRemoteObject* remote,
    const RadioConfigInterfaceDesc* desc)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    RadioConfig* self = g_object_new(THIS_TYPE, NULL);
    GBinderLocalRequest* req;
    GBinderWriter writer;
    int status;
+    guint req_code = RADIO_CONFIG_REQ_NONE;

    radio_base_initialize(&self->base);
+    self->interface_type = desc->interface_type;
    self->version = desc->version;
    self->remote = gbinder_remote_object_ref(remote);
-    self->client = gbinder_client_new2(remote, radio_config_iface_info,
-        G_N_ELEMENTS(radio_config_iface_info));
    self->indication = gbinder_servicemanager_new_local_object2(sm,
        desc->ind_ifaces, radio_config_indication, self);
    self->response = gbinder_servicemanager_new_local_object2(sm,
@@ -522,14 +622,28 @@ radio_config_create(
    self->death_id = gbinder_remote_object_add_death_handler(remote,
        radio_config_died, self);

+    if (self->interface_type == RADIO_INTERFACE_TYPE_HIDL) {
+        self->client = gbinder_client_new2(remote, radio_config_iface_info,
+            G_N_ELEMENTS(radio_config_iface_info));
+        req_code = RADIO_CONFIG_REQ_SET_RESPONSE_FUNCTIONS;
+    } else if (self->interface_type == RADIO_INTERFACE_TYPE_AIDL) {
+        self->client = gbinder_client_new2(remote, radio_config_aidl_iface_info,
+            G_N_ELEMENTS(radio_config_aidl_iface_info));
+        req_code = RADIO_CONFIG_AIDL_REQ_SET_RESPONSE_FUNCTIONS;
+
+        gbinder_local_object_set_stability(self->indication, GBINDER_STABILITY_VINTF);
+        gbinder_local_object_set_stability(self->response, GBINDER_STABILITY_VINTF);
+    }
+    GASSERT(self->client);
+
    /* IRadioConfig::setResponseFunctions */
    req = gbinder_client_new_request2(self->client,
-        RADIO_CONFIG_REQ_SET_RESPONSE_FUNCTIONS);
+        req_code);
    gbinder_local_request_init_writer(req, &writer);
    gbinder_writer_append_local_object(&writer, self->response);
    gbinder_writer_append_local_object(&writer, self->indication);
    gbinder_remote_reply_unref(gbinder_client_transact_sync_reply(self->client,
-        RADIO_CONFIG_REQ_SET_RESPONSE_FUNCTIONS, req, &status));
+        req_code, req, &status));
    GVERBOSE_("IRadioConfig::setResponseFunctions status %d", status);
    gbinder_local_request_unref(req);
    return self;
@@ -543,6 +657,7 @@ RadioConfig*
 radio_config_new(
    void)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    return radio_config_new_with_version(RADIO_CONFIG_INTERFACE_MAX);
 }

@@ -550,20 +665,53 @@ RadioConfig*
 radio_config_new_with_version(
    RADIO_CONFIG_INTERFACE max_version)
 {
-    /* Validate the requested version to avoid out-of-bounds access */
-    if (max_version < RADIO_CONFIG_INTERFACE_1_0) {
-        max_version = RADIO_CONFIG_INTERFACE_1_0;
-    } else if (max_version > RADIO_CONFIG_INTERFACE_MAX) {
-        max_version = RADIO_CONFIG_INTERFACE_MAX;
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
+    return radio_config_new_with_version_and_interface_type(max_version,
+        RADIO_INTERFACE_TYPE_HIDL);
+}
+
+RadioConfig*
+radio_config_new_with_version_and_interface_type(
+    RADIO_CONFIG_INTERFACE max_version,
+    RADIO_INTERFACE_TYPE interface_type)
+{
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
+    static RadioConfig** instances = NULL;
+    const RadioConfigInterfaceDesc* interfaces = NULL;
+    gsize num_interfaces = 0;
+    const char* binder_device = GBINDER_DEFAULT_HWBINDER;
+
+    if (interface_type == RADIO_INTERFACE_TYPE_HIDL) {
+        /* Validate the requested version to avoid out-of-bounds access */
+        if (max_version < RADIO_CONFIG_INTERFACE_1_0) {
+            max_version = RADIO_CONFIG_INTERFACE_1_0;
+        } else if (max_version > RADIO_CONFIG_INTERFACE_MAX) {
+            max_version = RADIO_CONFIG_INTERFACE_MAX;
+        }
+
+        instances = radio_config_instance;
+        interfaces = radio_config_interfaces;
+        num_interfaces = G_N_ELEMENTS(radio_config_interfaces);
+    } else if (interface_type == RADIO_INTERFACE_TYPE_AIDL) {
+        /* Only RADIO_CONFIG_AIDL_INTERFACE_1 is supported for now */
+        max_version = RADIO_CONFIG_AIDL_INTERFACE_1;
+
+        binder_device = GBINDER_DEFAULT_BINDER;
+        instances = radio_config_aidl_instance;
+        interfaces = radio_config_aidl_interfaces;
+        num_interfaces = G_N_ELEMENTS(radio_config_aidl_interfaces);
+    } else {
+        GINFO("Wrong interface_type %d (neither HIDL nor AIDL)", interface_type);
+        return NULL;
    }

-    if (radio_config_instance[max_version]) {
+    if (instances[max_version]) {
        /* The requested instance already exists */
-        return radio_config_ref(radio_config_instance[max_version]);
+        return radio_config_ref(instances[max_version]);
    } else {
-        /* Assume /dev/hwbinder */
+        /* Assume /dev/hwbinder for HIDL, /dev/binder for AIDL */
        GBinderServiceManager* sm =
-            gbinder_servicemanager_new(GBINDER_DEFAULT_HWBINDER);
+            gbinder_servicemanager_new(binder_device);

        if (sm) {
            guint i;
@@ -572,8 +720,8 @@ radio_config_new_with_version(
            RadioConfig* config = NULL;

            /* Find maximum available version not exceeding the requested one */
-            for (i=0; i<G_N_ELEMENTS(radio_config_interfaces) && !obj; i++) {
-                desc = radio_config_interfaces + i;
+            for (i=0; i<num_interfaces && !obj; i++) {
+                desc = interfaces + i;
                if (desc->version <= max_version) {
                    obj = gbinder_servicemanager_get_service_sync(sm,
                        desc->fqname, NULL);
@@ -582,9 +730,8 @@ radio_config_new_with_version(
                         * desc->version isn't necessarily equal to
                         * max_version
                         */
-                        if (radio_config_instance[desc->version]) {
-                            config = radio_config_ref(radio_config_instance
-                                [desc->version]);
+                        if (instances[desc->version]) {
+                            config = radio_config_ref(instances[desc->version]);
                        } else {
                            GINFO("Connected to %s", desc->fqname);
                            config = radio_config_create(sm, obj, desc);
@@ -596,9 +743,9 @@ radio_config_new_with_version(

            gbinder_servicemanager_unref(sm);
            if (config) {
-                radio_config_instance[desc->version] = config;
+                instances[desc->version] = config;
                g_object_weak_ref(G_OBJECT(config), radio_config_gone,
-                    radio_config_instance + desc->version);
+                    instances + desc->version);
                return config;
            }
        }
@@ -610,6 +757,7 @@ RadioConfig*
 radio_config_ref(
    RadioConfig* self)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    if (G_LIKELY(self)) {
        g_object_ref(self);
    }
@@ -620,6 +768,7 @@ void
 radio_config_unref(
    RadioConfig* self)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    if (G_LIKELY(self)) {
        g_object_unref(self);
    }
@@ -629,13 +778,23 @@ gboolean
 radio_config_dead(
    RadioConfig* self)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    return G_UNLIKELY(!self) || self->dead;
 }

+RADIO_INTERFACE_TYPE
+radio_config_interface_type(
+    RadioConfig* self)
+{
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
+    return G_LIKELY(self) ? self->interface_type : RADIO_INTERFACE_TYPE_NONE;
+}
+
 RADIO_CONFIG_INTERFACE
 radio_config_interface(
    RadioConfig* self)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    return G_LIKELY(self) ? self->version : RADIO_CONFIG_INTERFACE_NONE;
 }

@@ -644,6 +803,7 @@ radio_config_rpc_header_size(
    RadioConfig* self,
    RADIO_CONFIG_REQ req)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    if (G_LIKELY(self)) {
        GBytes* header = gbinder_client_rpc_header(self->client, req);

@@ -659,7 +819,8 @@ radio_config_req_name(
    RadioConfig* self,
    RADIO_CONFIG_REQ req)
 {
-    const char* known = radio_config_known_req_name(req);
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
+    const char* known = radio_config_known_req_name(self, req);

    if (known) {
        return known;
@@ -678,7 +839,8 @@ radio_config_resp_name(
    RadioConfig* self,
    RADIO_CONFIG_RESP resp)
 {
-    const char* known = radio_config_known_resp_name(resp);
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
+    const char* known = radio_config_known_resp_name(self, resp);

    if (known) {
        return known;
@@ -697,7 +859,8 @@ radio_config_ind_name(
    RadioConfig* self,
    RADIO_CONFIG_IND ind)
 {
-    const char* known = radio_config_known_ind_name(ind);
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
+    const char* known = radio_config_known_ind_name(self, ind);

    if (known) {
        return known;
@@ -717,6 +880,7 @@ radio_config_add_death_handler(
    RadioConfigFunc fn,
    gpointer user_data)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    return (G_LIKELY(self) && G_LIKELY(fn)) ?
        g_signal_connect_closure_by_id(self,
             radio_config_signals[SIGNAL_DEATH], 0,
@@ -730,6 +894,7 @@ radio_config_add_request_observer(
    RadioConfigRequestObserverFunc func,
    gpointer user_data)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    return radio_config_add_request_observer_with_priority(self,
        RADIO_OBSERVER_PRIORITY_DEFAULT, code, func, user_data);
 }
@@ -742,6 +907,7 @@ radio_config_add_request_observer_with_priority(
    RadioConfigRequestObserverFunc func,
    gpointer user_data)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    if (G_LIKELY(self) && G_LIKELY(func)) {
        const guint index = radio_observer_priority_index(priority);
        const RADIO_CONFIG_SIGNAL sig = SIGNAL_OBSERVE_REQUEST_0 + index;
@@ -770,6 +936,7 @@ radio_config_add_response_observer(
    RadioConfigResponseObserverFunc func,
    gpointer user_data)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    return radio_config_add_response_observer_with_priority(self,
        RADIO_OBSERVER_PRIORITY_DEFAULT, code, func, user_data);
 }
@@ -782,6 +949,7 @@ radio_config_add_response_observer_with_priority(
    RadioConfigResponseObserverFunc func,
    gpointer user_data)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    if (G_LIKELY(self) && G_LIKELY(func)) {
        const guint index = radio_observer_priority_index(priority);
        const RADIO_CONFIG_SIGNAL sig = SIGNAL_OBSERVE_RESPONSE_0 + index;
@@ -810,6 +978,7 @@ radio_config_add_indication_observer(
    RadioConfigIndicationObserverFunc func,
    gpointer user_data)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    return radio_config_add_indication_observer_with_priority(self,
        RADIO_OBSERVER_PRIORITY_DEFAULT, code, func, user_data);
 }
@@ -822,6 +991,7 @@ radio_config_add_indication_observer_with_priority(
    RadioConfigIndicationObserverFunc func,
    gpointer user_data) /* Since 1.4.3 */
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    if (G_LIKELY(self) && G_LIKELY(func)) {
        const guint pi = radio_observer_priority_index(priority);
        const RADIO_CONFIG_SIGNAL sig = SIGNAL_OBSERVE_INDICATION_0 + pi;
@@ -848,6 +1018,7 @@ radio_config_remove_handler(
    RadioConfig* self,
    gulong id)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    if (G_LIKELY(self) && G_LIKELY(id)) {
        g_signal_handler_disconnect(self, id);
    }
@@ -859,6 +1030,7 @@ radio_config_remove_handlers(
    gulong* ids,
    int count)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    gutil_disconnect_handlers(self, ids, count);
 }

@@ -871,6 +1043,7 @@ gboolean
 radio_config_is_dead(
    RadioBase* base)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    return THIS(base)->dead;
 }

@@ -879,6 +1052,7 @@ gboolean
 radio_config_can_submit_requests(
    RadioBase* base)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    return !radio_config_is_dead(base);
 }

@@ -888,6 +1062,7 @@ radio_config_new_request(
    RadioBase* base,
    guint32 code)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    return gbinder_client_new_request2(THIS(base)->client, code);
 }

@@ -898,6 +1073,7 @@ radio_config_send_request(
    RadioRequest* req,
    RadioBaseRequestSentFunc callback)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    RadioConfig* self = THIS(base);
    RadioConfigCall* call = g_slice_new(RadioConfigCall);
    GQuark quark = 0;
@@ -938,6 +1114,7 @@ radio_config_cancel_request(
    RadioBase* base,
    gulong id)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    gbinder_client_cancel(THIS(base)->client, id);
 }

@@ -950,6 +1127,7 @@ void
 radio_config_init(
    RadioConfig* self)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    self->version = RADIO_CONFIG_INTERFACE_NONE;
    self->pool = gutil_idle_pool_new();
    self->req_quarks = g_hash_table_new(g_direct_hash, g_direct_equal);
@@ -962,6 +1140,7 @@ void
 radio_config_finalize(
    GObject* object)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    RadioConfig* self = THIS(object);

    radio_config_drop_binder(self);
@@ -978,6 +1157,7 @@ void
 radio_config_class_init(
    RadioConfigClass* klass)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    RadioBaseClass* base_class = RADIO_BASE_CLASS(klass);
    GObjectClass* object_class = G_OBJECT_CLASS(klass);
    GType type = G_OBJECT_CLASS_TYPE(klass);
--- a/src/radio_instance.c
+++ b/src/radio_instance.c
@@ -156,17 +156,22 @@ G_STATIC_ASSERT(G_N_ELEMENTS(radio_response_ifaces) == RADIO_INTERFACE_COUNT + 1

 typedef struct radio_interface_desc {
    RADIO_INTERFACE version;
+    RADIO_AIDL_INTERFACE aidl_interface;
    const char* radio_iface;
    const char* const* ind_ifaces;
    const char* const* resp_ifaces;
+    gint32 set_response_functions_req;
 } RadioInterfaceDesc;

 #define RADIO_INTERFACE_INDEX(x) (RADIO_INTERFACE_COUNT - x - 1)

 #define RADIO_INTERFACE_DESC(v) \
-        RADIO_INTERFACE_##v, RADIO_##v, \
+        RADIO_INTERFACE_##v, \
+        RADIO_AIDL_INTERFACE_NONE, \
+        RADIO_##v, \
        radio_indication_ifaces + RADIO_INTERFACE_INDEX(RADIO_INTERFACE_##v), \
-        radio_response_ifaces + RADIO_INTERFACE_INDEX(RADIO_INTERFACE_##v)
+        radio_response_ifaces + RADIO_INTERFACE_INDEX(RADIO_INTERFACE_##v), \
+        RADIO_REQ_SET_RESPONSE_FUNCTIONS

 static const RadioInterfaceDesc radio_interfaces[] = {
   { RADIO_INTERFACE_DESC(1_5) },
@@ -178,6 +183,146 @@ static const RadioInterfaceDesc radio_interfaces[] = {
 };
 G_STATIC_ASSERT(G_N_ELEMENTS(radio_interfaces) == RADIO_INTERFACE_COUNT);

+static const GBinderClientIfaceInfo radio_aidl_iface_info[] = {
+    {RADIO_DATA, RADIO_DATA_1_REQ_LAST},
+    {RADIO_IMS, RADIO_IMS_1_REQ_LAST},
+    {RADIO_MESSAGING, RADIO_MESSAGING_1_REQ_LAST},
+    {RADIO_MODEM, RADIO_MODEM_1_REQ_LAST},
+    {RADIO_NETWORK, RADIO_NETWORK_1_REQ_LAST},
+    {RADIO_SIM, RADIO_SIM_1_REQ_LAST},
+    {RADIO_VOICE, RADIO_VOICE_1_REQ_LAST},
+};
+
+static const char* const radio_data_indication_ifaces[] = {
+    RADIO_DATA_INDICATION,
+    NULL
+};
+
+static const char* const radio_data_response_ifaces[] = {
+    RADIO_DATA_RESPONSE,
+    NULL
+};
+
+static const char* const radio_ims_indication_ifaces[] = {
+    RADIO_IMS_INDICATION,
+    NULL
+};
+
+static const char* const radio_ims_response_ifaces[] = {
+    RADIO_IMS_RESPONSE,
+    NULL
+};
+
+static const char* const radio_messaging_indication_ifaces[] = {
+    RADIO_MESSAGING_INDICATION,
+    NULL
+};
+
+static const char* const radio_messaging_response_ifaces[] = {
+    RADIO_MESSAGING_RESPONSE,
+    NULL
+};
+
+static const char* const radio_modem_indication_ifaces[] = {
+    RADIO_MODEM_INDICATION,
+    NULL
+};
+
+static const char* const radio_modem_response_ifaces[] = {
+    RADIO_MODEM_RESPONSE,
+    NULL
+};
+
+static const char* const radio_network_indication_ifaces[] = {
+    RADIO_NETWORK_INDICATION,
+    NULL
+};
+
+static const char* const radio_network_response_ifaces[] = {
+    RADIO_NETWORK_RESPONSE,
+    NULL
+};
+
+static const char* const radio_sim_indication_ifaces[] = {
+    RADIO_SIM_INDICATION,
+    NULL
+};
+
+static const char* const radio_sim_response_ifaces[] = {
+    RADIO_SIM_RESPONSE,
+    NULL
+};
+
+static const char* const radio_voice_indication_ifaces[] = {
+    RADIO_VOICE_INDICATION,
+    NULL
+};
+
+static const char* const radio_voice_response_ifaces[] = {
+    RADIO_VOICE_RESPONSE,
+    NULL
+};
+
+static const RadioInterfaceDesc radio_aidl_interfaces[] = {
+    {
+        RADIO_INTERFACE_NONE,
+        RADIO_DATA_INTERFACE,
+        RADIO_DATA,
+        radio_data_indication_ifaces,
+        radio_data_response_ifaces,
+        RADIO_DATA_REQ_SET_RESPONSE_FUNCTIONS,
+    },
+    {
+        RADIO_INTERFACE_NONE,
+        RADIO_IMS_INTERFACE,
+        RADIO_IMS,
+        radio_ims_indication_ifaces,
+        radio_ims_response_ifaces,
+        RADIO_IMS_REQ_SET_RESPONSE_FUNCTIONS,
+    },
+    {
+        RADIO_INTERFACE_NONE,
+        RADIO_MESSAGING_INTERFACE,
+        RADIO_MESSAGING,
+        radio_messaging_indication_ifaces,
+        radio_messaging_response_ifaces,
+        RADIO_MESSAGING_REQ_SET_RESPONSE_FUNCTIONS,
+    },
+    {
+        RADIO_INTERFACE_NONE,
+        RADIO_MODEM_INTERFACE,
+        RADIO_MODEM,
+        radio_modem_indication_ifaces,
+        radio_modem_response_ifaces,
+        RADIO_MODEM_REQ_SET_RESPONSE_FUNCTIONS,
+    },
+    {
+        RADIO_INTERFACE_NONE,
+        RADIO_NETWORK_INTERFACE,
+        RADIO_NETWORK,
+        radio_network_indication_ifaces,
+        radio_network_response_ifaces,
+        RADIO_NETWORK_REQ_SET_RESPONSE_FUNCTIONS,
+    },
+    {
+        RADIO_INTERFACE_NONE,
+        RADIO_SIM_INTERFACE,
+        RADIO_SIM,
+        radio_sim_indication_ifaces,
+        radio_sim_response_ifaces,
+        RADIO_SIM_REQ_SET_RESPONSE_FUNCTIONS,
+    },
+    {
+        RADIO_INTERFACE_NONE,
+        RADIO_VOICE_INTERFACE,
+        RADIO_VOICE,
+        radio_voice_indication_ifaces,
+        radio_voice_response_ifaces,
+        RADIO_VOICE_REQ_SET_RESPONSE_FUNCTIONS,
+    }
+};
+G_STATIC_ASSERT(G_N_ELEMENTS(radio_aidl_interfaces) == RADIO_AIDL_INTERFACE_COUNT);
+
 typedef struct radio_instance_tx {
    RadioInstance* instance;
    RadioInstanceTxCompleteFunc complete;
@@ -205,7 +350,7 @@ radio_instance_req_quark(

        q = GPOINTER_TO_UINT(g_hash_table_lookup(priv->req_quarks, key));
        if (!q) {
-            const char* known = radio_req_name(req);
+            const char* known = radio_req_name2(self, req);

            if (known) {
                q = g_quark_from_static_string(known);
@@ -232,7 +377,7 @@ radio_instance_resp_quark(

        q = GPOINTER_TO_UINT(g_hash_table_lookup(priv->resp_quarks, key));
        if (!q) {
-            const char* known = radio_resp_name(resp);
+            const char* known = radio_resp_name2(self, resp);

            if (known) {
                q = g_quark_from_static_string(known);
@@ -280,7 +425,14 @@ radio_instance_indication(
    RadioInstance* self = RADIO_INSTANCE(user_data);
    const char* iface = gbinder_remote_request_interface(req);

-    if (gutil_strv_contains((const GStrV*)radio_indication_ifaces, iface)) {
+    if (gutil_strv_contains((const GStrV*)radio_indication_ifaces, iface)
+        || gutil_strv_contains((const GStrV*)radio_data_indication_ifaces, iface)
+        || gutil_strv_contains((const GStrV*)radio_ims_indication_ifaces, iface)
+        || gutil_strv_contains((const GStrV*)radio_messaging_indication_ifaces, iface)
+        || gutil_strv_contains((const GStrV*)radio_modem_indication_ifaces, iface)
+        || gutil_strv_contains((const GStrV*)radio_network_indication_ifaces, iface)
+        || gutil_strv_contains((const GStrV*)radio_sim_indication_ifaces, iface)
+        || gutil_strv_contains((const GStrV*)radio_voice_indication_ifaces, iface)) {
        GBinderReader reader;
        guint type;

@@ -294,6 +446,7 @@ radio_instance_indication(
                SIGNAL_OBSERVE_INDICATION_0;
            int p = RADIO_OBSERVER_PRIORITY_HIGHEST;
            gboolean handled = FALSE;
+            guint ind_ril_connected = 0;

            /* High-priority observers are notified first */
            for (; p > RADIO_OBSERVER_PRIORITY_DEFAULT; p--) {
@@ -305,7 +458,14 @@ radio_instance_indication(
            }

            /* rilConnected is a special case */
-            if (code == RADIO_IND_RIL_CONNECTED) {
+            if (self->interface_type == RADIO_INTERFACE_TYPE_HIDL) {
+                ind_ril_connected = RADIO_IND_RIL_CONNECTED;
+            } else if (self->interface_type == RADIO_INTERFACE_TYPE_AIDL
+                && gutil_strv_contains((const GStrV*)radio_modem_indication_ifaces, iface)) {
+                ind_ril_connected = RADIO_MODEM_IND_RIL_CONNECTED;
+            }
+
+            if (ind_ril_connected && code == ind_ril_connected) {
                if (G_UNLIKELY(self->connected)) {
                    /* We are only supposed to receive it once */
                    GWARN("%s received unexpected rilConnected", self->slot);
@@ -360,69 +520,126 @@ radio_instance_response(
 {
    RadioInstance* self = RADIO_INSTANCE(user_data);
    const char* iface = gbinder_remote_request_interface(req);
+    const RadioResponseInfo* info = NULL;
+    GBinderReader reader;
+    gint32 ack_serial = 0;
+
+    gbinder_remote_request_init_reader(req, &reader);

    if (gutil_strv_contains((const GStrV*)radio_response_ifaces, iface)) {
-        GBinderReader reader;
-
-        /* All these should be one-way transactions */
-        GASSERT(flags & GBINDER_TX_FLAG_ONEWAY);
-        gbinder_remote_request_init_reader(req, &reader);
        if (code == RADIO_RESP_ACKNOWLEDGE_REQUEST) {
-            /* oneway acknowledgeRequest(int32_t serial) */
-            gint32 serial;
-
-            GDEBUG("%s %u acknowledgeRequest", iface, code);
-            if (gbinder_reader_read_int32(&reader, &serial)) {
-                g_signal_emit(self, radio_instance_signals[SIGNAL_ACK], 0,
-                    serial);
-            }
+            gbinder_reader_read_int32(&reader, &ack_serial);
        } else {
            /* All other responses have RadioResponseInfo */
-            const RadioResponseInfo* info =
-                gbinder_reader_read_hidl_struct(&reader, RadioResponseInfo);
-
-            if (info) {
-                const GQuark quark = radio_instance_resp_quark(self, code);
-                const guint* signals = radio_instance_signals +
-                    SIGNAL_OBSERVE_RESPONSE_0;
-                int p = RADIO_OBSERVER_PRIORITY_HIGHEST;
-                gboolean handled = FALSE;
-
-                /* High-priority observers are notified first */
-                for (; p > RADIO_OBSERVER_PRIORITY_DEFAULT; p--) {
-                    if (signals[RADIO_OBSERVER_PRIORITY_INDEX(p)]) {
-                        g_signal_emit(self, signals
-                            [RADIO_OBSERVER_PRIORITY_INDEX(p)],
-                            quark, code, info, &reader);
-                    }
-                }
-
-                /* Then handlers */
-                g_signal_emit(self, radio_instance_signals
-                    [SIGNAL_HANDLE_RESPONSE],
-                    quark, code, info, &reader, &handled);
-
-                /* And then remaining observers in their priority order */
-                for (; p >= RADIO_OBSERVER_PRIORITY_LOWEST; p--) {
-                    if (signals[RADIO_OBSERVER_PRIORITY_INDEX(p)]) {
-                        g_signal_emit(self, signals
-                            [RADIO_OBSERVER_PRIORITY_INDEX(p)],
-                            quark, code, info, &reader);
-                    }
-                }
-
-                /* Ack unhandled responses */
-                if (info->type == RADIO_RESP_SOLICITED_ACK_EXP && !handled) {
-                    GDEBUG("ack unhandled response");
-                    radio_instance_ack(self);
-                }
-            }
+            info = gbinder_reader_read_hidl_struct(&reader, RadioResponseInfo);
+        }
+    } else if (gutil_strv_contains((const GStrV*)radio_data_response_ifaces, iface)) {
+        if (code == RADIO_DATA_RESP_ACKNOWLEDGE_REQUEST) {
+            gbinder_reader_read_int32(&reader, &ack_serial);
+        } else {
+            gsize out_size;
+            info = gbinder_reader_read_parcelable(&reader, &out_size);
+            GASSERT(out_size >= sizeof(RadioResponseInfo));
+        }
+    } else if (gutil_strv_contains((const GStrV*)radio_ims_response_ifaces, iface)) {
+        {
+            /* RadioResponseInfo has the same fields/padding between HIDL and AIDL */
+            gsize out_size;
+            info = gbinder_reader_read_parcelable(&reader, &out_size);
+            GASSERT(out_size >= sizeof(RadioResponseInfo));
+        }
+    } else if (gutil_strv_contains((const GStrV*)radio_messaging_response_ifaces, iface)) {
+        if (code == RADIO_MESSAGING_RESP_ACKNOWLEDGE_REQUEST) {
+            gbinder_reader_read_int32(&reader, &ack_serial);
+        } else {
+            /* RadioResponseInfo has the same fields/padding between HIDL and AIDL */
+            gsize out_size;
+            info = gbinder_reader_read_parcelable(&reader, &out_size);
+            GASSERT(out_size >= sizeof(RadioResponseInfo));
+        }
+    } else if (gutil_strv_contains((const GStrV*)radio_modem_response_ifaces, iface)) {
+        if (code == RADIO_MODEM_RESP_ACKNOWLEDGE_REQUEST) {
+            gbinder_reader_read_int32(&reader, &ack_serial);
+        } else {
+            /* RadioResponseInfo has the same fields/padding between HIDL and AIDL */
+            gsize out_size;
+            info = gbinder_reader_read_parcelable(&reader, &out_size);
+            GASSERT(out_size >= sizeof(RadioResponseInfo));
+        }
+    } else if (gutil_strv_contains((const GStrV*)radio_network_response_ifaces, iface)) {
+        if (code == RADIO_NETWORK_RESP_ACKNOWLEDGE_REQUEST) {
+            gbinder_reader_read_int32(&reader, &ack_serial);
+        } else {
+            gsize out_size;
+            info = gbinder_reader_read_parcelable(&reader, &out_size);
+            GASSERT(out_size >= sizeof(RadioResponseInfo));
+        }
+    } else if (gutil_strv_contains((const GStrV*)radio_sim_response_ifaces, iface)) {
+        if (code == RADIO_SIM_RESP_ACKNOWLEDGE_REQUEST) {
+            gbinder_reader_read_int32(&reader, &ack_serial);
+        } else {
+            gsize out_size;
+            info = gbinder_reader_read_parcelable(&reader, &out_size);
+            GASSERT(out_size >= sizeof(RadioResponseInfo));
+        }
+    } else if (gutil_strv_contains((const GStrV*)radio_voice_response_ifaces, iface)) {
+        if (code == RADIO_VOICE_RESP_ACKNOWLEDGE_REQUEST) {
+            gbinder_reader_read_int32(&reader, &ack_serial);
+        } else {
+            gsize out_size;
+            info = gbinder_reader_read_parcelable(&reader, &out_size);
+            GASSERT(out_size >= sizeof(RadioResponseInfo));
        }
-        *status = GBINDER_STATUS_OK;
    } else {
        GWARN("Unexpected response %s %u", iface, code);
        *status = GBINDER_STATUS_FAILED;
+        return NULL;
    }
+
+    /* All these should be one-way transactions */
+    GASSERT(flags & GBINDER_TX_FLAG_ONEWAY);
+
+    if (ack_serial) {
+        GDEBUG("%s %u acknowledgeRequest", iface, code);
+        g_signal_emit(self, radio_instance_signals[SIGNAL_ACK], 0,
+            ack_serial);
+    } else if (info) {
+        const GQuark quark = radio_instance_resp_quark(self, code);
+        const guint* signals = radio_instance_signals +
+            SIGNAL_OBSERVE_RESPONSE_0;
+        int p = RADIO_OBSERVER_PRIORITY_HIGHEST;
+        gboolean handled = FALSE;
+
+        /* High-priority observers are notified first */
+        for (; p > RADIO_OBSERVER_PRIORITY_DEFAULT; p--) {
+            if (signals[RADIO_OBSERVER_PRIORITY_INDEX(p)]) {
+                g_signal_emit(self, signals
+                    [RADIO_OBSERVER_PRIORITY_INDEX(p)],
+                    quark, code, info, &reader);
+            }
+        }
+
+        /* Then handlers */
+        g_signal_emit(self, radio_instance_signals
+            [SIGNAL_HANDLE_RESPONSE],
+            quark, code, info, &reader, &handled);
+
+        /* And then remaining observers in their priority order */
+        for (; p >= RADIO_OBSERVER_PRIORITY_LOWEST; p--) {
+            if (signals[RADIO_OBSERVER_PRIORITY_INDEX(p)]) {
+                g_signal_emit(self, signals
+                    [RADIO_OBSERVER_PRIORITY_INDEX(p)],
+                    quark, code, info, &reader);
+            }
+        }
+
+        /* Ack unhandled responses */
+        if (info->type == RADIO_RESP_SOLICITED_ACK_EXP && !handled) {
+            GDEBUG("ack unhandled response");
+            radio_instance_ack(self);
+        }
+    }
+    *status = GBINDER_STATUS_OK;
    return NULL;
 }

@@ -520,10 +737,9 @@ radio_instance_create_version(
    self->modem = priv->modem = g_strdup(modem);
    self->slot_index = slot_index;
    self->version = desc->version;
+    self->interface_aidl = desc->aidl_interface;

    priv->remote = gbinder_remote_object_ref(remote);
-    priv->client = gbinder_client_new2(remote,
-        radio_iface_info, G_N_ELEMENTS(radio_iface_info));
    priv->indication = gbinder_servicemanager_new_local_object2(sm,
        desc->ind_ifaces, radio_instance_indication, self);
    priv->response = gbinder_servicemanager_new_local_object2(sm,
@@ -531,14 +747,27 @@ radio_instance_create_version(
    priv->death_id = gbinder_remote_object_add_death_handler(remote,
        radio_instance_died, self);

+    if (desc->version != RADIO_INTERFACE_NONE) {
+        self->interface_type = RADIO_INTERFACE_TYPE_HIDL;
+        priv->client = gbinder_client_new2(remote,
+            radio_iface_info, G_N_ELEMENTS(radio_iface_info));
+    } else if (desc->aidl_interface != RADIO_AIDL_INTERFACE_NONE) {
+        self->interface_type = RADIO_INTERFACE_TYPE_AIDL;
+        priv->client = gbinder_client_new2(remote,
+            radio_aidl_iface_info + desc->aidl_interface, 1);
+
+        gbinder_local_object_set_stability(priv->indication, GBINDER_STABILITY_VINTF);
+        gbinder_local_object_set_stability(priv->response, GBINDER_STABILITY_VINTF);
+    }
+
    /* IRadio::setResponseFunctions */
    req = gbinder_client_new_request2(priv->client,
-        RADIO_REQ_SET_RESPONSE_FUNCTIONS);
+        desc->set_response_functions_req);
    gbinder_local_request_init_writer(req, &writer);
    gbinder_writer_append_local_object(&writer, priv->response);
    gbinder_writer_append_local_object(&writer, priv->indication);
    gbinder_remote_reply_unref(gbinder_client_transact_sync_reply(priv->client,
-        RADIO_REQ_SET_RESPONSE_FUNCTIONS, req, &status));
+        desc->set_response_functions_req, req, &status));
    GVERBOSE_("setResponseFunctions %s status %d", slot, status);
    gbinder_local_request_unref(req);

@@ -561,32 +790,47 @@ radio_instance_create(
    const char* key,
    const char* modem,
    int slot_index,
-    RADIO_INTERFACE max_version)
+    RADIO_INTERFACE max_version,
+    RADIO_AIDL_INTERFACE aidl_interface)
 {
    RadioInstance* self = NULL;
    GBinderServiceManager* sm = gbinder_servicemanager_new(dev);
+    const RadioInterfaceDesc* interfaces = NULL;
+    gsize num_interfaces = 0;

-    if (sm) {
-        guint i;
-
-        for (i = 0; i < G_N_ELEMENTS(radio_interfaces) && !self; i++) {
-            const RadioInterfaceDesc* desc = radio_interfaces + i;
-
-            if (desc->version <= max_version) {
-                char* fqname = g_strconcat(desc->radio_iface, "/", slot, NULL);
-                GBinderRemoteObject* obj = /* autoreleased */
-                    gbinder_servicemanager_get_service_sync(sm, fqname, NULL);
-
-                if (obj) {
-                    GINFO("Connected to %s", fqname);
-                    self = radio_instance_create_version(sm, obj, dev, slot,
-                        key, modem, slot_index, desc);
-                }
-                g_free(fqname);
-            }
-        }
-        gbinder_servicemanager_unref(sm);
+    if (!sm) {
+        GERR_("Failed to get ServiceManager on %s", dev);
+        return NULL;
    }
+
+    if (aidl_interface == RADIO_AIDL_INTERFACE_NONE) {
+        interfaces = radio_interfaces;
+        num_interfaces = G_N_ELEMENTS(radio_interfaces);
+    } else if (aidl_interface > RADIO_AIDL_INTERFACE_NONE
+                && aidl_interface < RADIO_AIDL_INTERFACE_COUNT) {
+        interfaces = radio_aidl_interfaces + aidl_interface;
+        num_interfaces = 1;
+    }
+
+    for (guint i = 0; i < num_interfaces && !self; i++) {
+        const RadioInterfaceDesc* desc = interfaces + i;
+
+        if (desc->version <= max_version) {
+            char* fqname = g_strconcat(desc->radio_iface, "/", slot, NULL);
+            GBinderRemoteObject* obj = /* autoreleased */
+                gbinder_servicemanager_get_service_sync(sm, fqname, NULL);
+
+            if (obj) {
+                GINFO("Connected to %s", fqname);
+                self = radio_instance_create_version(sm, obj, dev, slot,
+                    key, modem, slot_index, desc);
+            }
+            g_free(fqname);
+        }
+    }
+
+    gbinder_servicemanager_unref(sm);
+
    return self;
 }

@@ -595,9 +839,10 @@ char*
 radio_instance_make_key(
    const char* dev,
    const char* name,
-    RADIO_INTERFACE version)
+    RADIO_INTERFACE version,
+    RADIO_AIDL_INTERFACE aidl_interface)
 {
-    return g_strdup_printf("%s:%s:%d", dev, name, version);
+    return g_strdup_printf("%s:%s:%d:%d", dev, name, version, aidl_interface);
 }

 static
@@ -705,7 +950,7 @@ radio_instance_ind_quark(

        q = GPOINTER_TO_UINT(g_hash_table_lookup(priv->ind_quarks, key));
        if (!q) {
-            const char* known = radio_ind_name(ind);
+            const char* known = radio_ind_name2(self, ind);

            if (known) {
                q = g_quark_from_static_string(known);
@@ -776,8 +1021,24 @@ radio_instance_new_with_modem_slot_and_version(
    int slot,
    RADIO_INTERFACE version) /* Since 1.2.1 */
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
+    return radio_instance_new_with_modem_slot_version_and_interface(
+        dev, name, modem, slot, version, RADIO_AIDL_INTERFACE_NONE);
+}
+
+RadioInstance*
+radio_instance_new_with_modem_slot_version_and_interface(
+    const char* dev,
+    const char* name,
+    const char* modem,
+    int slot,
+    RADIO_INTERFACE version,
+    RADIO_AIDL_INTERFACE aidl_interface) /* Since 1.6.0 */
+{
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    if (dev && dev[0] && name && name[0]) {
-        char* key = radio_instance_make_key(dev, name, version);
+        /* HIDL and AIDL would use different binder devices */
+        char* key = radio_instance_make_key(dev, name, version, aidl_interface);
        RadioInstance* self = NULL;

        if (radio_instance_table) {
@@ -787,7 +1048,8 @@ radio_instance_new_with_modem_slot_and_version(
            g_free(key);
            return radio_instance_ref(self);
        } else {
-            self = radio_instance_create(dev, name, key, modem, slot, version);
+            self = radio_instance_create(dev, name, key, modem, slot, version,
+                                         aidl_interface);
            if (self) {
                if (!radio_instance_table) {
                    radio_instance_table = g_hash_table_new_full
@@ -809,6 +1071,7 @@ radio_instance_get(
    const char* dev,
    const char* name)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    return radio_instance_get_with_version(dev, name, DEFAULT_INTERFACE);
 }

@@ -818,6 +1081,7 @@ radio_instance_get_with_interface(
    const char* name,
    RADIO_INTERFACE version) /* 1.2.1, deprecated */
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    return radio_instance_get_with_version(dev, name, version);
 }

@@ -827,10 +1091,11 @@ radio_instance_get_with_version(
    const char* name,
    RADIO_INTERFACE version) /* Since 1.2.2 */
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    RadioInstance* self = NULL;

    if (dev && dev[0] && name && name[0] && radio_instance_table) {
-        char* key = radio_instance_make_key(dev, name, version);
+        char* key = radio_instance_make_key(dev, name, version, RADIO_AIDL_INTERFACE_NONE);

        self = g_hash_table_lookup(radio_instance_table, key);
        g_free(key);
@@ -842,6 +1107,7 @@ RadioInstance* const*
 radio_instance_get_all(
    void)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    if (radio_instance_table) {
        /* If the table exists, it must be non-empty */
        const guint n = g_hash_table_size(radio_instance_table);
@@ -867,6 +1133,7 @@ RadioInstance*
 radio_instance_ref(
    RadioInstance* self)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    if (G_LIKELY(self)) {
        g_object_ref(RADIO_INSTANCE(self));
        return self;
@@ -879,6 +1146,7 @@ void
 radio_instance_unref(
    RadioInstance* self)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    if (G_LIKELY(self)) {
        g_object_unref(RADIO_INSTANCE(self));
    }
@@ -889,6 +1157,7 @@ radio_instance_rpc_header_size(
    RadioInstance* self,
    RADIO_REQ req) /* Since 1.4.3 */
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    if (G_LIKELY(self)) {
        RadioInstancePriv* priv = self->priv;
        GBytes* header = gbinder_client_rpc_header(priv->client, req);
@@ -905,7 +1174,8 @@ radio_instance_req_name(
    RadioInstance* self,
    RADIO_REQ req)
 {
-    const char* known = radio_req_name(req);
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
+    const char* known = radio_req_name2(self, req);

    if (known) {
        return known;
@@ -924,7 +1194,8 @@ radio_instance_resp_name(
    RadioInstance* self,
    RADIO_RESP resp)
 {
-    const char* known = radio_resp_name(resp);
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
+    const char* known = radio_resp_name2(self, resp);

    if (known) {
        return known;
@@ -943,7 +1214,8 @@ radio_instance_ind_name(
    RadioInstance* self,
    RADIO_IND ind)
 {
-    const char* known = radio_ind_name(ind);
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
+    const char* known = radio_ind_name2(self, ind);

    if (known) {
        return known;
@@ -961,6 +1233,7 @@ gboolean
 radio_instance_is_dead(
    RadioInstance* self)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    return G_UNLIKELY(!self) || self->dead;
 }

@@ -968,6 +1241,7 @@ gboolean
 radio_instance_ack(
    RadioInstance* self)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    if (G_LIKELY(self)) {
        GBinderClient* client = self->priv->client;
        const RADIO_REQ code = RADIO_REQ_RESPONSE_ACKNOWLEDGEMENT;
@@ -983,6 +1257,7 @@ radio_instance_new_request(
    RadioInstance* self,
    RADIO_REQ code)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    if (G_LIKELY(self)) {
        return gbinder_client_new_request2(self->priv->client, code);
    }
@@ -995,6 +1270,7 @@ radio_instance_send_request_sync(
    RADIO_REQ code,
    GBinderLocalRequest* args)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    if (G_LIKELY(self)) {
        GBinderClient* client = self->priv->client;

@@ -1009,6 +1285,7 @@ radio_instance_set_enabled(
    RadioInstance* self,
    gboolean enabled) /* Since 1.0.7 */
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    if (G_LIKELY(self) && self->enabled != enabled) {
        self->enabled = enabled;
        GDEBUG("%s %sabled", self->slot, enabled ? "en" : "dis");
@@ -1023,6 +1300,7 @@ radio_instance_add_request_observer(
    RadioRequestObserverFunc func,
    gpointer user_data) /* Since 1.4.3 */
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    return radio_instance_add_request_observer_with_priority(self,
        RADIO_OBSERVER_PRIORITY_DEFAULT, code, func, user_data);
 }
@@ -1035,6 +1313,7 @@ radio_instance_add_request_observer_with_priority(
    RadioRequestObserverFunc func,
    gpointer user_data) /* Since 1.4.3 */
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    if (G_LIKELY(self) && G_LIKELY(func)) {
        const guint index = radio_observer_priority_index(priority);
        const RADIO_INSTANCE_SIGNAL sig = SIGNAL_OBSERVE_REQUEST_0 + index;
@@ -1064,6 +1343,7 @@ radio_instance_add_response_observer(
    RadioResponseObserverFunc func,
    gpointer user_data)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    return radio_instance_add_response_observer_with_priority(self,
        RADIO_OBSERVER_PRIORITY_DEFAULT, code, func, user_data);
 }
@@ -1076,6 +1356,7 @@ radio_instance_add_response_observer_with_priority(
    RadioResponseObserverFunc func,
    gpointer user_data) /* Since 1.4.3 */
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    if (G_LIKELY(self) && G_LIKELY(func)) {
        const guint index = radio_observer_priority_index(priority);
        const RADIO_INSTANCE_SIGNAL sig = SIGNAL_OBSERVE_RESPONSE_0 + index;
@@ -1105,6 +1386,7 @@ radio_instance_add_indication_observer(
    RadioIndicationObserverFunc func,
    gpointer user_data)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    return radio_instance_add_indication_observer_with_priority(self,
        RADIO_OBSERVER_PRIORITY_DEFAULT, code, func, user_data);
 }
@@ -1117,6 +1399,7 @@ radio_instance_add_indication_observer_with_priority(
    RadioIndicationObserverFunc func,
    gpointer user_data) /* Since 1.4.3 */
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    if (G_LIKELY(self) && G_LIKELY(func)) {
        const guint index = radio_observer_priority_index(priority);
        const RADIO_INSTANCE_SIGNAL sig = SIGNAL_OBSERVE_INDICATION_0 + index;
@@ -1146,6 +1429,7 @@ radio_instance_add_response_handler(
    RadioResponseHandlerFunc func,
    gpointer user_data)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    return (G_LIKELY(self) && G_LIKELY(func)) ?
        g_signal_connect_closure_by_id(self,
            radio_instance_signals[SIGNAL_HANDLE_RESPONSE],
@@ -1160,6 +1444,7 @@ radio_instance_add_indication_handler(
    RadioIndicationHandlerFunc func,
    gpointer user_data)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    return (G_LIKELY(self) && G_LIKELY(func)) ?
        g_signal_connect_closure_by_id(self,
            radio_instance_signals[SIGNAL_HANDLE_INDICATION],
@@ -1173,6 +1458,7 @@ radio_instance_add_ack_handler(
    RadioAckFunc func,
    gpointer user_data)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    return (G_LIKELY(self) && G_LIKELY(func)) ? g_signal_connect(self,
        SIGNAL_ACK_NAME, G_CALLBACK(func), user_data) : 0;
 }
@@ -1183,6 +1469,7 @@ radio_instance_add_death_handler(
    RadioInstanceFunc func,
    gpointer user_data)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    return (G_LIKELY(self) && G_LIKELY(func)) ? g_signal_connect(self,
        SIGNAL_DEATH_NAME, G_CALLBACK(func), user_data) : 0;
 }
@@ -1193,6 +1480,7 @@ radio_instance_add_enabled_handler(
    RadioInstanceFunc func,
    gpointer user_data) /* Since 1.0.7 */
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    return (G_LIKELY(self) && G_LIKELY(func)) ? g_signal_connect(self,
        SIGNAL_ENABLED_NAME, G_CALLBACK(func), user_data) : 0;
 }
@@ -1203,6 +1491,7 @@ radio_instance_add_connected_handler(
    RadioInstanceFunc func,
    gpointer user_data) /* Since 1.4.3 */
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    return (G_LIKELY(self) && G_LIKELY(func)) ? g_signal_connect(self,
        SIGNAL_CONNECTED_NAME, G_CALLBACK(func), user_data) : 0;
 }
@@ -1212,6 +1501,7 @@ radio_instance_remove_handler(
    RadioInstance* self,
    gulong id)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    if (G_LIKELY(self) && G_LIKELY(id)) {
        g_signal_handler_disconnect(self, id);
    }
@@ -1223,6 +1513,7 @@ radio_instance_remove_handlers(
    gulong* ids,
    int count)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    gutil_disconnect_handlers(self, ids, count);
 }

@@ -1235,6 +1526,7 @@ void
 radio_instance_init(
    RadioInstance* self)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    RadioInstancePriv* priv = G_TYPE_INSTANCE_GET_PRIVATE
        (self, RADIO_TYPE_INSTANCE, RadioInstancePriv);

@@ -1250,6 +1542,7 @@ void
 radio_instance_finalize(
    GObject* object)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    RadioInstance* self = RADIO_INSTANCE(object);
    RadioInstancePriv* priv = self->priv;

@@ -1271,6 +1564,7 @@ void
 radio_instance_class_init(
    RadioInstanceClass* klass)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    GObjectClass* object_class = G_OBJECT_CLASS(klass);
    GType type = G_OBJECT_CLASS_TYPE(klass);

--- a/src/radio_log.h
+++ b/src/radio_log.h
@@ -41,6 +41,8 @@

 #define GLOG_MODULE_NAME GBINDER_RADIO_LOG_MODULE
 #include <gutil_log.h>
+#define DBG(fmt, ...) \
+    gutil_log(GLOG_MODULE_CURRENT, GLOG_LEVEL_ALWAYS, "gbinder-radio:"fmt, ##__VA_ARGS__)

 #endif /* RADIO_LOG_H */

--- a/src/radio_registry.c
+++ b/src/radio_registry.c
@@ -36,6 +36,7 @@

 #include "radio_registry_p.h"
 #include "radio_instance.h"
+#include "radio_log.h"

 #include <gutil_misc.h>

@@ -71,6 +72,7 @@ void
 radio_registry_instance_added(
    RadioInstance* radio)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    RadioRegistry* self = radio_registry_instance;

    if (self) {
@@ -85,6 +87,7 @@ void
 radio_registry_instance_removed(
    const char* key)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    RadioRegistry* self = radio_registry_instance;

    if (self) {
@@ -103,6 +106,7 @@ RadioRegistry*
 radio_registry_new(
    void)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    if (radio_registry_instance) {
        radio_registry_ref(radio_registry_instance);
    } else {
@@ -118,6 +122,7 @@ RadioRegistry*
 radio_registry_ref(
    RadioRegistry* self)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    if (G_LIKELY(self)) {
        g_object_ref(RADIO_REGISTRY(self));
        return self;
@@ -130,6 +135,7 @@ void
 radio_registry_unref(
    RadioRegistry* self)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    if (G_LIKELY(self)) {
        g_object_unref(RADIO_REGISTRY(self));
    }
@@ -142,6 +148,7 @@ radio_registry_add_instance_added_handler(
    RadioRegistryInstanceFunc func,
    gpointer user_data)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    if (G_LIKELY(self) && G_LIKELY(func)) {
        return g_signal_connect_closure_by_id(self,
            radio_registry_signals[SIGNAL_INSTANCE_ADDED],
@@ -158,6 +165,7 @@ radio_registry_add_instance_removed_handler(
    RadioRegistryStrFunc func,
    gpointer user_data)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    if (G_LIKELY(self) && G_LIKELY(func)) {
        return g_signal_connect_closure_by_id(self,
            radio_registry_signals[SIGNAL_INSTANCE_REMOVED],
@@ -172,6 +180,7 @@ radio_registry_remove_handler(
    RadioRegistry* self,
    gulong id)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    if (G_LIKELY(self) && G_LIKELY(id)) {
        g_signal_handler_disconnect(self, id);
    }
@@ -183,6 +192,7 @@ radio_registry_remove_handlers(
    gulong* ids,
    int count)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    gutil_disconnect_handlers(self, ids, count);
 }

@@ -195,6 +205,7 @@ void
 radio_registry_init(
    RadioRegistry* self)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
 }

 static
@@ -202,6 +213,7 @@ void
 radio_registry_class_init(
    RadioRegistryClass* klass)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    radio_registry_signals[SIGNAL_INSTANCE_ADDED] =
        g_signal_new(SIGNAL_INSTANCE_ADDED_NAME, G_OBJECT_CLASS_TYPE(klass),
            G_SIGNAL_RUN_FIRST | G_SIGNAL_DETAILED, 0, NULL, NULL, NULL,
--- a/src/radio_request.c
+++ b/src/radio_request.c
@@ -70,6 +70,7 @@ void
 radio_request_object_cancel(
    RadioRequestObject* self)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    RadioRequest* req = &self->pub;

    radio_base_cancel_request(req->object, req);
@@ -86,6 +87,7 @@ void
 radio_request_free(
    RadioRequestObject* self)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    RadioRequest* req = &self->pub;

    GVERBOSE_("%u (%08x) %p", req->code, req->serial, req);
@@ -115,6 +117,7 @@ void
 radio_request_object_unref(
    RadioRequestObject* self)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    if (G_LIKELY(self)) {
        GASSERT(self->refcount > 0);
        if (g_atomic_int_dec_and_test(&self->refcount)) {
@@ -133,6 +136,7 @@ radio_request_default_retry(
    const GBinderReader* reader,
    void* user_data)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    if (status != RADIO_TX_STATUS_OK) {
        GVERBOSE_("req %p %u (%08x) status %d", req, req->code, req->serial,
            status);
@@ -157,6 +161,7 @@ radio_request_object_new(
    GDestroyNotify destroy,
    void* user_data)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    RadioRequestObject* self = g_slice_new0(RadioRequestObject);
    RadioRequest* req = &self->pub;
    GBinderWriter tmp;
@@ -192,6 +197,7 @@ void
 radio_request_unref_func(
    gpointer req)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    radio_request_object_unref(radio_request_cast(req));
 }

@@ -200,6 +206,7 @@ radio_request_update_serial(
    RadioRequest* req,
    guint32 serial)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    GBinderWriter writer;

    gbinder_local_request_init_writer(req->args, &writer);
@@ -220,6 +227,7 @@ radio_request_new(
    GDestroyNotify destroy,
    void* user_data)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    return client ? radio_request_object_new(RADIO_BASE(client), NULL,
        code, writer, (RadioRequestGenericCompleteFunc) complete,
        destroy, user_data) : NULL;
@@ -234,6 +242,7 @@ radio_request_new2(
    GDestroyNotify destroy,
    void* user_data)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    return group ? radio_request_object_new(RADIO_BASE(group->client), group,
        code, writer, (RadioRequestGenericCompleteFunc) complete,
        destroy, user_data) : NULL;
@@ -248,6 +257,7 @@ radio_config_request_new(
    GDestroyNotify destroy,
    void* user_data) /* Since 1.4.6 */
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    return config ? radio_request_object_new(RADIO_BASE(config), NULL,
        code, writer, (RadioRequestGenericCompleteFunc) complete,
        destroy, user_data) : NULL;
@@ -257,6 +267,7 @@ RadioRequest*
 radio_request_ref(
    RadioRequest* req)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    RadioRequestObject* self = radio_request_cast(req);

    if (G_LIKELY(self)) {
@@ -270,6 +281,7 @@ void
 radio_request_unref(
    RadioRequest* req)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    radio_request_object_unref(radio_request_cast(req));
 }

@@ -278,6 +290,7 @@ radio_request_set_blocking(
    RadioRequest* req,
    gboolean blocking)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    if (G_LIKELY(req)) {
        req->blocking = blocking;
    }
@@ -288,6 +301,7 @@ radio_request_set_timeout(
    RadioRequest* req,
    guint ms)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    if (G_LIKELY(req) && req->timeout_ms != ms) {
        RadioBase* base = req->object;

@@ -307,6 +321,7 @@ radio_request_set_retry(
    guint delay_ms,     /* Delay before each retry, in milliseconds */
    int max_count)      /* Negative count to keep retrying indefinitely */
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    if (G_LIKELY(req)) {
        req->retry_delay_ms = delay_ms;
        req->max_retries = max_count;
@@ -318,6 +333,7 @@ radio_request_set_retry_func(
    RadioRequest* req,
    RadioRequestRetryFunc retry)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    if (G_LIKELY(req)) {
        req->retry = retry ? retry : radio_request_default_retry;
    }
@@ -327,6 +343,7 @@ gboolean
 radio_request_submit(
    RadioRequest* req)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    if (req && req->object && radio_base_submit_request(req->object, req)) {
        radio_request_cast(req)->flags |= RADIO_REQUEST_FLAG_SUBMITTED;
        return TRUE;
@@ -338,6 +355,7 @@ gboolean
 radio_request_retry(
    RadioRequest* req)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    return req && req->object && radio_base_retry_request(req->object, req);
 }

@@ -345,6 +363,7 @@ void
 radio_request_cancel(
    RadioRequest* req)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    RadioRequestObject* self = radio_request_cast(req);

    if (G_LIKELY(self)) {
@@ -357,6 +376,7 @@ void
 radio_request_drop(
    RadioRequest* req)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    RadioRequestObject* self = radio_request_cast(req);

    if (G_LIKELY(self)) {
@@ -370,6 +390,7 @@ void*
 radio_request_user_data(
    RadioRequest* req) /* Since 1.4.11 */
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    return G_LIKELY(req) ? req->user_data : NULL;
 }

--- a/src/radio_request_group.c
+++ b/src/radio_request_group.c
@@ -60,6 +60,7 @@ void
 radio_request_group_unlink_func(
    gpointer req)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    ((RadioRequest*)req)->group = NULL;
 }

@@ -68,6 +69,7 @@ void
 radio_request_group_free(
    RadioRequestGroupObject* self)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    RadioRequestGroup* group = &self->pub;

    radio_base_unblock(RADIO_BASE(group->client), group);
@@ -85,6 +87,7 @@ radio_request_group_add(
    RadioRequestGroup* group,
    RadioRequest* req)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    RadioRequestGroupObject* self = radio_request_group_cast(group);

    /* Request is never NULL but the group may be */
@@ -99,6 +102,7 @@ radio_request_group_remove(
    RadioRequestGroup* group,
    RadioRequest* req)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    RadioRequestGroupObject* self = radio_request_group_cast(group);

    /* Request is never NULL but the group may be */
@@ -115,6 +119,7 @@ RadioRequestGroup*
 radio_request_group_new(
    RadioClient* client)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    if (G_LIKELY(client)) {
        RadioRequestGroupObject* self = g_slice_new0(RadioRequestGroupObject);
        RadioRequestGroup* group = &self->pub;
@@ -132,6 +137,7 @@ RadioRequestGroup*
 radio_request_group_ref(
    RadioRequestGroup* group)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    RadioRequestGroupObject* self = radio_request_group_cast(group);

    if (G_LIKELY(self)) {
@@ -145,6 +151,7 @@ void
 radio_request_group_unref(
    RadioRequestGroup* group)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    RadioRequestGroupObject* self = radio_request_group_cast(group);

    if (G_LIKELY(self)) {
@@ -159,6 +166,7 @@ void
 radio_request_group_cancel(
    RadioRequestGroup* group)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    RadioRequestGroupObject* self = radio_request_group_cast(group);

    if (G_LIKELY(self)) {
@@ -194,6 +202,7 @@ RADIO_BLOCK
 radio_request_group_block_status(
    RadioRequestGroup* group)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    return group ? radio_base_block_status(RADIO_BASE(group->client), group) :
        RADIO_BLOCK_NONE;
 }
@@ -202,6 +211,7 @@ RADIO_BLOCK
 radio_request_group_block(
    RadioRequestGroup* group)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    return group ? radio_base_block(RADIO_BASE(group->client), group) :
        RADIO_BLOCK_NONE;
 }
@@ -210,6 +220,7 @@ void
 radio_request_group_unblock(
    RadioRequestGroup* group)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    if (group) {
        radio_base_unblock(RADIO_BASE(group->client), group);
    }
--- a/src/radio_util.c
+++ b/src/radio_util.c
@@ -35,6 +35,7 @@
 */

 #include "radio_util_p.h"
+#include "radio_instance.h"
 #include "radio_log.h"

 GLOG_MODULE_DEFINE("gbinder-radio");
@@ -43,6 +44,7 @@ guint
 radio_observer_priority_index(
    RADIO_OBSERVER_PRIORITY priority)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    if (priority < RADIO_OBSERVER_PRIORITY_LOWEST) {
        return 0;
    } else if (priority > RADIO_OBSERVER_PRIORITY_HIGHEST) {
@@ -56,29 +58,118 @@ const char*
 radio_req_name(
    RADIO_REQ req)
 {
-    switch (req) {
-    case RADIO_REQ_SET_RESPONSE_FUNCTIONS:   return "setResponseFunctions";
-    case RADIO_REQ_RESPONSE_ACKNOWLEDGEMENT: return "responseAcknowledgement";
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
+    return radio_req_name2(NULL, req);
+}
+
+const char*
+radio_req_name2(
+    RadioInstance* instance,
+    RADIO_REQ req)
+{
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
+    if (!G_LIKELY(instance) || instance->interface_type == RADIO_INTERFACE_TYPE_HIDL) {
+        switch (req) {
+        case RADIO_REQ_SET_RESPONSE_FUNCTIONS:   return "setResponseFunctions";
+        case RADIO_REQ_RESPONSE_ACKNOWLEDGEMENT: return "responseAcknowledgement";
 #define RADIO_REQ_(req,resp,Name,NAME) \
-    case RADIO_REQ_##NAME: return #Name;
+        case RADIO_REQ_##NAME: return #Name;
 #define RADIO_REQ__(req,resp,Name,NAME,x) \
-    case RADIO_REQ_##NAME##x: return #Name #x;
-    RADIO_CALL_1_0(RADIO_REQ_)
-    RADIO_CALL_1_1(RADIO_REQ_)
-    RADIO_CALL_1_2(RADIO_REQ_)
-    RADIO_CALL_1_3(RADIO_REQ_)
-    RADIO_CALL_1_4_(RADIO_REQ__)
-    RADIO_CALL_1_5_(RADIO_REQ__)
+        case RADIO_REQ_##NAME##x: return #Name #x;
+        RADIO_CALL_1_0(RADIO_REQ_)
+        RADIO_CALL_1_1(RADIO_REQ_)
+        RADIO_CALL_1_2(RADIO_REQ_)
+        RADIO_CALL_1_3(RADIO_REQ_)
+        RADIO_CALL_1_4_(RADIO_REQ__)
+        RADIO_CALL_1_5_(RADIO_REQ__)
 #undef RADIO_REQ_
 #undef RADIO_REQ__
-    case RADIO_REQ_START_NETWORK_SCAN_1_2:     return "startNetworkScan_1_2";
-    case RADIO_REQ_SET_INDICATION_FILTER_1_2:  return "setIndicationFilter_1_2";
-    case RADIO_REQ_SETUP_DATA_CALL_1_2:        return "setupDataCall_1_2";
-    case RADIO_REQ_DEACTIVATE_DATA_CALL_1_2:   return "deactivateDataCall_1_2";
-    case RADIO_REQ_SET_INITIAL_ATTACH_APN_1_4: return "setInitialAttachApn_1_4";
-    case RADIO_REQ_SET_DATA_PROFILE_1_4:       return "setDataProfile_1_4";
-    case RADIO_REQ_ANY:
-        break;
+        case RADIO_REQ_START_NETWORK_SCAN_1_2:     return "startNetworkScan_1_2";
+        case RADIO_REQ_SET_INDICATION_FILTER_1_2:  return "setIndicationFilter_1_2";
+        case RADIO_REQ_SETUP_DATA_CALL_1_2:        return "setupDataCall_1_2";
+        case RADIO_REQ_DEACTIVATE_DATA_CALL_1_2:   return "deactivateDataCall_1_2";
+        case RADIO_REQ_SET_INITIAL_ATTACH_APN_1_4: return "setInitialAttachApn_1_4";
+        case RADIO_REQ_SET_DATA_PROFILE_1_4:       return "setDataProfile_1_4";
+        case RADIO_REQ_ANY:
+            break;
+        }
+    } else if (instance->interface_aidl == RADIO_DATA_INTERFACE) {
+        switch ((RADIO_DATA_REQ)req) {
+#define RADIO_DATA_REQ_(req,resp,Name,NAME) \
+        case RADIO_DATA_REQ_##NAME: return #Name;
+        RADIO_DATA_CALL_1(RADIO_DATA_REQ_)
+#undef RADIO_DATA_REQ_
+        case RADIO_DATA_REQ_SET_RESPONSE_FUNCTIONS:   return "setResponseFunctions";
+        case RADIO_DATA_REQ_RESPONSE_ACKNOWLEDGEMENT: return "responseAcknowledgement";
+        case RADIO_DATA_REQ_ANY:
+            break;
+        }
+    } else if (instance->interface_aidl == RADIO_IMS_INTERFACE) {
+        switch ((RADIO_IMS_REQ)req) {
+#define RADIO_IMS_REQ_(req,resp,Name,NAME) \
+        case RADIO_IMS_REQ_##NAME: return #Name;
+        RADIO_IMS_CALL_1(RADIO_IMS_REQ_)
+#undef RADIO_IMS_REQ_
+        case RADIO_IMS_REQ_SET_RESPONSE_FUNCTIONS:   return "setResponseFunctions";
+        case RADIO_IMS_REQ_ANY:
+            break;
+        }
+    } else if (instance->interface_aidl == RADIO_MESSAGING_INTERFACE) {
+        switch ((RADIO_MESSAGING_REQ)req) {
+#define RADIO_MESSAGING_REQ_(req,resp,Name,NAME) \
+        case RADIO_MESSAGING_REQ_##NAME: return #Name;
+        RADIO_MESSAGING_CALL_1(RADIO_MESSAGING_REQ_)
+#undef RADIO_MESSAGING_REQ_
+        case RADIO_MESSAGING_REQ_SET_RESPONSE_FUNCTIONS:   return "setResponseFunctions";
+        case RADIO_MESSAGING_REQ_RESPONSE_ACKNOWLEDGEMENT: return "responseAcknowledgement";
+        case RADIO_MESSAGING_REQ_ANY:
+            break;
+        }
+    } else if (instance->interface_aidl == RADIO_MODEM_INTERFACE) {
+        switch ((RADIO_MODEM_REQ)req) {
+#define RADIO_MODEM_REQ_(req,resp,Name,NAME) \
+        case RADIO_MODEM_REQ_##NAME: return #Name;
+        RADIO_MODEM_CALL_1(RADIO_MODEM_REQ_)
+#undef RADIO_MODEM_REQ_
+        case RADIO_MODEM_REQ_SET_RESPONSE_FUNCTIONS:   return "setResponseFunctions";
+        case RADIO_MODEM_REQ_RESPONSE_ACKNOWLEDGEMENT: return "responseAcknowledgement";
+        case RADIO_MODEM_REQ_ANY:
+            break;
+        }
+    } else if (instance->interface_aidl == RADIO_NETWORK_INTERFACE) {
+        switch ((RADIO_NETWORK_REQ)req) {
+#define RADIO_NETWORK_REQ_(req,resp,Name,NAME) \
+        case RADIO_NETWORK_REQ_##NAME: return #Name;
+        RADIO_NETWORK_CALL_1(RADIO_NETWORK_REQ_)
+#undef RADIO_NETWORK_REQ_
+        case RADIO_NETWORK_REQ_SET_RESPONSE_FUNCTIONS:   return "setResponseFunctions";
+        case RADIO_NETWORK_REQ_RESPONSE_ACKNOWLEDGEMENT: return "responseAcknowledgement";
+        case RADIO_NETWORK_REQ_ANY:
+            break;
+        }
+    } else if (instance->interface_aidl == RADIO_SIM_INTERFACE) {
+        switch ((RADIO_SIM_REQ)req) {
+#define RADIO_SIM_REQ_(req,resp,Name,NAME) \
+        case RADIO_SIM_REQ_##NAME: return #Name;
+        RADIO_SIM_CALL_1(RADIO_SIM_REQ_)
+#undef RADIO_SIM_REQ_
+        case RADIO_SIM_REQ_SET_RESPONSE_FUNCTIONS:   return "setResponseFunctions";
+        case RADIO_SIM_REQ_RESPONSE_ACKNOWLEDGEMENT: return "responseAcknowledgement";
+        case RADIO_SIM_REQ_ANY:
+            break;
+        }
+    } else if (instance->interface_aidl == RADIO_VOICE_INTERFACE) {
+        switch ((RADIO_VOICE_REQ)req) {
+#define RADIO_VOICE_REQ_(req,resp,Name,NAME) \
+        case RADIO_VOICE_REQ_##NAME: return #Name;
+        RADIO_VOICE_CALL_1(RADIO_VOICE_REQ_)
+#undef RADIO_VOICE_REQ_
+        case RADIO_VOICE_REQ_HANGUP:                   return "hangup";
+        case RADIO_VOICE_REQ_SET_RESPONSE_FUNCTIONS:   return "setResponseFunctions";
+        case RADIO_VOICE_REQ_RESPONSE_ACKNOWLEDGEMENT: return "responseAcknowledgement";
+        case RADIO_VOICE_REQ_ANY:
+            break;
+        }
    }
    return NULL;
 }
@@ -87,48 +178,130 @@ const char*
 radio_resp_name(
    RADIO_RESP resp)
 {
-    switch (resp) {
-    case RADIO_RESP_ACKNOWLEDGE_REQUEST: return "acknowledgeRequest";
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
+    return radio_resp_name2(NULL, resp);
+}
+
+const char*
+radio_resp_name2(
+    RadioInstance* instance,
+    RADIO_RESP resp)
+{
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
+    if (!G_LIKELY(instance) || instance->interface_type == RADIO_INTERFACE_TYPE_HIDL) {
+        switch (resp) {
+        case RADIO_RESP_ACKNOWLEDGE_REQUEST: return "acknowledgeRequest";
 #define RADIO_RESP_(req,resp,Name,NAME) \
-    case RADIO_RESP_##NAME: return #Name "Response";
+        case RADIO_RESP_##NAME: return #Name "Response";
 #define RADIO_RESP__(req,resp,Name,NAME,x) \
-    case RADIO_RESP_##NAME##x: return #Name "Response" #x;
-    RADIO_CALL_1_0(RADIO_RESP_)
-    RADIO_CALL_1_1(RADIO_RESP_)
-    RADIO_CALL_1_2(RADIO_RESP_)
-    RADIO_CALL_1_3(RADIO_RESP_)
-    RADIO_CALL_1_4_(RADIO_RESP__)
-    RADIO_CALL_1_5_(RADIO_RESP__)
+        case RADIO_RESP_##NAME##x: return #Name "Response" #x;
+        RADIO_CALL_1_0(RADIO_RESP_)
+        RADIO_CALL_1_1(RADIO_RESP_)
+        RADIO_CALL_1_2(RADIO_RESP_)
+        RADIO_CALL_1_3(RADIO_RESP_)
+        RADIO_CALL_1_4_(RADIO_RESP__)
+        RADIO_CALL_1_5_(RADIO_RESP__)
 #undef RADIO_RESP_
 #undef RADIO_RESP__
-    case RADIO_RESP_GET_CELL_INFO_LIST_1_2:
-        return "getCellInfoListResponse_1_2";
-    case RADIO_RESP_GET_ICC_CARD_STATUS_1_2:
-        return "getIccCardStatusResponse_1_2";
-    case RADIO_RESP_GET_CURRENT_CALLS_1_2:
-        return "getCurrentCallsResponse_1_2";
-    case RADIO_RESP_GET_SIGNAL_STRENGTH_1_2:
-        return "getSignalStrengthResponse_1_2";
-    case RADIO_RESP_GET_VOICE_REGISTRATION_STATE_1_2:
-        return "getVoiceRegistrationStateResponse_1_2";
-    case RADIO_RESP_GET_DATA_REGISTRATION_STATE_1_2:
-        return "getDataRegistrationStateResponse_1_2";
-    case RADIO_RESP_GET_CELL_INFO_LIST_RESPONSE_1_4:
-        return "getCellInfoListResponse_1_4";
-    case RADIO_RESP_GET_DATA_REGISTRATION_STATE_RESPONSE_1_4:
-        return "getDataRegistrationStateResponse_1_4";
-    case RADIO_RESP_GET_ICC_CARD_STATUS_RESPONSE_1_4:
-        return "getIccCardStatusResponse_1_4";
-    case RADIO_RESP_GET_DATA_CALL_LIST_RESPONSE_1_4:
-        return "getDataCallListResponse_1_4";
-    case RADIO_RESP_GET_DATA_CALL_LIST_1_5:
-        return "getDataCallList_1_5";
-    case RADIO_RESP_GET_CELL_INFO_LIST_1_5:
-        return "getCellInfoListResponse_1_5";
-    case RADIO_RESP_GET_ICC_CARD_STATUS_1_5:
-        return "getIccCardStatus_1_5";
-    case RADIO_RESP_ANY:
-        break;
+        case RADIO_RESP_GET_CELL_INFO_LIST_1_2:
+            return "getCellInfoListResponse_1_2";
+        case RADIO_RESP_GET_ICC_CARD_STATUS_1_2:
+            return "getIccCardStatusResponse_1_2";
+        case RADIO_RESP_GET_CURRENT_CALLS_1_2:
+            return "getCurrentCallsResponse_1_2";
+        case RADIO_RESP_GET_SIGNAL_STRENGTH_1_2:
+            return "getSignalStrengthResponse_1_2";
+        case RADIO_RESP_GET_VOICE_REGISTRATION_STATE_1_2:
+            return "getVoiceRegistrationStateResponse_1_2";
+        case RADIO_RESP_GET_DATA_REGISTRATION_STATE_1_2:
+            return "getDataRegistrationStateResponse_1_2";
+        case RADIO_RESP_GET_CELL_INFO_LIST_RESPONSE_1_4:
+            return "getCellInfoListResponse_1_4";
+        case RADIO_RESP_GET_DATA_REGISTRATION_STATE_RESPONSE_1_4:
+            return "getDataRegistrationStateResponse_1_4";
+        case RADIO_RESP_GET_ICC_CARD_STATUS_RESPONSE_1_4:
+            return "getIccCardStatusResponse_1_4";
+        case RADIO_RESP_GET_DATA_CALL_LIST_RESPONSE_1_4:
+            return "getDataCallListResponse_1_4";
+        case RADIO_RESP_GET_DATA_CALL_LIST_1_5:
+            return "getDataCallList_1_5";
+        case RADIO_RESP_GET_CELL_INFO_LIST_1_5:
+            return "getCellInfoListResponse_1_5";
+        case RADIO_RESP_GET_ICC_CARD_STATUS_1_5:
+            return "getIccCardStatus_1_5";
+        case RADIO_RESP_ANY:
+            break;
+        }
+    } else if (instance->interface_aidl == RADIO_DATA_INTERFACE) {
+        switch ((RADIO_DATA_RESP)resp) {
+        case RADIO_DATA_RESP_ACKNOWLEDGE_REQUEST: return "acknowledgeRequest";
+#define RADIO_DATA_RESP_(req,resp,Name,NAME) \
+        case RADIO_DATA_RESP_##NAME: return #Name "Response";
+        RADIO_DATA_CALL_1(RADIO_DATA_RESP_)
+#undef RADIO_DATA_RESP_
+        case RADIO_DATA_RESP_ANY:
+            break;
+        }
+    } else if (instance->interface_aidl == RADIO_IMS_INTERFACE) {
+        switch ((RADIO_IMS_RESP)resp) {
+#define RADIO_IMS_RESP_(req,resp,Name,NAME) \
+        case RADIO_IMS_RESP_##NAME: return #Name "Response";
+        RADIO_IMS_CALL_1(RADIO_IMS_RESP_)
+#undef RADIO_IMS_RESP_
+        case RADIO_IMS_RESP_ANY:
+            break;
+        }
+    } else if (instance->interface_aidl == RADIO_MESSAGING_INTERFACE) {
+        switch ((RADIO_MESSAGING_RESP)resp) {
+        case RADIO_MESSAGING_RESP_ACKNOWLEDGE_REQUEST: return "acknowledgeRequest";
+#define RADIO_MESSAGING_RESP_(req,resp,Name,NAME) \
+        case RADIO_MESSAGING_RESP_##NAME: return #Name "Response";
+        RADIO_MESSAGING_CALL_1(RADIO_MESSAGING_RESP_)
+#undef RADIO_MESSAGING_RESP_
+        case RADIO_MESSAGING_RESP_ANY:
+            break;
+        }
+    } else if (instance->interface_aidl == RADIO_MODEM_INTERFACE) {
+        switch ((RADIO_MODEM_RESP)resp) {
+        case RADIO_MODEM_RESP_ACKNOWLEDGE_REQUEST: return "acknowledgeRequest";
+#define RADIO_MODEM_RESP_(req,resp,Name,NAME) \
+        case RADIO_MODEM_RESP_##NAME: return #Name "Response";
+        RADIO_MODEM_CALL_1(RADIO_MODEM_RESP_)
+#undef RADIO_MODEM_RESP_
+        case RADIO_MODEM_RESP_ANY:
+            break;
+        }
+    } else if (instance->interface_aidl == RADIO_NETWORK_INTERFACE) {
+        switch ((RADIO_NETWORK_RESP)resp) {
+        case RADIO_NETWORK_RESP_ACKNOWLEDGE_REQUEST: return "acknowledgeRequest";
+#define RADIO_NETWORK_RESP_(req,resp,Name,NAME) \
+        case RADIO_NETWORK_RESP_##NAME: return #Name "Response";
+        RADIO_NETWORK_CALL_1(RADIO_NETWORK_RESP_)
+#undef RADIO_NETWORK_RESP_
+        case RADIO_NETWORK_RESP_ANY:
+            break;
+        }
+    } else if (instance->interface_aidl == RADIO_SIM_INTERFACE) {
+        switch ((RADIO_SIM_RESP)resp) {
+        case RADIO_SIM_RESP_ACKNOWLEDGE_REQUEST: return "acknowledgeRequest";
+#define RADIO_SIM_RESP_(req,resp,Name,NAME) \
+        case RADIO_SIM_RESP_##NAME: return #Name "Response";
+        RADIO_SIM_CALL_1(RADIO_SIM_RESP_)
+#undef RADIO_SIM_RESP_
+        case RADIO_SIM_RESP_ANY:
+            break;
+        }
+    } else if (instance->interface_aidl == RADIO_VOICE_INTERFACE) {
+        switch ((RADIO_VOICE_RESP)resp) {
+        case RADIO_VOICE_RESP_ACKNOWLEDGE_REQUEST:        return "acknowledgeRequest";
+        case RADIO_VOICE_RESP_HANGUP_CONNECTION_RESPONSE: return "hangupConnectionResponse";
+#define RADIO_VOICE_RESP_(req,resp,Name,NAME) \
+        case RADIO_VOICE_RESP_##NAME: return #Name "Response";
+        RADIO_VOICE_CALL_1(RADIO_VOICE_RESP_)
+#undef RADIO_VOICE_RESP_
+        case RADIO_VOICE_RESP_ANY:
+            break;
+        }
    }
    return NULL;
 }
@@ -137,17 +310,92 @@ const char*
 radio_ind_name(
    RADIO_IND ind)
 {
-    switch (ind) {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
+    return radio_ind_name2(NULL, ind);
+}
+
+const char*
+radio_ind_name2(
+    RadioInstance* instance,
+    RADIO_IND ind)
+{
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
+    if (!G_LIKELY(instance) || instance->interface_type == RADIO_INTERFACE_TYPE_HIDL) {
+        switch (ind) {
 #define RADIO_IND_(code,Name,NAME) \
-    case RADIO_IND_##NAME: return #Name;
-    RADIO_EVENT_1_0(RADIO_IND_)
-    RADIO_EVENT_1_1(RADIO_IND_)
-    RADIO_EVENT_1_2(RADIO_IND_)
-    RADIO_EVENT_1_4(RADIO_IND_)
-    RADIO_EVENT_1_5(RADIO_IND_)
+        case RADIO_IND_##NAME: return #Name;
+        RADIO_EVENT_1_0(RADIO_IND_)
+        RADIO_EVENT_1_1(RADIO_IND_)
+        RADIO_EVENT_1_2(RADIO_IND_)
+        RADIO_EVENT_1_4(RADIO_IND_)
+        RADIO_EVENT_1_5(RADIO_IND_)
 #undef RADIO_IND_
-    case RADIO_IND_ANY:
-        break;
+        case RADIO_IND_ANY:
+            break;
+        }
+    } else if (instance->interface_aidl == RADIO_DATA_INTERFACE) {
+        switch ((RADIO_DATA_IND)ind) {
+#define RADIO_DATA_IND_(code,Name,NAME) \
+        case RADIO_DATA_IND_##NAME: return #Name;
+        RADIO_DATA_IND_1(RADIO_DATA_IND_)
+#undef RADIO_DATA_IND_
+        case RADIO_DATA_IND_ANY:
+            break;
+        }
+    } else if (instance->interface_aidl == RADIO_IMS_INTERFACE) {
+        switch ((RADIO_IMS_IND)ind) {
+#define RADIO_IMS_IND_(code,Name,NAME) \
+        case RADIO_IMS_IND_##NAME: return #Name;
+        RADIO_IMS_IND_1(RADIO_IMS_IND_)
+#undef RADIO_IMS_IND_
+        case RADIO_IMS_IND_ANY:
+            break;
+        }
+    } else if (instance->interface_aidl == RADIO_MESSAGING_INTERFACE) {
+        switch ((RADIO_MESSAGING_IND)ind) {
+#define RADIO_MESSAGING_IND_(code,Name,NAME) \
+        case RADIO_MESSAGING_IND_##NAME: return #Name;
+        RADIO_MESSAGING_IND_1(RADIO_MESSAGING_IND_)
+#undef RADIO_MESSAGING_IND_
+        case RADIO_MESSAGING_IND_ANY:
+            break;
+        }
+    } else if (instance->interface_aidl == RADIO_MODEM_INTERFACE) {
+        switch ((RADIO_MODEM_IND)ind) {
+#define RADIO_MODEM_IND_(code,Name,NAME) \
+        case RADIO_MODEM_IND_##NAME: return #Name;
+        RADIO_MODEM_IND_1(RADIO_MODEM_IND_)
+#undef RADIO_MODEM_IND_
+        case RADIO_MODEM_IND_ANY:
+            break;
+        }
+    } else if (instance->interface_aidl == RADIO_NETWORK_INTERFACE) {
+        switch ((RADIO_NETWORK_IND)ind) {
+#define RADIO_NETWORK_IND_(code,Name,NAME) \
+        case RADIO_NETWORK_IND_##NAME: return #Name;
+        RADIO_NETWORK_IND_1(RADIO_NETWORK_IND_)
+#undef RADIO_NETWORK_IND_
+        case RADIO_NETWORK_IND_ANY:
+            break;
+        }
+    } else if (instance->interface_aidl == RADIO_SIM_INTERFACE) {
+        switch ((RADIO_SIM_IND)ind) {
+#define RADIO_SIM_IND_(code,Name,NAME) \
+        case RADIO_SIM_IND_##NAME: return #Name;
+        RADIO_SIM_IND_1(RADIO_SIM_IND_)
+#undef RADIO_SIM_IND_
+        case RADIO_SIM_IND_ANY:
+            break;
+        }
+    } else if (instance->interface_aidl == RADIO_VOICE_INTERFACE) {
+        switch ((RADIO_VOICE_IND)ind) {
+#define RADIO_VOICE_IND_(code,Name,NAME) \
+        case RADIO_VOICE_IND_##NAME: return #Name;
+        RADIO_VOICE_IND_1(RADIO_VOICE_IND_)
+#undef RADIO_VOICE_IND_
+        case RADIO_VOICE_IND_ANY:
+            break;
+        }
    }
    return NULL;
 }
@@ -167,6 +415,7 @@ RADIO_RESP
 radio_req_resp(
    RADIO_REQ req)
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    switch (req) {
 #define RADIO_REQ_RESP_(req,resp,Name,NAME) \
    case RADIO_REQ_##NAME: return RADIO_RESP_##NAME;
@@ -214,6 +463,7 @@ radio_req_resp2(
    RADIO_REQ req,
    RADIO_INTERFACE iface) /* Since 1.4.5 */
 {
+    DBG("func:%s,line:%d,file:%s", __func__, __LINE__, __FILE__);
    switch (req) {
    /*
     * Requests expecting a response from a previous version of the
@@ -290,7 +540,7 @@ radio_req_resp2(
        return RADIO_RESP_NONE;

    /*
-     * getCurrentCalls
+     * getCurrentCalls{
     * getCurrentCallsResponse
     * getCurrentCallsResponse_1_2 <= the last one
     * getCurrentCalls_1_6
--- a/unit/common/test_gbinder_local_object.c
+++ b/unit/common/test_gbinder_local_object.c
@@ -43,6 +43,7 @@ struct gbinder_local_object {
    char** ifaces;
    GBinderLocalTransactFunc txproc;
    void* user_data;
+    GBINDER_STABILITY_LEVEL stability;
 };

 static const char hidl_base_interface[] = "android.hidl.base@1.0::IBase";
@@ -144,6 +145,16 @@ gbinder_local_object_drop(
    }
 }

+void
+gbinder_local_object_set_stability(
+    GBinderLocalObject* self,
+    GBINDER_STABILITY_LEVEL stability)
+{
+    if (self) {
+        self->stability = stability;
+    }
+}
+
 /*
 * Local Variables:
 * mode: C
--- a/unit/common/test_gbinder_reader_writer.c
+++ b/unit/common/test_gbinder_reader_writer.c
@@ -373,6 +373,24 @@ gbinder_reader_read_hidl_struct1(
    return NULL;
 }

+const void*
+gbinder_reader_read_parcelable(
+    GBinderReader* reader,
+    gsize* size)
+{
+    TestGBinderReader* self = test_gbinder_reader_cast(reader);
+    TestGBinderDataItem* item = self->item;
+
+    if (item && item->type == DATA_TYPE_BUFFER) {
+        if (size) {
+            *size = item->data.blob.size;
+        }
+        self->item = item->next;
+        return item->data.blob.buf;
+    }
+    return NULL;
+}
+
 GBinderRemoteObject*
 gbinder_reader_read_object(
    GBinderReader* reader)
Author	SHA1	Message	Date
kuailexs	690e4de7d5	debug logs	2025-10-23 23:17:41 +08:00
kuailexs	fddd1b7d56	debug logs	2025-10-23 23:01:30 +08:00
kuailexs	4cdc4cfe65	debug logs	2025-10-23 22:39:33 +08:00
kuailexs	1396126a6b	debug logs	2025-10-18 14:56:12 +08:00
kuailexs	a8fe0fe5c3	debug logs	2025-10-18 13:49:55 +08:00
kuailexs	50d6f649fa	debian files	2025-10-17 23:50:44 +08:00
kuailexs	eb631f637c	debian files	2025-10-17 23:15:20 +08:00
kuailexs	ae08826314	Fix symlink according to Debian policy	2025-10-17 23:13:54 +08:00
Matti Lehtimäki	a4a19a374a	Version 1.6.0	2024-09-26 14:06:44 +03:00
Matti Lehtimäki	00248f8da3	Merge pull request #28 from mer-hybris/aidl Add support for AIDL interfaces	2024-09-26 14:01:59 +03:00
Matti Lehtimäki	418405697e	[gbinder-radio] Implement support for AIDL IRadioIms. JB#61702	2024-09-23 23:37:55 +03:00
Matti Lehtimäki	12133c9685	[gbinder-radio] Implement support for AIDL IRadioVoice. JB#61702	2024-09-23 23:37:55 +03:00
Matti Lehtimäki	50c615095b	[gbinder-radio] Implement support for AIDL IRadioMessaging. JB#61702	2024-09-23 23:37:55 +03:00
Matti Lehtimäki	fa6a4d7e1a	[gbinder-radio] Implement support for AIDL IRadioData. JB#61702	2024-09-23 23:37:55 +03:00
Matti Lehtimäki	bedb4a7659	[gbinder-radio] Implement support for AIDL IRadioNetwork. JB#61702	2024-09-23 23:37:55 +03:00
Nikita Ukhrenkov	500465507e	[gbinder-radio] Implement support for AIDL IRadioSim. JB#61702	2024-09-23 23:37:55 +03:00
Nikita Ukhrenkov	b8917f5985	[gbinder-radio] Implement support for AIDL IRadioModem. JB#61702	2024-09-23 23:37:55 +03:00
Nikita Ukhrenkov	453595be28	[gbinder-radio] Implement support for AIDL IRadioConfig. JB#61702	2024-09-23 23:37:55 +03:00
Matti Lehtimäki	4803615920	Version 1.5.6	2023-04-21 14:56:04 +03:00
				`@@ -0,0 +1 @@`
				`debian/tmp/@LIBDIR@/libgbinder-radio.so.* @LIBDIR@`