.

Makefile

@@ -33,10 +33,16 @@ STATIC_LIB = $(NAME).a
 #
 
 SRC = \
-  sample_ext.c \
-  sample_ims.c \
   vendor_qti_plugin.c \
-  sample_slot.c
+  vendor_qti_ext.c \
+  vendor_qti_slot.c \
+  vendor_qti_ims_radio.c \
+  vendor_qti_ims.c \
+  vendor_qti_ims_call.c \
+  vendor_qti_ims_conf.c \
+  vendor_qti_ims_sms.c \
+  vendor_qti_ims_state.c \
+  vendor_qti_util.c
 
 #
 # Directories
@@ -59,7 +65,7 @@ INCLUDES = -I$(INCLUDE_DIR)
 BASE_FLAGS = -fPIC -fvisibility=hidden
 FULL_CFLAGS = $(BASE_FLAGS) $(CFLAGS) $(DEFINES) $(WARNINGS) $(INCLUDES) \
   -MMD -MP $(shell pkg-config --cflags $(PKGS))
-FULL_LDFLAGS = $(BASE_FLAGS) $(LDFLAGS) -shared \
+FULL_LDFLAGS = $(BASE_FLAGS) $(LDFLAGS) -shared -fPIC \
   $(shell pkg-config --libs $(LDPKGS))
 DEBUG_FLAGS = -g
 RELEASE_FLAGS =

README.md

