[gbinder-radio] Add support for IRadio@1.6. JB#63650

[gbinder-radio] Add support for IRadioConfig@1.3. JB#63650
Merge pull request #29 from monich/fix_loop
2025-08-24 22:17:12 +03:00 · 2025-08-24 19:16:02 +03:00 · 2024-10-28 18:18:05 +02:00 · 2024-10-28 02:29:51 +02:00 · 2024-09-26 14:06:44 +03:00 · 2024-09-26 14:01:59 +03:00
25 changed files with 2529 additions and 268 deletions
--- a/4
+++ b/4
@@ -23,8 +23,8 @@ all: debug release pkgconfig
 #

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

 # Version for pkg-config
 PCVERSION = $(VERSION_MAJOR).$(VERSION_MINOR).$(VERSION_RELEASE)
--- a/debian/changelog
+++ b/debian/changelog
@@ -1,3 +1,22 @@
+libgbinder-radio (1.6.0) unstable; urgency=medium
+
+  * Implement support for AIDL IRadioIms
+  * Implement support for AIDL IRadioVoice
+  * Implement support for AIDL IRadioMessaging
+  * Implement support for AIDL IRadioData
+  * Implement support for AIDL IRadioNetwork
+  * Implement support for AIDL IRadioSim
+  * Implement support for AIDL IRadioModem
+  * Implement support for AIDL IRadioConfig
+
+ -- Matti Lehtimäki <matti.lehtimaki@jolla.com>  Thu, 26 Sep 2024 14:03:30 +0300
+
+libgbinder-radio (1.5.6) unstable; urgency=medium
+
+  * Fix version in Makefile
+
+ -- Matti Lehtimäki <matti.lehtimaki@jolla.com>  Fri, 21 Apr 2023 14:55:38 +0300
+
 libgbinder-radio (1.5.5) unstable; urgency=medium

  * Fix RADIO_CELL_IDENTITY_TYPE_1_5 enum values
--- 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
@@ -48,6 +48,7 @@ typedef enum radio_config_interface {
    RADIO_CONFIG_INTERFACE_1_0,
    RADIO_CONFIG_INTERFACE_1_1,
    RADIO_CONFIG_INTERFACE_1_2, /* Since 1.5.0 */
+    RADIO_CONFIG_INTERFACE_1_3, /* Since 1.6.1 */
    RADIO_CONFIG_INTERFACE_COUNT
 } RADIO_CONFIG_INTERFACE;

