debian files

Fix symlink according to Debian policy
Version 1.6.0
2025-10-17 23:15:20 +08:00 · 2025-10-17 23:13:54 +08:00 · 2024-09-26 14:06:44 +03:00 · 2024-09-26 14:01:59 +03:00 · 2024-09-23 23:37:55 +03:00 · 2024-09-23 23:37:55 +03:00
38 changed files with 3349 additions and 552 deletions
--- a/6
+++ b/6
@@ -23,8 +23,8 @@ all: debug release pkgconfig
 #

 VERSION_MAJOR = 1
-VERSION_MINOR = 4
-VERSION_RELEASE = 6
+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,108 +1,49 @@
-libgbinder-radio (1.4.6) unstable; urgency=medium
+libgbinder-radio (1.6.0-0ubports1) UNRELEASED; urgency=unknown

-  * Added RadioConfig API
+  * New upstream release v1.6.0 

- -- Slava Monich <slava.monich@jolla.com>  Sat, 08 Jan 2022 20:58:06 +0200
+ -- UBports package upgrader bot <dev@ubports.com>  Fri, 13 Dec 2024 04:07:25 +0000

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

-  * Added radio_req_resp2()
+  * New upstream release v1.5.6 

- -- Slava Monich <slava.monich@jolla.com>  Thu, 16 Dec 2021 01:18:54 +0200
+ -- UBports package upgrader bot <dev@ubports.com>  Thu, 09 Nov 2023 00:27:17 +0000

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

-  * Added IRadio@1.2 IndicationFilter bits
+  * Update from upstream

- -- Slava Monich <slava.monich@jolla.com>  Tue, 14 Dec 2021 18:01:43 +0200
+ -- Lionel Duboeuf <lduboeuf@ouvaton.org>  Wed, 08 Jan 2023 10:52:34 +0100

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

-  * Added RadioClient and related APIs
+  * Rename libgbinder-radio-dev to libgbinder-radio1-dev
+  * Generate install files correctly again

- -- Slava Monich <slava.monich@jolla.com>  Thu, 02 Dec 2021 19:08:47 +0200
+ -- Guido Berhoerster <guido+gitlab.com@berhoerster.name>  Wed, 24 Nov 2021 10:52:34 +0100

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

-  * Don't assume that GBinderServiceManager is a GObject
-  * Added unit tests
+  * 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>  Sun, 12 Sep 2021 18:05:19 +0300
+ -- Guido Berhoerster <guido+gitlab.com@berhoerster.name>  Mon, 15 Nov 2021 15:02:18 +0100

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

-  * Added RADIO_CELL_INFO_TYPE_1_4 enum
+  * Bump version, no changes.

- -- Slava Monich <slava.monich@jolla.com>  Thu, 20 May 2021 16:32:16 +0300
+ -- Guido Berhoerster <guido+gitlab.com@berhoerster.name>  Thu, 11 Nov 2021 15:02:07 +0100

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

-  * Support for radio@1.4 interfaces
-  * Fixed RadioCellInfo_1_4 definition
+  * Initial packaging for UBPorts

- -- 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/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
@@ -5,7 +5,7 @@
 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_config_types.h
+++ b/include/radio_config_types.h
@@ -47,6 +47,7 @@ typedef enum radio_config_interface {
    RADIO_CONFIG_INTERFACE_NONE = -1,
    RADIO_CONFIG_INTERFACE_1_0,
    RADIO_CONFIG_INTERFACE_1_1,
+    RADIO_CONFIG_INTERFACE_1_2, /* Since 1.5.0 */
    RADIO_CONFIG_INTERFACE_COUNT
 } RADIO_CONFIG_INTERFACE;