@@ -17,4 +17,4 @@
 | --- | --- | --- |
 | Modem | [oFono](https://github.com/sailfishos/ofono)([ril driver](https://github.com/sailfishos/ofono/tree/master/ofono/drivers/ril)) <> [libgrilio](https://github.com/sailfishos/libgrilio) <> [ofono-ril-binder-plugin](https://github.com/mer-hybris/ofono-ril-binder-plugin) <> [libgbinder-radio](https://github.com/mer-hybris/libgbinder-radio) <> [libgbinder](https://github.com/mer-hybris/libgbinder) <> Android BSP HAL: android.hardware.radio | Android BSP >= 8 |
 |  | [oFono](https://github.com/sailfishos/ofono)([ril driver](https://github.com/sailfishos/ofono/tree/master/ofono/drivers/ril)) <> [libgrilio](https://github.com/sailfishos/libgrilio) <> socket <> Android BSP: rild | Android BSP <= 7 |
-|  | [oFono](https://github.com/sailfishos/ofono)<> [ofono-binder-plugin](https://github.com/mer-hybris/ofono-binder-plugin) <> ofono-vendor-qti-radio-plugin(未开源) <> [libgbinder-radio](https://github.com/mer-hybris/libgbinder-radio) <> [libgbinder](https://github.com/mer-hybris/libgbinder) <> Android BSP HAL: android.hardware.radio | for VoLTE |
+|  | [oFono](https://github.com/sailfishos/ofono)<> [ofono-binder-plugin](https://github.com/mer-hybris/ofono-binder-plugin) <> ofono-vendor-qti-radio-plugin(未开源) <> [libgbinder-radio](https://github.com/mer-hybris/libgbinder-radio) <> [libgbinder](https://github.com/mer-hybris/libgbinder) <> Android BSP HAL: vendor.qti.hardware.radio.ims | for VoLTE |

include/vendor_qti_ext.h

@@ -3,8 +3,6 @@
 
 #include <binder_ext_types.h>
 
-extern const char qti_plugin_name[];
-
 BinderExtPlugin* vendor_qti_ext_new(void);
 
 #endif

include/vendor_qti_ims.h

@@ -3,6 +3,6 @@
 
 #include <binder_ext_ims.h>
 
-BinderExtIms* vendor_qti_ims_new(const char* slot);
+BinderExtIms* vendor_qti_ims_new(VendorQtiImsRadio* ims_radio, VendorQtiImsStateObject* ims_state);
 
 #endif

include/vendor_qti_ims_call.h

@@ -0,0 +1,8 @@
+#ifndef VENDOR_QTI_IMS_CALL_H
+#define VENDOR_QTI_IMS_CALL_H
+
+#include "binder_ext_call.h"
+
+BinderExtCall* vendor_qti_ims_call_new(VendorQtiImsRadio* ims_radio, VendorQtiImsStateObject* ims_state);
+
+#endif

include/vendor_qti_ims_radio.h

@@ -1,10 +1,186 @@
-#ifndef VENDOR_QTI_SLOT_H
+#ifndef VENDOR_QTI_IMS_RADIO_H
-#define VENDOR_QTI_SLOT_H
+#define VENDOR_QTI_IMS_RADIO_H
 
 #include <binder_ext_slot.h>
 
 #include <radio_types.h>
+#include "vendor_qti_types.h"
 
-VendorQtiImsRadio* vendor_qti_ims_radio_new(RadioInstance* radio, GHashTable* params);
+/* c(req,resp,callName,CALL_NAME) */
+#define IMS_RADIO_CALL_1_0(c) \
+    c(2,1,dial,DIAL) \
+    c(3,31,addParticipant,ADD_PARTICIPANT) \
+    c(4,11,getRegistrationState,GET_REGISTRATION_STATE) \
+    c(5,2,answer,ANSWER) \
+    c(6,3,hangup,HANGUP) \
+    c(7,4,requestRegistrationChange,REQUEST_REGISTRATION_CHANGE) \
+    c(8,5,queryServiceStatus,QUERY_SERVICE_STATUS) \
+    c(9,6,setServiceStatus,SET_SERVICE_STATUS) \
+    c(10,7,hold,HOLD) \
+    c(11,8,resume,RESUME) \
+    c(12,9,setConfig,SET_CONFIG) \
+    c(13,10,getConfig,GET_CONFIG) \
+    c(14,13,conference,CONFERENCE) \
+    c(15,14,getClip,GET_CLIP) \
+    c(16,15,getClir,GET_CLIR) \
+    c(17,16,setClir,SET_CLIR) \
+    c(18,17,getColr,GET_COLR) \
+    c(20,18,exitEmergencyCallbackMode,EXIT_EMERGENCY_CALLBACK_MODE) \
+    c(21,19,sendDtmf,SEND_DTMF) \
+    c(22,20,startDtmf,START_DTMF) \
+    c(23,21,stopDtmf,STOP_DTMF) \
+    c(24,22,setUiTtyMode,SET_UI_TTY_MODE) \
+    c(25,23,modifyCallInitiate,MODIFY_CALL_INITIATE) \
+    c(26,24,modifyCallConfirm,MODIFY_CALL_CONFIRM) \
+    c(27,25,queryCallForwardStatus,QUERY_CALL_FORWARD_STATUS) \
+    c(29,26,getCallWaiting,GET_CALL_WAITING) \
+    c(31,28,setSuppServiceNotification,SET_SUPP_SERVICE_NOTIFICATION) \
+    c(32,27,explicitCallTransfer,EXPLICIT_CALL_TRANSFER) \
+    c(33,12,suppServiceStatus,SUPP_SERVICE_STATUS) \
+    c(34,29,getRtpStatistics,GET_RTP_STATISTICS) \
+    c(35,30,getRtpErrorStatistics,GET_RTP_ERROR_STATISTICS) \
+    c(36,32,deflectCall,DEFLECT_CALL) \
+    c(37,33,sendGeolocationInfo,SEND_GEOLOCATION_INFO) \
+    c(38,34,getImsSubConfig,GET_IMS_SUB_CONFIG) \
+    c(39,35,sendRttMessage,SEND_RTT_MESSAGE) \
+    c(40,36,cancelModifyCall,CANCEL_MODIFY_CALL)
+
+#define IMS_RADIO_CALL_1_2(c) /* Since 1.2.0 */ \
+    c(43,37,sendImsSms,SEND_IMS_SMS)
+
+typedef enum ims_radio_req {
+    IMS_RADIO_REQ_ANY = 0,
+    IMS_RADIO_REQ_NONE = 0,
+#define IMS_RADIO_REQ_(req,resp,Name,NAME) IMS_RADIO_REQ_##NAME = req,
+
+    /* vendor.qti.hardware.radio.ims@1.0::IImsRadio */
+    IMS_RADIO_REQ_SET_CALLBACK = 1, /* setCallback */
+    IMS_RADIO_CALL_1_0(IMS_RADIO_REQ_)
+    IMS_RADIO_REQ_SET_COLR = 19,/* setColr */
+    IMS_RADIO_1_0_REQ_LAST = IMS_RADIO_REQ_CANCEL_MODIFY_CALL,
+
+    /* vendor.qti.hardware.radio.ims@1.1::IImsRadio */
+    IMS_RADIO_REQ_HANGUP_1_1 = 41,/* hangup_1_1 */
+    IMS_RADIO_1_1_REQ_LAST = IMS_RADIO_REQ_HANGUP_1_1,
+
+    /* vendor.qti.hardware.radio.ims@1.2::IImsRadio */
+    IMS_RADIO_REQ_HANGUP_1_2 = 42,/* hangup_1_2 */
+    IMS_RADIO_CALL_1_2(IMS_RADIO_REQ_)
+    IMS_RADIO_REQ_ACKNOWLEDGE_SMS = 44,/* acknowledgeSms */
+    IMS_RADIO_REQ_ACKNOWLEDGE_SMS_REPORT = 45,/* acknowledgeSmsReport */
+    IMS_RADIO_REQ_UNKOWN_1 = 46,
+    IMS_RADIO_REQ_UNKOWN_2 = 47,
+    IMS_RADIO_1_2_REQ_LAST = IMS_RADIO_REQ_UNKOWN_2,
+#undef IMS_RADIO_REQ_
+} IMS_RADIO_REQ;
+G_STATIC_ASSERT(sizeof(IMS_RADIO_REQ) == 4);
+
+typedef enum ims_radio_resp {
+    IMS_RADIO_RESP_ANY = 0,
+    IMS_RADIO_RESP_NONE = 0,
+#define IMS_RADIO_RESP_(req,resp,Name,NAME) IMS_RADIO_RESP_##NAME = resp,
+
+    /* vendor.qti.hardware.radio.ims@1.1::IImsRadioResponse */
+    IMS_RADIO_CALL_1_0(IMS_RADIO_RESP_)
+    IMS_RADIO_1_0_RESP_LAST = IMS_RADIO_RESP_CANCEL_MODIFY_CALL,
+
+    /* vendor.qti.hardware.radio.ims@1.1::IImsRadioResponse */
+    IMS_RADIO_1_1_RESP_LAST = IMS_RADIO_1_0_RESP_LAST,
+
+    /* vendor.qti.hardware.radio.ims@1.1::IImsRadioResponse */
+    IMS_RADIO_CALL_1_2(IMS_RADIO_RESP_)
+    IMS_RADIO_1_2_RESP_LAST = IMS_RADIO_RESP_SEND_IMS_SMS,
+
+#undef IMS_RADIO_RESP_
+} IMS_RADIO_RESP;
+G_STATIC_ASSERT(sizeof(IMS_RADIO_RESP) == 4);
+
+/* e(code,eventName,EVENT_NAME) */
+#define IMS_RADIO_EVENT_1_0(e) \
+    e(1,callStateChanged,CALL_STATE_CHANGED) \
+    e(2,ring,RING) \
+    e(3,ringbackTone,RINGBACK_TONE) \
+    e(4,registrationChanged,REGISTRATION_CHANGED) \
+    e(5,handover,HANDOVER) \
+    e(6,serviceStatusChanged,SERVICE_STATUS_CHANGED) \
+    e(7,radioStateChanged,RADIO_STATE_CHANGED) \
+    e(8,enterEmergencyCallBackMode,ENTER_EMERGENCY_CALL_BACK_MODE) \
+    e(9,exitEmergencyCallBackMode,EXIT_EMERGENCY_CALL_BACK_MODE) \
+    e(10,ttyNotification,TTY_NOTIFICATION) \
+    e(11,refreshConferenceInfo,REFRESH_CONFERENCE_INFO) \
+    e(12,refreshViceInfo,REFRESH_VICE_INFO) \
+    e(13,modifyCall,MODIFY_CALL) \
+    e(14,suppServiceNotification,SUPP_SERVICE_NOTIFICATION) \
+    e(15,messageWaiting,MESSAGE_WAITING) \
+    e(16,geolocationInfoRequested,GEOLOCATION_INFO_REQUESTED) \
+    e(17,imsSubConfigChanged,IMS_SUB_CONFIG_CHANGED) \
+    e(18,participantStatusInfo,PARTICIPANT_STATUS_INFO) \
+    e(19,registrationBlockStatus,REGISTRATION_BLOCK_STATUS) \
+    e(20,rttMessageReceived,RTT_MESSAGE_RECEIVED) \
+    e(21,voWiFiCallQuality,VO_WIFI_CALL_QUALITY) \
+    e(22,supplementaryServiceIndication,SUPPLEMENTARY_SERVICE_INDICATION)
+
+#define IMS_RADIO_EVENT_1_1(e) \
+    e(23,callStateChanged_1_1,CALL_STATE_CHANGED_1_1)
+
+#define IMS_RADIO_EVENT_1_2(e) \
+    e(24,callStateChanged_1_2,CALL_STATE_CHANGED_1_2) \
+    e(25,imsSmsStatusReport,IMS_SMS_STATUS_REPORT) \
+    e(26,incomingImsSms,INCOMING_IMS_SMS) \
+    e(27,vopsChanged,VOPS_CHANGED)
+
+typedef enum ims_radio_ind {
+    IMS_RADIO_IND_ANY = 0,
+    IMS_RADIO_IND_NONE = 0,
+#define IMS_RADIO_IND_(code,Name,NAME) IMS_RADIO_IND_##NAME = code,
+
+    /* vendor.qti.hardware.radio.ims@1.0::IImsRadioIndication */
+    IMS_RADIO_EVENT_1_0(IMS_RADIO_IND_)
+    IMS_RADIO_1_0_IND_LAST = IMS_RADIO_IND_SUPPLEMENTARY_SERVICE_INDICATION,
+
+    /* vendor.qti.hardware.radio.ims@1.1::IImsRadioIndication */
+    IMS_RADIO_EVENT_1_1(IMS_RADIO_IND_)
+    IMS_RADIO_1_1_IND_LAST = IMS_RADIO_IND_CALL_STATE_CHANGED_1_1,  /* Since 1.2.4 */
+
+    /* vendor.qti.hardware.radio.ims@1.2::IImsRadioIndication */
+    IMS_RADIO_EVENT_1_2(IMS_RADIO_IND_)
+    IMS_RADIO_1_2_IND_LAST = IMS_RADIO_IND_VOPS_CHANGED, /* Since 1.2.4 */
+
+#undef IMS_RADIO_IND_
+} IMS_RADIO_IND;
+G_STATIC_ASSERT(sizeof(IMS_RADIO_IND) == 4);
+
+typedef enum ims_radio_interface {
+    IMS_RADIO_INTERFACE_NONE = -1, /* Since 1.4.3 */
+    IMS_RADIO_INTERFACE_1_0,
+    IMS_RADIO_INTERFACE_1_1,
+    IMS_RADIO_INTERFACE_1_2,
+    IMS_RADIO_INTERFACE_COUNT
+} IMS_RADIO_INTERFACE; /* Since 1.2.0 */
+
+
+#define IMS_RADIO_IFACE_PREFIX     "vendor.qti.hardware.radio.ims@"
+#define IMS_RADIO_IFACE            "IImsRadio"
+#define IMS_RADIO_RESPONSE_IFACE   "IImsRadioResponse"
+#define IMS_RADIO_INDICATION_IFACE "IImsRadioIndication"
+#define IMS_RADIO_IFACE_1_0(x)     IMS_RADIO_IFACE_PREFIX "1.0::" x
+#define IMS_RADIO_IFACE_1_1(x)     IMS_RADIO_IFACE_PREFIX "1.1::" x
+#define IMS_RADIO_IFACE_1_2(x)     IMS_RADIO_IFACE_PREFIX "1.2::" x
+#define IMS_RADIO_1_0              IMS_RADIO_IFACE_1_0(IMS_RADIO_IFACE)
+#define IMS_RADIO_1_1              IMS_RADIO_IFACE_1_1(IMS_RADIO_IFACE)
+#define IMS_RADIO_1_2              IMS_RADIO_IFACE_1_2(IMS_RADIO_IFACE)
+#define IMS_RADIO_RESPONSE_1_0     IMS_RADIO_IFACE_1_0(IMS_RADIO_RESPONSE_IFACE)
+#define IMS_RADIO_RESPONSE_1_1     IMS_RADIO_IFACE_1_1(IMS_RADIO_RESPONSE_IFACE)
+#define IMS_RADIO_RESPONSE_1_2     IMS_RADIO_IFACE_1_2(IMS_RADIO_RESPONSE_IFACE)
+#define IMS_RADIO_INDICATION_1_0   IMS_RADIO_IFACE_1_0(IMS_RADIO_INDICATION_IFACE)
+#define IMS_RADIO_INDICATION_1_1   IMS_RADIO_IFACE_1_1(IMS_RADIO_INDICATION_IFACE)
+#define IMS_RADIO_INDICATION_1_2   IMS_RADIO_IFACE_1_2(IMS_RADIO_INDICATION_IFACE)
+
+
+VendorQtiImsRadio* vendor_qti_ims_radio_new(const char* dev, const char* name);
+
+VendorQtiImsRadio* vendor_qti_ims_radio_ref(VendorQtiImsRadio* self);
+
+void vendor_qti_ims_radio_unref(VendorQtiImsRadio* self);
 
 #endif

include/vendor_qti_ims_sms.h

@@ -0,0 +1,8 @@
+#ifndef VENDOR_QTI_IMS_SMS_H
+#define VENDOR_QTI_IMS_SMS_H
+
+#include "binder_ext_sms.h"
+
+BinderExtSms* vendor_qti_ims_sms_new(VendorQtiImsRadio* ims_radio, VendorQtiImsStateObject* ims_state);
+
+#endif

include/vendor_qti_ims_state.h

@@ -0,0 +1,11 @@
+#ifndef VENDOR_QTI_IMS_STATE_H
+#define VENDOR_QTI_IMS_STATE_H
+
+#include "vendor_qti_types.h"
+
+VendorQtiImsStateObject* vendor_qti_ims_state_new(VendorQtiImsRadio* ims_radio);
+
+VendorQtiImsStateObject* vendor_qti_ims_state_ref(VendorQtiImsStateObject* self);
+
+void vendor_qti_ims_state_unref(VendorQtiImsStateObject* self);
+#endif

include/vendor_qti_types.h

@@ -0,0 +1,18 @@
+#ifndef VENDOR_QTI_TYPES_H
+#define VENDOR_QTI_TYPES_H
+
+#include <glib.h>
+
+G_BEGIN_DECLS
+
+typedef struct qti_slot VendorQtiSlot;
+typedef struct qti_ims VendorQtiIms;
+typedef struct qti_ims_sms VendorQtiImsSms;
+typedef struct qti_ims_radio VendorQtiImsRadio;
+typedef struct qti_ims_call VendorQtiImsCall;
+typedef struct qti_ims_state VendorQtiImsStateObject;
+typedef struct qti_ims_conf VendorQtiImsConfObject;
+
+G_END_DECLS
+
+#endif /* VENDOR_QTI_TYPES_H */

include/vendor_qti_util.h

@@ -0,0 +1,7 @@
+#ifndef VENDOR_QTI_UITL_H
+#define VENDOR_QTI_UITL_H
+
+#include "vendor_qti_ims_radio.h"
+
+
+#endif

src/vendor_qti_ext.c

@@ -18,13 +18,13 @@ typedef struct qti_plugin {
 
 } VendorQtiExt;
 
-GType qti_plugin_get_type();
+//GType qti_plugin_get_type();
 G_DEFINE_TYPE(VendorQtiExt, qti_plugin, BINDER_EXT_TYPE_PLUGIN)
 
 #define THIS_TYPE qti_plugin_get_type()
 #define THIS(obj) G_TYPE_CHECK_INSTANCE_CAST(obj, THIS_TYPE, VendorQtiExt)
 
-static const char qti_plugin_name[] = "qti";
+const char qti_plugin_name[] = "qti";
 
 /*==========================================================================*
  * BinderExtPluginClass

src/vendor_qti_ims.c

@@ -0,0 +1,161 @@
+#include <ofono/log.h>
+#include "binder_ext_types.h"
+#include "vendor_qti_types.h"
+#include <binder_ext_ims_impl.h>
+#include "vendor_qti_ims.h"
+
+typedef GObjectClass VendorQtiImsClass;
+struct qti_ims {
+    GObject parent;
+    char* slot;
+};
+
+static
+void
+qti_ims_iface_init(
+    BinderExtImsInterface* iface);
+
+GType qti_ims_get_type();
+G_DEFINE_TYPE_WITH_CODE(VendorQtiIms, qti_ims, G_TYPE_OBJECT,
+G_IMPLEMENT_INTERFACE(BINDER_EXT_TYPE_IMS, qti_ims_iface_init))
+
+#define THIS_TYPE qti_ims_get_type()
+#define THIS(obj) G_TYPE_CHECK_INSTANCE_CAST(obj, THIS_TYPE, VendorQtiIms)
+#define PARENT_CLASS qti_ims_parent_class
+
+enum qti_ims_signal {
+    SIGNAL_STATE_CHANGED,
+    SIGNAL_COUNT
+};
+
+#define SIGNAL_STATE_CHANGED_NAME    "qti-ims-state-changed"
+
+static guint qti_ims_signals[SIGNAL_COUNT] = { 0 };
+
+/*==========================================================================*
+ * BinderExtImsInterface
+ *==========================================================================*/
+
+static
+BINDER_EXT_IMS_STATE
+qti_ims_get_state(
+    BinderExtIms* ext)
+{
+    VendorQtiIms* self = THIS(ext);
+
+    DBG("%s", self->slot);
+#pragma message("TODO: return the actual state")
+    return BINDER_EXT_IMS_STATE_UNKNOWN;
+}
+
+static
+guint
+qti_ims_set_registration(
+    BinderExtIms* ext,
+    BINDER_EXT_IMS_REGISTRATION registration,
+    BinderExtImsResultFunc complete,
+    GDestroyNotify destroy,
+    void* user_data)
+{
+    VendorQtiIms* self = THIS(ext);
+    const gboolean on = (registration != BINDER_EXT_IMS_REGISTRATION_OFF);
+
+    DBG("%s %s", self->slot, on ? "on" : "off");
+    if (on) {
+#pragma message("TODO: turn IMS registration on")
+    } else {
+#pragma message("TODO: turn IMS registration off")
+    }
+    return 0;
+}
+
+static
+void
+qti_ims_cancel(
+    BinderExtIms* ext,
+    guint id)
+{
+    VendorQtiIms* self = THIS(ext);
+
+    /*
+     * Cancel a pending operation identified by the id returned by the
+     * above qti_ims_set_registration() call.
+     */
+    DBG("%s %u", self->slot, id);
+}
+
+static
+gulong
+qti_ims_add_state_handler(
+    BinderExtIms* ext,
+    BinderExtImsFunc handler,
+    void* user_data)
+{
+    VendorQtiIms* self = THIS(ext);
+
+    DBG("%s", self->slot);
+    return G_LIKELY(handler) ? g_signal_connect(self,
+        SIGNAL_STATE_CHANGED_NAME, G_CALLBACK(handler), user_data) : 0;
+}
+
+static
+void
+qti_ims_iface_init(
+    BinderExtImsInterface* iface)
+{
+    iface->version = BINDER_EXT_IMS_INTERFACE_VERSION;
+    iface->get_state = qti_ims_get_state;
+    iface->set_registration = qti_ims_set_registration;
+    iface->cancel = qti_ims_cancel;
+    iface->add_state_handler = qti_ims_add_state_handler;
+}
+
+/*==========================================================================*
+ * API
+ *==========================================================================*/
+
+BinderExtIms*
+qti_ims_new(VendorQtiImsRadio* ims_radio, VendorQtiImsStateObject* ims_state)
+{
+    VendorQtiIms* self = g_object_new(THIS_TYPE, NULL);
+
+    /*
+     * This could be the place to register a listener that gets invoked
+     * on registration state change and emits SIGNAL_STATE_CHANGED.
+     */
+
+    return BINDER_EXT_IMS(self);
+}
+
+/*==========================================================================*
+ * Internals
+ *==========================================================================*/
+
+static
+void
+qti_ims_finalize(
+    GObject* object)
+{
+    VendorQtiIms* self = THIS(object);
+
+    g_free(self->slot);
+    G_OBJECT_CLASS(PARENT_CLASS)->finalize(object);
+}
+
+static
+void
+qti_ims_init(
+    VendorQtiIms* self)
+{
+}
+
+static
+void
+qti_ims_class_init(
+    VendorQtiImsClass* klass)
+{
+    G_OBJECT_CLASS(klass)->finalize = qti_ims_finalize;
+    qti_ims_signals[SIGNAL_STATE_CHANGED] =
+        g_signal_new(SIGNAL_STATE_CHANGED_NAME, G_OBJECT_CLASS_TYPE(klass),
+            G_SIGNAL_RUN_FIRST, 0, NULL, NULL, NULL, G_TYPE_NONE, 0);
+}

src/vendor_qti_ims_call.c

@@ -1,25 +1,54 @@
+#include <ofono/log.h>
 
+#include <binder_ext_call_impl.h>
 
+#include "vendor_qti_types.h"
 
-typedef BinderExtCallClass VendorQtiImsCallClass;
+#include "vendor_qti_ims_call.h"
-typedef struct QtiImsCall {
+
-    BinderExtCall parent;
+typedef GObjectClass VendorQtiImsCallClass;
+struct qti_ims_call {
+    GObject parent;
     void * v_1;
     void * v_2;
     void * v_3;
     void * v_4;
     void * v_5;
     void * v_6;
-} VendorQtiImsCall;
+};
 
-G_DEFINE_TYPE(VendorQtiImsCall, qti_ims_call, BINDER_EXT_TYPE_CALL)
+static void qti_ims_call_iface_init(BinderExtCallInterface* iface);
+
+G_DEFINE_TYPE_WITH_CODE(VendorQtiImsCall, qti_ims_call, G_TYPE_OBJECT,
+G_IMPLEMENT_INTERFACE(BINDER_EXT_TYPE_CALL, qti_ims_call_iface_init))
 
 #define QTI_IMS_CALL_TYPE_SLOT qti_ims_call_get_type()
 #define QTI_IMS_CALL_SLOT(obj) G_TYPE_CHECK_INSTANCE_CAST(obj, QTI_IMS_CALL_TYPE_SLOT, VendorQtiImsCall)
 #define QTI_IMS_CALL_IS_SLOT(obj) G_TYPE_CHECK_INSTANCE_TYPE(obj, QTI_IMS_CALL_TYPE_SLOT)
 
+static
+void
+qti_ims_call_init(
+    VendorQtiImsCall* self)
+{
     
+}
 
+static
+void
+qti_ims_call_class_init(
+    VendorQtiImsCallClass* klass)
+{
+
+}
+static void qti_ims_call_iface_init(BinderExtCallInterface* iface){
+
+}
+
+BinderExtCall* vendor_qti_ims_call_new(VendorQtiImsRadio* ims_radio, VendorQtiImsStateObject* ims_state){
+    return NULL;
+}
+/*
 vendor_qti_ims_call_conference_info_start_element
 vendor_qti_ims_call_reg_state_update
 vendor_qti_ims_call_hangup
@@ -36,3 +65,4 @@ vendor_qti_ims_call_handle_conference_info
 vendor_qti_ims_call_handle_conf_user_deleted
 vendor_qti_ims_call_handle_conf_user_info_changed
 vendor_qti_ims_call_handle_state_change
+*/

src/vendor_qti_ims_conf.c

@@ -1,5 +1,12 @@
+#include <ofono/log.h>
+#include "vendor_qti_types.h"
+#include <glib-object.h>
 
-
+struct qti_ims_conf{
+    GObject parent;
+};
+/**
 vendor_qti_ims_conf_info_state
 vendor_qti_ims_conf_info_apply
 vendor_qti_ims_conf_info_endpoint_status
+*/

src/vendor_qti_ims_radio.c

@@ -1,29 +1,297 @@
+#include <ofono/log.h>
+#include <gbinder.h>
+#include <glib.h>
+#include <gutil_idlepool.h>
+#include <glib-object.h>
 
 #include "vendor_qti_ims_radio.h"
 
-typedef VendorQtiImsRadioClass VendorQtiExtClass;
+#define DEFAULT_INTERFACE IMS_RADIO_INTERFACE_1_2
-typedef struct qti_ims_radio {
-    BinderExtPlugin parent;
-    int num;
 
-} VendorQtiImsRadio;
+static const GBinderClientIfaceInfo ims_radio_iface_info[] = {
+    {IMS_RADIO_1_2, IMS_RADIO_1_2_REQ_LAST },
+    {IMS_RADIO_1_1, IMS_RADIO_1_1_REQ_LAST },
+    {IMS_RADIO_1_0, IMS_RADIO_1_0_REQ_LAST }
+};
+G_STATIC_ASSERT(G_N_ELEMENTS(ims_radio_iface_info) == IMS_RADIO_INTERFACE_COUNT);
+
+static const char* const ims_radio_indication_ifaces[] = {
+    IMS_RADIO_INDICATION_1_2,
+    IMS_RADIO_INDICATION_1_1,
+    IMS_RADIO_INDICATION_1_0,
+    NULL
+};
+G_STATIC_ASSERT(G_N_ELEMENTS(ims_radio_indication_ifaces) == IMS_RADIO_INTERFACE_COUNT + 1);
+
+static const char* const ims_radio_response_ifaces[] = {
+    IMS_RADIO_RESPONSE_1_2,
+    IMS_RADIO_RESPONSE_1_1,
+    IMS_RADIO_RESPONSE_1_0,
+    NULL
+};
+G_STATIC_ASSERT(G_N_ELEMENTS(ims_radio_response_ifaces) == IMS_RADIO_INTERFACE_COUNT + 1);
+
+typedef struct ims_radio_interface_desc {
+    RADIO_INTERFACE version;
+    const char* radio_iface;
+    const char* const* ind_ifaces;
+    const char* const* resp_ifaces;
+} ImsRadioInterfaceDesc;
+
+#define IMS_RADIO_INTERFACE_INDEX(x) (IMS_RADIO_INTERFACE_COUNT - x - 1)
+
+#define IMS_RADIO_INTERFACE_DESC(v) \
+        IMS_RADIO_INTERFACE_##v, IMS_RADIO_##v, \
+        ims_radio_indication_ifaces + IMS_RADIO_INTERFACE_INDEX(IMS_RADIO_INTERFACE_##v), \
+        ims_radio_response_ifaces + IMS_RADIO_INTERFACE_INDEX(IMS_RADIO_INTERFACE_##v)
+
+static const ImsRadioInterfaceDesc ims_radio_interfaces[] = {
+   { IMS_RADIO_INTERFACE_DESC(1_2) },
+   { IMS_RADIO_INTERFACE_DESC(1_1) },
+   { IMS_RADIO_INTERFACE_DESC(1_0) }
+};
+G_STATIC_ASSERT(G_N_ELEMENTS(ims_radio_interfaces) == IMS_RADIO_INTERFACE_COUNT);
 
 
+typedef GObjectClass VendorQtiImsRadioClass;
+struct qti_ims_radio {
+    GObject parent;
+    char* name;
+    GBinderClient* client;
+    GBinderRemoteObject* remote;
+    GBinderLocalObject* response;
+    GBinderLocalObject* indication;
+    GUtilIdlePool* idle;
+    GHashTable* table;
+};
+
+G_DEFINE_TYPE(VendorQtiImsRadio, qti_ims_radio, G_TYPE_OBJECT)
+
+#define THIS_TYPE qti_ims_radio_get_type()
+#define THIS(obj) G_TYPE_CHECK_INSTANCE_CAST(obj, THIS_TYPE, VendorQtiImsRadio)
+#define IS_THIS(obj) G_TYPE_CHECK_INSTANCE_TYPE(obj, THIS_TYPE)
+#define PARENT_CLASS qti_ims_radio_parent_class
+
+enum qti_ims_radio_signal {
+    SIGNAL_REG_STATE_CHANGED,
+    SIGNAL_INCOMING_SMS,
+    SIGNAL_SMS_STATUS_REPORT,
+    SIGNAL_CALL_RING,
+    SIGNAL_CALL_STATE_CHANGED,
+    SIGNAL_SUPP_SERVICE_NOTIFY,
+    SIGNAL_CONFERENCE_INFO,
+    SIGNAL_COUNT
+};
+
+#define SIGNAL_REG_STATE_CHANGED_NAME "qti-ims-radio-reg-state-changed"
+#define SIGNAL_INCOMING_SMS_NAME "qti-ims-radio-incoming-sms"
+#define SIGNAL_SMS_STATUS_REPORT_NAME "qti-ims-radio-sms-status-report"
+#define SIGNAL_CALL_RING_NAME "qti-ims-radio-call-ring"
+#define SIGNAL_CALL_STATE_CHANGED_NAME "qti-ims-radio-call-state-changed"
+#define SIGNAL_SUPP_SERVICE_NOTIFY_NAME "qti-ims-radio-supp-service-notify"
+#define SIGNAL_CONFERENCE_INFO_NAME "qti-ims-radio-conference-info"
+
+static guint qti_ims_radio_signals[SIGNAL_COUNT] = { 0 };
+
+
+/*==========================================================================*
+ * Internals
+ *==========================================================================*/
+static
+void
+qti_ims_radio_finalize(
+    GObject* object)
+{
+    VendorQtiImsRadio* self = THIS(object);
+
+    g_hash_table_unref(self->table);
+    gbinder_client_unref(self->client);
+    gutil_idle_pool_destroy(self->idle);
+    G_OBJECT_CLASS(PARENT_CLASS)->finalize(object);
+}
+
+static void destroy_value(gpointer hash_data) {
+    //printf("destroy value:%s\n",hash_data);
+    //因为我这里的值是数组形式不是指针所以不用释放内存。我就直接清空吧
+/*    free(hash_data);
+    hash_data = NULL;*/
+    //memset(hash_data,0,sizeof(hash_data));
+}
+static
+void
+qti_ims_radio_init(
+    VendorQtiImsRadio* self)
+{
+    self->idle = gutil_idle_pool_new();
+    self->table = g_hash_table_new_full(g_direct_hash, g_direct_equal, NULL, destroy_value);
+}
+
+static
+void
+qti_ims_radio_class_init(
+    VendorQtiImsRadioClass* klass)
+{
+    G_OBJECT_CLASS(klass)->finalize = qti_ims_radio_finalize;
+    qti_ims_radio_signals[SIGNAL_REG_STATE_CHANGED] =
+        g_signal_new(SIGNAL_REG_STATE_CHANGED_NAME,
+        G_TYPE_FROM_CLASS(klass), G_SIGNAL_RUN_FIRST, 0, NULL, NULL, NULL, G_TYPE_NONE, 2, 28LL);
+    qti_ims_radio_signals[SIGNAL_INCOMING_SMS] =
+        g_signal_new(SIGNAL_INCOMING_SMS_NAME,
+        G_TYPE_FROM_CLASS(klass), G_SIGNAL_RUN_FIRST, 0, NULL, NULL, NULL, G_TYPE_NONE, 4, 64LL);
+    qti_ims_radio_signals[SIGNAL_SMS_STATUS_REPORT] =
+        g_signal_new(SIGNAL_SMS_STATUS_REPORT_NAME,
+        G_TYPE_FROM_CLASS(klass), G_SIGNAL_RUN_FIRST, 0, NULL, NULL, NULL, G_TYPE_NONE, 4, 64LL);
+    qti_ims_radio_signals[SIGNAL_CALL_RING] =
+        g_signal_new(SIGNAL_CALL_RING_NAME,
+        G_TYPE_FROM_CLASS(klass), G_SIGNAL_RUN_FIRST, 0, NULL, NULL, NULL, G_TYPE_NONE, 0);
+    qti_ims_radio_signals[SIGNAL_CALL_STATE_CHANGED] =
+        g_signal_new(SIGNAL_CALL_STATE_CHANGED_NAME,
+        G_TYPE_FROM_CLASS(klass), G_SIGNAL_RUN_FIRST, 0, NULL, NULL, NULL, G_TYPE_NONE, 2, 68LL);
+    qti_ims_radio_signals[SIGNAL_SUPP_SERVICE_NOTIFY] =
+        g_signal_new(SIGNAL_SUPP_SERVICE_NOTIFY_NAME,
+        G_TYPE_FROM_CLASS(klass), G_SIGNAL_RUN_FIRST, 0, NULL, NULL, NULL, G_TYPE_NONE, 1, 68LL);
+    qti_ims_radio_signals[SIGNAL_CONFERENCE_INFO] =
+        g_signal_new(SIGNAL_CONFERENCE_INFO_NAME,
+        G_TYPE_FROM_CLASS(klass), G_SIGNAL_RUN_FIRST, 0, NULL, NULL, NULL, G_TYPE_NONE, 1, 68LL);
+}
+
+/**
 vendor_qti_ims_radio_registration_info
 vendor_qti_ims_radio_get_reg_state_response
 vendor_qti_ims_radio_send_ims_sms_response
 vendor_qti_ims_radio_sip_result_response
 
-vendor_qti_ims_radio_response
-vendor_qti_ims_radio_indication
 vendor_qti_ims_radio_handle_supp_service_notification
 vendor_qti_ims_radio_handle_call_state_changed
 vendor_qti_ims_radio_handle_sms_status_report
 vendor_qti_ims_radio_handle_incoming_ims_sms
+*/
+static
+GBinderLocalReply*
+vendor_qti_ims_radio_response(
+    GBinderLocalObject* obj,
+    GBinderRemoteRequest* req,
+    guint code,
+    guint flags,
+    int* status,
+    void* user_data)
+{
+    VendorQtiImsRadio* self = THIS(user_data);
+    const char* iface = gbinder_remote_request_interface(req);
+    if(gutil_strv_contains((const GStrV*)ims_radio_response_ifaces, iface)){
+        GBinderReader reader;
+        gbinder_remote_request_init_reader(req, &reader);
+        gint32 serial;
+        if (gbinder_reader_read_int32(&reader, &serial)) {
+            g_hash_table_lookup(self->table,serial);
+        }
 
-
+        *status = GBINDER_STATUS_OK;
+    }else{
+        GINFO("[%s] Unexpected %s %u", self->name,iface,code);
+        *status = GBINDER_STATUS_FAILED;
+    }
+    return NULL;
+}
+static
+GBinderLocalReply*
+vendor_qti_ims_radio_indication(
+    GBinderLocalObject* obj,
+    GBinderRemoteRequest* req,
+    guint code,
+    guint flags,
+    int* status,
+    void* user_data)
+{
+    VendorQtiImsRadio* self = THIS(user_data);
+    const char* iface = gbinder_remote_request_interface(req);
+    return NULL;
+}
 /*==========================================================================*
  * API
  *==========================================================================*/
- vendor_qti_ims_radio_new(){
+VendorQtiImsRadio* vendor_qti_ims_radio_create(
+    GBinderServiceManager* sm,
+    GBinderRemoteObject* remote,
+    const char* dev,
+    const char* name,
+    const ImsRadioInterfaceDesc* desc)
+{
+    VendorQtiImsRadio* self = g_object_new(THIS_TYPE, NULL);
+    GBinderLocalRequest* req;
+    GBinderWriter writer;
+    int status;
+
+    self->name = g_strdup(name);
+    self->client = gbinder_client_new2(remote, ims_radio_iface_info, G_N_ELEMENTS(ims_radio_iface_info));
+
+    self->response = gbinder_servicemanager_new_local_object2(sm, desc->resp_ifaces, vendor_qti_ims_radio_response, self);
+
+    self->indication = gbinder_servicemanager_new_local_object2(sm, desc->ind_ifaces, vendor_qti_ims_radio_indication, self);
+
+    /* IImsRadio::setCallback */
+    req = gbinder_client_new_request2(self->client,
+        IMS_RADIO_REQ_SET_CALLBACK);
+    gbinder_local_request_init_writer(req, &writer);
+    gbinder_writer_append_local_object(&writer, self->response);
+    gbinder_writer_append_local_object(&writer, self->indication);
+    // log
+    gbinder_remote_reply_unref(gbinder_client_transact_sync_reply(self->client,
+        IMS_RADIO_REQ_SET_CALLBACK, req, &status));
+    GINFO("setCallback %s status %d", self->name, status);
+    gbinder_local_request_unref(req);
+
+    return self;
+}
+
+VendorQtiImsRadio* vendor_qti_ims_radio_new_with_version(
+    const char* dev,
+    const char* name,
+    RADIO_INTERFACE max_version) /* Since 1.2.1 */
+{
+    VendorQtiImsRadio* self = NULL;
+    GBinderServiceManager* sm = gbinder_servicemanager_new(dev);
+    if (sm) {
+        guint i;
+        for (i = 0; i < G_N_ELEMENTS(ims_radio_interfaces) && !self; i++) {
+            const ImsRadioInterfaceDesc* desc = ims_radio_interfaces + i;
+
+            if (desc->version <= max_version) {
+                char* fqname = g_strconcat(desc->radio_iface, "/", name, NULL);
+                GBinderRemoteObject* obj = gbinder_servicemanager_get_service_sync(sm, fqname, NULL);
+
+                if (obj) {
+                    GINFO("Connected to %s", fqname);
+                    self = vendor_qti_ims_radio_create(sm, obj, dev, name, desc);
                 }
+                g_free(fqname);
+            }
+        }
+        gbinder_servicemanager_unref(sm);
+    }
+    return self;
+}
+
+VendorQtiImsRadio* vendor_qti_ims_radio_new(const char* dev, const char* name)
+{
+    return vendor_qti_ims_radio_new_with_version(dev, name, DEFAULT_INTERFACE);
+}
+
+VendorQtiImsRadio*
+vendor_qti_ims_radio_ref(
+    VendorQtiImsRadio* self)
+{
+    if (G_LIKELY(self)) {
+        g_object_ref(self);
+    }
+    return self;
+}
+
+void
+vendor_qti_ims_radio_unref(
+    VendorQtiImsRadio* self)
+{
+    if (G_LIKELY(self)) {
+        g_object_unref(self);
+    }
+}

src/vendor_qti_ims_sms.c

@@ -1,15 +1,18 @@
-
+#include <ofono/log.h>
-
 #include "binder_ext_sms_impl.h"
 
+#include "vendor_qti_types.h"
+#include "vendor_qti_ims_sms.h"
 
 typedef GObjectClass VendorQtiImsSmsClass;
-typedef struct qti_ims_sms {
+struct qti_ims_sms {
     GObject parent;
     int cancelled;
     VendorQtiImsRadio* ims_radio;
     VendorQtiImsStateObject* ims_state;
-} VendorQtiImsSms;
+    gulong incoming;
+    gulong status_report;
+};
 
 static void qti_ims_sms_iface_init(BinderExtSmsInterface* iface);
 G_DEFINE_TYPE_WITH_CODE(VendorQtiImsSms, qti_ims_sms, G_TYPE_OBJECT,
@@ -18,6 +21,18 @@ G_IMPLEMENT_INTERFACE(BINDER_EXT_TYPE_SMS, qti_ims_sms_iface_init))
 #define QTI_TYPE_SMS qti_ims_sms_get_type()
 #define QTI_IMS_SMS(obj) G_TYPE_CHECK_INSTANCE_CAST(obj, QTI_TYPE_SMS, VendorQtiImsSms)
 
+enum qti_ims_sms_signal {
+    SIGNAL_INCOMING,
+    SIGNAL_STATUS_REPORT,
+    SIGNAL_COUNT
+};
+
+#define SIGNAL_INCOMING_NAME "qti-ims-sms-incoming"
+#define SIGNAL_STATUS_REPORT_NAME "qti-ims-sms-status-report"
+
+static guint qti_ims_sms_signals[SIGNAL_COUNT] = { 0 };
+
+
 static
 void
 qti_ims_sms_init(
@@ -30,10 +45,10 @@ void
 qti_ims_sms_class_init(
     VendorQtiImsSmsClass* klass)
 {
-    sms_incoming_signal = g_signal_new("qti-ims-sms-incoming", 
+    qti_ims_sms_signals[SIGNAL_INCOMING] = g_signal_new(SIGNAL_INCOMING_NAME, 
                                     G_TYPE_FROM_CLASS (klass), 
                                     1LL, 0LL, 0LL, 0LL, 0LL, 4LL, 2, 68LL);
-    sms_status_report_signal = g_signal_new("qti-ims-sms-status-report", 
+    qti_ims_sms_signals[SIGNAL_STATUS_REPORT] = g_signal_new(SIGNAL_STATUS_REPORT_NAME, 
                                     G_TYPE_FROM_CLASS (klass), 
                                     1LL, 0LL, 0LL, 0LL, 0LL, 4LL, 3, 68LL);
 }
@@ -45,15 +60,29 @@ qti_ims_sms_class_init(
 guint vendor_qti_ims_sms_send(BinderExtSms* ext, const char* smsc, const void* pdu,
     gsize pdu_len, guint msg_ref, BINDER_EXT_SMS_SEND_FLAGS flags,
     BinderExtSmsSendFunc complete, GDestroyNotify destroy,
-    void* user_data);
+    void* user_data){
-void vendor_qti_ims_sms_cancel(BinderExtSms* ext, guint id);
+    return 0;
-void vendor_qti_ims_sms_ack_report(BinderExtSms* ext, guint msg_ref, gboolean ok);
+}
-void vendor_qti_ims_sms_ack_incoming(BinderExtSms* ext, gboolean ok);
+void vendor_qti_ims_sms_cancel(BinderExtSms* ext, guint id){
+
+}
+void vendor_qti_ims_sms_ack_report(BinderExtSms* ext, guint msg_ref, gboolean ok){
+    
+}
+void vendor_qti_ims_sms_ack_incoming(BinderExtSms* ext, gboolean ok){
+    
+}
 gulong vendor_qti_ims_sms_add_report_handler(BinderExtSms* ext,
-    BinderExtSmsReportFunc handler, void* user_data);
+    BinderExtSmsReportFunc handler, void* user_data){
+    return 0;
+}
 gulong vendor_qti_ims_sms_add_incoming_handler(BinderExtSms* ext,
-    BinderExtSmsIncomingFunc handler, void* user_data);
+    BinderExtSmsIncomingFunc handler, void* user_data){
-void vendor_qti_ims_sms_remove_handler(BinderExtSms* ext, gulong id);
+    return 0;
+}
+void vendor_qti_ims_sms_remove_handler(BinderExtSms* ext, gulong id){
+    
+}
 
 
 static void qti_ims_sms_iface_init(BinderExtSmsInterface* iface){
@@ -68,13 +97,23 @@ static void qti_ims_sms_iface_init(BinderExtSmsInterface* iface){
     iface->remove_handler = vendor_qti_ims_sms_remove_handler;
 }
 
+static qti_ims_sms_signal_emit_incoming(){
+
+}
+gulong qti_ims_sms_connect_signal_incoming(VendorQtiImsRadio* ims_radio){
+
+}
 
 BinderExtSms* vendor_qti_ims_sms_new(VendorQtiImsRadio* ims_radio,VendorQtiImsStateObject* ims_state){
-    VendorQtiImsSms* sms= g_object_new(QTI_TYPE_SMS, NULL);
+    VendorQtiImsSms* self = g_object_new(QTI_TYPE_SMS, NULL);
     
-    sms->ims_state = ims_state; // 不是直接赋值
+    self->ims_state = vendor_qti_ims_radio_ref(ims_state);
-    sms->ims_radio = ims_radio; // 不是直接赋值
+    self->ims_radio = vendor_qti_ims_state_ref(ims_radio);
-    // TODO绑定信号  qti-ims-radio-incoming-sms qti-ims-radio-sms-status-report
     
-    return BINDER_EXT_IMS(sms);
+    //self->incoming = g_signal_connect(ims_radio,"");
+    //self->status_report = ;
+    //qti-ims-radio-incoming-sms
+    //qti-ims-radio-sms-status-report
+
+    return BINDER_EXT_IMS(self);
 }

src/vendor_qti_ims_state.c

@@ -0,0 +1,51 @@
+#include <ofono/log.h>
+#include <glib-object.h>
+#include "vendor_qti_ims_state.h"
+
+typedef GObjectClass VendorQtiImsStateObjectClass;
+struct qti_ims_state{
+    GObject parent;
+};
+
+G_DEFINE_TYPE(VendorQtiImsStateObject, qti_ims_state, G_TYPE_OBJECT)
+
+#define THIS_TYPE qti_ims_state_get_type()
+#define THIS(obj) G_TYPE_CHECK_INSTANCE_CAST(obj, THIS_TYPE, VendorQtiImsStateObject)
+#define IS_THIS(obj) G_TYPE_CHECK_INSTANCE_TYPE(obj, THIS_TYPE)
+#define PARENT_CLASS qti_ims_state_parent_class
+
+static
+void
+qti_ims_state_init(
+    VendorQtiImsStateObject* self)
+{
+}
+static
+void
+qti_ims_state_class_init(
+    VendorQtiImsStateObjectClass* klass)
+{
+}
+
+VendorQtiImsStateObject* vendor_qti_ims_state_new(VendorQtiImsRadio* ims_radio){
+    return NULL;
+}
+
+VendorQtiImsStateObject*
+vendor_qti_ims_state_ref(
+    VendorQtiImsStateObject* self)
+{
+    if (G_LIKELY(self)) {
+        g_object_ref(self);
+    }
+    return self;
+}
+
+void
+vendor_qti_ims_state_unref(
+    VendorQtiImsStateObject* self)
+{
+    if (G_LIKELY(self)) {
+        g_object_unref(self);
+    }
+}

src/vendor_qti_plugin.c

@@ -7,6 +7,7 @@
 /*==========================================================================*
  * QTI plugin
  *==========================================================================*/
+extern const char qti_plugin_name[];
 
 // sub_B940
 static int vendor_qti_plugin_init(void){

src/vendor_qti_slot.c

@@ -1,7 +1,19 @@
 
+#include <ofono/log.h>
+
+#include "radio_instance.h"
+
+#include "binder_ext_ims.h"
+#include "binder_ext_sms.h"
+#include "binder_ext_call.h"
+
+#include "binder_ext_slot_impl.h"
+
+#include "vendor_qti_types.h"
+
 #include "vendor_qti_slot.h"
-#include "binder_ext_ims.h"
+#include "vendor_qti_ims_radio.h"
-#include "binder_ext_slot_impl.h"
+#include "vendor_qti_ims_state.h"
 
 
 /*==========================================================================*
@@ -9,15 +21,14 @@
  *==========================================================================*/
 
 typedef BinderExtSlotClass VendorQtiSlotClass;
-typedef struct qti_slot {
+struct qti_slot {
     BinderExtSlot parent;
-    int* shutdown;
+    BinderExtIms* ims;// 4
-    VendorQtiIms* ims;// 4
+    BinderExtSms* ims_sms;// 5
-    VendorQtiImsSms* ims_sms;// 5
+    BinderExtCall* ims_call;// 6
-    VendorQtiImsCall* ims_call;// 6
     VendorQtiImsRadio* ims_radio;// 7
     VendorQtiImsStateObject* ims_state; // 8
-} VendorQtiSlot;
+};
 
 G_DEFINE_TYPE(VendorQtiSlot, qti_slot, BINDER_EXT_TYPE_SLOT)
 
@@ -37,6 +48,16 @@ qti_slot_get_interface(
     BinderExtSlot* slot,
     GType iface)
 {
+    VendorQtiSlot *self = THIS(slot);
+    if (iface == BINDER_EXT_TYPE_IMS) {
+        return self->ims;
+    }
+    if (iface == BINDER_EXT_TYPE_SMS) {
+        return self->ims_sms;
+    }
+    if (iface == BINDER_EXT_TYPE_CALL) {
+        return self->ims_call;
+    }
     return BINDER_EXT_SLOT_CLASS(PARENT_CLASS)->
         get_interface(slot, iface);
 }
@@ -46,11 +67,8 @@ void
 qti_slot_shutdown(
     BinderExtSlot* slot)
 {
-    VendorQtiSlot* self = QTI_SLOT(slot);
+    VendorQtiSlot* self = THIS(slot);
 
-    if (self->shutdown) {
-        (*self->shutdown)++;
-    }
     BINDER_EXT_SLOT_CLASS(PARENT_CLASS)->shutdown(slot);
 }
 
@@ -59,20 +77,22 @@ qti_slot_shutdown(
  *==========================================================================*/
  BinderExtSlot* vendor_qti_slot_new(RadioInstance* radio, GHashTable* params)
 {
-    VendorQtiSlot* slot = g_object_new(QTI_TYPE_SLOT, NULL);
+    VendorQtiSlot* self = g_object_new(THIS_TYPE, NULL);
-
+    BinderExtSlot* slot = &self->parent;
-    char* ims_radio_num = g_strdup_printf("imsradio%d", radio->slot_index);
+    char* ims_radio_name = g_strdup_printf("imsradio%d", radio->slot_index);
     //
-    VendorQtiImsRadio* ims_radio = vendor_qti_ims_radio_new(radio->enabled,ims_radio_num,2);
+    VendorQtiImsRadio* ims_radio = vendor_qti_ims_radio_new(radio->dev, ims_radio_name);
-    slot->ims_radio = ims_radio;
+    self->ims_radio = ims_radio;
+
     if(ims_radio != NULL){
         VendorQtiImsStateObject* ims_state = vendor_qti_ims_state_new(ims_radio);
-        slot->ims_state = ims_state;
+        self->ims_state = ims_state;
-        slot->ims = vendor_qti_ims_new(ims_radio,ims_state);
+        self->ims = vendor_qti_ims_new(ims_radio,ims_state);
-        slot->ims_call = vendor_qti_ims_call_new(slot->ims_radio,slot->ims_state);
+        self->ims_call = vendor_qti_ims_call_new(self->ims_radio,self->ims_state);
-        slot->ims_sms = vendor_qti_ims_sms_new(slot->ims_radio,slot->ims_state);
+        self->ims_sms = vendor_qti_ims_sms_new(self->ims_radio,self->ims_state);
     }
-    g_free(ims_radio_num);
+
+    g_free(ims_radio_name);
     return slot;
 }
 

src/vendor_qti_util.c

@@ -1,2 +1,61 @@
 
-vendor_qti_util_markup_parse
+#include "vendor_qti_ims_radio.h"
+#include "vendor_qti_util.h"
+
+
+// vendor_qti_util_markup_parse
+
+const char*
+vendor_qti_util_radio_req_name(
+    IMS_RADIO_REQ req)
+{
+    switch (req) {
+#define IMS_RADIO_REQ_(req,resp,Name,NAME) \
+    case IMS_RADIO_REQ_##NAME: return #Name;
+    IMS_RADIO_CALL_1_0(IMS_RADIO_REQ_)
+    IMS_RADIO_CALL_1_2(IMS_RADIO_REQ_)
+#undef IMS_RADIO_REQ_
+    case IMS_RADIO_REQ_SET_CALLBACK:   return "setCallback";
+    case IMS_RADIO_REQ_SET_COLR:     return "setColr";
+    case IMS_RADIO_REQ_HANGUP_1_1:  return "hangup_1_1";
+    case IMS_RADIO_REQ_HANGUP_1_2:        return "hangup_1_2";
+    case IMS_RADIO_REQ_ACKNOWLEDGE_SMS:   return "acknowledgeSms";
+    case IMS_RADIO_REQ_ACKNOWLEDGE_SMS_REPORT: return "acknowledgeSmsReport";
+    case IMS_RADIO_REQ_ANY:
+        break;
+    }
+    return NULL;
+}
+
+const char*
+vendor_qti_util_radio_resp_name(
+    IMS_RADIO_RESP resp)
+{
+    switch (resp) {
+#define IMS_RADIO_RESP_(req,resp,Name,NAME) \
+    case IMS_RADIO_RESP_##NAME: return #Name "Response";
+    IMS_RADIO_CALL_1_0(IMS_RADIO_RESP_)
+    IMS_RADIO_CALL_1_2(IMS_RADIO_RESP_)
+#undef IMS_RADIO_RESP_
+    case IMS_RADIO_RESP_ANY:
+        break;
+    }
+    return NULL;
+}
+
+const char*
+vendor_qti_util_radio_ind_name(
+    IMS_RADIO_IND ind)
+{
+    switch (ind) {
+#define IMS_RADIO_IND_(code,Name,NAME) \
+    case IMS_RADIO_IND_##NAME: return #Name;
+    IMS_RADIO_EVENT_1_0(IMS_RADIO_IND_)
+    IMS_RADIO_EVENT_1_1(IMS_RADIO_IND_)
+    IMS_RADIO_EVENT_1_2(IMS_RADIO_IND_)
+#undef IMS_RADIO_IND_
+    case IMS_RADIO_IND_ANY:
+        break;
+    }
+    return NULL;
+}