@@ -61,18 +62,23 @@ typedef enum radio_config_interface {
 #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_IFACE_1_3(x)     RADIO_CONFIG_IFACE_PREFIX "1.3::" 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_3              RADIO_CONFIG_IFACE_1_3(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_1_3_FQNAME       RADIO_CONFIG_1_3 "/" 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_RESPONSE_1_3 \
+        RADIO_CONFIG_IFACE_1_3(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 \
@@ -133,6 +139,9 @@ G_STATIC_ASSERT(sizeof(RadioModemsConfig) == 1);
    c(6,5,setModemsConfig,SET_MODEMS_CONFIG) \
    c(7,6,getModemsConfig,GET_MODEMS_CONFIG)

+#define RADIO_CONFIG_CALL_1_3(c) \
+    c(8,8,getHalDeviceCapabilities,GET_HAL_DEVICE_CAPABILITIES) /* Since 1.6.1 */
+
 /* i(code,Name,IND_NAME) */
 #define RADIO_CONFIG_IND_1_0(i) \
    i(1,simSlotsStatusChanged,SIM_SLOTS_STATUS_CHANGED)
@@ -152,7 +161,11 @@ typedef enum radio_config_req {

    /* android.hardware.radio.config@1.1::IRadioConfig */
    RADIO_CONFIG_CALL_1_1(RADIO_CONFIG_REQ_)
-    RADIO_CONFIG_1_1_REQ_LAST = RADIO_CONFIG_REQ_GET_MODEMS_CONFIG
+    RADIO_CONFIG_1_1_REQ_LAST = RADIO_CONFIG_REQ_GET_MODEMS_CONFIG,
+
+    /* android.hardware.radio.config@1.3::IRadioConfig */
+    RADIO_CONFIG_CALL_1_3(RADIO_CONFIG_REQ_)
+    RADIO_CONFIG_1_3_REQ_LAST = RADIO_CONFIG_REQ_GET_HAL_DEVICE_CAPABILITIES

 #undef RADIO_CONFIG_REQ_
 } RADIO_CONFIG_REQ;
@@ -173,7 +186,11 @@ typedef enum radio_config_resp {

    /* 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
+    RADIO_CONFIG_1_2_RESP_LAST = RADIO_CONFIG_RESP_GET_SIM_SLOTS_STATUS_1_2,
+
+    /* android.hardware.radio.config@1.3::IRadioConfigResponse */
+    RADIO_CONFIG_CALL_1_3(RADIO_CONFIG_RESP_)
+    RADIO_CONFIG_1_3_RESP_LAST = RADIO_CONFIG_RESP_GET_HAL_DEVICE_CAPABILITIES
 #undef RADIO_CONFIG_RESP_
 } RADIO_CONFIG_RESP;
 G_STATIC_ASSERT(sizeof(RADIO_CONFIG_RESP) == 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_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
@@ -63,9 +63,28 @@ typedef enum radio_interface {
    RADIO_INTERFACE_1_3,
    RADIO_INTERFACE_1_4,
    RADIO_INTERFACE_1_5, /* Since 1.5.0 */
+    RADIO_INTERFACE_1_6, /* Since 1.6.1 */
    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,
@@ -82,24 +101,28 @@ typedef enum radio_observer_priority {
 #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_IFACE_1_6(x)     RADIO_IFACE_PREFIX "1.6::" 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_1_6              RADIO_IFACE_1_6(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_RESPONSE_1_6     RADIO_IFACE_1_6(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)
+#define RADIO_INDICATION_1_6   RADIO_IFACE_1_6(RADIO_INDICATION_IFACE)

 /* Types defined in types.hal */

@@ -178,6 +201,11 @@ typedef enum radio_error {
    RADIO_ERROR_DEVICE_IN_USE = 64,
    RADIO_ERROR_ABORTED = 65,
    RADIO_ERROR_INVALID_RESPONSE = 66,
+    RADIO_ERROR_SIMULTANEOUS_SMS_AND_CALL_NOT_ALLOWED = 67,
+    RADIO_ERROR_ACCESS_BARRED = 68,
+    RADIO_ERROR_BLOCKED_DUE_TO_CALL = 69,
+    RADIO_ERROR_RF_HARDWARE_ISSUE = 70,
+    RADIO_ERROR_NO_RF_CALIBRATION_INFO = 71,
    RADIO_ERROR_OEM_ERROR_1 = 501,
    RADIO_ERROR_OEM_ERROR_2 = 502,
    RADIO_ERROR_OEM_ERROR_3 = 503,
@@ -834,6 +862,7 @@ typedef enum radio_ngran_band {
    RADIO_NGRAN_BAND_18 = 18,
    RADIO_NGRAN_BAND_20 = 20,
    RADIO_NGRAN_BAND_25 = 25,
+    RADIO_NGRAN_BAND_26 = 26,
    RADIO_NGRAN_BAND_28 = 28,
    RADIO_NGRAN_BAND_29 = 29,
    RADIO_NGRAN_BAND_30 = 30,
@@ -842,9 +871,11 @@ typedef enum radio_ngran_band {
    RADIO_NGRAN_BAND_39 = 39,
    RADIO_NGRAN_BAND_40 = 40,
    RADIO_NGRAN_BAND_41 = 41,
+    RADIO_NGRAN_BAND_46 = 46,
    RADIO_NGRAN_BAND_48 = 48,
    RADIO_NGRAN_BAND_50 = 50,
    RADIO_NGRAN_BAND_51 = 51,
+    RADIO_NGRAN_BAND_53 = 53,
    RADIO_NGRAN_BAND_65 = 65,
    RADIO_NGRAN_BAND_66 = 66,
    RADIO_NGRAN_BAND_70 = 70,
@@ -868,6 +899,7 @@ typedef enum radio_ngran_band {
    RADIO_NGRAN_BAND_93 = 93,
    RADIO_NGRAN_BAND_94 = 94,
    RADIO_NGRAN_BAND_95 = 95,
+    RADIO_NGRAN_BAND_96 = 96,
    RADIO_NGRAN_BAND_257 = 257,
    RADIO_NGRAN_BAND_258 = 258,
    RADIO_NGRAN_BAND_260 = 260,
@@ -1292,6 +1324,9 @@ typedef enum radio_data_call_fail_cause {
    RADIO_DATA_CALL_FAIL_VSNCP_RECONNECT_NOT_ALLOWED = 0x8C9,
    RADIO_DATA_CALL_FAIL_IPV6_PREFIX_UNAVAILABLE = 0x8CA,
    RADIO_DATA_CALL_FAIL_HANDOFF_PREFERENCE_CHANGED = 0x8CB,
+    RADIO_DATA_CALL_FAIL_SLICE_REJECTED = 0x8CC,
+    RADIO_DATA_CALL_FAIL_MATCH_ALL_RULE_NOT_ALLOWED = 0x8CD,
+    RADIO_DATA_CALL_FAIL_ALL_MATCHING_RULES_FAILED = 0x8CE,
    RADIO_DATA_CALL_FAIL_OEM_DCFAILCAUSE_1 = 0x1001,
    RADIO_DATA_CALL_FAIL_OEM_DCFAILCAUSE_2 = 0x1002,
    RADIO_DATA_CALL_FAIL_OEM_DCFAILCAUSE_3 = 0x1003,
@@ -1405,6 +1440,12 @@ typedef struct radio_call_1_2 {
 } RADIO_ALIGNED(8) RadioCall_1_2; /* Since 1.2.3 */
 G_STATIC_ASSERT(sizeof(RadioCall_1_2) == 96);

+typedef struct radio_call_1_6 {
+    RadioCall_1_2 base RADIO_ALIGNED(8);
+    GBinderHidlString forwardedNumber RADIO_ALIGNED(8);
+} RADIO_ALIGNED(8) RadioCall_1_6; /* Since 1.2.3 */
+G_STATIC_ASSERT(sizeof(RadioCall_1_6) == 112);
+
 typedef struct radio_dial {
    GBinderHidlString address RADIO_ALIGNED(8);
    RADIO_CLIR clir RADIO_ALIGNED(4);
@@ -1544,6 +1585,93 @@ typedef struct radio_data_call_1_5 {
 } RADIO_ALIGNED(8) RadioDataCall_1_5; /* Since 1.5.0 */
 G_STATIC_ASSERT(sizeof(RadioDataCall_1_5) == 112);

+typedef struct radio_qos_bandwidth {
+    guint32 maxBitrateKbps RADIO_ALIGNED(4);
+    guint32 guaranteedBitrateKbps RADIO_ALIGNED(4);
+} RADIO_ALIGNED(4) RadioQosBandwidth; /* Since 1.6.1 */
+G_STATIC_ASSERT(sizeof(RadioQosBandwidth) == 8);
+
+typedef struct radio_eps_qos {
+    guint16 qci RADIO_ALIGNED(2);
+    RadioQosBandwidth downlink RADIO_ALIGNED(4);
+    RadioQosBandwidth uplink RADIO_ALIGNED(4);
+} RADIO_ALIGNED(4) RadioEpsQos; /* Since 1.6.1 */
+G_STATIC_ASSERT(sizeof(RadioEpsQos) == 20);
+
+typedef struct radio_nr_qos {
+    guint16 fiveQi RADIO_ALIGNED(2);
+    RadioQosBandwidth downlink RADIO_ALIGNED(4);
+    RadioQosBandwidth uplink RADIO_ALIGNED(4);
+    guint8 qfi RADIO_ALIGNED(1) /* 1-63 */;
+    guint16 averagingWindowMs RADIO_ALIGNED(2);
+} RADIO_ALIGNED(4) RadioNrQos; /* Since 1.6.1 */
+G_STATIC_ASSERT(sizeof(RadioNrQos) == 24);
+
+typedef struct radio_slice_info {
+    guint8 sst RADIO_ALIGNED(1); /* SliceServiceType */
+    gint32 sliceDifferentiator RADIO_ALIGNED(4);
+    guint8 mappedHplmnSst RADIO_ALIGNED(1); /* SliceServiceType */
+    gint32 mappedHplmnSD RADIO_ALIGNED(4);
+    gint8 status RADIO_ALIGNED(1); /* SliceStatus */
+} RADIO_ALIGNED(4) RadioSliceInfo; /* Since 1.6.1 */
+G_STATIC_ASSERT(sizeof(RadioSliceInfo) == 20);
+
+typedef struct radio_optional_slice_info {
+    guint8 available RADIO_ALIGNED(1);
+    RadioSliceInfo sliceInfo RADIO_ALIGNED(4);
+} RADIO_ALIGNED(4) RadioOptionalSliceInfo; /* Since 1.6.1 */
+G_STATIC_ASSERT(sizeof(RadioOptionalSliceInfo) == 24);
+
+typedef struct radio_dnn {
+    guint8 available RADIO_ALIGNED(1);
+    GBinderHidlString dnn RADIO_ALIGNED(8);
+} RADIO_ALIGNED(8) RadioDnn; /* Since 1.6.1 */
+G_STATIC_ASSERT(sizeof(RadioDnn) == 24);
+
+typedef struct radio_os_app_id {
+    guint8 available RADIO_ALIGNED(1);
+    GBinderHidlVec osAppId RADIO_ALIGNED(8); /* vec<uint8_t> */
+} RADIO_ALIGNED(8) RadioOsAppId; /* Since 1.6.1 */
+G_STATIC_ASSERT(sizeof(RadioOsAppId) == 24);
+
+typedef struct radio_traffic_descriptor {
+    RadioDnn dnn RADIO_ALIGNED(8);
+    RadioOsAppId osAppId RADIO_ALIGNED(8);
+} RADIO_ALIGNED(8) RadioTrafficDescriptor; /* Since 1.6.1 */
+G_STATIC_ASSERT(sizeof(RadioTrafficDescriptor) == 48);
+
+typedef struct radio_optional_traffic_descriptor {
+    guint8 available RADIO_ALIGNED(1);
+    RadioTrafficDescriptor trafficDescriptor RADIO_ALIGNED(8);
+} RADIO_ALIGNED(8) RadioOptionalTrafficDescriptor; /* Since 1.6.1 */
+G_STATIC_ASSERT(sizeof(RadioOptionalTrafficDescriptor) == 56);
+
+typedef struct radio_data_call_1_6 {
+    RADIO_DATA_CALL_FAIL_CAUSE cause RADIO_ALIGNED(4);
+    gint64 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);
+    guint8 qosType RADIO_ALIGNED(1); /* QOS_TYPE */
+    union {
+        RadioEpsQos eps;
+        RadioNrQos nr;
+    } RADIO_ALIGNED(4) defaultQos;
+    GBinderHidlVec qosSessions RADIO_ALIGNED(8); /* vec<QosSession> */
+    gint8 handoverFailureMode RADIO_ALIGNED(1) /* HandoverFailureMode */;
+    gint32 pduSessionId RADIO_ALIGNED(4);
+    RadioOptionalSliceInfo value RADIO_ALIGNED(4);
+    GBinderHidlVec trafficDescriptors RADIO_ALIGNED(8); /* vec<TrafficDescriptor> */
+} RADIO_ALIGNED(8) RadioDataCall_1_6; /* Since 1.6.1 */
+G_STATIC_ASSERT(sizeof(RadioDataCall_1_6) == 216);
+
 typedef struct radio_sms_write_args {
    gint32 status RADIO_ALIGNED(4);
    GBinderHidlString pdu RADIO_ALIGNED(8);
@@ -1929,6 +2057,29 @@ typedef struct radio_reg_state_result_1_5 {
 } RADIO_ALIGNED(8) RadioRegStateResult_1_5; /* Since 1.5.0 */
 G_STATIC_ASSERT(sizeof(RadioRegStateResult_1_5) == 224);

+typedef struct radio_nr_vops_info {
+    guint8 vopsSupported RADIO_ALIGNED(1);
+    guint8 emcSupported RADIO_ALIGNED(1);
+    guint8 emfSupported RADIO_ALIGNED(1);
+} RADIO_ALIGNED(1) RadioNrVopsInfo;  /* Since 1.6.1 */
+G_STATIC_ASSERT(sizeof(RadioNrVopsInfo) == 3);
+
+typedef struct radio_reg_state_result_1_6 {
+    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);
+        RadioNrVopsInfo ngranNrVopsInfo RADIO_ALIGNED(1);
+        gboolean geranDtmSupported RADIO_ALIGNED(1);
+    } accessTechnologySpecificInfo RADIO_ALIGNED(4);
+} RADIO_ALIGNED(8) RadioRegStateResult_1_6; /* Since 1.6.1 */
+G_STATIC_ASSERT(sizeof(RadioRegStateResult_1_6) == 224);
+
 typedef struct radio_signal_strength_gsm {
    guint32 signalStrength RADIO_ALIGNED(4);
    guint32 bitErrorRate RADIO_ALIGNED(4);
@@ -2024,6 +2175,30 @@ typedef struct radio_signal_strength_1_4 {
 } RADIO_ALIGNED(4) RadioSignalStrength_1_4; /* Since 1.2.5 */
 G_STATIC_ASSERT(sizeof(RadioSignalStrength_1_4) == 108);

+typedef struct radio_signal_strength_lte_1_6 {
+    RadioSignalStrengthLte base RADIO_ALIGNED(4);
+    guint32 cqiTableIndex RADIO_ALIGNED(4);
+} RADIO_ALIGNED(4) RadioSignalStrengthLte_1_6; /* Since 1.6.1 */
+G_STATIC_ASSERT(sizeof(RadioSignalStrengthLte_1_6) == 28);
+
+typedef struct radio_signal_strength_nr_1_6 {
+    RadioSignalStrengthNr base RADIO_ALIGNED(4);
+    guint32 csiCqiTableIndex RADIO_ALIGNED(4);
+    GBinderHidlVec csiCqiReport RADIO_ALIGNED(8);
+} RADIO_ALIGNED(8) RadioSignalStrengthNr_1_6; /* Since 1.6.1 */
+G_STATIC_ASSERT(sizeof(RadioSignalStrengthNr_1_6) == 48);
+
+typedef struct radio_signal_strength_1_6 {
+    RadioSignalStrengthGsm gsm RADIO_ALIGNED(4);
+    RadioSignalStrengthCdma cdma RADIO_ALIGNED(4);
+    RadioSignalStrengthEvdo evdo RADIO_ALIGNED(4);
+    RadioSignalStrengthLte_1_6 lte RADIO_ALIGNED(4);
+    RadioSignalStrengthTdScdma_1_2 tdscdma RADIO_ALIGNED(4);
+    RadioSignalStrengthWcdma_1_2 wcdma RADIO_ALIGNED(4);
+    RadioSignalStrengthNr_1_6 nr RADIO_ALIGNED(4);
+} RADIO_ALIGNED(4) RadioSignalStrength_1_6; /* Since 1.6.1 */
+G_STATIC_ASSERT(sizeof(RadioSignalStrength_1_6) == 136);
+
 typedef struct radio_cell_info_gsm {
    RadioCellIdentityGsm cellIdentityGsm RADIO_ALIGNED(8);
    RadioSignalStrengthGsm signalStrengthGsm RADIO_ALIGNED(4);
@@ -2160,6 +2335,33 @@ typedef struct radio_cell_info_1_5 {
 } RADIO_ALIGNED(8) RadioCellInfo_1_5; /* Since 1.5.0 */
 G_STATIC_ASSERT(sizeof(RadioCellInfo_1_5) == 216);

+typedef struct radio_cell_info_lte_1_6 {
+    RadioCellIdentityLte_1_5 cellIdentityLte RADIO_ALIGNED(8);
+    RadioSignalStrengthLte_1_6 signalStrengthLte RADIO_ALIGNED(4);
+} RADIO_ALIGNED(8) RadioCellInfoLte_1_6; /* Since 1.6.1 */
+G_STATIC_ASSERT(sizeof(RadioCellInfoLte_1_6) == 192);
+
+typedef struct radio_cell_info_nr_1_6 {
+    RadioCellIdentityNr_1_5 cellIdentityNr RADIO_ALIGNED(8);
+    RadioSignalStrengthNr_1_6 signalStrengthNr RADIO_ALIGNED(4);
+} RADIO_ALIGNED(8) RadioCellInfoNr_1_6; /* Since 1.6.1 */
+G_STATIC_ASSERT(sizeof(RadioCellInfoNr_1_6) == 168);
+
+typedef struct radio_cell_info_1_6 {
+    guint8 registered RADIO_ALIGNED(1);
+    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_6 lte RADIO_ALIGNED(8);
+        RadioCellInfoNr_1_6 nr RADIO_ALIGNED(8);
+        RadioCellInfoCdma_1_2 cdma RADIO_ALIGNED(8);
+    } info RADIO_ALIGNED(8);
+} RADIO_ALIGNED(8) RadioCellInfo_1_6; /* Since 1.6.1 */
+G_STATIC_ASSERT(sizeof(RadioCellInfo_1_6) == 208);
+
 typedef struct radio_physical_channel_config {
    RADIO_CELL_CONNECTION_STATUS connectionStatus RADIO_ALIGNED(4);
    gint32 cellBandwidthDownlink RADIO_ALIGNED(4);
@@ -2184,6 +2386,25 @@ typedef struct radio_physical_channel_config_1_4 {
 } RADIO_ALIGNED(8) RadioPhysicalChannelConfig_1_4; /* Since 1.5.4 */
 G_STATIC_ASSERT(sizeof(RadioPhysicalChannelConfig_1_4) == 48);

+typedef struct radio_physical_channel_config_1_6 {
+    RADIO_CELL_CONNECTION_STATUS connectionStatus RADIO_ALIGNED(4);
+    RADIO_TECH rat RADIO_ALIGNED(4);
+    gint32 downlinkChannelNumber RADIO_ALIGNED(4);
+    gint32 uplinkChannelNumber RADIO_ALIGNED(4);
+    gint32 cellBandwidthDownlinkKhz RADIO_ALIGNED(4);
+    gint32 cellBandwidthUplinkKhz RADIO_ALIGNED(4);
+    GBinderHidlVec contextIds RADIO_ALIGNED(8); /* vec<gint32> */
+    guint32 physicalCellId RADIO_ALIGNED(4);
+    guint8 bandType RADIO_ALIGNED(1); /* BAND_TYPE */
+    union {
+        gint32 geranBand;
+        gint32 utranBand;
+        gint32 eutranBand;
+        gint32 ngranBand;
+    } RADIO_ALIGNED(4) band;
+} RADIO_ALIGNED(8) RadioPhysicalChannelConfig_1_6; /* Since 1.6.1 */
+G_STATIC_ASSERT(sizeof(RadioPhysicalChannelConfig_1_6) == 56);
+
 typedef struct radio_gsm_broadcast_sms_config {
    gint32 fromServiceId RADIO_ALIGNED(4);
    gint32 toServiceId RADIO_ALIGNED(4);
@@ -2270,6 +2491,7 @@ typedef struct radio_network_scan_result {
                                               /* or vec<RadioCellInfo_1_2> */
                                               /* or vec<RadioCellInfo_1_4> */
                                               /* or vec<RadioCellInfo_1_5> */
+                                               /* or vec<RadioCellInfo_1_6> */
 } RADIO_ALIGNED(8) RadioNetworkScanResult; /* Since 1.2.5 */
 G_STATIC_ASSERT(sizeof(RadioNetworkScanResult) == 24);

@@ -2499,6 +2721,35 @@ G_STATIC_ASSERT(sizeof(RadioNetworkScanRequest_1_5) == 56);
    c(171,176,sendCdmaSmsExpectMore,SEND_CDMA_SMS_EXPECT_MORE,) \
    c(172,177,supplySimDepersonalization,SUPPLY_SIM_PERSONALIZATION,)

+#define RADIO_CALL_1_6_(c) /* Since 1.6.1 */ \
+    c(173,179,setRadioPower,SET_RADIO_POWER,_1_6) \
+    c(174,181,getDataCallList,GET_DATA_CALL_LIST,_1_6) \
+    c(175,180,setupDataCall,SETUP_DATA_CALL,_1_6) \
+    c(176,182,sendSms,SEND_SMS,_1_6) \
+    c(177,183,sendSmsExpectMore,SEND_SMS_EXPECT_MORE,_1_6) \
+    c(178,184,sendCdmaSms,SEND_CDMA_SMS,_1_6) \
+    c(179,185,sendCdmaSmsExpectMore,SEND_CDMA_SMS_EXPECT_MORE,_1_6) \
+    c(180,186,setSimCardPower,SET_SIM_CARD_POWER,_1_6) \
+    c(181,187,setNrDualConnectivityState,SET_NR_DUAL_CONNECTIVITY_STATE,) \
+    c(182,188,isNrDualConnectivityEnabled,IS_NR_DUAL_CONNECTIVITY_ENABLED,) \
+    c(183,189,allocatePduSessionId,ALLOCATE_PDU_SESSION_ID,) \
+    c(184,190,releasePduSessionId,RELEASE_PDU_SESSION_ID,) \
+    c(185,191,startHandover,START_HANDOVER,) \
+    c(186,192,cancelHandover,CANCEL_HANDOVER,) \
+    c(187,193,setAllowedNetworkTypesBitmap,SET_ALLOWED_NETWORK_TYPES_BITMAP,) \
+    c(188,194,getAllowedNetworkTypesBitmap,GET_ALLOWED_NETWORK_TYPES_BITMAP,) \
+    c(189,195,setDataThrottling,SET_DATA_THROTTLING,) \
+    c(191,196,getSystemSelectionChannels,GET_SYSTEM_SELECTION_CHANNELS,) \
+    c(192,197,getCellInfoList,GET_CELL_INFO_LIST,_1_6) \
+    c(193,199,getVoiceRegistrationState,GET_VOICE_REGISTRATION_STATE,_1_6) \
+    c(194,198,getSignalStrength,GET_SIGNAL_STRENGTH,_1_6) \
+    c(195,200,getDataRegistrationState,GET_DATA_REGISTRATION_STATE,_1_6) \
+    c(196,201,getCurrentCalls,GET_CURRENT_CALLS,_1_6) \
+    c(197,202,getSlicingConfig,GET_SLICING_CONFIG,) \
+    c(199,203,getSimPhonebookRecords,GET_SIM_PHONEBOOK_RECORDS,) \
+    c(200,204,getSimPhonebookCapacity,GET_SIM_PHONEBOOK_CAPACITY,) \
+    c(201,205,updateSimPhonebookRecords,UPDATE_SIM_PHONEBOOK_RECORDS,)
+
 /* e(code,eventName,EVENT_NAME) */
 #define RADIO_EVENT_1_0(e) \
    e(1,radioStateChanged,RADIO_STATE_CHANGED) \
@@ -2575,6 +2826,17 @@ G_STATIC_ASSERT(sizeof(RadioNetworkScanRequest_1_5) == 56);
    e(64,networkScanResult_1_5,NETWORK_SCAN_RESULT_1_5) \
    e(65,dataCallListChanged_1_5,DATA_CALL_LIST_CHANGED_1_5)

+#define RADIO_EVENT_1_6(e)  /* Since 1.6.1 */ \
+    e(66,dataCallListChanged_1_6,DATA_CALL_LIST_CHANGED_1_6) \
+    e(67,unthrottleApn, UNTHROTTLE_APN) \
+    e(68,currentLinkCapacityEstimate_1_6, CURRENT_LINK_CAPACITY_ESTIMATE_1_6) \
+    e(69,currentSignalStrength_1_6,CURRENT_SIGNAL_STRENGTH_1_6) \
+    e(70,cellInfoList_1_6,CELL_INFO_LIST_1_6) \
+    e(71,networkScanResult_1_6,NETWORK_SCAN_RESULT_1_6) \
+    e(72,currentPhysicalChannelConfigs_1_6,CURRENT_PHYSICAL_CHANNEL_CONFIGS_1_6) \
+    e(73,simPhonebookChanged, SIM_PHONEBOOK_CHANGED) \
+    e(74,simPhonebookRecordsReceived, SIM_PHONEBOOK_RECORDS_RECEIVED)
+
 typedef enum radio_req {
    RADIO_REQ_ANY = 0,
    RADIO_REQ_NONE = 0,
@@ -2611,7 +2873,13 @@ typedef enum radio_req {

    /* 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
+    RADIO_1_5_REQ_LAST = RADIO_REQ_SUPPLY_SIM_PERSONALIZATION,
+
+    /* android.hardware.radio@1.6::IRadio */
+    RADIO_CALL_1_6_(RADIO_REQ__) /* Since 1.6.1 */
+    RADIO_REQ_EMERGENCY_DIAL_1_6 = 190,
+    RADIO_REQ_SET_CARRIER_INFO_FOR_IMSI_ENCRYPTION_1_6 = 198,
+    RADIO_1_6_REQ_LAST = RADIO_REQ_UPDATE_SIM_PHONEBOOK_RECORDS
 #undef RADIO_REQ_
 #undef RADIO_REQ__
 } RADIO_REQ;
@@ -2659,7 +2927,11 @@ typedef enum radio_resp {
    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
+    RADIO_1_5_RESP_LAST = RADIO_RESP_GET_ICC_CARD_STATUS_1_5,
+
+    /* android.hardware.radio@1.6::IRadioResponse */
+    RADIO_CALL_1_6_(RADIO_RESP__) /* Since 1.6.1 */
+    RADIO_1_6_RESP_LAST = RADIO_RESP_UPDATE_SIM_PHONEBOOK_RECORDS
 #undef RADIO_RESP_
 #undef RADIO_RESP__
 } RADIO_RESP;
@@ -2707,7 +2979,11 @@ typedef enum radio_ind {

    /* 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 */
+    RADIO_1_5_IND_LAST = RADIO_IND_DATA_CALL_LIST_CHANGED_1_5, /* Since 1.5.0 */
+
+    /* android.hardware.radio@1.6::IRadioIndication */
+    RADIO_EVENT_1_6(RADIO_IND_)
+    RADIO_1_6_IND_LAST = RADIO_IND_SIM_PHONEBOOK_RECORDS_RECEIVED /* Since 1.6.1 */
 #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.5.5
+Version: 1.6.0
 Release: 0
 Summary: Binder client library for Android radio interfaces
 License: BSD
--- a/src/radio_client.c
+++ b/src/radio_client.c
@@ -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,6 +115,7 @@ 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_3, RADIO_CONFIG_1_3_REQ_LAST },
    {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 }
@@ -121,7 +123,14 @@ static const GBinderClientIfaceInfo radio_config_iface_info[] = {
 G_STATIC_ASSERT(G_N_ELEMENTS(radio_config_iface_info) ==
    RADIO_CONFIG_INTERFACE_COUNT);

+static const GBinderClientIfaceInfo radio_config_aidl_iface_info[] = {
+    {RADIO_CONFIG_AIDL, RADIO_CONFIG_1_1_REQ_LAST }
+};
+G_STATIC_ASSERT(G_N_ELEMENTS(radio_config_aidl_iface_info) ==
+    RADIO_CONFIG_AIDL_INTERFACE_COUNT);
+
 static const char* const radio_config_indication_ifaces[] = {
+    RADIO_CONFIG_INDICATION_1_2,
    RADIO_CONFIG_INDICATION_1_2,
    RADIO_CONFIG_INDICATION_1_1,
    RADIO_CONFIG_INDICATION_1_0,
@@ -130,7 +139,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_3,
    RADIO_CONFIG_RESPONSE_1_2,
    RADIO_CONFIG_RESPONSE_1_1,
    RADIO_CONFIG_RESPONSE_1_0,
@@ -139,7 +156,15 @@ static const char* const radio_config_response_ifaces[] = {
 G_STATIC_ASSERT(G_N_ELEMENTS(radio_config_response_ifaces) ==
    RADIO_CONFIG_INTERFACE_COUNT + 1);

+static const char* const radio_config_aidl_response_ifaces[] = {
+    RADIO_CONFIG_AIDL_RESPONSE,
+    NULL
+};
+G_STATIC_ASSERT(G_N_ELEMENTS(radio_config_aidl_response_ifaces) ==
+    RADIO_CONFIG_AIDL_INTERFACE_COUNT + 1);
+
 typedef struct radio_config_interface_desc {
+    RADIO_INTERFACE_TYPE interface_type;
    RADIO_CONFIG_INTERFACE version;
    const char* fqname;
    const char* radio_iface;
@@ -150,6 +175,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, \
@@ -159,6 +185,7 @@ 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_3) },
   { RADIO_CONFIG_INTERFACE_DESC(1_2) },
   { RADIO_CONFIG_INTERFACE_DESC(1_1) },
   { RADIO_CONFIG_INTERFACE_DESC(1_0) }
@@ -166,9 +193,24 @@ static const RadioConfigInterfaceDesc radio_config_interfaces[] = {
 G_STATIC_ASSERT(G_N_ELEMENTS(radio_config_interfaces) ==
    RADIO_CONFIG_INTERFACE_COUNT);

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

 typedef struct radio_config_call {
    RadioRequest* req;
@@ -205,8 +247,10 @@ radio_config_call_complete(
 static
 const char*
 radio_config_known_req_name(
+    RadioConfig* self,
    RADIO_CONFIG_REQ req)
 {
+    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) \
@@ -214,47 +258,85 @@ radio_config_known_req_name(
        RADIO_CONFIG_CALL_1_0(RADIO_CONFIG_REQ_)
        RADIO_CONFIG_CALL_1_1(RADIO_CONFIG_REQ_)
        /* 1.2 defines no new requests */
+        RADIO_CONFIG_CALL_1_3(RADIO_CONFIG_REQ_)
 #undef RADIO_CONFIG_REQ_
        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;
 }

 static
 const char*
 radio_config_known_resp_name(
+    RadioConfig* self,
    RADIO_CONFIG_RESP 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_)
+        RADIO_CONFIG_CALL_1_3(RADIO_CONFIG_RESP_)
 #undef RADIO_CONFIG_RESP_
        case RADIO_CONFIG_RESP_GET_SIM_SLOTS_STATUS_1_2:
            return "getSimSlotsStatusResponse_1_2";
        case RADIO_CONFIG_RESP_ANY:
            break;
        }
+    } 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;
 }

 static
 const char*
 radio_config_known_ind_name(
+    RadioConfig* self,
    RADIO_CONFIG_IND 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 */
        RADIO_CONFIG_IND_1_2(RADIO_CONFIG_IND_)
+        /* 1.3 defines no new indications */
 #undef RADIO_CONFIG_IND_
        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;
 }

@@ -271,7 +353,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);
@@ -297,7 +379,7 @@ radio_config_resp_quark(

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

            if (known) {
                q = g_quark_from_static_string(known);
@@ -323,7 +405,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);
@@ -393,15 +475,26 @@ 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);
+    } 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);
@@ -421,7 +514,7 @@ radio_config_response(

        /* 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);
+            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",
@@ -439,7 +532,7 @@ radio_config_response(
        radio_config_unref(self);
        *status = GBINDER_STATUS_OK;
    }
-    }
+
    return NULL;
 }

@@ -509,12 +602,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,
@@ -522,14 +615,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;
@@ -550,6 +657,21 @@ RadioConfig*
 radio_config_new_with_version(
    RADIO_CONFIG_INTERFACE max_version)
 {
+    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;
@@ -557,13 +679,29 @@ radio_config_new_with_version(
            max_version = RADIO_CONFIG_INTERFACE_MAX;
        }

-    if (radio_config_instance[max_version]) {
-        /* The requested instance already exists */
-        return radio_config_ref(radio_config_instance[max_version]);
+        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 {
-        /* Assume /dev/hwbinder */
+        GINFO("Wrong interface_type %d (neither HIDL nor AIDL)", interface_type);
+        return NULL;
+    }
+
+    if (instances[max_version]) {
+        /* The requested instance already exists */
+        return radio_config_ref(instances[max_version]);
+    } else {
+        /* Assume /dev/hwbinder for HIDL, /dev/binder for AIDL */
        GBinderServiceManager* sm =
-            gbinder_servicemanager_new(GBINDER_DEFAULT_HWBINDER);
+            gbinder_servicemanager_new(binder_device);

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

            /* Find maximum available version not exceeding the requested one */
-            for (i=0; i<G_N_ELEMENTS(radio_config_interfaces) && !obj; i++) {
-                desc = radio_config_interfaces + i;
+            for (i=0; i<num_interfaces && !obj; i++) {
+                desc = interfaces + i;
                if (desc->version <= max_version) {
                    obj = gbinder_servicemanager_get_service_sync(sm,
                        desc->fqname, NULL);
@@ -582,9 +720,8 @@ radio_config_new_with_version(
                         * desc->version isn't necessarily equal to
                         * max_version
                         */
-                        if (radio_config_instance[desc->version]) {
-                            config = radio_config_ref(radio_config_instance
-                                [desc->version]);
+                        if (instances[desc->version]) {
+                            config = radio_config_ref(instances[desc->version]);
                        } else {
                            GINFO("Connected to %s", desc->fqname);
                            config = radio_config_create(sm, obj, desc);
@@ -596,9 +733,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;
            }
        }
@@ -632,6 +769,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)
@@ -659,7 +803,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;
@@ -678,7 +822,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;
@@ -697,7 +841,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_6, RADIO_1_6_REQ_LAST },
    {RADIO_1_5, RADIO_1_5_REQ_LAST },
    {RADIO_1_4, RADIO_1_4_REQ_LAST },
    {RADIO_1_3, RADIO_1_3_REQ_LAST },
@@ -133,6 +134,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_6,
    RADIO_INDICATION_1_5,
    RADIO_INDICATION_1_4,
    RADIO_INDICATION_1_3,
@@ -144,6 +146,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_6,
    RADIO_RESPONSE_1_5,
    RADIO_RESPONSE_1_4,
    RADIO_RESPONSE_1_3,
@@ -156,19 +159,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_6) },
   { RADIO_INTERFACE_DESC(1_5) },
   { RADIO_INTERFACE_DESC(1_4) },
   { RADIO_INTERFACE_DESC(1_3) },
@@ -178,6 +187,146 @@ static const RadioInterfaceDesc radio_interfaces[] = {
 };
 G_STATIC_ASSERT(G_N_ELEMENTS(radio_interfaces) == RADIO_INTERFACE_COUNT);

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

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

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

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

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

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

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

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

            /* rilConnected is a special case */
-            if (code == RADIO_IND_RIL_CONNECTED) {
+            if (self->interface_type == RADIO_INTERFACE_TYPE_HIDL) {
+                ind_ril_connected = RADIO_IND_RIL_CONNECTED;
+            } else if (self->interface_type == RADIO_INTERFACE_TYPE_AIDL
+                && gutil_strv_contains((const GStrV*)radio_modem_indication_ifaces, iface)) {
+                ind_ril_connected = RADIO_MODEM_IND_RIL_CONNECTED;
+            }
+
+            if (ind_ril_connected && code == ind_ril_connected) {
                if (G_UNLIKELY(self->connected)) {
                    /* We are only supposed to receive it once */
                    GWARN("%s received unexpected rilConnected", self->slot);
@@ -360,28 +524,90 @@ 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;
+        if (code == RADIO_RESP_ACKNOWLEDGE_REQUEST) {
+            gbinder_reader_read_int32(&reader, &ack_serial);
+        } else {
+            /* All other responses have RadioResponseInfo */
+            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));
+        }
+    } 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);
-        gbinder_remote_request_init_reader(req, &reader);
-        if (code == RADIO_RESP_ACKNOWLEDGE_REQUEST) {
-            /* oneway acknowledgeRequest(int32_t serial) */
-            gint32 serial;

+    if (ack_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);
-            }
-        } else {
-            /* All other responses have RadioResponseInfo */
-            const RadioResponseInfo* info =
-                gbinder_reader_read_hidl_struct(&reader, RadioResponseInfo);
-
-            if (info) {
+            ack_serial);
+    } else if (info) {
        const GQuark quark = radio_instance_resp_quark(self, code);
        const guint* signals = radio_instance_signals +
            SIGNAL_OBSERVE_RESPONSE_0;
@@ -417,12 +643,7 @@ radio_instance_response(
            radio_instance_ack(self);
        }
    }
-        }
    *status = GBINDER_STATUS_OK;
-    } else {
-        GWARN("Unexpected response %s %u", iface, code);
-        *status = GBINDER_STATUS_FAILED;
-    }
    return NULL;
 }

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

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

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

@@ -561,16 +794,30 @@ 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 i, num_interfaces = 0;

-    if (sm) {
-        guint i;
+    if (!sm) {
+        GERR_("Failed to get ServiceManager on %s", dev);
+        return NULL;
+    }

-        for (i = 0; i < G_N_ELEMENTS(radio_interfaces) && !self; i++) {
-            const RadioInterfaceDesc* desc = radio_interfaces + i;
+    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 (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);
@@ -585,8 +832,9 @@ radio_instance_create(
            g_free(fqname);
        }
    }
+
    gbinder_servicemanager_unref(sm);
-    }
+
    return self;
 }

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

 static
@@ -705,7 +954,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);
@@ -775,9 +1024,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) {
@@ -787,7 +1050,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
@@ -830,7 +1094,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);
@@ -905,7 +1169,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;
@@ -924,7 +1188,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;
@@ -943,7 +1207,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_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,6 +57,15 @@ const char*
 radio_req_name(
    RADIO_REQ req)
 {
+    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";
@@ -69,6 +79,7 @@ radio_req_name(
        RADIO_CALL_1_3(RADIO_REQ_)
        RADIO_CALL_1_4_(RADIO_REQ__)
        RADIO_CALL_1_5_(RADIO_REQ__)
+        RADIO_CALL_1_6_(RADIO_REQ__)
 #undef RADIO_REQ_
 #undef RADIO_REQ__
        case RADIO_REQ_START_NETWORK_SCAN_1_2:                   return "startNetworkScan_1_2";
@@ -77,9 +88,89 @@ radio_req_name(
        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_EMERGENCY_DIAL_1_6:                       return "emergencyDial_1_6";
+        case RADIO_REQ_SET_CARRIER_INFO_FOR_IMSI_ENCRYPTION_1_6: return "setCarrierInfoForImsiEncryption_1_6";
        case RADIO_REQ_ANY:
            break;
        }
+    } else if (instance->interface_aidl == RADIO_DATA_INTERFACE) {
+        switch ((RADIO_DATA_REQ)req) {
+#define RADIO_DATA_REQ_(req,resp,Name,NAME) \
+        case RADIO_DATA_REQ_##NAME: return #Name;
+        RADIO_DATA_CALL_1(RADIO_DATA_REQ_)
+#undef RADIO_DATA_REQ_
+        case RADIO_DATA_REQ_SET_RESPONSE_FUNCTIONS:   return "setResponseFunctions";
+        case RADIO_DATA_REQ_RESPONSE_ACKNOWLEDGEMENT: return "responseAcknowledgement";
+        case RADIO_DATA_REQ_ANY:
+            break;
+        }
+    } else if (instance->interface_aidl == RADIO_IMS_INTERFACE) {
+        switch ((RADIO_IMS_REQ)req) {
+#define RADIO_IMS_REQ_(req,resp,Name,NAME) \
+        case RADIO_IMS_REQ_##NAME: return #Name;
+        RADIO_IMS_CALL_1(RADIO_IMS_REQ_)
+#undef RADIO_IMS_REQ_
+        case RADIO_IMS_REQ_SET_RESPONSE_FUNCTIONS:   return "setResponseFunctions";
+        case RADIO_IMS_REQ_ANY:
+            break;
+        }
+    } else if (instance->interface_aidl == RADIO_MESSAGING_INTERFACE) {
+        switch ((RADIO_MESSAGING_REQ)req) {
+#define RADIO_MESSAGING_REQ_(req,resp,Name,NAME) \
+        case RADIO_MESSAGING_REQ_##NAME: return #Name;
+        RADIO_MESSAGING_CALL_1(RADIO_MESSAGING_REQ_)
+#undef RADIO_MESSAGING_REQ_
+        case RADIO_MESSAGING_REQ_SET_RESPONSE_FUNCTIONS:   return "setResponseFunctions";
+        case RADIO_MESSAGING_REQ_RESPONSE_ACKNOWLEDGEMENT: return "responseAcknowledgement";
+        case RADIO_MESSAGING_REQ_ANY:
+            break;
+        }
+    } else if (instance->interface_aidl == RADIO_MODEM_INTERFACE) {
+        switch ((RADIO_MODEM_REQ)req) {
+#define RADIO_MODEM_REQ_(req,resp,Name,NAME) \
+        case RADIO_MODEM_REQ_##NAME: return #Name;
+        RADIO_MODEM_CALL_1(RADIO_MODEM_REQ_)
+#undef RADIO_MODEM_REQ_
+        case RADIO_MODEM_REQ_SET_RESPONSE_FUNCTIONS:   return "setResponseFunctions";
+        case RADIO_MODEM_REQ_RESPONSE_ACKNOWLEDGEMENT: return "responseAcknowledgement";
+        case RADIO_MODEM_REQ_ANY:
+            break;
+        }
+    } else if (instance->interface_aidl == RADIO_NETWORK_INTERFACE) {
+        switch ((RADIO_NETWORK_REQ)req) {
+#define RADIO_NETWORK_REQ_(req,resp,Name,NAME) \
+        case RADIO_NETWORK_REQ_##NAME: return #Name;
+        RADIO_NETWORK_CALL_1(RADIO_NETWORK_REQ_)
+#undef RADIO_NETWORK_REQ_
+        case RADIO_NETWORK_REQ_SET_RESPONSE_FUNCTIONS:   return "setResponseFunctions";
+        case RADIO_NETWORK_REQ_RESPONSE_ACKNOWLEDGEMENT: return "responseAcknowledgement";
+        case RADIO_NETWORK_REQ_ANY:
+            break;
+        }
+    } else if (instance->interface_aidl == RADIO_SIM_INTERFACE) {
+        switch ((RADIO_SIM_REQ)req) {
+#define RADIO_SIM_REQ_(req,resp,Name,NAME) \
+        case RADIO_SIM_REQ_##NAME: return #Name;
+        RADIO_SIM_CALL_1(RADIO_SIM_REQ_)
+#undef RADIO_SIM_REQ_
+        case RADIO_SIM_REQ_SET_RESPONSE_FUNCTIONS:   return "setResponseFunctions";
+        case RADIO_SIM_REQ_RESPONSE_ACKNOWLEDGEMENT: return "responseAcknowledgement";
+        case RADIO_SIM_REQ_ANY:
+            break;
+        }
+    } else if (instance->interface_aidl == RADIO_VOICE_INTERFACE) {
+        switch ((RADIO_VOICE_REQ)req) {
+#define RADIO_VOICE_REQ_(req,resp,Name,NAME) \
+        case RADIO_VOICE_REQ_##NAME: return #Name;
+        RADIO_VOICE_CALL_1(RADIO_VOICE_REQ_)
+#undef RADIO_VOICE_REQ_
+        case RADIO_VOICE_REQ_HANGUP:                   return "hangup";
+        case RADIO_VOICE_REQ_SET_RESPONSE_FUNCTIONS:   return "setResponseFunctions";
+        case RADIO_VOICE_REQ_RESPONSE_ACKNOWLEDGEMENT: return "responseAcknowledgement";
+        case RADIO_VOICE_REQ_ANY:
+            break;
+        }
+    }
    return NULL;
 }

@@ -87,6 +178,15 @@ const char*
 radio_resp_name(
    RADIO_RESP resp)
 {
+    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) \
@@ -99,6 +199,7 @@ radio_resp_name(
        RADIO_CALL_1_3(RADIO_RESP_)
        RADIO_CALL_1_4_(RADIO_RESP__)
        RADIO_CALL_1_5_(RADIO_RESP__)
+        RADIO_CALL_1_6_(RADIO_RESP__)
 #undef RADIO_RESP_
 #undef RADIO_RESP__
        case RADIO_RESP_GET_CELL_INFO_LIST_1_2:
@@ -130,6 +231,77 @@ radio_resp_name(
        case RADIO_RESP_ANY:
            break;
        }
+    } else if (instance->interface_aidl == RADIO_DATA_INTERFACE) {
+        switch ((RADIO_DATA_RESP)resp) {
+        case RADIO_DATA_RESP_ACKNOWLEDGE_REQUEST: return "acknowledgeRequest";
+#define RADIO_DATA_RESP_(req,resp,Name,NAME) \
+        case RADIO_DATA_RESP_##NAME: return #Name "Response";
+        RADIO_DATA_CALL_1(RADIO_DATA_RESP_)
+#undef RADIO_DATA_RESP_
+        case RADIO_DATA_RESP_ANY:
+            break;
+        }
+    } else if (instance->interface_aidl == RADIO_IMS_INTERFACE) {
+        switch ((RADIO_IMS_RESP)resp) {
+#define RADIO_IMS_RESP_(req,resp,Name,NAME) \
+        case RADIO_IMS_RESP_##NAME: return #Name "Response";
+        RADIO_IMS_CALL_1(RADIO_IMS_RESP_)
+#undef RADIO_IMS_RESP_
+        case RADIO_IMS_RESP_ANY:
+            break;
+        }
+    } else if (instance->interface_aidl == RADIO_MESSAGING_INTERFACE) {
+        switch ((RADIO_MESSAGING_RESP)resp) {
+        case RADIO_MESSAGING_RESP_ACKNOWLEDGE_REQUEST: return "acknowledgeRequest";
+#define RADIO_MESSAGING_RESP_(req,resp,Name,NAME) \
+        case RADIO_MESSAGING_RESP_##NAME: return #Name "Response";
+        RADIO_MESSAGING_CALL_1(RADIO_MESSAGING_RESP_)
+#undef RADIO_MESSAGING_RESP_
+        case RADIO_MESSAGING_RESP_ANY:
+            break;
+        }
+    } else if (instance->interface_aidl == RADIO_MODEM_INTERFACE) {
+        switch ((RADIO_MODEM_RESP)resp) {
+        case RADIO_MODEM_RESP_ACKNOWLEDGE_REQUEST: return "acknowledgeRequest";
+#define RADIO_MODEM_RESP_(req,resp,Name,NAME) \
+        case RADIO_MODEM_RESP_##NAME: return #Name "Response";
+        RADIO_MODEM_CALL_1(RADIO_MODEM_RESP_)
+#undef RADIO_MODEM_RESP_
+        case RADIO_MODEM_RESP_ANY:
+            break;
+        }
+    } else if (instance->interface_aidl == RADIO_NETWORK_INTERFACE) {
+        switch ((RADIO_NETWORK_RESP)resp) {
+        case RADIO_NETWORK_RESP_ACKNOWLEDGE_REQUEST: return "acknowledgeRequest";
+#define RADIO_NETWORK_RESP_(req,resp,Name,NAME) \
+        case RADIO_NETWORK_RESP_##NAME: return #Name "Response";
+        RADIO_NETWORK_CALL_1(RADIO_NETWORK_RESP_)
+#undef RADIO_NETWORK_RESP_
+        case RADIO_NETWORK_RESP_ANY:
+            break;
+        }
+    } else if (instance->interface_aidl == RADIO_SIM_INTERFACE) {
+        switch ((RADIO_SIM_RESP)resp) {
+        case RADIO_SIM_RESP_ACKNOWLEDGE_REQUEST: return "acknowledgeRequest";
+#define RADIO_SIM_RESP_(req,resp,Name,NAME) \
+        case RADIO_SIM_RESP_##NAME: return #Name "Response";
+        RADIO_SIM_CALL_1(RADIO_SIM_RESP_)
+#undef RADIO_SIM_RESP_
+        case RADIO_SIM_RESP_ANY:
+            break;
+        }
+    } else if (instance->interface_aidl == RADIO_VOICE_INTERFACE) {
+        switch ((RADIO_VOICE_RESP)resp) {
+        case RADIO_VOICE_RESP_ACKNOWLEDGE_REQUEST:        return "acknowledgeRequest";
+        case RADIO_VOICE_RESP_HANGUP_CONNECTION_RESPONSE: return "hangupConnectionResponse";
+#define RADIO_VOICE_RESP_(req,resp,Name,NAME) \
+        case RADIO_VOICE_RESP_##NAME: return #Name "Response";
+        RADIO_VOICE_CALL_1(RADIO_VOICE_RESP_)
+#undef RADIO_VOICE_RESP_
+        case RADIO_VOICE_RESP_ANY:
+            break;
+        }
+    }
    return NULL;
 }

@@ -137,6 +309,15 @@ const char*
 radio_ind_name(
    RADIO_IND 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;
@@ -145,10 +326,75 @@ radio_ind_name(
        RADIO_EVENT_1_2(RADIO_IND_)
        RADIO_EVENT_1_4(RADIO_IND_)
        RADIO_EVENT_1_5(RADIO_IND_)
+        RADIO_EVENT_1_6(RADIO_IND_)
 #undef RADIO_IND_
        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;
 }

@@ -178,6 +424,7 @@ radio_req_resp(
    RADIO_CALL_1_3(RADIO_REQ_RESP_)
    RADIO_CALL_1_4_(RADIO_REQ_RESP__)
    RADIO_CALL_1_5_(RADIO_REQ_RESP__)
+    RADIO_CALL_1_6_(RADIO_REQ_RESP__)
 #undef RADIO_REQ_RESP_
 #undef RADIO_REQ_RESP__
    case RADIO_REQ_SETUP_DATA_CALL_1_2:
@@ -192,6 +439,10 @@ radio_req_resp(
        return RADIO_RESP_SET_DATA_PROFILE;
    case RADIO_REQ_SET_INDICATION_FILTER_1_2:
        return RADIO_RESP_SET_INDICATION_FILTER;
+    case RADIO_REQ_EMERGENCY_DIAL_1_6:
+        return RADIO_RESP_EMERGENCY_DIAL;
+    case RADIO_REQ_SET_CARRIER_INFO_FOR_IMSI_ENCRYPTION_1_6:
+        return RADIO_RESP_SET_CARRIER_INFO_FOR_IMSI_ENCRYPTION;

    /*
     * All these still need to be listed here to ensure a compilation
@@ -229,6 +480,10 @@ radio_req_resp2(
        return RADIO_RESP_SET_INITIAL_ATTACH_APN;
    case RADIO_REQ_SET_DATA_PROFILE_1_4:
        return RADIO_RESP_SET_DATA_PROFILE;
+    case RADIO_REQ_EMERGENCY_DIAL_1_6:
+        return RADIO_RESP_EMERGENCY_DIAL;
+    case RADIO_REQ_SET_CARRIER_INFO_FOR_IMSI_ENCRYPTION_1_6:
+        return RADIO_RESP_SET_CARRIER_INFO_FOR_IMSI_ENCRYPTION;
    case RADIO_REQ_SET_INDICATION_FILTER_1_2:
 /* case RADIO_REQ_SET_INDICATION_FILTER_1_5: */
        return RADIO_RESP_SET_INDICATION_FILTER;
@@ -257,6 +512,7 @@ radio_req_resp2(
        case RADIO_INTERFACE_1_4:
            return RADIO_RESP_GET_ICC_CARD_STATUS_1_4;
        case RADIO_INTERFACE_1_5:
+        case RADIO_INTERFACE_1_6:
            return RADIO_RESP_GET_ICC_CARD_STATUS_1_5;
        case RADIO_INTERFACE_NONE:
        case RADIO_INTERFACE_COUNT:
@@ -270,7 +526,6 @@ radio_req_resp2(
     * getCellInfoListResponse_1_2
     * getCellInfoListResponse_1_4
     * getCellInfoListResponse_1_5 <= the last one
-     * getCellInfoList_1_6
     */
    case RADIO_REQ_GET_CELL_INFO_LIST:
        switch (iface) {
@@ -293,7 +548,6 @@ radio_req_resp2(
     * getCurrentCalls
     * getCurrentCallsResponse
     * getCurrentCallsResponse_1_2 <= the last one
-     * getCurrentCalls_1_6
     */
    case RADIO_REQ_GET_CURRENT_CALLS:
        switch (iface) {
@@ -311,7 +565,6 @@ radio_req_resp2(
     * getSignalStrength
     * getSignalStrengthResponse
     * getSignalStrengthResponse_1_2 <= the last one
-     * getSignalStrength_1_4
     */
    case RADIO_REQ_GET_SIGNAL_STRENGTH:
        switch (iface) {
@@ -329,7 +582,6 @@ radio_req_resp2(
     * getVoiceRegistrationState
     * getVoiceRegistrationStateResponse
     * getVoiceRegistrationStateResponse_1_2 <= the last one
-     * getVoiceRegistrationState_1_5
     */
    case RADIO_REQ_GET_VOICE_REGISTRATION_STATE:
        switch (iface) {
@@ -348,7 +600,6 @@ radio_req_resp2(
     * getDataRegistrationStateResponse
     * getDataRegistrationStateResponse_1_2
     * getDataRegistrationStateResponse_1_4 <= the last one
-     * getDataRegistrationState_1_5
     */
    case RADIO_REQ_GET_DATA_REGISTRATION_STATE:
        switch (iface) {
@@ -370,7 +621,6 @@ radio_req_resp2(
     * getDataCallListResponse
     * getDataCallListResponse_1_4
     * getDataCallListResponse_1_5 <= the last one
-     * getDataCallList_1_6
     */
    case RADIO_REQ_GET_DATA_CALL_LIST:
        switch (iface) {
--- 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_config/unit_config.c
+++ b/unit/unit_config/unit_config.c
@@ -52,12 +52,14 @@ static const GBinderClientIfaceInfo radio_config_ind_iface_info[] = {
 };

 static const GBinderClientIfaceInfo radio_config_resp_iface_info[] = {
+    {RADIO_CONFIG_RESPONSE_1_3, RADIO_CONFIG_1_3_RESP_LAST },
    {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_3,
    RADIO_CONFIG_1_2,
    RADIO_CONFIG_1_1,
    RADIO_CONFIG_1_0,
@@ -67,7 +69,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_2_FQNAME
+    RADIO_CONFIG_1_2_FQNAME,
+    RADIO_CONFIG_1_3_FQNAME
 };

 static
@@ -132,6 +135,7 @@ test_config_req_resp(
    case RADIO_CONFIG_REQ_##NAME: return RADIO_CONFIG_RESP_##NAME;
    RADIO_CONFIG_CALL_1_0(REQ_RESP_)
    RADIO_CONFIG_CALL_1_1(REQ_RESP_)
+    RADIO_CONFIG_CALL_1_3(REQ_RESP_)
 #undef REQ_RESP_
    case RADIO_CONFIG_REQ_SET_RESPONSE_FUNCTIONS:
        return RADIO_CONFIG_RESP_NONE;
@@ -410,7 +414,7 @@ test_name(
    void)
 {
    TestCommon test;
-    RadioConfig* client = test_common_init(&test, RADIO_CONFIG_INTERFACE_1_1);
+    RadioConfig* client = test_common_init(&test, RADIO_CONFIG_INTERFACE_1_3);

    g_assert_cmpstr(radio_config_req_name(client,
        RADIO_CONFIG_REQ_SET_RESPONSE_FUNCTIONS), == ,
@@ -421,6 +425,9 @@ test_name(
    g_assert_cmpstr(radio_config_req_name(client,
        RADIO_CONFIG_REQ_GET_PHONE_CAPABILITY), == ,
        "getPhoneCapability");
+    g_assert_cmpstr(radio_config_req_name(client,
+        RADIO_CONFIG_REQ_GET_HAL_DEVICE_CAPABILITIES), == ,
+        "getHalDeviceCapabilities");
    g_assert_cmpstr(radio_config_req_name(client,
        (RADIO_CONFIG_REQ)123), == ,
        "123");
@@ -431,6 +438,9 @@ test_name(
    g_assert_cmpstr(radio_config_resp_name(client,
        RADIO_CONFIG_RESP_GET_PHONE_CAPABILITY), == ,
        "getPhoneCapabilityResponse");
+    g_assert_cmpstr(radio_config_resp_name(client,
+        RADIO_CONFIG_RESP_GET_HAL_DEVICE_CAPABILITIES), == ,
+        "getHalDeviceCapabilitiesResponse");
    g_assert_cmpstr(radio_config_resp_name(client,
        (RADIO_CONFIG_RESP)1234), == ,
        "1234");
--- a/unit/unit_util/unit_util.c
+++ b/unit/unit_util/unit_util.c
@@ -72,6 +72,8 @@ test_req_name(
        "startNetworkScan_1_4");
    g_assert_cmpstr(radio_req_name(RADIO_REQ_START_NETWORK_SCAN_1_5),==,
        "startNetworkScan_1_5");
+    g_assert_cmpstr(radio_req_name(RADIO_REQ_START_HANDOVER),==,
+        "startHandover");
 }

 /*==========================================================================*
@@ -101,6 +103,8 @@ test_resp_name(
        "startNetworkScanResponse_1_4");
    g_assert_cmpstr(radio_resp_name(RADIO_RESP_START_NETWORK_SCAN_1_5),==,
        "startNetworkScanResponse_1_5");
+    g_assert_cmpstr(radio_resp_name(RADIO_RESP_START_HANDOVER),==,
+        "startHandoverResponse");
 }

 /*==========================================================================*
@@ -124,6 +128,8 @@ test_ind_name(
        "currentEmergencyNumberList");
    g_assert_cmpstr(radio_ind_name(RADIO_IND_REGISTRATION_FAILED),==,
        "registrationFailed");
+    g_assert_cmpstr(radio_ind_name(RADIO_IND_UNTHROTTLE_APN),==,
+        "unthrottleApn");
 }

 /*==========================================================================*
@@ -155,7 +161,8 @@ test_req_resp(
          RADIO_RESP_SET_SIGNAL_STRENGTH_REPORTING_CRITERIA },
        { RADIO_REQ_SET_SYSTEM_SELECTION_CHANNELS,
          RADIO_RESP_SET_SYSTEM_SELECTION_CHANNELS },
-        { RADIO_REQ_EMERGENCY_DIAL, RADIO_RESP_EMERGENCY_DIAL }
+        { RADIO_REQ_EMERGENCY_DIAL, RADIO_RESP_EMERGENCY_DIAL },
+        { RADIO_REQ_START_HANDOVER, RADIO_RESP_START_HANDOVER }
    };

    int i;
@@ -234,6 +241,8 @@ test_req_resp2(
          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_1_6,
+          RADIO_RESP_GET_ICC_CARD_STATUS_1_5 },
        { RADIO_REQ_GET_ICC_CARD_STATUS, RADIO_INTERFACE_COUNT,
          RADIO_RESP_NONE },
        { RADIO_REQ_GET_ICC_CARD_STATUS, RADIO_INTERFACE_NONE,
Author	SHA1	Message	Date
Matti Lehtimäki	9ea472ec8f	[gbinder-radio] Add support for IRadio@1.6. JB#63650	2025-08-24 22:17:12 +03:00
Matti Lehtimäki	f5b4d12574	[gbinder-radio] Add support for IRadioConfig@1.3. JB#63650	2025-08-24 19:16:02 +03:00
Slava Monich	98865d72ba	Merge pull request #29 from monich/fix_loop Fix compilation error	2024-10-28 18:18:05 +02:00
Slava Monich	7b40341c01	[gbinder-radio] Fix compilation error. JB#61702 src/radio_instance.c: In function 'radio_instance_create': src/radio_instance.c:815:5: error: 'for' loop initial declarations are only allowed in C99 or C11 mode for (guint i = 0; i < num_interfaces && !self; i++) { ^ src/radio_instance.c:815:5: note: use option -std=c99, -std=gnu99, -std=c11 or -std=gnu11 to compile your code	2024-10-28 02:29:51 +02: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