@@ -59,18 +60,25 @@ typedef enum radio_config_interface {
 #define RADIO_CONFIG_INDICATION_IFACE "IRadioConfigIndication"
 #define RADIO_CONFIG_IFACE_1_0(x)     RADIO_CONFIG_IFACE_PREFIX "1.0::" x
 #define RADIO_CONFIG_IFACE_1_1(x)     RADIO_CONFIG_IFACE_PREFIX "1.1::" x
+#define RADIO_CONFIG_IFACE_1_2(x)     RADIO_CONFIG_IFACE_PREFIX "1.2::" x
 #define RADIO_CONFIG_1_0              RADIO_CONFIG_IFACE_1_0(RADIO_CONFIG_IFACE)
 #define RADIO_CONFIG_1_1              RADIO_CONFIG_IFACE_1_1(RADIO_CONFIG_IFACE)
+#define RADIO_CONFIG_1_2              RADIO_CONFIG_IFACE_1_2(RADIO_CONFIG_IFACE)
 #define RADIO_CONFIG_1_0_FQNAME       RADIO_CONFIG_1_0 "/" RADIO_CONFIG_INSTANCE
 #define RADIO_CONFIG_1_1_FQNAME       RADIO_CONFIG_1_1 "/" RADIO_CONFIG_INSTANCE
+#define RADIO_CONFIG_1_2_FQNAME       RADIO_CONFIG_1_2 "/" RADIO_CONFIG_INSTANCE
 #define RADIO_CONFIG_RESPONSE_1_0 \
        RADIO_CONFIG_IFACE_1_0(RADIO_CONFIG_RESPONSE_IFACE)
 #define RADIO_CONFIG_RESPONSE_1_1 \
        RADIO_CONFIG_IFACE_1_1(RADIO_CONFIG_RESPONSE_IFACE)
+#define RADIO_CONFIG_RESPONSE_1_2 \
+        RADIO_CONFIG_IFACE_1_2(RADIO_CONFIG_RESPONSE_IFACE)
 #define RADIO_CONFIG_INDICATION_1_0 \
        RADIO_CONFIG_IFACE_1_0(RADIO_CONFIG_INDICATION_IFACE)
 #define RADIO_CONFIG_INDICATION_1_1 \
        RADIO_CONFIG_IFACE_1_1(RADIO_CONFIG_INDICATION_IFACE)
+#define RADIO_CONFIG_INDICATION_1_2 \
+        RADIO_CONFIG_IFACE_1_2(RADIO_CONFIG_INDICATION_IFACE)

 /* Types defined in types.hal */

@@ -129,6 +137,9 @@ G_STATIC_ASSERT(sizeof(RadioModemsConfig) == 1);
 #define RADIO_CONFIG_IND_1_0(i) \
    i(1,simSlotsStatusChanged,SIM_SLOTS_STATUS_CHANGED)

+#define RADIO_CONFIG_IND_1_2(i) \
+    i(2,simSlotsStatusChanged_1_2,SIM_SLOTS_STATUS_CHANGED_1_2) /* Since 1.5.0 */
+
 typedef enum radio_config_req {
    RADIO_CONFIG_REQ_ANY = 0,
    RADIO_CONFIG_REQ_NONE = 0,
@@ -158,7 +169,11 @@ typedef enum radio_config_resp {

    /* android.hardware.radio.config@1.1::IRadioConfigResponse */
    RADIO_CONFIG_CALL_1_1(RADIO_CONFIG_RESP_)
-    RADIO_CONFIG_1_1_RESP_LAST = RADIO_CONFIG_RESP_GET_MODEMS_CONFIG
+    RADIO_CONFIG_1_1_RESP_LAST = RADIO_CONFIG_RESP_GET_MODEMS_CONFIG,
+
+    /* android.hardware.radio.config@1.2::IRadioConfigResponse */
+    RADIO_CONFIG_RESP_GET_SIM_SLOTS_STATUS_1_2 = 7, /* Since 1.5.0 */
+    RADIO_CONFIG_1_2_RESP_LAST = RADIO_CONFIG_RESP_GET_SIM_SLOTS_STATUS_1_2
 #undef RADIO_CONFIG_RESP_
 } RADIO_CONFIG_RESP;
 G_STATIC_ASSERT(sizeof(RADIO_CONFIG_RESP) == 4);
@@ -170,7 +185,11 @@ typedef enum radio_config_ind {

    /* android.hardware.radio.config@1.0::IRadioConfigIndication */
    RADIO_CONFIG_IND_1_0(RADIO_CONFIG_IND_)
-    RADIO_CONFIG_1_0_IND_LAST = RADIO_CONFIG_IND_SIM_SLOTS_STATUS_CHANGED
+    RADIO_CONFIG_1_0_IND_LAST = RADIO_CONFIG_IND_SIM_SLOTS_STATUS_CHANGED,
+
+    /* android.hardware.radio.config@1.2::IRadioConfigIndication */
+    RADIO_CONFIG_IND_1_2(RADIO_CONFIG_IND_) /* Since 1.5.0 */
+    RADIO_CONFIG_1_2_IND_LAST = RADIO_CONFIG_IND_SIM_SLOTS_STATUS_CHANGED_1_2
 #undef RADIO_CONFIG_IND_
 } RADIO_CONFIG_IND;
 G_STATIC_ASSERT(sizeof(RADIO_CONFIG_IND) == 4);
--- 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_request.h
+++ b/include/radio_request.h
@@ -207,6 +207,10 @@ radio_request_set_retry_func(
    RadioRequest* req,
    RadioRequestRetryFunc retry);

+void*
+radio_request_user_data(
+    RadioRequest* req); /* Since 1.4.11 */
+
 G_END_DECLS

 #endif /* RADIO_REQUEST_H */
--- 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
@@ -62,9 +62,28 @@ typedef enum radio_interface {
    RADIO_INTERFACE_1_2,
    RADIO_INTERFACE_1_3,
    RADIO_INTERFACE_1_4,
+    RADIO_INTERFACE_1_5, /* Since 1.5.0 */
    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,
@@ -80,21 +99,25 @@ typedef enum radio_observer_priority {
 #define RADIO_IFACE_1_2(x)     RADIO_IFACE_PREFIX "1.2::" x
 #define RADIO_IFACE_1_3(x)     RADIO_IFACE_PREFIX "1.3::" x
 #define RADIO_IFACE_1_4(x)     RADIO_IFACE_PREFIX "1.4::" x
+#define RADIO_IFACE_1_5(x)     RADIO_IFACE_PREFIX "1.5::" x
 #define RADIO_1_0              RADIO_IFACE_1_0(RADIO_IFACE)
 #define RADIO_1_1              RADIO_IFACE_1_1(RADIO_IFACE)
 #define RADIO_1_2              RADIO_IFACE_1_2(RADIO_IFACE)
 #define RADIO_1_3              RADIO_IFACE_1_3(RADIO_IFACE)
 #define RADIO_1_4              RADIO_IFACE_1_4(RADIO_IFACE)
+#define RADIO_1_5              RADIO_IFACE_1_5(RADIO_IFACE)
 #define RADIO_RESPONSE_1_0     RADIO_IFACE_1_0(RADIO_RESPONSE_IFACE)
 #define RADIO_RESPONSE_1_1     RADIO_IFACE_1_1(RADIO_RESPONSE_IFACE)
 #define RADIO_RESPONSE_1_2     RADIO_IFACE_1_2(RADIO_RESPONSE_IFACE)
 #define RADIO_RESPONSE_1_3     RADIO_IFACE_1_3(RADIO_RESPONSE_IFACE)
 #define RADIO_RESPONSE_1_4     RADIO_IFACE_1_4(RADIO_RESPONSE_IFACE)
+#define RADIO_RESPONSE_1_5     RADIO_IFACE_1_5(RADIO_RESPONSE_IFACE)
 #define RADIO_INDICATION_1_0   RADIO_IFACE_1_0(RADIO_INDICATION_IFACE)
 #define RADIO_INDICATION_1_1   RADIO_IFACE_1_1(RADIO_INDICATION_IFACE)
 #define RADIO_INDICATION_1_2   RADIO_IFACE_1_2(RADIO_INDICATION_IFACE)
 #define RADIO_INDICATION_1_3   RADIO_IFACE_1_3(RADIO_INDICATION_IFACE)
 #define RADIO_INDICATION_1_4   RADIO_IFACE_1_4(RADIO_INDICATION_IFACE)
+#define RADIO_INDICATION_1_5   RADIO_IFACE_1_5(RADIO_INDICATION_IFACE)

 /* Types defined in types.hal */

@@ -222,6 +245,12 @@ typedef enum radio_reg_state {
 } RADIO_REG_STATE;
 G_STATIC_ASSERT(sizeof(RADIO_REG_STATE) == 4);

+typedef enum radio_reg_access_technology_specific_info_type {
+    RADIO_REG_ACCESS_TECHNOLOGY_SPECIFIC_INFO_NONE = 0,
+    RADIO_REG_ACCESS_TECHNOLOGY_SPECIFIC_INFO_CDMA = 1,
+    RADIO_REG_ACCESS_TECHNOLOGY_SPECIFIC_INFO_EUTRAN = 2
+} RADIO_REG_ACCESS_TECHNOLOGY_SPECIFIC_INFO_TYPE; /* Since 1.5.0 */
+
 typedef enum radio_ind_filter {
    RADIO_IND_FILTER_NONE = 0,
    RADIO_IND_FILTER_SIGNAL_STRENGTH = 0x01,
@@ -234,7 +263,14 @@ typedef enum radio_ind_filter {
    /* Since 1.4.4 (those appeared in IRadio@1.2) */
    RADIO_IND_FILTER_LINK_CAPACITY_ESTIMATE = 0x08,
    RADIO_IND_FILTER_PHYSICAL_CHANNEL_CONFIG = 0x10,
-    RADIO_IND_FILTER_ALL_1_2 = ~0
+    RADIO_IND_FILTER_ALL_1_2 =
+        RADIO_IND_FILTER_ALL |
+        RADIO_IND_FILTER_LINK_CAPACITY_ESTIMATE |
+        RADIO_IND_FILTER_PHYSICAL_CHANNEL_CONFIG,
+    /* Since 1.5.5 (those appeared in IRadio@1.5) */
+    RADIO_IND_FILTER_REGISTRATION_FAILURE = 0x20,
+    RADIO_IND_FILTER_BARRING_INFO = 0x40,
+    RADIO_IND_FILTER_ALL_1_5 = ~0
 } RADIO_IND_FILTER;
 G_STATIC_ASSERT(sizeof(RADIO_IND_FILTER) == 4);

@@ -275,6 +311,52 @@ typedef enum radio_cell_info_type_1_4 {
    RADIO_CELL_INFO_1_4_NR
 } RADIO_CELL_INFO_TYPE_1_4; /* Since 1.4.1 */

+/* Cast guint8 RadioCellInfo_1_5.cellInfoType to this. */
+typedef enum radio_cell_info_type_1_5 {
+    RADIO_CELL_INFO_1_5_GSM = 0,
+    RADIO_CELL_INFO_1_5_WCDMA,
+    RADIO_CELL_INFO_1_5_TD_SCDMA,
+    RADIO_CELL_INFO_1_5_LTE,
+    RADIO_CELL_INFO_1_5_NR,
+    RADIO_CELL_INFO_1_5_CDMA
+} RADIO_CELL_INFO_TYPE_1_5; /* Since 1.5.0 */
+
+/* Cast guint8 RadioCellIdentity_1_5.cellIdentityType to this. */
+typedef enum radio_cell_identity_type_1_5 {
+    RADIO_CELL_IDENTITY_1_5_NONE = 0,
+    RADIO_CELL_IDENTITY_1_5_GSM,
+    RADIO_CELL_IDENTITY_1_5_WCDMA,
+    RADIO_CELL_IDENTITY_1_5_TD_SCDMA,
+    RADIO_CELL_IDENTITY_1_5_CDMA,
+    RADIO_CELL_IDENTITY_1_5_LTE,
+    RADIO_CELL_IDENTITY_1_5_NR
+} RADIO_CELL_IDENTITY_TYPE_1_5; /* Since 1.5.0 */
+
+/* Valid values of RadioNetworkScanRequest_1_5::type */
+typedef enum radio_network_scan_specifier_1_5_type {
+    RADIO_NETWORK_SCAN_SPECIFIER_1_5_GERAN = 0,
+    RADIO_NETWORK_SCAN_SPECIFIER_1_5_UTRAN,
+    RADIO_NETWORK_SCAN_SPECIFIER_1_5_EUTRAN,
+    RADIO_NETWORK_SCAN_SPECIFIER_1_5_NGRAN
+} RADIO_NETWORK_SCAN_SPECIFIER_1_5_TYPE; /* Since 1.5.2 */
+
+typedef enum radio_frequency_info_type {
+    RADIO_FREQUENCY_INFO_TYPE_RANGE,
+    RADIO_FREQUENCY_INFO_TYPE_CHANNEL_NUMBER,
+} RADIO_FREQUENCY_INFO_TYPE; /* Since 1.5.4 */;
+
+typedef enum radio_frequency_range {
+    /* Indicates the frequency range is below 1GHz. */
+    RADIO_FREQUENCY_RANGE_LOW = 1,
+    /* Indicates the frequency range is between 1GHz and 3GHz. */
+    RADIO_FREQUENCY_RANGE_MID,
+    /* Indicates the frequency range is between 3GHz and 6GHz. */
+    RADIO_FREQUENCY_RANGE_HIGH,
+    /* Indicates the frequency range is above 6GHz (millimeter wave frequency). */
+    RADIO_FREQUENCY_RANGE_MMWAVE,
+} RADIO_FREQUENCY_RANGE; /* Since 1.5.4 */;
+G_STATIC_ASSERT(sizeof(RADIO_FREQUENCY_RANGE) == 4);
+
 typedef enum radio_tech {
    RADIO_TECH_UNKNOWN = 0,
    RADIO_TECH_GPRS,
@@ -295,7 +377,8 @@ typedef enum radio_tech {
    RADIO_TECH_GSM,
    RADIO_TECH_TD_SCDMA,
    RADIO_TECH_IWLAN,
-    RADIO_TECH_LTE_CA
+    RADIO_TECH_LTE_CA,
+    RADIO_TECH_NR /* Since 1.5.4 */
 } RADIO_TECH;
 G_STATIC_ASSERT(sizeof(RADIO_TECH) == 4);

@@ -320,7 +403,8 @@ typedef enum radio_access_family {
    RAF_GSM = (1 << RADIO_TECH_GSM),
    RAF_TD_SCDMA = (1 << RADIO_TECH_TD_SCDMA),
    RAF_IWLAN = (1 << RADIO_TECH_IWLAN),
-    RAF_LTE_CA = (1 << RADIO_TECH_LTE_CA)
+    RAF_LTE_CA = (1 << RADIO_TECH_LTE_CA),
+    RAF_NR = (1 << RADIO_TECH_NR) /* Since 1.5.4 */
 } RADIO_ACCESS_FAMILY;
 G_STATIC_ASSERT(sizeof(RADIO_ACCESS_FAMILY) == 4);

@@ -345,10 +429,12 @@ typedef enum radio_apn_types {
    RADIO_APN_TYPE_IA = 1 << 8,
    RADIO_APN_TYPE_EMERGENCY = 1 << 9,
    RADIO_APN_TYPE_MCX = 1 << 10, /* Since 1.2.5 */
+    RADIO_APN_TYPE_XCAP = 1 << 11, /* Since 1.5.0 */
    RADIO_APN_TYPE_ALL = RADIO_APN_TYPE_DEFAULT | RADIO_APN_TYPE_MMS |
        RADIO_APN_TYPE_SUPL | RADIO_APN_TYPE_DUN | RADIO_APN_TYPE_HIPRI |
        RADIO_APN_TYPE_FOTA | RADIO_APN_TYPE_IMS | RADIO_APN_TYPE_CBS |
-        RADIO_APN_TYPE_IA | RADIO_APN_TYPE_EMERGENCY | RADIO_APN_TYPE_MCX
+        RADIO_APN_TYPE_IA | RADIO_APN_TYPE_EMERGENCY | RADIO_APN_TYPE_MCX |
+        RADIO_APN_TYPE_XCAP
 } RADIO_APN_TYPES;
 G_STATIC_ASSERT(sizeof(RADIO_APN_TYPES) == 4);

@@ -460,16 +546,29 @@ typedef enum radio_data_request_reason {
 } RADIO_DATA_REQUEST_REASON; /* Since 1.2.0 */
 G_STATIC_ASSERT(sizeof(RADIO_DATA_REQUEST_REASON) == 4);

+/* This is AccessNetwork from types.hal */
 typedef enum radio_access_network {
    RADIO_ACCESS_NETWORK_UNKNOWN,
    RADIO_ACCESS_NETWORK_GERAN,
    RADIO_ACCESS_NETWORK_UTRAN,
    RADIO_ACCESS_NETWORK_EUTRAN,
    RADIO_ACCESS_NETWORK_CDMA2000,
-    RADIO_ACCESS_NETWORK_IWLAN
+    RADIO_ACCESS_NETWORK_IWLAN,
+    RADIO_ACCESS_NETWORK_NGRAN /* Since 1.5.0 */
 } RADIO_ACCESS_NETWORK; /* Since 1.2.0 */
 G_STATIC_ASSERT(sizeof(RADIO_ACCESS_NETWORK) == 4);

+/* And this is RadioAccessNetworks (easy to confuse with AccessNetwork) */
+typedef enum radio_access_networks {
+    RADIO_ACCESS_NETWORKS_UNKNOWN,
+    RADIO_ACCESS_NETWORKS_GERAN,
+    RADIO_ACCESS_NETWORKS_UTRAN,
+    RADIO_ACCESS_NETWORKS_EUTRAN,
+    RADIO_ACCESS_NETWORKS_NGRAN,
+    RADIO_ACCESS_NETWORKS_CDMA2000
+} RADIO_ACCESS_NETWORKS; /* Since 1.5.3 */
+G_STATIC_ASSERT(sizeof(RADIO_ACCESS_NETWORKS) == 4);
+
 typedef enum radio_data_profile_type {
    RADIO_DATA_PROFILE_COMMON,
    RADIO_DATA_PROFILE_3GPP,
@@ -477,6 +576,12 @@ typedef enum radio_data_profile_type {
 } RADIO_DATA_PROFILE_TYPE; /* Since 1.2.5 */
 G_STATIC_ASSERT(sizeof(RADIO_DATA_PROFILE_TYPE) == 4);

+typedef enum radio_tech_family {
+    RADIO_TECH_FAMILY_3GPP,
+    RADIO_TECH_FAMILY_3GPP2
+} RADIO_TECH_FAMILY; /* Since 1.4.9 */
+G_STATIC_ASSERT(sizeof(RADIO_TECH_FAMILY) == 4);
+
 typedef enum radio_pdp_protocol_type {
    RADIO_PDP_PROTOCOL_UNKNOWN = -1,
    RADIO_PDP_PROTOCOL_IP,
@@ -521,6 +626,12 @@ typedef enum radio_scan_status {
 } RADIO_SCAN_STATUS; /* Since 1.2.5 */
 G_STATIC_ASSERT(sizeof(RADIO_SCAN_STATUS) == 4);

+typedef enum radio_scan_type {
+    RADIO_SCAN_ONE_SHOT,
+    RADIO_SCAN_PERIODIC
+} RADIO_SCAN_TYPE; /* Since 1.5.2 */
+G_STATIC_ASSERT(sizeof(RADIO_SCAN_TYPE) == 4);
+
 typedef enum radio_uicc_sub_act {
    RADIO_UICC_SUB_DEACTIVATE,
    RADIO_UICC_SUB_ACTIVATE
@@ -617,6 +728,171 @@ typedef enum radio_clir {
 } RADIO_CLIR; /* Since 1.4.3 */
 G_STATIC_ASSERT(sizeof(RADIO_CLIR) == 4);

+typedef enum radio_geran_band {
+    RADIO_GERAN_BAND_T380 = 1,
+    RADIO_GERAN_BAND_T410 = 2,
+    RADIO_GERAN_BAND_450 = 3,
+    RADIO_GERAN_BAND_480 = 4,
+    RADIO_GERAN_BAND_710 = 5,
+    RADIO_GERAN_BAND_750 = 6,
+    RADIO_GERAN_BAND_T810 = 7,
+    RADIO_GERAN_BAND_850 = 8,
+    RADIO_GERAN_BAND_P900 = 9,
+    RADIO_GERAN_BAND_E900 = 10,
+    RADIO_GERAN_BAND_R900 = 11,
+    RADIO_GERAN_BAND_DCS1800 = 12,
+    RADIO_GERAN_BAND_PCS1900 = 13,
+    RADIO_GERAN_BAND_ER900 = 14
+} RADIO_GERAN_BAND; /* Since 1.5.2 */
+G_STATIC_ASSERT(sizeof(RADIO_GERAN_BAND) == 4);
+
+typedef enum radio_utran_band {
+    RADIO_UTRAN_BAND_1 = 1,
+    RADIO_UTRAN_BAND_2 = 2,
+    RADIO_UTRAN_BAND_3 = 3,
+    RADIO_UTRAN_BAND_4 = 4,
+    RADIO_UTRAN_BAND_5 = 5,
+    RADIO_UTRAN_BAND_6 = 6,
+    RADIO_UTRAN_BAND_7 = 7,
+    RADIO_UTRAN_BAND_8 = 8,
+    RADIO_UTRAN_BAND_9 = 9,
+    RADIO_UTRAN_BAND_10 = 10,
+    RADIO_UTRAN_BAND_11 = 11,
+    RADIO_UTRAN_BAND_12 = 12,
+    RADIO_UTRAN_BAND_13 = 13,
+    RADIO_UTRAN_BAND_14 = 14,
+    RADIO_UTRAN_BAND_19 = 19,
+    RADIO_UTRAN_BAND_20 = 20,
+    RADIO_UTRAN_BAND_21 = 21,
+    RADIO_UTRAN_BAND_22 = 22,
+    RADIO_UTRAN_BAND_25 = 25,
+    RADIO_UTRAN_BAND_26 = 26,
+    RADIO_UTRAN_BAND_A = 101, /* Since IRadio 1.5 */
+    RADIO_UTRAN_BAND_B = 102, /* Since IRadio 1.5 */
+    RADIO_UTRAN_BAND_C = 103, /* Since IRadio 1.5 */
+    RADIO_UTRAN_BAND_D = 104, /* Since IRadio 1.5 */
+    RADIO_UTRAN_BAND_E = 105, /* Since IRadio 1.5 */
+    RADIO_UTRAN_BAND_F = 106  /* Since IRadio 1.5 */
+} RADIO_UTRAN_BAND; /* Since 1.5.2 */
+G_STATIC_ASSERT(sizeof(RADIO_UTRAN_BAND) == 4);
+
+typedef enum radio_eutran_band {
+    RADIO_EUTRAN_BAND_1 = 1,
+    RADIO_EUTRAN_BAND_2 = 2,
+    RADIO_EUTRAN_BAND_3 = 3,
+    RADIO_EUTRAN_BAND_4 = 4,
+    RADIO_EUTRAN_BAND_5 = 5,
+    RADIO_EUTRAN_BAND_6 = 6,
+    RADIO_EUTRAN_BAND_7 = 7,
+    RADIO_EUTRAN_BAND_8 = 8,
+    RADIO_EUTRAN_BAND_9 = 9,
+    RADIO_EUTRAN_BAND_10 = 10,
+    RADIO_EUTRAN_BAND_11 = 11,
+    RADIO_EUTRAN_BAND_12 = 12,
+    RADIO_EUTRAN_BAND_13 = 13,
+    RADIO_EUTRAN_BAND_14 = 14,
+    RADIO_EUTRAN_BAND_17 = 17,
+    RADIO_EUTRAN_BAND_18 = 18,
+    RADIO_EUTRAN_BAND_19 = 19,
+    RADIO_EUTRAN_BAND_20 = 20,
+    RADIO_EUTRAN_BAND_21 = 21,
+    RADIO_EUTRAN_BAND_22 = 22,
+    RADIO_EUTRAN_BAND_23 = 23,
+    RADIO_EUTRAN_BAND_24 = 24,
+    RADIO_EUTRAN_BAND_25 = 25,
+    RADIO_EUTRAN_BAND_26 = 26,
+    RADIO_EUTRAN_BAND_27 = 27,
+    RADIO_EUTRAN_BAND_28 = 28,
+    RADIO_EUTRAN_BAND_30 = 30,
+    RADIO_EUTRAN_BAND_31 = 31,
+    RADIO_EUTRAN_BAND_33 = 33,
+    RADIO_EUTRAN_BAND_34 = 34,
+    RADIO_EUTRAN_BAND_35 = 35,
+    RADIO_EUTRAN_BAND_36 = 36,
+    RADIO_EUTRAN_BAND_37 = 37,
+    RADIO_EUTRAN_BAND_38 = 38,
+    RADIO_EUTRAN_BAND_39 = 39,
+    RADIO_EUTRAN_BAND_40 = 40,
+    RADIO_EUTRAN_BAND_41 = 41,
+    RADIO_EUTRAN_BAND_42 = 42,
+    RADIO_EUTRAN_BAND_43 = 43,
+    RADIO_EUTRAN_BAND_44 = 44,
+    RADIO_EUTRAN_BAND_45 = 45,
+    RADIO_EUTRAN_BAND_46 = 46,
+    RADIO_EUTRAN_BAND_47 = 47,
+    RADIO_EUTRAN_BAND_48 = 48,
+    RADIO_EUTRAN_BAND_49 = 49, /* Since IRadio 1.5 */
+    RADIO_EUTRAN_BAND_50 = 50, /* Since IRadio 1.5 */
+    RADIO_EUTRAN_BAND_51 = 51, /* Since IRadio 1.5 */
+    RADIO_EUTRAN_BAND_52 = 52, /* Since IRadio 1.5 */
+    RADIO_EUTRAN_BAND_53 = 53, /* Since IRadio 1.5 */
+    RADIO_EUTRAN_BAND_65 = 65,
+    RADIO_EUTRAN_BAND_66 = 66,
+    RADIO_EUTRAN_BAND_68 = 68,
+    RADIO_EUTRAN_BAND_70 = 70,
+    RADIO_EUTRAN_BAND_71 = 71, /* Since IRadio 1.5 */
+    RADIO_EUTRAN_BAND_72 = 72, /* Since IRadio 1.5 */
+    RADIO_EUTRAN_BAND_73 = 73, /* Since IRadio 1.5 */
+    RADIO_EUTRAN_BAND_74 = 74, /* Since IRadio 1.5 */
+    RADIO_EUTRAN_BAND_85 = 85, /* Since IRadio 1.5 */
+    RADIO_EUTRAN_BAND_87 = 87, /* Since IRadio 1.5 */
+    RADIO_EUTRAN_BAND_88 = 88  /* Since IRadio 1.5 */
+} RADIO_EUTRAN_BAND; /* Since 1.5.2 */
+G_STATIC_ASSERT(sizeof(RADIO_EUTRAN_BAND) == 4);
+
+typedef enum radio_ngran_band {
+    RADIO_NGRAN_BAND_1 = 1,
+    RADIO_NGRAN_BAND_2 = 2,
+    RADIO_NGRAN_BAND_3 = 3,
+    RADIO_NGRAN_BAND_5 = 5,
+    RADIO_NGRAN_BAND_7 = 7,
+    RADIO_NGRAN_BAND_8 = 8,
+    RADIO_NGRAN_BAND_12 = 12,
+    RADIO_NGRAN_BAND_14 = 14,
+    RADIO_NGRAN_BAND_18 = 18,
+    RADIO_NGRAN_BAND_20 = 20,
+    RADIO_NGRAN_BAND_25 = 25,
+    RADIO_NGRAN_BAND_28 = 28,
+    RADIO_NGRAN_BAND_29 = 29,
+    RADIO_NGRAN_BAND_30 = 30,
+    RADIO_NGRAN_BAND_34 = 34,
+    RADIO_NGRAN_BAND_38 = 38,
+    RADIO_NGRAN_BAND_39 = 39,
+    RADIO_NGRAN_BAND_40 = 40,
+    RADIO_NGRAN_BAND_41 = 41,
+    RADIO_NGRAN_BAND_48 = 48,
+    RADIO_NGRAN_BAND_50 = 50,
+    RADIO_NGRAN_BAND_51 = 51,
+    RADIO_NGRAN_BAND_65 = 65,
+    RADIO_NGRAN_BAND_66 = 66,
+    RADIO_NGRAN_BAND_70 = 70,
+    RADIO_NGRAN_BAND_71 = 71,
+    RADIO_NGRAN_BAND_74 = 74,
+    RADIO_NGRAN_BAND_75 = 75,
+    RADIO_NGRAN_BAND_76 = 76,
+    RADIO_NGRAN_BAND_77 = 77,
+    RADIO_NGRAN_BAND_78 = 78,
+    RADIO_NGRAN_BAND_79 = 79,
+    RADIO_NGRAN_BAND_80 = 80,
+    RADIO_NGRAN_BAND_81 = 81,
+    RADIO_NGRAN_BAND_82 = 82,
+    RADIO_NGRAN_BAND_83 = 83,
+    RADIO_NGRAN_BAND_84 = 84,
+    RADIO_NGRAN_BAND_86 = 86,
+    RADIO_NGRAN_BAND_89 = 89,
+    RADIO_NGRAN_BAND_90 = 90,
+    RADIO_NGRAN_BAND_91 = 91,
+    RADIO_NGRAN_BAND_92 = 92,
+    RADIO_NGRAN_BAND_93 = 93,
+    RADIO_NGRAN_BAND_94 = 94,
+    RADIO_NGRAN_BAND_95 = 95,
+    RADIO_NGRAN_BAND_257 = 257,
+    RADIO_NGRAN_BAND_258 = 258,
+    RADIO_NGRAN_BAND_260 = 260,
+    RADIO_NGRAN_BAND_261 = 261
+} RADIO_NGRAN_BAND; /* Since 1.5.2 */
+G_STATIC_ASSERT(sizeof(RADIO_NGRAN_BAND) == 4);
+
 typedef enum radio_last_call_fail_cause {
    RADIO_LAST_CALL_FAIL_NONE = 0,
    RADIO_LAST_CALL_FAIL_UNOBTAINABLE_NUMBER = 1,
@@ -1093,6 +1369,12 @@ typedef struct radio_card_status_1_4 {
 } RADIO_ALIGNED(8) RadioCardStatus_1_4; /* Since 1.4.0 */
 G_STATIC_ASSERT(sizeof(RadioCardStatus_1_4) == 96);

+typedef struct radio_card_status_1_5 {
+    RadioCardStatus_1_4 base RADIO_ALIGNED(8);
+    GBinderHidlVec applications RADIO_ALIGNED(8);
+} RADIO_ALIGNED(8) RadioCardStatus_1_5; /* Since 1.5.0 */
+G_STATIC_ASSERT(sizeof(RadioCardStatus_1_5) == 112);
+
 typedef struct radio_app_status {
    RADIO_APP_TYPE appType RADIO_ALIGNED(4);
    RADIO_APP_STATE appState RADIO_ALIGNED(4);
@@ -1105,6 +1387,12 @@ typedef struct radio_app_status {
 } RADIO_ALIGNED(8) RadioAppStatus;
 G_STATIC_ASSERT(sizeof(RadioAppStatus) == 64);

+typedef struct radio_app_status_1_5 {
+    RadioAppStatus base RADIO_ALIGNED(8);
+    RADIO_PERSO_SUBSTATE persoSubstate RADIO_ALIGNED(4);
+} RADIO_ALIGNED(8) RadioAppStatus_1_5; /* Since 1.5.5 */
+G_STATIC_ASSERT(sizeof(RadioAppStatus_1_5) == 72);
+
 typedef struct radio_uus_info {
    gint32 uusType RADIO_ALIGNED(4);
    gint32 uusDcs RADIO_ALIGNED(4);
@@ -1198,6 +1486,28 @@ typedef struct radio_data_profile_1_4 {
 } RADIO_ALIGNED(8) RadioDataProfile_1_4; /* Since 1.2.5 */
 G_STATIC_ASSERT(sizeof(RadioDataProfile_1_4) == 112);

+typedef struct radio_data_profile_1_5 {
+    RADIO_DATA_PROFILE_ID profileId RADIO_ALIGNED(4);
+    GBinderHidlString apn RADIO_ALIGNED(8);
+    RADIO_PDP_PROTOCOL_TYPE protocol RADIO_ALIGNED(4);
+    RADIO_PDP_PROTOCOL_TYPE roamingProtocol RADIO_ALIGNED(4);
+    RADIO_APN_AUTH_TYPE authType RADIO_ALIGNED(4);
+    GBinderHidlString user RADIO_ALIGNED(8);
+    GBinderHidlString password RADIO_ALIGNED(8);
+    RADIO_DATA_PROFILE_TYPE type RADIO_ALIGNED(4);
+    gint32 maxConnsTime RADIO_ALIGNED(4);
+    gint32 maxConns RADIO_ALIGNED(4);
+    gint32 waitTime RADIO_ALIGNED(4);
+    guint8 enabled RADIO_ALIGNED(1);
+    RADIO_APN_TYPES supportedApnTypesBitmap RADIO_ALIGNED(4);
+    RADIO_ACCESS_FAMILY bearerBitmap RADIO_ALIGNED(4);
+    gint32 mtuV4 RADIO_ALIGNED(4);
+    gint32 mtuV6 RADIO_ALIGNED(4);
+    guint8 preferred RADIO_ALIGNED(1);
+    guint8 persistent RADIO_ALIGNED(1);
+} RADIO_ALIGNED(8) RadioDataProfile_1_5; /* Since 1.5.0 */
+G_STATIC_ASSERT(sizeof(RadioDataProfile_1_5) == 112);
+
 typedef struct radio_data_call {
    RADIO_DATA_CALL_FAIL_CAUSE status RADIO_ALIGNED(4);
    gint32 suggestedRetryTime RADIO_ALIGNED(4);
@@ -1228,6 +1538,30 @@ typedef struct radio_data_call_1_4 {
 } RADIO_ALIGNED(8) RadioDataCall_1_4; /* Since 1.2.5 */
 G_STATIC_ASSERT(sizeof(RadioDataCall_1_4) == 112);

+typedef struct radio_link_address {
+    GBinderHidlString address RADIO_ALIGNED(8);
+    gint32 properties RADIO_ALIGNED(4);
+    guint64 deprecationTime RADIO_ALIGNED(8);
+    guint64 expirationTime RADIO_ALIGNED(8);
+} RADIO_ALIGNED(8) RadioLinkAddress; /* Since 1.5.0 */
+G_STATIC_ASSERT(sizeof(RadioLinkAddress) == 40);
+
+typedef struct radio_data_call_1_5 {
+    RADIO_DATA_CALL_FAIL_CAUSE cause RADIO_ALIGNED(4);
+    gint32 suggestedRetryTime RADIO_ALIGNED(4);
+    gint32 cid RADIO_ALIGNED(4);
+    RADIO_DATA_CALL_ACTIVE_STATUS active RADIO_ALIGNED(4);
+    RADIO_PDP_PROTOCOL_TYPE type RADIO_ALIGNED(4);
+    GBinderHidlString ifname RADIO_ALIGNED(8);
+    GBinderHidlVec addresses RADIO_ALIGNED(8); /* vec<RadioLinkAddress> */
+    GBinderHidlVec dnses RADIO_ALIGNED(8);     /* vec<GBinderHidlString> */
+    GBinderHidlVec gateways RADIO_ALIGNED(8);  /* vec<GBinderHidlString> */
+    GBinderHidlVec pcscf RADIO_ALIGNED(8);     /* vec<GBinderHidlString> */
+    gint32 mtuV4 RADIO_ALIGNED(4);
+    gint32 mtuV6 RADIO_ALIGNED(4);
+} RADIO_ALIGNED(8) RadioDataCall_1_5; /* Since 1.5.0 */
+G_STATIC_ASSERT(sizeof(RadioDataCall_1_5) == 112);
+
 typedef struct radio_sms_write_args {
    gint32 status RADIO_ALIGNED(4);
    GBinderHidlString pdu RADIO_ALIGNED(8);
@@ -1248,6 +1582,15 @@ typedef struct radio_send_sms_result {
 } RADIO_ALIGNED(8) RadioSendSmsResult;
 G_STATIC_ASSERT(sizeof(RadioSendSmsResult) == 32);

+typedef struct radio_ims_sms_message {
+    RADIO_TECH_FAMILY tech RADIO_ALIGNED(4);
+    gboolean retry RADIO_ALIGNED(1);
+    gint32 messageRef RADIO_ALIGNED(4);
+    GBinderHidlVec cdmaMessage RADIO_ALIGNED(8); /* vec<CdmaSmsMessage> */
+    GBinderHidlVec gsmMessage RADIO_ALIGNED(8);  /* vec<RadioGsmSmsMessage> */
+} RADIO_ALIGNED(8) RadioImsSmsMessage; /* Since 1.4.9 */
+G_STATIC_ASSERT(sizeof(RadioImsSmsMessage) == 48);
+
 typedef struct radio_icc_io {
    gint32 command RADIO_ALIGNED(4);
    gint32 fileId RADIO_ALIGNED(4);
@@ -1339,11 +1682,11 @@ typedef struct radio_cell_info_1_2 {
    guint8 registered RADIO_ALIGNED(1);
    gint32 timeStampType RADIO_ALIGNED(4);
    guint64 timeStamp RADIO_ALIGNED(8);
-    GBinderHidlVec gsm RADIO_ALIGNED(8);     /* vec<RadioCellInfoGsm> */
-    GBinderHidlVec cdma RADIO_ALIGNED(8);    /* vec<RadioCellInfoCdma> */
-    GBinderHidlVec lte RADIO_ALIGNED(8);     /* vec<RadioCellInfoLte> */
-    GBinderHidlVec wcdma RADIO_ALIGNED(8);   /* vec<RadioCellInfoWcdma> */
-    GBinderHidlVec tdscdma RADIO_ALIGNED(8); /* vec<RadioCellInfoTdscdma> */
+    GBinderHidlVec gsm RADIO_ALIGNED(8);     /* vec<RadioCellInfoGsm_1_2> */
+    GBinderHidlVec cdma RADIO_ALIGNED(8);    /* vec<RadioCellInfoCdma_1_2> */
+    GBinderHidlVec lte RADIO_ALIGNED(8);     /* vec<RadioCellInfoLte_1_2> */
+    GBinderHidlVec wcdma RADIO_ALIGNED(8);   /* vec<RadioCellInfoWcdma_1_2> */
+    GBinderHidlVec tdscdma RADIO_ALIGNED(8); /* vec<RadioCellInfoTdscdma_1_2> */
    RADIO_CELL_CONNECTION_STATUS connectionStatus RADIO_ALIGNED(4);
 } RADIO_ALIGNED(8) RadioCellInfo_1_2; /* Since 1.2.0 */
 G_STATIC_ASSERT(sizeof(RadioCellInfo_1_2) == 112);
@@ -1370,6 +1713,12 @@ typedef struct radio_cell_identity_gsm_1_2 {
 } RADIO_ALIGNED(8) RadioCellIdentityGsm_1_2; /* Since 1.2.3 */
 G_STATIC_ASSERT(sizeof(RadioCellIdentityGsm_1_2) == 80);

+typedef struct radio_cell_identity_gsm_1_5 {
+    RadioCellIdentityGsm_1_2 base RADIO_ALIGNED(8);
+    GBinderHidlVec additionalPlmns RADIO_ALIGNED(8); /* vec<GBinderHidlString> */
+} RADIO_ALIGNED(8) RadioCellIdentityGsm_1_5; /* Since 1.5.0 */
+G_STATIC_ASSERT(sizeof(RadioCellIdentityGsm_1_5) == 96);
+
 typedef struct radio_cell_identity_wcdma {
    GBinderHidlString mcc RADIO_ALIGNED(8);
    GBinderHidlString mnc RADIO_ALIGNED(8);
@@ -1386,6 +1735,23 @@ typedef struct radio_cell_identity_wcdma_1_2 {
 } RADIO_ALIGNED(8) RadioCellIdentityWcdma_1_2; /* Since 1.2.3 */
 G_STATIC_ASSERT(sizeof(RadioCellIdentityWcdma_1_2) == 80);

+typedef struct radio_closed_subscriber_group_info {
+    gboolean csgIndication RADIO_ALIGNED(1);
+    GBinderHidlString homeNodebName RADIO_ALIGNED(8);
+    gint32 csgIdentity RADIO_ALIGNED(4);
+} RADIO_ALIGNED(8) RadioClosedSubscriberGroupInfo; /* Since 1.5.0 */
+G_STATIC_ASSERT(sizeof(RadioClosedSubscriberGroupInfo) == 32);
+
+typedef struct radio_cell_identity_wcdma_1_5 {
+    RadioCellIdentityWcdma_1_2 base RADIO_ALIGNED(8);
+    GBinderHidlVec additionalPlmns RADIO_ALIGNED(8); /* vec<GBinderHidlString> */
+    guint8 csgInfoAvailable RADIO_ALIGNED(1);
+    union {
+        RadioClosedSubscriberGroupInfo gsm RADIO_ALIGNED(8);
+    } optionalCsgInfo RADIO_ALIGNED(8);
+} RADIO_ALIGNED(8) RadioCellIdentityWcdma_1_5; /* Since 1.5.0 */
+G_STATIC_ASSERT(sizeof(RadioCellIdentityWcdma_1_5) == 136);
+
 typedef struct radio_cell_identity_cdma {
    gint32 networkId RADIO_ALIGNED(4);
    gint32 systemId RADIO_ALIGNED(4);
@@ -1418,6 +1784,17 @@ typedef struct radio_cell_identity_lte_1_2 {
 } RADIO_ALIGNED(8) RadioCellIdentityLte_1_2; /* Since 1.2.3 */
 G_STATIC_ASSERT(sizeof(RadioCellIdentityLte_1_2) == 88);

+typedef struct radio_cell_identity_lte_1_5 {
+    RadioCellIdentityLte_1_2 base RADIO_ALIGNED(8);
+    GBinderHidlVec additionalPlmns RADIO_ALIGNED(8); /* vec<GBinderHidlString> */
+    guint8 csgInfoAvailable RADIO_ALIGNED(1);
+    union {
+        RadioClosedSubscriberGroupInfo gsm RADIO_ALIGNED(8);
+    } optionalCsgInfo RADIO_ALIGNED(8);
+    GBinderHidlVec bands RADIO_ALIGNED(8); /* vec<EutranBands> */
+} RADIO_ALIGNED(8) RadioCellIdentityLte_1_5; /* Since 1.5.0 */
+G_STATIC_ASSERT(sizeof(RadioCellIdentityLte_1_5) == 160);
+
 typedef struct radio_cell_identity_tdscdma {
    GBinderHidlString mcc RADIO_ALIGNED(8);
    GBinderHidlString mnc RADIO_ALIGNED(8);
@@ -1434,6 +1811,16 @@ typedef struct radio_cell_identity_tdscdma_1_2 {
 } RADIO_ALIGNED(8) RadioCellIdentityTdscdma_1_2; /* Since 1.2.3 */
 G_STATIC_ASSERT(sizeof(RadioCellIdentityTdscdma_1_2) == 88);

+typedef struct radio_cell_identity_tdscdma_1_5 {
+    RadioCellIdentityTdscdma_1_2 base RADIO_ALIGNED(8);
+    GBinderHidlVec additionalPlmns RADIO_ALIGNED(8); /* vec<GBinderHidlString> */
+    guint8 csgInfoAvailable RADIO_ALIGNED(1);
+    union {
+        RadioClosedSubscriberGroupInfo gsm RADIO_ALIGNED(8);
+    } optionalCsgInfo RADIO_ALIGNED(8);
+} RADIO_ALIGNED(8) RadioCellIdentityTdscdma_1_5; /* Since 1.5.0 */
+G_STATIC_ASSERT(sizeof(RadioCellIdentityTdscdma_1_5) == 144);
+
 typedef struct radio_cell_identity_nr {
    GBinderHidlString mcc RADIO_ALIGNED(8);
    GBinderHidlString mnc RADIO_ALIGNED(8);
@@ -1445,6 +1832,26 @@ typedef struct radio_cell_identity_nr {
 } RADIO_ALIGNED(8) RadioCellIdentityNr; /* Since 1.2.5 */
 G_STATIC_ASSERT(sizeof(RadioCellIdentityNr) == 88);

+typedef struct radio_cell_identity_nr_1_5 {
+    RadioCellIdentityNr base RADIO_ALIGNED(8);
+    GBinderHidlVec additionalPlmns RADIO_ALIGNED(8); /* vec<GBinderHidlString> */
+    GBinderHidlVec bands RADIO_ALIGNED(8); /* vec<NgranBands> */
+} RADIO_ALIGNED(8) RadioCellIdentityNr_1_5; /* Since 1.5.0 */
+G_STATIC_ASSERT(sizeof(RadioCellIdentityNr_1_5) == 120);
+
+typedef struct radio_cell_identity_1_5 {
+    guint8 cellIdentityType RADIO_ALIGNED(1); /* RADIO_CELL_IDENTITY_TYPE_1_5 */
+    union {
+        RadioCellIdentityGsm_1_5 gsm RADIO_ALIGNED(8);
+        RadioCellIdentityWcdma_1_5 wcdma RADIO_ALIGNED(8);
+        RadioCellIdentityTdscdma_1_5 tdscdma RADIO_ALIGNED(8);
+        RadioCellIdentityCdma_1_2 cdma RADIO_ALIGNED(8);
+        RadioCellIdentityLte_1_5 lte RADIO_ALIGNED(8);
+        RadioCellIdentityNr_1_5 nr RADIO_ALIGNED(8);
+    } RADIO_ALIGNED(8) identity;
+} RADIO_ALIGNED(8) RadioCellIdentity_1_5; /* Since 1.5.0 */
+G_STATIC_ASSERT(sizeof(RadioCellIdentity_1_5) == 168);
+
 typedef struct radio_voice_reg_state_result {
    RADIO_REG_STATE regState RADIO_ALIGNED(4);
    RADIO_TECH rat RADIO_ALIGNED(4);
@@ -1488,10 +1895,17 @@ typedef struct radio_data_reg_state_result_1_2 {
 G_STATIC_ASSERT(sizeof(RadioDataRegStateResult_1_2) == 104);

 typedef struct radio_data_reg_lte_vops_info {
-    guint32 isVopsSupported RADIO_ALIGNED(4);
-    guint32 isEmcBearerSupported RADIO_ALIGNED(4);
-} RADIO_ALIGNED(4) RadioDataRegLteVopsInfo;  /* Since 1.4.0 */
-G_STATIC_ASSERT(sizeof(RadioDataRegLteVopsInfo) == 8);
+    guint8 isVopsSupported RADIO_ALIGNED(1);
+    guint8 isEmcBearerSupported RADIO_ALIGNED(1);
+} RADIO_ALIGNED(1) RadioDataRegLteVopsInfo;  /* Since 1.4.12 */
+G_STATIC_ASSERT(sizeof(RadioDataRegLteVopsInfo) == 2);
+
+typedef struct radio_data_reg_nr_inicators {
+    guint8 isEndcAvailable RADIO_ALIGNED(1);
+    guint8 isDcNrRestricted RADIO_ALIGNED(1);
+    guint8 isNrAvailable RADIO_ALIGNED(1);
+} RADIO_ALIGNED(1) RadioDataRegNrIndicators;  /* Since 1.4.12 */
+G_STATIC_ASSERT(sizeof(RadioDataRegNrIndicators) == 3);

 typedef struct radio_data_reg_state_result_1_4 {
    RADIO_REG_STATE regState RADIO_ALIGNED(4);
@@ -1499,10 +1913,40 @@ typedef struct radio_data_reg_state_result_1_4 {
    gint32 reasonDataDenied RADIO_ALIGNED(4);
    gint32 maxDataCalls RADIO_ALIGNED(4);
    RadioCellIdentity_1_2 cellIdentity RADIO_ALIGNED(8);
-    RadioDataRegLteVopsInfo lteVopsInfo RADIO_ALIGNED(4);
-} RADIO_ALIGNED(8) RadioDataRegStateResult_1_4;  /* Since 1.4.0 */
+    guint8 lteVopsInfoValid RADIO_ALIGNED(1);
+    RadioDataRegLteVopsInfo lteVopsInfo RADIO_ALIGNED(1);
+    RadioDataRegNrIndicators nrIndicators RADIO_ALIGNED(1);
+} RADIO_ALIGNED(8) RadioDataRegStateResult_1_4;  /* Since 1.4.12 */
 G_STATIC_ASSERT(sizeof(RadioDataRegStateResult_1_4) == 112);

+typedef struct radio_reg_cdma2000_registration_info {
+    guint8 cssSupported RADIO_ALIGNED(1);
+    gint32 roamingIndicator RADIO_ALIGNED(4);
+    gint32 systemIsInPrl RADIO_ALIGNED(4);
+    gint32 defaultRoamingIndicator RADIO_ALIGNED(4);
+} RADIO_ALIGNED(4) RadioRegCdma2000RegistrationInfo; /* Since 1.5.0 */
+G_STATIC_ASSERT(sizeof(RadioRegCdma2000RegistrationInfo) == 16);
+
+typedef struct radio_reg_eutran_registration_info {
+    RadioDataRegLteVopsInfo lteVopsInfo RADIO_ALIGNED(1);
+    RadioDataRegNrIndicators nrIndicators RADIO_ALIGNED(1);
+} RADIO_ALIGNED(1) RadioRegEutranRegistrationInfo; /* Since 1.5.0 */
+G_STATIC_ASSERT(sizeof(RadioRegEutranRegistrationInfo) == 5);
+
+typedef struct radio_reg_state_result_1_5 {
+    RADIO_REG_STATE regState RADIO_ALIGNED(4);
+    RADIO_TECH rat RADIO_ALIGNED(4);
+    gint32 reasonDataDenied RADIO_ALIGNED(4);
+    RadioCellIdentity_1_5 cellIdentity RADIO_ALIGNED(8);
+    GBinderHidlString registeredPlmn RADIO_ALIGNED(8);
+    guint8 accessTechnologySpecificInfoType RADIO_ALIGNED(1); /* RADIO_REG_ACCESS_TECHNOLOGY_SPECIFIC_INFO_TYPE */
+    union {
+        RadioRegCdma2000RegistrationInfo cdmaInfo RADIO_ALIGNED(4);
+        RadioRegEutranRegistrationInfo eutranInfo RADIO_ALIGNED(1);
+    } accessTechnologySpecificInfo RADIO_ALIGNED(4);
+} RADIO_ALIGNED(8) RadioRegStateResult_1_5; /* Since 1.5.0 */
+G_STATIC_ASSERT(sizeof(RadioRegStateResult_1_5) == 224);
+
 typedef struct radio_signal_strength_gsm {
    guint32 signalStrength RADIO_ALIGNED(4);
    guint32 bitErrorRate RADIO_ALIGNED(4);
@@ -1668,13 +2112,13 @@ G_STATIC_ASSERT(sizeof(RadioCellInfoTdscdma_1_2) == 104);

 typedef struct radio_cell_info_nr {
    RadioSignalStrengthNr signalStrength RADIO_ALIGNED(4);
-    RadioCellIdentityNr cellidentity RADIO_ALIGNED(8);
+    RadioCellIdentityNr cellIdentity RADIO_ALIGNED(8);
 } RADIO_ALIGNED(8) RadioCellInfoNr; /* Since 1.2.5 */
 G_STATIC_ASSERT(sizeof(RadioCellInfoNr) == 112);

 typedef struct radio_cell_info_1_4 {
    guint8 registered RADIO_ALIGNED(1);
-    guint32 connectionStatus RADIO_ALIGNED(4);
+    RADIO_CELL_CONNECTION_STATUS connectionStatus RADIO_ALIGNED(4);
    guint8 cellInfoType RADIO_ALIGNED(1); /* RADIO_CELL_INFO_TYPE_1_4 */
    union {
        RadioCellInfoGsm_1_2 gsm RADIO_ALIGNED(8);
@@ -1687,6 +2131,77 @@ typedef struct radio_cell_info_1_4 {
 } RADIO_ALIGNED(8) RadioCellInfo_1_4; /* Since 1.2.5 */
 G_STATIC_ASSERT(sizeof(RadioCellInfo_1_4) == 136);

+typedef struct radio_cell_info_gsm_1_5 {
+    RadioCellIdentityGsm_1_5 cellIdentityGsm RADIO_ALIGNED(8);
+    RadioSignalStrengthGsm signalStrengthGsm RADIO_ALIGNED(4);
+} RADIO_ALIGNED(8) RadioCellInfoGsm_1_5; /* Since 1.5.0 */
+G_STATIC_ASSERT(sizeof(RadioCellInfoGsm_1_5) == 112);
+
+typedef struct radio_cell_info_wcdma_1_5 {
+    RadioCellIdentityWcdma_1_5 cellIdentityWcdma RADIO_ALIGNED(8);
+    RadioSignalStrengthWcdma_1_2 signalStrengthWcdma RADIO_ALIGNED(4);
+} RADIO_ALIGNED(8) RadioCellInfoWcdma_1_5; /* Since 1.5.0 */
+G_STATIC_ASSERT(sizeof(RadioCellInfoWcdma_1_5) == 152);
+
+typedef struct radio_cell_info_lte_1_5 {
+    RadioCellIdentityLte_1_5 cellIdentityLte RADIO_ALIGNED(8);
+    RadioSignalStrengthLte signalStrengthLte RADIO_ALIGNED(4);
+} RADIO_ALIGNED(8) RadioCellInfoLte_1_5; /* Since 1.5.0 */
+G_STATIC_ASSERT(sizeof(RadioCellInfoLte_1_5) == 184);
+
+typedef struct radio_cell_info_tdscdma_1_5 {
+    RadioCellIdentityTdscdma_1_5 cellIdentityTdscdma RADIO_ALIGNED(8);
+    RadioSignalStrengthTdScdma_1_2 signalStrengthTdscdma RADIO_ALIGNED(4);
+} RADIO_ALIGNED(8) RadioCellInfoTdscdma_1_5; /* Since 1.5.0 */
+G_STATIC_ASSERT(sizeof(RadioCellInfoTdscdma_1_5) == 160);
+
+typedef struct radio_cell_info_nr_1_5 {
+    RadioCellIdentityNr_1_5 cellIdentityNr RADIO_ALIGNED(8);
+    RadioSignalStrengthNr signalStrengthNr RADIO_ALIGNED(4);
+} RADIO_ALIGNED(8) RadioCellInfoNr_1_5; /* Since 1.5.0 */
+G_STATIC_ASSERT(sizeof(RadioCellInfoNr_1_5) == 144);
+
+typedef struct radio_cell_info_1_5 {
+    guint8 registered RADIO_ALIGNED(1);
+    gint32 timeStampType RADIO_ALIGNED(4);
+    guint64 timeStamp RADIO_ALIGNED(8);
+    RADIO_CELL_CONNECTION_STATUS connectionStatus RADIO_ALIGNED(4);
+    guint8 cellInfoType RADIO_ALIGNED(8); /* RADIO_CELL_INFO_TYPE_1_5 */
+    union {
+        RadioCellInfoGsm_1_5 gsm RADIO_ALIGNED(8);
+        RadioCellInfoWcdma_1_5 wcdma RADIO_ALIGNED(8);
+        RadioCellInfoTdscdma_1_5 tdscdma RADIO_ALIGNED(8);
+        RadioCellInfoLte_1_5 lte RADIO_ALIGNED(8);
+        RadioCellInfoNr_1_5 nr RADIO_ALIGNED(8);
+        RadioCellInfoCdma_1_2 cdma RADIO_ALIGNED(8);
+    } info RADIO_ALIGNED(8);
+} RADIO_ALIGNED(8) RadioCellInfo_1_5; /* Since 1.5.0 */
+G_STATIC_ASSERT(sizeof(RadioCellInfo_1_5) == 216);
+
+typedef struct radio_physical_channel_config {
+    RADIO_CELL_CONNECTION_STATUS connectionStatus RADIO_ALIGNED(4);
+    gint32 cellBandwidthDownlink RADIO_ALIGNED(4);
+} RADIO_ALIGNED(4) RadioPhysicalChannelConfig; /* Since 1.5.4 */
+G_STATIC_ASSERT(sizeof(RadioPhysicalChannelConfig) == 8);
+
+typedef struct radio_frequency_info {
+    guint8 frequencyInfoType RADIO_ALIGNED(1); /* RADIO_FREQUENCY_INFO_TYPE */
+    union {
+        RADIO_FREQUENCY_RANGE range RADIO_ALIGNED(4);
+        gint32 channelNumber RADIO_ALIGNED(4);
+    } info RADIO_ALIGNED(4);
+} RADIO_ALIGNED(4) RadioFrequencyInfo; /* Since 1.5.4 */
+G_STATIC_ASSERT(sizeof(RadioFrequencyInfo) == 8);
+
+typedef struct radio_physical_channel_config_1_4 {
+    RadioPhysicalChannelConfig base RADIO_ALIGNED(4);
+    RADIO_TECH rat RADIO_ALIGNED(4);
+    RadioFrequencyInfo rfInfo RADIO_ALIGNED(4);
+    GBinderHidlVec contextIds RADIO_ALIGNED(8);
+    guint32 physicalCellId RADIO_ALIGNED(4);
+} RADIO_ALIGNED(8) RadioPhysicalChannelConfig_1_4; /* Since 1.5.4 */
+G_STATIC_ASSERT(sizeof(RadioPhysicalChannelConfig_1_4) == 48);
+
 typedef struct radio_gsm_broadcast_sms_config {
    gint32 fromServiceId RADIO_ALIGNED(4);
    gint32 toServiceId RADIO_ALIGNED(4);
@@ -1770,10 +2285,52 @@ typedef struct radio_network_scan_result {
    RADIO_SCAN_STATUS status RADIO_ALIGNED(4);
    RADIO_ERROR error RADIO_ALIGNED(4);
    GBinderHidlVec networkInfos RADIO_ALIGNED(8); /* vec<RadioCellInfo> */
+                                               /* or vec<RadioCellInfo_1_2> */
                                               /* or vec<RadioCellInfo_1_4> */
+                                               /* or vec<RadioCellInfo_1_5> */
 } RADIO_ALIGNED(8) RadioNetworkScanResult; /* Since 1.2.5 */
 G_STATIC_ASSERT(sizeof(RadioNetworkScanResult) == 24);

+typedef struct radio_network_scan_specifier {
+    RADIO_ACCESS_NETWORKS radioAccessNetwork RADIO_ALIGNED(4);
+    GBinderHidlVec geranBands RADIO_ALIGNED(8); /* vec<RADIO_GERAN_BAND> */
+    GBinderHidlVec utranBands RADIO_ALIGNED(8); /* vec<RADIO_UTRAN_BAND> */
+    GBinderHidlVec eutranBands RADIO_ALIGNED(8); /* vec<RADIO_EUTRAN_BAND> */
+    GBinderHidlVec channels RADIO_ALIGNED(8); /* vec<int32_t> */
+} RADIO_ALIGNED(8) RadioAccessSpecifier; /* Since 1.5.2 */
+G_STATIC_ASSERT(sizeof(RadioAccessSpecifier) == 72);
+
+typedef struct radio_network_scan_specifier_1_5 {
+    RADIO_ACCESS_NETWORKS radioAccessNetwork RADIO_ALIGNED(4);
+    guint8 type RADIO_ALIGNED(8); /* RADIO_NETWORK_SCAN_SPECIFIER_1_5_TYPE */
+    GBinderHidlVec bands RADIO_ALIGNED(8);  /* vec<RADIO_GERAN_BAND> */
+                                         /* or vec<RADIO_UTRAN_BAND> */
+                                         /* or vec<RADIO_EUTRAN_BAND> */
+                                         /* or vec<RADIO_NGRAN_BAND> */
+    GBinderHidlVec channels RADIO_ALIGNED(8); /* vec<int32_t> */
+} RADIO_ALIGNED(8) RadioAccessSpecifier_1_5; /* Since 1.5.2 */
+G_STATIC_ASSERT(sizeof(RadioAccessSpecifier_1_5) == 48);
+
+typedef struct radio_network_scan_request {
+    RADIO_SCAN_TYPE type RADIO_ALIGNED(4);
+    gint32 interval RADIO_ALIGNED(4); /* Periodic scan interval, seconds */
+    GBinderHidlVec specifiers RADIO_ALIGNED(8); /* vec<RadioAccessSpecifier> */
+} RADIO_ALIGNED(8) RadioNetworkScanRequest; /* Since 1.5.2 */
+G_STATIC_ASSERT(sizeof(RadioNetworkScanRequest) == 24);
+
+typedef struct radio_network_scan_request_1_5 {
+    RADIO_SCAN_TYPE type RADIO_ALIGNED(4);
+    gint32 interval RADIO_ALIGNED(4); /* [5..300] seconds */
+    GBinderHidlVec specifiers RADIO_ALIGNED(8); /*vec <RadioAccessSpecifier> */
+                                          /*or vec<RadioAccessSpecifier_1_5> */
+    gint32 maxSearchTime RADIO_ALIGNED(4);      /* [60..3600] seconds */
+    guint8 incrementalResults RADIO_ALIGNED(1); /* TRUE/FALSE */
+    gint32 incrementalResultsPeriodicity RADIO_ALIGNED(4); /* [1..10] */
+    GBinderHidlVec mccMncs RADIO_ALIGNED(8);    /* vec<GBinderHidlString> */
+} RADIO_ALIGNED(8) RadioNetworkScanRequest_1_2,
+    RadioNetworkScanRequest_1_5; /* Since 1.5.2 */
+G_STATIC_ASSERT(sizeof(RadioNetworkScanRequest_1_5) == 56);
+
 /* c(req,resp,callName,CALL_NAME) */
 #define RADIO_CALL_1_0(c) \
    c(2,1,getIccCardStatus,GET_ICC_CARD_STATUS) \
@@ -1922,15 +2479,43 @@ G_STATIC_ASSERT(sizeof(RadioNetworkScanResult) == 24);
    c(144,145,enableModem,ENABLE_MODEM) \
    c(145,146,getModemStackStatus,GET_MODEM_STACK_STATUS)

-#define RADIO_CALL_1_4(c) /* Since 1.2.5 */ \
-    c(146,155,setupDataCall_1_4,SETUP_DATA_CALL_1_4) \
-    c(149,147,emergencyDial,EMERGENCY_DIAL) \
-    c(150,148,startNetworkScan_1_4,START_NETWORK_SCAN_1_4) \
-    c(151,152,getPreferredNetworkTypeBitmap,GET_PREFERRED_NETWORK_TYPE_BITMAP) \
-    c(152,153,setPreferredNetworkTypeBitmap,SET_PREFERRED_NETWORK_TYPE_BITMAP) \
-    c(153,156,setAllowedCarriers_1_4,SET_ALLOWED_CARRIERS_1_4) \
-    c(154,157,getAllowedCarriers_1_4,GET_ALLOWED_CARRIERS_1_4) \
-    c(155,158,getSignalStrength_1_4,GET_SIGNAL_STRENGTH_1_4)
+/*
+ * From 1.2.5 to 1.5.0 there was RADIO_CALL_1_4 which took a macro with 4
+ * arguments as a parameter. In 1.5.1 it was replaced with RADIO_CALL_1_4_
+ * which takes a macro with 5 arguments.
+ */
+#define RADIO_CALL_1_4_(c) /* Since 1.5.1 */ \
+    c(146,155,setupDataCall,SETUP_DATA_CALL,_1_4) \
+    c(149,147,emergencyDial,EMERGENCY_DIAL,) \
+    c(150,148,startNetworkScan,START_NETWORK_SCAN,_1_4) \
+    c(151,152,getPreferredNetworkTypeBitmap,GET_PREFERRED_NETWORK_TYPE_BITMAP,) \
+    c(152,153,setPreferredNetworkTypeBitmap,SET_PREFERRED_NETWORK_TYPE_BITMAP,) \
+    c(153,156,setAllowedCarriers,SET_ALLOWED_CARRIERS,_1_4) \
+    c(154,157,getAllowedCarriers,GET_ALLOWED_CARRIERS,_1_4) \
+    c(155,158,getSignalStrength,GET_SIGNAL_STRENGTH,_1_4)
+
+/*
+ * Similarly to RADIO_CALL_1_4, RADIO_CALL_1_5 macro which appeared in 1.5.0
+ * was replaced with RADIO_CALL_1_5_ in 1.5.1
+ */
+#define RADIO_CALL_1_5_(c) /* Since 1.5.1 */ \
+    c(156,159,setSignalStrengthReportingCriteria,SET_SIGNAL_STRENGTH_REPORTING_CRITERIA,_1_5) \
+    c(157,160,setLinkCapacityReportingCriteria,SET_LINK_CAPACITY_REPORTING_CRITERIA,_1_5) \
+    c(158,161,enableUiccApplications,ENABLE_UICC_APPLICATIONS,) \
+    c(159,162,areUiccApplicationsEnabled,ARE_UICC_APPLICATIONS_ENABLED,) \
+    c(160,163,setSystemSelectionChannels,SET_SYSTEM_SELECTION_CHANNELS,_1_5) \
+    c(161,164,startNetworkScan,START_NETWORK_SCAN,_1_5) \
+    c(162,165,setupDataCall,SETUP_DATA_CALL,_1_5) \
+    c(163,167,setInitialAttachApn,SET_INITIAL_ATTACH_APN,_1_5) \
+    c(164,168,setDataProfile,SET_DATA_PROFILE,_1_5) \
+    c(165,169,setRadioPower,SET_RADIO_POWER,_1_5) \
+    c(166,170,setIndicationFilter,SET_INDICATION_FILTER,_1_5) \
+    c(167,171,getBarringInfo,GET_BARRING_INFO,) \
+    c(168,172,getVoiceRegistrationState,GET_VOICE_REGISTRATION_STATE,_1_5) \
+    c(169,173,getDataRegistrationState,GET_DATA_REGISTRATION_STATE,_1_5) \
+    c(170,175,setNetworkSelectionModeManual,SET_NETWORK_SELECTION_MODE_MANUAL,_1_5) \
+    c(171,176,sendCdmaSmsExpectMore,SEND_CDMA_SMS_EXPECT_MORE,) \
+    c(172,177,supplySimDepersonalization,SUPPLY_SIM_PERSONALIZATION,)

 /* e(code,eventName,EVENT_NAME) */
 #define RADIO_EVENT_1_0(e) \
@@ -2000,10 +2585,19 @@ G_STATIC_ASSERT(sizeof(RadioNetworkScanResult) == 24);
    e(58,dataCallListChanged_1_4,DATA_CALL_LIST_CHANGED_1_4) \
    e(59,currentSignalStrength_1_4,CURRENT_SIGNAL_STRENGTH_1_4)

+#define RADIO_EVENT_1_5(e)  /* Since 1.5.0 */ \
+    e(60,uiccApplicationsEnablementChanged, UICC_APPLICATION_ENABLEMENT_CHANGED) \
+    e(61,registrationFailed, REGISTRATION_FAILED) \
+    e(62,barringInfoChanged, BARRING_INFO_CHANGED) \
+    e(63,cellInfoList_1_5,CELL_INFO_LIST_1_5) \
+    e(64,networkScanResult_1_5,NETWORK_SCAN_RESULT_1_5) \
+    e(65,dataCallListChanged_1_5,DATA_CALL_LIST_CHANGED_1_5)
+
 typedef enum radio_req {
    RADIO_REQ_ANY = 0,
    RADIO_REQ_NONE = 0,
 #define RADIO_REQ_(req,resp,Name,NAME) RADIO_REQ_##NAME = req,
+#define RADIO_REQ__(req,resp,Name,NAME,x) RADIO_REQ_##NAME##x = req,

    /* android.hardware.radio@1.0::IRadio */
    RADIO_REQ_SET_RESPONSE_FUNCTIONS = 1, /* setResponseFunctions */
@@ -2028,11 +2622,16 @@ typedef enum radio_req {
    RADIO_1_3_REQ_LAST = RADIO_REQ_GET_MODEM_STACK_STATUS,

    /* android.hardware.radio@1.4::IRadio */
-    RADIO_CALL_1_4(RADIO_REQ_) /* Since 1.2.5 */
+    RADIO_CALL_1_4_(RADIO_REQ__) /* Since 1.2.5 */
    RADIO_REQ_SET_INITIAL_ATTACH_APN_1_4 = 147,
    RADIO_REQ_SET_DATA_PROFILE_1_4 = 148,
-    RADIO_1_4_REQ_LAST = RADIO_REQ_GET_SIGNAL_STRENGTH_1_4
+    RADIO_1_4_REQ_LAST = RADIO_REQ_GET_SIGNAL_STRENGTH_1_4,
+
+    /* android.hardware.radio@1.5::IRadio */
+    RADIO_CALL_1_5_(RADIO_REQ__) /* Since 1.5.0 */
+    RADIO_1_5_REQ_LAST = RADIO_REQ_SUPPLY_SIM_PERSONALIZATION
 #undef RADIO_REQ_
+#undef RADIO_REQ__
 } RADIO_REQ;
 G_STATIC_ASSERT(sizeof(RADIO_REQ) == 4);

@@ -2040,6 +2639,7 @@ typedef enum radio_resp {
    RADIO_RESP_ANY = 0,
    RADIO_RESP_NONE = 0,
 #define RADIO_RESP_(req,resp,Name,NAME) RADIO_RESP_##NAME = resp,
+#define RADIO_RESP__(req,resp,Name,NAME,x) RADIO_RESP_##NAME##x = resp,

    /* android.hardware.radio@1.0::IRadioResponse */
    RADIO_CALL_1_0(RADIO_RESP_)
@@ -2065,13 +2665,21 @@ typedef enum radio_resp {
    RADIO_1_3_RESP_LAST = RADIO_RESP_GET_MODEM_STACK_STATUS,

    /* android.hardware.radio@1.4::IRadioResponse */
-    RADIO_CALL_1_4(RADIO_RESP_) /* Since 1.2.5 */
+    RADIO_CALL_1_4_(RADIO_RESP__) /* Since 1.2.5 */
    RADIO_RESP_GET_CELL_INFO_LIST_1_4 = 149,
    RADIO_RESP_GET_DATA_REGISTRATION_STATE_1_4 = 150,
    RADIO_RESP_GET_ICC_CARD_STATUS_1_4 = 151,
    RADIO_RESP_GET_DATA_CALL_LIST_1_4 = 154,
-    RADIO_1_4_RESP_LAST = RADIO_RESP_GET_SIGNAL_STRENGTH_1_4
+    RADIO_1_4_RESP_LAST = RADIO_RESP_GET_SIGNAL_STRENGTH_1_4,
+
+    /* android.hardware.radio@1.5::IRadioResponse */
+    RADIO_CALL_1_5_(RADIO_RESP__) /* Since 1.5.0 */
+    RADIO_RESP_GET_DATA_CALL_LIST_1_5 = 166,
+    RADIO_RESP_GET_CELL_INFO_LIST_1_5 = 174,
+    RADIO_RESP_GET_ICC_CARD_STATUS_1_5 = 178,
+    RADIO_1_5_RESP_LAST = RADIO_RESP_GET_ICC_CARD_STATUS_1_5
 #undef RADIO_RESP_
+#undef RADIO_RESP__
 } RADIO_RESP;
 G_STATIC_ASSERT(sizeof(RADIO_RESP) == 4);

@@ -2113,7 +2721,11 @@ typedef enum radio_ind {

    /* android.hardware.radio@1.4::IRadioIndication */
    RADIO_EVENT_1_4(RADIO_IND_)
-    RADIO_1_4_IND_LAST = RADIO_IND_CURRENT_SIGNAL_STRENGTH_1_4 /* Since 1.2.5 */
+    RADIO_1_4_IND_LAST = RADIO_IND_CURRENT_SIGNAL_STRENGTH_1_4, /* Since 1.2.5 */
+
+    /* android.hardware.radio@1.5::IRadioIndication */
+    RADIO_EVENT_1_5(RADIO_IND_)
+    RADIO_1_5_IND_LAST = RADIO_IND_DATA_CALL_LIST_CHANGED_1_5 /* Since 1.5.0 */
 #undef RADIO_IND_
 } RADIO_IND;
 G_STATIC_ASSERT(sizeof(RADIO_IND) == 4);
--- 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.4.6
+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
@@ -1,6 +1,6 @@
 /*
- * Copyright (C) 2021 Jolla Ltd.
- * Copyright (C) 2021 Slava Monich <slava.monich@jolla.com>
+ * Copyright (C) 2021-2022 Jolla Ltd.
+ * Copyright (C) 2021-2022 Slava Monich <slava.monich@jolla.com>
 *
 * You may use this file under the terms of the BSD license as follows:
 *
@@ -83,12 +83,6 @@ static inline gboolean
 radio_base_can_retry(RadioRequest* req)
    { return req->max_retries < 0 || req->max_retries > req->retry_count; }

-static inline gboolean
-radio_base_request_blocked(RadioBasePriv* q, RadioRequest* req)
-    { return (q->owner != req->group &&
-             (q->owner || q->owner_queue)) ||
-             (q->block_req && q->block_req != req); }
-
 /*==========================================================================*
 * Implementation
 *==========================================================================*/
@@ -172,6 +166,7 @@ radio_base_deactivate_request(
    if (priv->block_req == req) {
        /* Let the life continue */
        priv->block_req = NULL;
+        GVERBOSE_("block %p => %p", req, priv->block_req);
        radio_request_unref(req);
    }
 }
@@ -302,34 +297,104 @@ radio_base_submit_transaction(
 static
 gboolean
 radio_base_can_set_owner(
-    RadioBase* self,
+    RadioBasePriv* priv,
    RadioRequestGroup* group)
 {
-    RadioBasePriv* priv = self->priv;
-    GHashTableIter it;
-    gpointer value;
+    /*
+     * Caller has verified that the group isn't already the owner.
+     * It's also been checked that either the owner queue is empty,
+     * of this group is the first one in the queue.
+     */
+    DEBUG_ASSERT(!priv->owner_queue || priv->owner_queue->data == group);

-    g_hash_table_iter_init(&it, priv->pending);
-    while (g_hash_table_iter_next(&it, NULL, &value)) {
-        RadioRequest* req = value;
+    if (g_hash_table_size(priv->pending)) {
+        GHashTableIter it;
+        gpointer value;

-        if (req->group != group) {
-            /*
-             * There's a pending request not associated with any group
-             * or associated with a different group. The specified group
-             * can't become the owner just yet.
-             */
-            return FALSE;
+        g_hash_table_iter_init(&it, priv->pending);
+        while (g_hash_table_iter_next(&it, NULL, &value)) {
+            RadioRequest* req = value;
+
+            DEBUG_ASSERT(req->state == RADIO_REQUEST_STATE_PENDING);
+            if (req->group != group) {
+                /*
+                 * There's a pending request not associated with any
+                 * group or associated with a different group. The
+                 * specified group can't become the owner just yet.
+                 */
+                return FALSE;
+            }
        }
+
    }

    /*
     * There are no pending requests, or all pending requests are
-     * associated with the specified group. This group can be the owner.
+     * associated with this group.
     */
    return TRUE;
 }

+static
+void
+radio_base_move_owner_queue(
+    RadioBase* self)
+{
+    RadioBasePriv* priv = self->priv;
+
+    if (!priv->owner && priv->owner_queue) {
+        GSList* l = priv->owner_queue;
+        RadioRequestGroup* group = l->data;
+
+        if (radio_base_can_set_owner(priv, group)) {
+            GVERBOSE_("owner %p", group);
+            priv->owner = group;
+            priv->owner_queue = l->next;
+            g_slist_free_1(l);
+            g_signal_emit(self, radio_base_signals[SIGNAL_OWNER], 0);
+        }
+    }
+}
+
+static
+gboolean
+radio_base_can_submit_request(
+    RadioBasePriv* priv,
+    RadioRequest* req)
+{
+    if (priv->block_req) {
+        /* The current blocker can be resubmitted */
+        return priv->block_req == req;
+    } else if (req->group) {
+        /* The request is a part of a group */
+        if (req->group == priv->owner) {
+            /* The group is the current owner */
+            return TRUE;
+        } else if (priv->owner) {
+            /* Another group owns the whole thing */
+            return FALSE;
+        } else if (!priv->owner_queue) {
+            /* No group is waiting to become the owner */
+            return TRUE;
+        } else if (priv->owner_queue->data == req->group) {
+            /*
+             * This group is waiting to become the owner and it's the
+             * first one in the queue.
+             */
+            return radio_base_can_set_owner(priv, req->group);
+        } else {
+            /*
+             * Another group waiting to become the owner. This request
+             * will have to wait.
+             */
+            return FALSE;
+        }
+    } else {
+        /* Can submit if there's no owner and no one wants to become one */
+        return !priv->owner && !priv->owner_queue;
+    }
+}
+
 static
 void
 radio_base_queue_request(
@@ -361,7 +426,7 @@ radio_base_submit_queued_requests(
        while (req) {
            RadioRequest* next = req->queue_next;

-            if (!radio_base_request_blocked(priv, req) &&
+            if (radio_base_can_submit_request(priv, req) &&
                /* If the request is scheduled, don't submit it too early */
                (!req->scheduled || now >= req->scheduled)) {
                /* Remove it from the queue (prev remains untouched) */
@@ -369,9 +434,13 @@ radio_base_submit_queued_requests(

                /* Initiate the transaction and update the request state */
                if (radio_base_submit_transaction(self, req)) {
+                    radio_base_move_owner_queue(self);
                    submitted++;
                    if (req->blocking) {
-                        priv->block_req = radio_request_ref(req);
+                        if (!priv->block_req) {
+                            GVERBOSE_("block %p => %p", priv->block_req, req);
+                            priv->block_req = radio_request_ref(req);
+                        }
                        break;
                    }
                } else {
@@ -462,25 +531,6 @@ radio_base_initialize(
 {
 }

-RadioBase*
-radio_base_ref(
-    RadioBase* self)
-{
-    if (G_LIKELY(self)) {
-        g_object_ref(self);
-    }
-    return self;
-}
-
-void
-radio_base_unref(
-    RadioBase* self)
-{
-    if (G_LIKELY(self)) {
-        g_object_unref(self);
-    }
-}
-
 void
 radio_base_register_request(
    RadioBase* self,
@@ -503,6 +553,7 @@ radio_base_unregister_request(
    if (G_LIKELY(self)) {
        RadioBasePriv* priv = self->priv;

+        GVERBOSE_("request %u %p (%08x) done", req->code, req, req->serial);
        g_hash_table_remove(priv->requests, KEY(req->serial));
        g_hash_table_remove(priv->requests, KEY(req->serial2));
        req->serial = req->serial2 = 0;
@@ -563,8 +614,12 @@ radio_base_retry_request(
        if (radio_base_submit_queued_requests(self)) {
            radio_base_reset_timeout(self);
        }
-        return (req->state == RADIO_REQUEST_STATE_PENDING);
+        if (req->state == RADIO_REQUEST_STATE_PENDING) {
+            return TRUE;
+        }
    }
+    GVERBOSE_("can't retry request %u (%08x/%08x) %p", req->code,
+        req->serial, req->serial2, req);
    return FALSE;
 }

@@ -599,15 +654,25 @@ radio_base_reset_timeout(
        gpointer value;

        /* Calculate the new deadline */
+        GVERBOSE_("time %" G_GINT64_FORMAT " block %p owner %p queue %p",
+            now, priv->block_req, priv->owner, priv->owner_queue ?
+            priv->owner_queue->data : NULL);
+
        g_hash_table_iter_init(&it, priv->active);
        while (g_hash_table_iter_next(&it, NULL, &value)) {
            RadioRequest* req = value;

+            GVERBOSE_("%p %" G_GINT64_FORMAT " %" G_GINT64_FORMAT, req,
+                req->deadline, req->scheduled);
            if (!next_wakeup || next_wakeup > req->deadline) {
+                GVERBOSE_("  %" G_GINT64_FORMAT " => %" G_GINT64_FORMAT,
+                    next_wakeup, req->deadline);
                next_wakeup = req->deadline;
            }
-            if (req->scheduled && !radio_base_request_blocked(priv, req)) {
+            if (req->scheduled && radio_base_can_submit_request(priv, req)) {
                if (!next_wakeup || next_wakeup > req->scheduled) {
+                    GVERBOSE_("  %" G_GINT64_FORMAT " => %" G_GINT64_FORMAT,
+                        next_wakeup, req->scheduled);
                    next_wakeup = req->scheduled;
                }
            }
@@ -666,7 +731,8 @@ radio_base_block(
        /* This group is already the owner */
        return  RADIO_BLOCK_ACQUIRED;
    } else if (!priv->owner && !priv->owner_queue &&
-        radio_base_can_set_owner(self, group)) {
+        radio_base_can_set_owner(priv, group)) {
+        GVERBOSE_("owner %p", group);
        priv->owner = group;
        g_signal_emit(self, radio_base_signals[SIGNAL_OWNER], 0);
        return RADIO_BLOCK_ACQUIRED;
@@ -684,25 +750,24 @@ radio_base_unblock(
    RadioBase* self,
    RadioRequestGroup* group)
 {
-    /* Group is never NULL but base pointer isn't checked by the caller */
-    if (G_LIKELY(self)) {
-        RadioBasePriv* priv = self->priv;
+    /* Parameters are checked by the caller */
+    RadioBasePriv* priv = self->priv;

-        if (priv->owner == group) {
-            if (priv->owner_queue) {
-                priv->owner = priv->owner_queue->data;
-                priv->owner_queue = g_slist_delete_link(priv->owner_queue,
-                    priv->owner_queue);
-            } else {
-                priv->owner = NULL;
-            }
-            g_signal_emit(self, radio_base_signals[SIGNAL_OWNER], 0);
-            if (radio_base_submit_queued_requests(self)) {
-                radio_base_reset_timeout(self);
-            }
+    if (priv->owner == group) {
+        if (priv->owner_queue) {
+            priv->owner = priv->owner_queue->data;
+            priv->owner_queue = g_slist_delete_link(priv->owner_queue,
+                priv->owner_queue);
        } else {
-            priv->owner_queue = g_slist_remove(priv->owner_queue, group);
+            GVERBOSE_("owner %p", NULL);
+            priv->owner = NULL;
        }
+        g_signal_emit(self, radio_base_signals[SIGNAL_OWNER], 0);
+        if (radio_base_submit_queued_requests(self) || !priv->owner) {
+            radio_base_reset_timeout(self);
+        }
+    } else {
+        priv->owner_queue = g_slist_remove(priv->owner_queue, group);
    }
 }

@@ -722,6 +787,9 @@ radio_base_handle_resp(
        /* Temporary ref */
        g_object_ref(self);

+        /* It's no longer pending */
+        g_hash_table_remove(priv->pending, KEY(info->serial));
+
        /* Response may come before completion of the request */
        radio_base_cancel_request(self, req);

@@ -736,18 +804,7 @@ radio_base_handle_resp(
        } else if (g_hash_table_steal(priv->active, KEY(info->serial))) {
            req->state = RADIO_REQUEST_STATE_DONE;
            radio_base_deactivate_request(self, req);
-            if (!priv->owner && priv->owner_queue) {
-                /* There's a request group waiting to become the owner */
-                GSList* l = priv->owner_queue;
-                RadioRequestGroup* group = l->data;
-
-                if (radio_base_can_set_owner(self, group)) {
-                    priv->owner = group;
-                    priv->owner_queue = l->next;
-                    g_slist_free_1(l);
-                    g_signal_emit(self, radio_base_signals[SIGNAL_OWNER], 0);
-                }
-            }
+            radio_base_move_owner_queue(self);
            if (req->complete) {
                RadioRequestCompleteFunc fn = req->complete;

--- a/src/radio_base.h
+++ b/src/radio_base.h
@@ -1,6 +1,6 @@
 /*
- * Copyright (C) 2021 Jolla Ltd.
- * Copyright (C) 2021 Slava Monich <slava.monich@jolla.com>
+ * Copyright (C) 2021-2022 Jolla Ltd.
+ * Copyright (C) 2021-2022 Slava Monich <slava.monich@jolla.com>
 *
 * You may use this file under the terms of the BSD license as follows:
 *
@@ -86,16 +86,6 @@ radio_base_initialize(
    RadioBase* base)
    RADIO_INTERNAL;

-RadioBase*
-radio_base_ref(
-    RadioBase* base)
-    RADIO_INTERNAL;
-
-void
-radio_base_unref(
-    RadioBase* base)
-    RADIO_INTERNAL;
-
 void
 radio_base_register_request(
    RadioBase* base,
--- a/src/radio_client.c
+++ b/src/radio_client.c
@@ -1,6 +1,6 @@
 /*
- * Copyright (C) 2021 Jolla Ltd.
- * Copyright (C) 2021 Slava Monich <slava.monich@jolla.com>
+ * Copyright (C) 2021-2022 Jolla Ltd.
+ * Copyright (C) 2021-2022 Slava Monich <slava.monich@jolla.com>
 *
 * You may use this file under the terms of the BSD license as follows:
 *
@@ -131,10 +131,10 @@ radio_client_handle_death(
 {
    RadioBase* base = RADIO_BASE(user_data);

-    radio_base_ref(base);
+    g_object_ref(base);
    radio_base_handle_death(base);
    g_signal_emit(base, radio_client_signals[SIGNAL_DEATH], 0);
-    radio_base_unref(base);
+    g_object_unref(base);
 }

 static
@@ -180,7 +180,7 @@ radio_client_handle_resp(
    gpointer user_data)
 {
    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,
@@ -281,6 +281,13 @@ radio_client_interface(
    return G_LIKELY(self) ? self->instance->version : RADIO_INTERFACE_NONE;
 }

+RADIO_AIDL_INTERFACE
+radio_client_aidl_interface(
+    RadioClient* self)
+{
+    return G_LIKELY(self) ? self->instance->interface_aidl : RADIO_AIDL_INTERFACE_NONE;
+}
+
 void
 radio_client_set_default_timeout(
    RadioClient* self,
--- 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;
@@ -114,13 +115,21 @@ static const char* radio_config_signal_observe_indication_name[] = {
 static guint radio_config_signals[SIGNAL_COUNT] = { 0 };

 static const GBinderClientIfaceInfo radio_config_iface_info[] = {
+    {RADIO_CONFIG_1_1, RADIO_CONFIG_1_1_REQ_LAST },
    {RADIO_CONFIG_1_1, RADIO_CONFIG_1_1_REQ_LAST },
    {RADIO_CONFIG_1_0, RADIO_CONFIG_1_0_REQ_LAST }
 };
 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,
    RADIO_CONFIG_INDICATION_1_0,
    NULL
@@ -128,7 +137,15 @@ 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,
    RADIO_CONFIG_RESPONSE_1_0,
    NULL
@@ -136,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;
@@ -147,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, \
@@ -156,15 +182,31 @@ typedef struct radio_config_interface_desc {
        RADIO_CONFIG_INTERFACE_INDEX(RADIO_CONFIG_INTERFACE_##v)

 static const RadioConfigInterfaceDesc radio_config_interfaces[] = {
+   { RADIO_CONFIG_INTERFACE_DESC(1_2) },
   { RADIO_CONFIG_INTERFACE_DESC(1_1) },
   { RADIO_CONFIG_INTERFACE_DESC(1_0) }
 };
 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;
@@ -201,17 +243,31 @@ 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";
+    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_)
+        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;
 }
@@ -219,16 +275,30 @@ radio_config_known_req_name(
 static
 const char*
 radio_config_known_resp_name(
+    RadioConfig* self,
    RADIO_CONFIG_RESP resp)
 {
-    switch (resp) {
+    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_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;
 }
@@ -236,16 +306,29 @@ radio_config_known_resp_name(
 static
 const char*
 radio_config_known_ind_name(
+    RadioConfig* self,
    RADIO_CONFIG_IND ind)
 {
-    switch (ind) {
+    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 */
+        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;
 }
@@ -263,7 +346,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);
@@ -289,7 +372,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);
@@ -315,7 +398,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);
@@ -385,53 +468,64 @@ radio_config_response(
 {
    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;
 }

@@ -501,12 +595,12 @@ radio_config_create(
    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,
@@ -514,14 +608,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;
@@ -542,20 +650,51 @@ 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;
+    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)
+{
+    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;
@@ -564,8 +703,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);
@@ -574,9 +713,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);
@@ -588,9 +726,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;
            }
        }
@@ -624,6 +762,13 @@ radio_config_dead(
    return G_UNLIKELY(!self) || self->dead;
 }

+RADIO_INTERFACE_TYPE
+radio_config_interface_type(
+    RadioConfig* self)
+{
+    return G_LIKELY(self) ? self->interface_type : RADIO_INTERFACE_TYPE_NONE;
+}
+
 RADIO_CONFIG_INTERFACE
 radio_config_interface(
    RadioConfig* self)
@@ -651,7 +796,7 @@ radio_config_req_name(
    RadioConfig* self,
    RADIO_CONFIG_REQ req)
 {
-    const char* known = radio_config_known_req_name(req);
+    const char* known = radio_config_known_req_name(self, req);

    if (known) {
        return known;
@@ -670,7 +815,7 @@ radio_config_resp_name(
    RadioConfig* self,
    RADIO_CONFIG_RESP resp)
 {
-    const char* known = radio_config_known_resp_name(resp);
+    const char* known = radio_config_known_resp_name(self, resp);

    if (known) {
        return known;
@@ -689,7 +834,7 @@ radio_config_ind_name(
    RadioConfig* self,
    RADIO_CONFIG_IND ind)
 {
-    const char* known = radio_config_known_ind_name(ind);
+    const char* known = radio_config_known_ind_name(self, ind);

    if (known) {
        return known;
--- a/src/radio_instance.c
+++ b/src/radio_instance.c
@@ -123,6 +123,7 @@ static GHashTable* radio_instance_table = NULL;
 #define DEFAULT_INTERFACE RADIO_INTERFACE_1_0

 static const GBinderClientIfaceInfo radio_iface_info[] = {
+    {RADIO_1_5, RADIO_1_5_REQ_LAST },
    {RADIO_1_4, RADIO_1_4_REQ_LAST },
    {RADIO_1_3, RADIO_1_3_REQ_LAST },
    {RADIO_1_2, RADIO_1_2_REQ_LAST },
@@ -132,6 +133,7 @@ static const GBinderClientIfaceInfo radio_iface_info[] = {
 G_STATIC_ASSERT(G_N_ELEMENTS(radio_iface_info) == RADIO_INTERFACE_COUNT);

 static const char* const radio_indication_ifaces[] = {
+    RADIO_INDICATION_1_5,
    RADIO_INDICATION_1_4,
    RADIO_INDICATION_1_3,
    RADIO_INDICATION_1_2,
@@ -142,6 +144,7 @@ static const char* const radio_indication_ifaces[] = {
 G_STATIC_ASSERT(G_N_ELEMENTS(radio_indication_ifaces) == RADIO_INTERFACE_COUNT + 1);

 static const char* const radio_response_ifaces[] = {
+    RADIO_RESPONSE_1_5,
    RADIO_RESPONSE_1_4,
    RADIO_RESPONSE_1_3,
    RADIO_RESPONSE_1_2,
@@ -153,19 +156,25 @@ 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) },
   { RADIO_INTERFACE_DESC(1_4) },
   { RADIO_INTERFACE_DESC(1_3) },
   { RADIO_INTERFACE_DESC(1_2) },
@@ -174,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;
@@ -201,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);
@@ -228,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);
@@ -276,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;

@@ -290,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--) {
@@ -301,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);
@@ -356,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;
 }

@@ -516,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,
@@ -527,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);

@@ -557,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;
 }

@@ -591,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
@@ -701,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);
@@ -771,9 +1020,23 @@ radio_instance_new_with_modem_slot_and_version(
    const char* modem,
    int slot,
    RADIO_INTERFACE version) /* Since 1.2.1 */
+{
+    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 */
 {
    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) {
@@ -783,7 +1046,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
@@ -826,7 +1090,7 @@ radio_instance_get_with_version(
    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);
@@ -901,7 +1165,7 @@ radio_instance_req_name(
    RadioInstance* self,
    RADIO_REQ req)
 {
-    const char* known = radio_req_name(req);
+    const char* known = radio_req_name2(self, req);

    if (known) {
        return known;
@@ -920,7 +1184,7 @@ radio_instance_resp_name(
    RadioInstance* self,
    RADIO_RESP resp)
 {
-    const char* known = radio_resp_name(resp);
+    const char* known = radio_resp_name2(self, resp);

    if (known) {
        return known;
@@ -939,7 +1203,7 @@ radio_instance_ind_name(
    RadioInstance* self,
    RADIO_IND ind)
 {
-    const char* known = radio_ind_name(ind);
+    const char* known = radio_ind_name2(self, ind);

    if (known) {
        return known;
--- a/src/radio_request.c
+++ b/src/radio_request.c
@@ -44,11 +44,17 @@

 #include <gutil_macros.h>

+typedef enum radio_request_flags {
+    RADIO_REQUEST_NO_FLAGS = 0,
+    RADIO_REQUEST_FLAG_DROPPED = 0x01,
+    RADIO_REQUEST_FLAG_SUBMITTED = 0x02
+} RADIO_REQUEST_FLAGS;
+
 typedef struct radio_request_object {
    RadioRequest pub;
    GDestroyNotify destroy;
    gsize serial_offset;
-    gboolean dropped;
+    RADIO_REQUEST_FLAGS flags;
    gint refcount;
 } RadioRequestObject;

@@ -67,8 +73,8 @@ radio_request_object_cancel(
    RadioRequest* req = &self->pub;

    radio_base_cancel_request(req->object, req);
-    if (!self->dropped) {
-        self->dropped = TRUE;
+    if (!(self->flags & RADIO_REQUEST_FLAG_DROPPED)) {
+        self->flags |= RADIO_REQUEST_FLAG_DROPPED;
        radio_request_group_remove(req->group, req);
        radio_base_request_dropped(req);
    }
@@ -82,8 +88,11 @@ radio_request_free(
 {
    RadioRequest* req = &self->pub;

+    GVERBOSE_("%u (%08x) %p", req->code, req->serial, req);
    radio_request_object_cancel(self);
-    if (req->complete) {
+
+    /* Don't invoke completion routine if the request was never submitted */
+    if (req->complete && (self->flags & RADIO_REQUEST_FLAG_SUBMITTED)) {
        RadioRequestCompleteFunc complete = req->complete;

        /* Request is being freed too early, before completion */
@@ -124,7 +133,17 @@ radio_request_default_retry(
    const GBinderReader* reader,
    void* user_data)
 {
-    return status != RADIO_TX_STATUS_OK || error != RADIO_ERROR_NONE;
+    if (status != RADIO_TX_STATUS_OK) {
+        GVERBOSE_("req %p %u (%08x) status %d", req, req->code, req->serial,
+            status);
+        return TRUE;
+    } else if (error != RADIO_ERROR_NONE) {
+        GVERBOSE_("req %p %u (%08x) error %d", req, req->code, req->serial,
+            error);
+        return TRUE;
+    } else {
+        return FALSE;
+    }
 }

 static
@@ -154,6 +173,7 @@ radio_request_object_new(
    /* Assign serial and add to the group */
    radio_base_register_request(base, req);
    radio_request_group_add(group, req);
+    GVERBOSE_("%u (%08x) %p group %p", req->code, req->serial, req, group);

    /* Build the argument list */
    if (!writer) writer = &tmp;
@@ -307,7 +327,11 @@ gboolean
 radio_request_submit(
    RadioRequest* req)
 {
-    return req && req->object && radio_base_submit_request(req->object, req);
+    if (req && req->object && radio_base_submit_request(req->object, req)) {
+        radio_request_cast(req)->flags |= RADIO_REQUEST_FLAG_SUBMITTED;
+        return TRUE;
+    }
+    return FALSE;
 }

 gboolean
@@ -342,6 +366,13 @@ radio_request_drop(
    }
 }

+void*
+radio_request_user_data(
+    RadioRequest* req) /* Since 1.4.11 */
+{
+    return G_LIKELY(req) ? req->user_data : NULL;
+}
+
 /*
 * Local Variables:
 * mode: C
--- a/src/radio_request_group.c
+++ b/src/radio_request_group.c
@@ -69,11 +69,10 @@ radio_request_group_free(
    RadioRequestGroupObject* self)
 {
    RadioRequestGroup* group = &self->pub;
-    RadioBase* base = RADIO_BASE(group->client);

-    radio_base_unblock(base, group);
+    radio_base_unblock(RADIO_BASE(group->client), group);
    g_hash_table_destroy(self->requests);
-    radio_base_unref(base);
+    radio_client_unref(group->client);
    gutil_slice_free(self);
 }

--- a/src/radio_types_p.h
+++ b/src/radio_types_p.h
@@ -54,6 +54,16 @@ G_STATIC_ASSERT(RADIO_OBSERVER_PRIORITY_HIGHEST == 7);
 #define RADIO_OBSERVER_PRIORITY_COUNT \
    (RADIO_OBSERVER_PRIORITY_INDEX(RADIO_OBSERVER_PRIORITY_HIGHEST) + 1)

+/*
+ * A special assert fatal in debug build and non-fatal in release.
+ * Marks truely unavoidable conditions.
+ */
+#ifdef DEBUG
+#  define DEBUG_ASSERT(expr) g_assert(expr)
+#else
+#  define DEBUG_ASSERT(expr)
+#endif
+
 #endif /* RADIO_TYPES_PRIVATE_H */

 /*
--- 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");
@@ -56,25 +57,116 @@ 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";
+    return radio_req_name2(NULL, req);
+}
+
+const char*
+radio_req_name2(
+    RadioInstance* instance,
+    RADIO_REQ req)
+{
+    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;
-    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_)
+        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__)
 #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;
+#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;
+        }
+    } 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;
 }
@@ -83,38 +175,128 @@ const char*
 radio_resp_name(
    RADIO_RESP resp)
 {
-    switch (resp) {
-    case RADIO_RESP_ACKNOWLEDGE_REQUEST: return "acknowledgeRequest";
+    return radio_resp_name2(NULL, resp);
+}
+
+const char*
+radio_resp_name2(
+    RadioInstance* instance,
+    RADIO_RESP resp)
+{
+    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";
-    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_)
+        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__)
 #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_ANY:
-        break;
+#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;
+        }
+    } 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;
 }
@@ -123,16 +305,90 @@ const char*
 radio_ind_name(
    RADIO_IND ind)
 {
-    switch (ind) {
+    return radio_ind_name2(NULL, ind);
+}
+
+const char*
+radio_ind_name2(
+    RadioInstance* instance,
+    RADIO_IND ind)
+{
+    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_)
+        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;
 }
@@ -153,14 +409,18 @@ radio_req_resp(
    RADIO_REQ req)
 {
    switch (req) {
-#define RADIO_REQ_(req,resp,Name,NAME) \
+#define RADIO_REQ_RESP_(req,resp,Name,NAME) \
    case RADIO_REQ_##NAME: return RADIO_RESP_##NAME;
-    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_)
-#undef RADIO_REQ_
+#define RADIO_REQ_RESP__(req,resp,Name,NAME,x) \
+    case RADIO_REQ_##NAME##x: return RADIO_RESP_##NAME##x;
+    RADIO_CALL_1_0(RADIO_REQ_RESP_)
+    RADIO_CALL_1_1(RADIO_REQ_RESP_)
+    RADIO_CALL_1_2(RADIO_REQ_RESP_)
+    RADIO_CALL_1_3(RADIO_REQ_RESP_)
+    RADIO_CALL_1_4_(RADIO_REQ_RESP__)
+    RADIO_CALL_1_5_(RADIO_REQ_RESP__)
+#undef RADIO_REQ_RESP_
+#undef RADIO_REQ_RESP__
    case RADIO_REQ_SETUP_DATA_CALL_1_2:
        return RADIO_RESP_SETUP_DATA_CALL;
    case RADIO_REQ_DEACTIVATE_DATA_CALL_1_2:
@@ -237,10 +497,8 @@ radio_req_resp2(
            return RADIO_RESP_GET_ICC_CARD_STATUS_1_2;
        case RADIO_INTERFACE_1_4:
            return RADIO_RESP_GET_ICC_CARD_STATUS_1_4;
-        /*
        case RADIO_INTERFACE_1_5:
            return RADIO_RESP_GET_ICC_CARD_STATUS_1_5;
-        */
        case RADIO_INTERFACE_NONE:
        case RADIO_INTERFACE_COUNT:
            break;
@@ -265,12 +523,9 @@ radio_req_resp2(
            return RADIO_RESP_GET_CELL_INFO_LIST_1_2;
        case RADIO_INTERFACE_1_4:
            return RADIO_RESP_GET_CELL_INFO_LIST_1_4;
-        /*
        default:
            return RADIO_RESP_GET_CELL_INFO_LIST_1_5;
-        */
        case RADIO_INTERFACE_NONE:
-        case RADIO_INTERFACE_COUNT:
            break;
        }
        return RADIO_RESP_NONE;
@@ -286,7 +541,7 @@ radio_req_resp2(
        case RADIO_INTERFACE_1_0:
        case RADIO_INTERFACE_1_1:
            return RADIO_RESP_GET_CURRENT_CALLS;
-        default:
+        default: /* The last one */
            return RADIO_RESP_GET_CURRENT_CALLS_1_2;
        case RADIO_INTERFACE_NONE:
            break;
@@ -304,7 +559,7 @@ radio_req_resp2(
        case RADIO_INTERFACE_1_0:
        case RADIO_INTERFACE_1_1:
            return RADIO_RESP_GET_SIGNAL_STRENGTH;
-        default:
+        default: /* The last one */
            return RADIO_RESP_GET_SIGNAL_STRENGTH_1_2;
        case RADIO_INTERFACE_NONE:
            break;
@@ -322,7 +577,7 @@ radio_req_resp2(
        case RADIO_INTERFACE_1_0:
        case RADIO_INTERFACE_1_1:
            return RADIO_RESP_GET_VOICE_REGISTRATION_STATE;
-        default:
+        default: /* The last one */
            return RADIO_RESP_GET_VOICE_REGISTRATION_STATE_1_2;
        case RADIO_INTERFACE_NONE:
            break;
@@ -344,7 +599,7 @@ radio_req_resp2(
        case RADIO_INTERFACE_1_2:
        case RADIO_INTERFACE_1_3:
            return RADIO_RESP_GET_DATA_REGISTRATION_STATE_1_2;
-        default:
+        default: /* The last one */
            return RADIO_RESP_GET_DATA_REGISTRATION_STATE_1_4;
        case RADIO_INTERFACE_NONE:
            break;
@@ -367,12 +622,9 @@ radio_req_resp2(
            return RADIO_RESP_GET_DATA_CALL_LIST;
        case RADIO_INTERFACE_1_4:
            return RADIO_RESP_GET_DATA_CALL_LIST_1_4;
-        /*
-        default:
+        default: /* The last one */
            return RADIO_RESP_GET_DATA_CALL_LIST_1_5;
-        */
        case RADIO_INTERFACE_NONE:
-        case RADIO_INTERFACE_COUNT:
            break;
        }
        return RADIO_RESP_NONE;
--- 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)
--- a/unit/unit_client/unit_client.c
+++ b/unit/unit_client/unit_client.c
@@ -390,6 +390,26 @@ test_simple_destroy_cb(
    test_quit_later(test->loop);
 }

+static
+void
+test_simple_complete_ok_cb(
+    RadioRequest* req,
+    RADIO_TX_STATUS status,
+    RADIO_RESP resp,
+    RADIO_ERROR error,
+    const GBinderReader* reader,
+    gpointer user_data)
+{
+    TestSimple* test = user_data;
+
+    GDEBUG("status %u", status);
+    g_assert_cmpint(status, == ,RADIO_TX_STATUS_OK);
+    g_assert_cmpint(error, == ,RADIO_ERROR_NONE);
+    g_assert(!test->completed);
+    g_assert(!test->destroyed);
+    test->completed = TRUE;
+}
+
 static
 void
 test_simple_complete_fail_cb(
@@ -471,6 +491,7 @@ test_null(
    g_assert(!radio_request_ref(NULL));
    g_assert(!radio_request_submit(NULL));
    g_assert(!radio_request_retry(NULL));
+    g_assert(!radio_request_user_data(NULL));

    radio_request_group_cancel(NULL);
    radio_request_group_unref(NULL);
@@ -495,6 +516,7 @@ test_basic(
    TestCommon test;
    RadioRequest* req;
    RadioClient* client = test_common_init(&test);
+    GBinderWriter args;
    gboolean destroyed = FALSE;

    g_assert_cmpstr(radio_client_slot(client), == ,test.radio->slot);
@@ -524,9 +546,10 @@ test_basic(
    radio_request_drop(req);  /* Matches radio_request_ref() above */
    radio_request_drop(req);  /* Releases the final ref */

-    /* Make sure destroy callback is invoked */
-    req = radio_request_new(client, RADIO_REQ_GET_MUTE, NULL, NULL,
-        test_destroy_once, &destroyed);
+    /* Make sure destroy (but not completion) callback is invoked */
+    req = radio_request_new(client, RADIO_REQ_GET_MUTE, &args,
+        test_complete_not_reached, test_destroy_once, &destroyed);
+    g_assert(radio_request_user_data(req) == &destroyed);
    radio_request_unref(req);
    g_assert(destroyed);

@@ -724,13 +747,28 @@ test_resp_complete_cb(
 {
    TestSimple* test = user_data;

-    GDEBUG("resp %d", resp);
    g_assert_cmpint(status, == ,RADIO_TX_STATUS_OK);
    g_assert_cmpint(resp, == ,RADIO_RESP_GET_MUTE);
    g_assert_cmpint(error, == ,RADIO_ERROR_NONE);
-    g_assert(!test->completed);
-    g_assert(!test->destroyed);
-    test->completed = TRUE;
+    g_assert_cmpint(test->completed, <= ,test->destroyed);
+    test->completed++;
+    GDEBUG("resp %d %d", resp, test->completed);
+}
+
+static
+void
+test_resp_destroy_cb(
+    gpointer user_data)
+{
+    TestSimple* test = user_data;
+
+    test->destroyed++;
+    g_assert_cmpint(test->completed, >= ,test->destroyed);
+    GDEBUG("destroy %d", test->destroyed);
+    if (test->destroyed == 2) {
+        GDEBUG("done");
+        test_quit_later(test->loop);
+    }
 }

 static
@@ -745,30 +783,37 @@ test_resp(
    TestSimple test;
    RadioClient* client = test_simple_init(&test);
    GBinderClient* resp_client = test.common.service.resp_client;
-    RadioRequest* req = radio_request_new(client, RADIO_REQ_GET_MUTE, NULL,
-        test_resp_complete_cb, test_simple_destroy_cb, &test);
+    RadioRequest* req1 = radio_request_new(client, RADIO_REQ_GET_MUTE, NULL,
+        test_resp_complete_cb, test_resp_destroy_cb, &test);
+    RadioRequest* req2 = radio_request_new(client, RADIO_REQ_GET_MUTE, NULL,
+        test_resp_complete_cb, test_resp_destroy_cb, &test);

-    g_assert(req);
-    g_assert(req->serial);
-    radio_request_submit(req);
-    radio_request_submit(req); /* Second submit is ignored */
+    g_assert(req1);
+    g_assert(req2);
+    g_assert(req1->serial);
+    g_assert(req2->serial);
+    g_assert(radio_request_submit(req1));
+    g_assert(!radio_request_submit(req1)); /* Second time it fails */
+    radio_request_set_retry(req2, 0, -1); /* Won't actually be retried */
+    g_assert(radio_request_submit(req2));
    test_common_connected(&test.common);

-    /* Ack the request*/
+    /* Ack the first one */
    ack = gbinder_client_new_request2(resp_client,
        RADIO_RESP_ACKNOWLEDGE_REQUEST);
-    gbinder_local_request_append_int32(ack, req->serial);
+    gbinder_local_request_append_int32(ack, req1->serial);
    g_assert_cmpint(gbinder_client_transact_sync_oneway(resp_client,
        RADIO_RESP_ACKNOWLEDGE_REQUEST, ack), == ,GBINDER_STATUS_OK);
-    g_assert(req->acked);
+    g_assert(req1->acked);

-    /* Release our ref, the internal one will be dropped when req is done */
-    radio_request_unref(req);
+    /* Release our refs */
+    radio_request_unref(req1);
+    radio_request_unref(req2);

    test_run(&test_opt, test.loop);

-    g_assert(test.completed);
-    g_assert(test.destroyed);
+    g_assert_cmpint(test.completed, == ,2);
+    g_assert_cmpint(test.destroyed, == ,test.completed);

    /* This ack is invalid and will be ignored */
    g_assert_cmpint(gbinder_client_transact_sync_oneway(resp_client,
@@ -802,9 +847,9 @@ void
 test_group(
    void)
 {
-    TestCommon test;
+    TestSimple test;
    RadioRequest* req;
-    RadioClient* client = test_common_init(&test);
+    RadioClient* client = test_simple_init(&test);
    RadioRequestGroup* group = radio_request_group_new(client);
    RadioRequestGroup* group2;
    gulong id;
@@ -812,7 +857,7 @@ test_group(
    int blocked = 0;

    g_assert(group);
-    test_common_connected(&test);
+    test_common_connected(&test.common);

    /* Test ref/unref */
    g_assert(radio_request_group_ref(group) == group);
@@ -849,17 +894,28 @@ test_group(
    req = radio_request_new2(group, RADIO_REQ_GET_MUTE, NULL,
        test_complete_not_reached, test_inc_cb, &destroyed);
    g_assert(req);
-    radio_request_submit(req);
+    g_assert(radio_request_submit(req));
    radio_request_unref(req);

    req = radio_request_new2(group, RADIO_REQ_GET_MUTE, NULL,
        test_complete_not_reached, test_inc_cb, &destroyed);
    g_assert(req);
-    radio_request_submit(req);
+    g_assert(radio_request_submit(req));
    radio_request_unref(req);

-    /* And cancel them all in one shot */
+    /* Create a request without a group */
+    req = radio_request_new(client, RADIO_REQ_GET_MUTE, NULL,
+        test_simple_complete_ok_cb, test_simple_destroy_cb, &test);
+
+    /* It can't be submitted right away because client is owned by group */
+    GDEBUG("Submitting a standalone request");
+    g_assert(radio_request_submit(req));
+    g_assert_cmpint(req->state, == ,RADIO_REQUEST_STATE_QUEUED);
+    radio_request_unref(req);
+
+    /* Cancel the whole group in one shot */
    g_assert(!destroyed);
+    GDEBUG("Cancelling group");
    radio_request_group_cancel(group);
    g_assert_cmpint(destroyed, == ,2);

@@ -872,10 +928,17 @@ test_group(
    radio_request_unref(req);
    g_assert_cmpint(destroyed, == ,3);

-    /* Cleanup */
+    /*
+     * Unblocking the group will allow the group-less request to get
+     * actually submitted, complete and quit the loop.
+     */
+    GDEBUG("Unblocking");
    radio_request_group_unblock(group);
+    test_run(&test_opt, test.loop);
+
+    /* Cleanup */
    radio_request_group_unref(group);
-    test_common_cleanup(&test);
+    test_simple_cleanup(&test);
 }

 /*==========================================================================*
@@ -904,7 +967,7 @@ test_group2(
    req = radio_request_new2(group, RADIO_REQ_GET_MUTE, NULL,
        test_complete_not_reached, test_inc_cb, &destroyed);
    g_assert(req);
-    radio_request_submit(req);
+    g_assert(radio_request_submit(req));
    g_assert_cmpint(req->state, == ,RADIO_REQUEST_STATE_PENDING);

    /* The group immediately becomes an owner because the pending
@@ -1029,7 +1092,7 @@ test_group3(
    req = radio_request_new(client, RADIO_REQ_GET_MUTE, NULL,
        test_group3_complete_cb, test_group3_destroy_continue_cb, &test);
    g_assert(req);
-    radio_request_submit(req);
+    g_assert(radio_request_submit(req));
    g_assert_cmpint(req->state, == ,RADIO_REQUEST_STATE_PENDING);
    radio_request_unref(req);

@@ -1065,19 +1128,19 @@ test_group3(
    req3 = radio_request_new2(group3, RADIO_REQ_GET_MUTE, NULL,
        test_group3_complete2_cb, test_group3_destroy_continue_cb, &test);
    g_assert(req3);
-    radio_request_submit(req3);
+    g_assert(radio_request_submit(req3));
    g_assert_cmpint(req3->state, == ,RADIO_REQUEST_STATE_QUEUED);

    req2 = radio_request_new2(group2, RADIO_REQ_GET_MUTE, NULL,
        test_group3_complete2_cb, test_group3_destroy_continue_cb, &test);
    g_assert(req2);
-    radio_request_submit(req2);
+    g_assert(radio_request_submit(req2));
    g_assert_cmpint(req2->state, == ,RADIO_REQUEST_STATE_QUEUED);

    req1 = radio_request_new2(group1, RADIO_REQ_GET_MUTE, NULL,
        test_group3_complete2_cb, test_group3_destroy_continue_cb, &test);
    g_assert(req1);
-    radio_request_submit(req1);
+    g_assert(radio_request_submit(req1));
    g_assert_cmpint(req1->state, == ,RADIO_REQUEST_STATE_QUEUED);

    /* Wait for the first request to complete */
@@ -1197,7 +1260,7 @@ test_block(
    g_assert(req);
    g_assert(req->serial);
    radio_request_set_blocking(req, TRUE);
-    radio_request_submit(req);
+    g_assert(radio_request_submit(req));
    g_assert_cmpint(req->state, == ,RADIO_REQUEST_STATE_PENDING);
    radio_request_unref(req);

@@ -1206,7 +1269,7 @@ test_block(
        test_block_complete_cb, test_block_destroy_cb, &test);
    g_assert(req);
    g_assert(req->serial);
-    radio_request_submit(req);
+    g_assert(radio_request_submit(req));
    g_assert_cmpint(req->state, == ,RADIO_REQUEST_STATE_QUEUED);
    radio_request_unref(req);

@@ -1214,7 +1277,7 @@ test_block(
        test_block_complete_cb, test_block_destroy_cb, &test);
    g_assert(req);
    g_assert(req->serial);
-    radio_request_submit(req);
+    g_assert(radio_request_submit(req));
    g_assert_cmpint(req->state, == ,RADIO_REQUEST_STATE_QUEUED);
    radio_request_unref(req);

@@ -1305,7 +1368,7 @@ test_block_timeout(
    g_assert(req->serial);
    radio_request_set_blocking(req, TRUE);
    radio_request_set_timeout(req, 100);
-    radio_request_submit(req);
+    g_assert(radio_request_submit(req));
    g_assert_cmpint(req->state, == ,RADIO_REQUEST_STATE_PENDING);
    radio_request_unref(req);

@@ -1314,7 +1377,106 @@ test_block_timeout(
        test_block_timeout_complete2_cb, test_block_timeout_destroy_cb, &test);
    g_assert(req);
    g_assert(req->serial);
-    radio_request_submit(req);
+    g_assert(radio_request_submit(req));
+    g_assert_cmpint(req->state, == ,RADIO_REQUEST_STATE_QUEUED);
+    radio_request_unref(req);
+
+    /* And wait for both request to get destroyed */
+    test_run(&test_opt, test.loop);
+
+    g_assert_cmpint(test.completed, == ,2);
+    g_assert_cmpint(test.destroyed, == ,2);
+
+    /* Cleanup */
+    test_simple_cleanup(&test);
+}
+
+/*==========================================================================*
+ * block_retry
+ *==========================================================================*/
+
+static
+void
+test_block_retry_complete1_cb(
+    RadioRequest* req,
+    RADIO_TX_STATUS status,
+    RADIO_RESP resp,
+    RADIO_ERROR error,
+    const GBinderReader* reader,
+    gpointer user_data)
+{
+    TestSimple* test = user_data;
+
+    g_assert_cmpint(status, == ,RADIO_TX_STATUS_OK);
+    g_assert_cmpint(resp, == ,ERROR_RESP);
+    g_assert_cmpint(error, == ,RADIO_ERROR_GENERIC_FAILURE);
+    g_assert_cmpint(req->retry_count, == ,req->max_retries);
+    g_assert(req->blocking);
+    g_assert(!test->completed);
+    test->completed++;
+    GDEBUG("block timed out");
+}
+
+static
+void
+test_block_retry_complete2_cb(
+    RadioRequest* req,
+    RADIO_TX_STATUS status,
+    RADIO_RESP resp,
+    RADIO_ERROR error,
+    const GBinderReader* reader,
+    gpointer user_data)
+{
+    TestSimple* test = user_data;
+
+    g_assert_cmpint(status, == ,RADIO_TX_STATUS_OK);
+    g_assert_cmpint(resp, == ,RADIO_RESP_GET_MUTE);
+    g_assert_cmpint(error, == ,RADIO_ERROR_NONE);
+    g_assert_cmpint(test->completed, == ,1);
+    test->completed++;
+    GDEBUG("second request completed");
+    test_quit_later(test->loop);
+}
+
+static
+void
+test_block_retry_destroy_cb(
+    gpointer user_data)
+{
+    TestSimple* test = user_data;
+
+    test->destroyed++;
+    GDEBUG("destruction %u", test->destroyed);
+    g_assert_cmpint(test->completed, >= ,test->destroyed);
+}
+
+static
+void
+test_block_retry(
+    void)
+{
+    TestSimple test;
+    RadioClient* client = test_simple_init(&test);
+    RadioRequest* req = radio_request_new(client, ERROR_REQ, NULL,
+        test_block_retry_complete1_cb, test_block_retry_destroy_cb, &test);
+
+    test_common_connected(&test.common);
+
+    /* Make it blocking and retriable */
+    g_assert(req);
+    g_assert(req->serial);
+    radio_request_set_blocking(req, TRUE);
+    radio_request_set_retry(req, 10, 5);
+    g_assert(radio_request_submit(req));
+    g_assert_cmpint(req->state, == ,RADIO_REQUEST_STATE_PENDING);
+    radio_request_unref(req);
+
+    /* And non-blocking */
+    req = radio_request_new(client, RADIO_REQ_GET_MUTE, NULL,
+        test_block_retry_complete2_cb, test_block_retry_destroy_cb, &test);
+    g_assert(req);
+    g_assert(req->serial);
+    g_assert(radio_request_submit(req));
    g_assert_cmpint(req->state, == ,RADIO_REQUEST_STATE_QUEUED);
    radio_request_unref(req);

@@ -1371,7 +1533,7 @@ test_retry(

    radio_request_set_retry_func(req, NULL); /* Use the default */
    radio_request_set_retry(req, 10, TEST_RETRY_COUNT);
-    radio_request_submit(req);
+    g_assert(radio_request_submit(req));
    radio_request_unref(req);

    test_run(&test_opt, test.loop);
@@ -1512,7 +1674,7 @@ test_err(
    /* Just setting retry function has no effect until non-zero number of
     * retries is set, too. */
    radio_request_set_retry_func(req, test_retry_not_reached);
-    radio_request_submit(req);
+    g_assert(radio_request_submit(req));
    radio_request_unref(req);

    test_common_connected(&test.common);
@@ -1592,7 +1754,7 @@ test_timeout(
    g_assert(req);
    g_assert(req->serial);
    radio_request_set_timeout(req, 2 * TEST_TIMEOUT_MS);
-    radio_request_submit(req);
+    g_assert(radio_request_submit(req));
    radio_request_set_timeout(req, 100); /* Resets the timeout */
    radio_request_set_timeout(req, 100); /* Has no effect */
    radio_request_unref(req);
@@ -1626,7 +1788,7 @@ test_timeout2(
    g_assert(req);
    g_assert(req->serial);
    radio_request_set_timeout(req, 2000 * TEST_TIMEOUT_SEC);
-    radio_request_submit(req);
+    g_assert(radio_request_submit(req));
    radio_request_set_timeout(req, 100); /* Resets the timeout */
    radio_request_set_timeout(req, 100); /* Has no effect */
    radio_request_unref(req);
@@ -1695,7 +1857,7 @@ test_timeout3(
    g_assert(req->serial);
    radio_request_set_retry(req, TEST_TIMEOUT_MS, 2);
    radio_request_set_timeout(req, 2 * TEST_TIMEOUT_MS);
-    radio_request_submit(req);
+    g_assert(radio_request_submit(req));
    radio_request_set_timeout(req, 100); /* Resets the timeout */
    radio_request_set_timeout(req, 100); /* Has no effect */

@@ -1737,14 +1899,14 @@ test_timeout4(
    g_assert(req1);
    g_assert(req1->serial);
    radio_request_set_timeout(req1, TEST_TIMEOUT_MS * 2);
-    radio_request_submit(req1);
+    g_assert(radio_request_submit(req1));

    /* And this one will time out quickly */
    req2 = radio_request_new(client, IGNORE_REQ, NULL,
        test_timeout_complete_cb, test_simple_destroy_cb, &test);
    g_assert(req2);
    g_assert(req2->serial);
-    radio_request_submit(req2);
+    g_assert(radio_request_submit(req2));
    radio_request_unref(req2);
    radio_client_set_default_timeout(client, 100);
    radio_client_set_default_timeout(client, 100); /* Has no effect */
@@ -1782,7 +1944,7 @@ test_destroy(

    g_assert(req);
    g_assert(req->serial);
-    radio_request_submit(req);
+    g_assert(radio_request_submit(req));
    radio_request_unref(req);

    /* Destroy the client without waiting for request to complete */
@@ -1918,6 +2080,7 @@ int main(int argc, char* argv[])
    g_test_add_func(TEST_("group3"), test_group3);
    g_test_add_func(TEST_("block"), test_block);
    g_test_add_func(TEST_("block_timeout"), test_block_timeout);
+    g_test_add_func(TEST_("block_retry"), test_block_retry);
    g_test_add_func(TEST_("retry"), test_retry);
    g_test_add_func(TEST_("retry2"), test_retry2);
    g_test_add_func(TEST_("fail"), test_fail);
--- a/unit/unit_config/unit_config.c
+++ b/unit/unit_config/unit_config.c
@@ -52,11 +52,13 @@ static const GBinderClientIfaceInfo radio_config_ind_iface_info[] = {
 };

 static const GBinderClientIfaceInfo radio_config_resp_iface_info[] = {
+    {RADIO_CONFIG_RESPONSE_1_2, RADIO_CONFIG_1_2_RESP_LAST },
    {RADIO_CONFIG_RESPONSE_1_1, RADIO_CONFIG_1_1_RESP_LAST },
    {RADIO_CONFIG_RESPONSE_1_0, RADIO_CONFIG_1_0_RESP_LAST }
 };

 static const char* const radio_config_req_ifaces[] = {
+    RADIO_CONFIG_1_2,
    RADIO_CONFIG_1_1,
    RADIO_CONFIG_1_0,
    NULL
@@ -64,7 +66,8 @@ static const char* const radio_config_req_ifaces[] = {

 static const char* const radio_config_fqnames[] = {
    RADIO_CONFIG_1_0_FQNAME,
-    RADIO_CONFIG_1_1_FQNAME
+    RADIO_CONFIG_1_1_FQNAME,
+    RADIO_CONFIG_1_2_FQNAME
 };

 static
--- a/unit/unit_util/unit_util.c
+++ b/unit/unit_util/unit_util.c
@@ -1,6 +1,6 @@
 /*
- * Copyright (C) 2021 Jolla Ltd.
- * Copyright (C) 2021 Slava Monich <slava.monich@jolla.com>
+ * Copyright (C) 2022 Jolla Ltd.
+ * Copyright (C) 2022 Slava Monich <slava.monich@jolla.com>
 *
 * You may use this file under the terms of the BSD license as follows:
 *
@@ -66,6 +66,12 @@ test_req_name(
        "setSystemSelectionChannels");
    g_assert_cmpstr(radio_req_name(RADIO_REQ_EMERGENCY_DIAL),==,
        "emergencyDial");
+    g_assert_cmpstr(radio_req_name(RADIO_REQ_ENABLE_UICC_APPLICATIONS),==,
+        "enableUiccApplications");
+    g_assert_cmpstr(radio_req_name(RADIO_REQ_START_NETWORK_SCAN_1_4),==,
+        "startNetworkScan_1_4");
+    g_assert_cmpstr(radio_req_name(RADIO_REQ_START_NETWORK_SCAN_1_5),==,
+        "startNetworkScan_1_5");
 }

 /*==========================================================================*
@@ -89,6 +95,12 @@ test_resp_name(
        "setSystemSelectionChannelsResponse");
    g_assert_cmpstr(radio_resp_name(RADIO_RESP_EMERGENCY_DIAL),==,
        "emergencyDialResponse");
+    g_assert_cmpstr(radio_resp_name(RADIO_RESP_ENABLE_UICC_APPLICATIONS),==,
+        "enableUiccApplicationsResponse");
+    g_assert_cmpstr(radio_resp_name(RADIO_RESP_START_NETWORK_SCAN_1_4),==,
+        "startNetworkScanResponse_1_4");
+    g_assert_cmpstr(radio_resp_name(RADIO_RESP_START_NETWORK_SCAN_1_5),==,
+        "startNetworkScanResponse_1_5");
 }

 /*==========================================================================*
@@ -110,6 +122,8 @@ test_ind_name(
        "currentLinkCapacityEstimate");
    g_assert_cmpstr(radio_ind_name(RADIO_IND_CURRENT_EMERGENCY_NUMBER_LIST),==,
        "currentEmergencyNumberList");
+    g_assert_cmpstr(radio_ind_name(RADIO_IND_REGISTRATION_FAILED),==,
+        "registrationFailed");
 }

 /*==========================================================================*
@@ -204,10 +218,9 @@ test_req_resp2(
          RADIO_RESP_SET_INDICATION_FILTER },
        { RADIO_REQ_SET_INDICATION_FILTER_1_2, RADIO_INTERFACE_1_4,
          RADIO_RESP_SET_INDICATION_FILTER },
-        /*
        { RADIO_REQ_SET_INDICATION_FILTER_1_5, RADIO_INTERFACE_1_5,
-          RADIO_RESP_SET_INDICATION_FILTER },
-        */
+          RADIO_RESP_SET_INDICATION_FILTER_1_5 },
+

        { RADIO_REQ_GET_ICC_CARD_STATUS, RADIO_INTERFACE_1_0,
          RADIO_RESP_GET_ICC_CARD_STATUS },
@@ -219,12 +232,10 @@ test_req_resp2(
          RADIO_RESP_GET_ICC_CARD_STATUS_1_2 },
        { RADIO_REQ_GET_ICC_CARD_STATUS, RADIO_INTERFACE_1_4,
          RADIO_RESP_GET_ICC_CARD_STATUS_1_4 },
-        /*
        { RADIO_REQ_GET_ICC_CARD_STATUS, RADIO_INTERFACE_1_5,
          RADIO_RESP_GET_ICC_CARD_STATUS_1_5 },
        { RADIO_REQ_GET_ICC_CARD_STATUS, RADIO_INTERFACE_COUNT,
-          RADIO_RESP_GET_ICC_CARD_STATUS_1_5 },
-        */
+          RADIO_RESP_NONE },
        { RADIO_REQ_GET_ICC_CARD_STATUS, RADIO_INTERFACE_NONE,
          RADIO_RESP_NONE },

@@ -238,12 +249,10 @@ test_req_resp2(
          RADIO_RESP_GET_CELL_INFO_LIST_1_2 },
        { RADIO_REQ_GET_CELL_INFO_LIST, RADIO_INTERFACE_1_4,
          RADIO_RESP_GET_CELL_INFO_LIST_1_4 },
-        /*
        { RADIO_REQ_GET_CELL_INFO_LIST, RADIO_INTERFACE_1_5,
          RADIO_RESP_GET_CELL_INFO_LIST_1_5 },
        { RADIO_REQ_GET_CELL_INFO_LIST, RADIO_INTERFACE_COUNT,
          RADIO_RESP_GET_CELL_INFO_LIST_1_5 },
-        */
        { RADIO_REQ_GET_CELL_INFO_LIST, RADIO_INTERFACE_NONE,
          RADIO_RESP_NONE },

@@ -317,12 +326,10 @@ test_req_resp2(
          RADIO_RESP_GET_DATA_CALL_LIST },
        { RADIO_REQ_GET_DATA_CALL_LIST, RADIO_INTERFACE_1_4,
          RADIO_RESP_GET_DATA_CALL_LIST_1_4 },
-        /*
        { RADIO_REQ_GET_DATA_CALL_LIST, RADIO_INTERFACE_1_5,
          RADIO_RESP_GET_DATA_CALL_LIST_1_5 },
        { RADIO_REQ_GET_DATA_CALL_LIST, RADIO_INTERFACE_COUNT,
          RADIO_RESP_GET_DATA_CALL_LIST_1_5 },
-        */
        { RADIO_REQ_GET_DATA_CALL_LIST, RADIO_INTERFACE_NONE,
          RADIO_RESP_NONE }
    };
Author	SHA1	Message	Date
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
Matti Lehtimäki	d4a04ab083	Version 1.5.5	2023-04-14 22:44:58 +03:00
Matti Lehtimäki	5cf3d8c3cc	Merge pull request #27 from mer-hybris/jb58746-fixes Add missing RadioAppStatus_1_5 struct and radio indication filter enum values. Fix cell identity enum values.	2023-04-14 22:40:27 +03:00
Matti Lehtimäki	b319fa4dc6	[gbinder-radio] Add missing RadioAppStatus_1_5 struct. JB#58746	2023-04-12 16:55:21 +03:00
Matti Lehtimäki	5cfa6756ee	[gbinder-radio] Add missing radio indication filter enum values for IRadio@1.5 interface. JB#58746	2023-04-12 16:55:18 +03:00
Matti Lehtimäki	a997d138fa	[gbinder-radio] Fix RADIO_CELL_IDENTITY_TYPE_1_5 enum values. JB#58746	2023-04-12 16:51:52 +03:00
Slava Monich	48da098644	Version 1.5.4	2022-11-30 19:17:31 +02:00
Slava Monich	3d3e023fe8	Merge pull request #26 from mer-hybris/jb58763 Add NR support	2022-11-30 19:10:06 +02:00
Matti Lehtimäki	a9da4c95d2	[gbinder-radio] Add RadioPhysicalChannelConfig structs. JB#58763 Available for IRadio@1.2 and IRadio@1.4.	2022-11-30 18:57:25 +02:00
Matti Lehtimäki	6407a0271c	[gbinder-radio] Add missing enums for NR. JB#58763	2022-11-30 18:57:25 +02:00
Matti Lehtimäki	05073a8367	[gbinder-radio] Fix RadioCellIdentity_1_5 struct. JB#58746	2022-11-30 18:57:25 +02:00
Slava Monich	7725869a27	Version 1.5.3	2022-11-19 17:52:18 +02:00
Slava Monich	7b33c6d70b	Merge pull request #25 from monich/ran Add RADIO_ACCESS_NETWORKS enum	2022-11-19 17:41:50 +02:00
Slava Monich	b38ddeb4c0	[gbinder-radio] Added RADIO_ACCESS_NETWORKS enum. JB#58746 There are two similar enums defined in types.hal files, AccessNetwork and RadioAccessNetworks. They can be easily confused with each other and yet their enum values e.g. for NGRAN are different (although GERAN, UTRAN and EUTRAN values match). Our mapping goes like this: AccessNetwork => RADIO_ACCESS_NETWORK RadioAccessNetworks => RADIO_ACCESS_NETWORKS	2022-11-19 03:48:48 +02:00
Slava Monich	db387d213a	[gbinder-radio] Housekeeping. JB#58006 Fixed comments, use appropriate enums	2022-11-19 03:44:50 +02:00
Slava Monich	ae0af8512f	Version 1.5.2	2022-11-17 03:13:49 +02:00
Slava Monich	bf51970422	Merge pull request #24 from monich/scan Added network scan related types	2022-11-17 03:07:29 +02:00
Slava Monich	e11e9a7eb1	[gbinder-radio] Added network scan related types. JB#58746	2022-11-17 03:04:32 +02:00
Slava Monich	606801a3c3	Version 1.5.1	2022-11-14 22:37:48 +02:00
Slava Monich	881dd6eef9	Merge pull request #23 from monich/resp-names Fixed names of 1.4 and 1.5 responses	2022-11-14 21:43:43 +02:00
Slava Monich	66ed8a3c7d	[gbinder-radio] Fixed names of 1.4 and 1.5 responses. JB#58006 Now they match declarations in the .hal files instead of being e.g. startNetworkScan_1_4Response vs startNetworkScanResponse_1_4	2022-11-14 21:02:05 +02:00
Slava Monich	89f3f5886f	Version 1.5.0	2022-09-16 14:17:18 +03:00
Slava Monich	499e48df9a	[gbinder-radio] Fixed getCellInfoList/getDataCallList response mapping Since getCellInfoListResponse_1_5 is the last one, it must be returned not just for 1.5 but also for all subsequent versions of the interface. The same logic applies to getDataCallListResponse_1_5	2022-09-16 14:08:05 +03:00
Slava Monich	ad536645e7	Merge pull request #22 from mer-hybris/jb58746 Add support for Radio@1.5 and RadioConfig@1.2	2022-09-16 13:36:21 +03:00
Matti Lehtimäki	0281a5ccdc	[gbinder-radio] Add support for RadioConfig@1.2. JB#58746	2022-09-16 03:36:29 +03:00
Matti Lehtimäki	ce70fb9744	[gbinder-radio] Add support for IRadio@1.5. JB#58746	2022-09-16 03:36:28 +03:00
Slava Monich	4e0723ca6c	Version 1.4.12	2022-09-11 21:38:15 +03:00
Slava Monich	050f83a22b	Merge pull request #21 from mer-hybris/jb58091-struct Fix RadioDataRegStateResult struct for IRadio@1.4	2022-09-11 21:31:26 +03:00
Matti Lehtimäki	736032efa0	[gbinder-radio] Fix RadioDataRegStateResult struct for IRadio@1.4. JB#58091	2022-09-11 20:43:43 +03:00
Slava Monich	c6d8e8d1e6	Version 1.4.11	2022-08-31 19:12:54 +03:00
Slava Monich	ee7fdd06d4	Merge pull request #20 from monich/user_data Add radio_request_user_data()	2022-08-31 19:08:22 +03:00
Slava Monich	8fa78cc777	[gbinder-radio] Added radio_request_user_data(). JB#58006	2022-08-31 14:29:45 +03:00
Slava Monich	f4276f8602	Version 1.4.10	2022-04-15 22:01:08 +03:00
Slava Monich	ff1195ffc6	Merge pull request #19 from monich/complete Tweak completion callback criteria	2022-04-15 21:55:43 +03:00
Slava Monich	11673897fa	[gbinder-radio] Tweaked completion callback criteria. JB#58006 Don't invoke completion callback for the requests that were never submitted.	2022-04-15 21:22:06 +03:00
Slava Monich	520fe4257a	Version 1.4.9	2022-02-17 01:49:55 +02:00
Slava Monich	179e8d6160	Merge pull request #18 from monich/ims Add IMS types	2022-02-17 01:32:49 +02:00
Slava Monich	6d52c79f6c	[gbinder-radio] Added IMS types. JB#57425	2022-02-17 00:53:56 +02:00
Slava Monich	48026e4fe6	Version 1.4.8	2022-01-19 03:34:14 +02:00
Slava Monich	451711a1ce	Merge pull request #17 from monich/block-retry Fix retries of blocking requests	2022-01-19 03:29:44 +02:00
Slava Monich	32523f2b1a	[unit] Added test for retry of a blocking request. JB#57102	2022-01-19 03:24:54 +02:00
Slava Monich	e0e475c4e3	[gbinder-radio] Fixed retries of blocking requests. JB#57102 A blocking request shouldn't block itself.	2022-01-19 01:25:00 +02:00
Slava Monich	02789fa6a4	[gbinder-radio] More logging in radio_request_default_retry() To make it clear why request was (or wasn't) retried	2022-01-19 01:22:12 +02:00
Slava Monich	6a4f434592	Version 1.4.7	2022-01-10 01:04:17 +02:00
Slava Monich	a96fdf6c42	[gbinder-radio] Fixed owner queue logic. JB#56824	2022-01-10 01:02:01 +02:00
Slava Monich	77a9b126ef	[gbinder-radio] Added internal DEBUG_ASSERT macro It's an assert fatal in debug build and non-fatal in release. Marks truely unavoidable conditions.	2022-01-09 19:30:39 +02:00
Slava Monich	5085ccc3c6	[gbinder-radio] Houskeeping radio_base_ref/unref are unnecessary. It's an internal API, it doesn't add much to compile time type safety, and the object pointer is always checked for NULL by the caller anyway, there's no need to check it twice.	2022-01-09 19:28:02 +02:00
				`@@ -0,0 +1 @@`
				`debian/tmp/@LIBDIR@/libgbinder-radio.so.* @LIBDIR@`