Change the adapter state check logic

[platform/core/connectivity/bluetooth-frwk.git] / bt-api / bt-request-sender.c

diff --git a/bt-api/bt-request-sender.c b/bt-api/bt-request-sender.c
index bbfd821..d98d939 100644 (file)
--- a/bt-api/bt-request-sender.c
+++ b/bt-api/bt-request-sender.c
@@ -35,6 +35,7 @@
 static GSList *sending_requests;
 
 static GDBusProxy *service_gproxy;
+static GDBusProxy *service_gproxy_not_autostart;
 
 static GDBusProxy *__bt_gdbus_init_service_proxy(void)
 {
@@ -67,11 +68,50 @@ static GDBusProxy *__bt_gdbus_init_service_proxy(void)
        return proxy;
 }
 
+static GDBusProxy *__bt_gdbus_init_service_proxy_not_autostart(void)
+{
+       GDBusConnection *service_gconn;
+       GDBusProxy *proxy;
+       GError *err = NULL;
+
+       service_gconn = _bt_get_system_common_conn();
+
+       if (!service_gconn)
+               return NULL;
+
+       /* G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START
+        * method call will be failed not auto activation
+        * if service is unavailble. */
+       proxy =  g_dbus_proxy_new_sync(service_gconn,
+                       G_DBUS_PROXY_FLAGS_DO_NOT_AUTO_START, NULL,
+                       BT_DBUS_NAME,
+                       BT_SERVICE_PATH,
+                       BT_DBUS_NAME,
+                       NULL, &err);
+       if (!proxy) {
+               if (err) {
+                        BT_ERR("Unable to create proxy: %s", err->message);
+                        g_clear_error(&err);
+               }
+
+               return NULL;
+       }
+
+       service_gproxy_not_autostart = proxy;
+
+       return proxy;
+}
+
 static GDBusProxy *__bt_gdbus_get_service_proxy(void)
 {
        return (service_gproxy) ? service_gproxy : __bt_gdbus_init_service_proxy();
 }
 
+static GDBusProxy *__bt_gdbus_get_service_proxy_not_autostart(void)
+{
+       return (service_gproxy_not_autostart) ? service_gproxy_not_autostart : __bt_gdbus_init_service_proxy_not_autostart();
+}
+
 void _bt_gdbus_deinit_proxys(void)
 {
        if (service_gproxy) {
@@ -945,3 +985,99 @@ int _bt_sync_send_request_with_unix_fd_list(
 
        return result;
 }
+
+int _bt_sync_send_request_not_autostart(int service_type, int service_function,
+                       GArray *in_param1, GArray *in_param2,
+                       GArray *in_param3, GArray *in_param4,
+                       GArray **out_param1)
+{
+       int result = BLUETOOTH_ERROR_NONE;
+       GError *error = NULL;
+       GArray *in_param5 = NULL;
+//     GArray *out_param2 = NULL;
+
+       GDBusProxy  *proxy;
+       GVariant *ret;
+       GVariant *param1;
+       GVariant *param2;
+       GVariant *param3;
+       GVariant *param4;
+       GVariant *param5;
+
+       switch (service_type) {
+       case BT_BLUEZ_SERVICE:
+       case BT_OBEX_SERVICE:
+       case BT_AGENT_SERVICE:
+       case BT_CHECK_PRIVILEGE:
+               proxy = __bt_gdbus_get_service_proxy_not_autostart();
+               if (!proxy)
+                       return BLUETOOTH_ERROR_INTERNAL;
+
+               in_param5 = g_array_new(TRUE, TRUE, sizeof(gchar));
+
+
+
+               param1 = g_variant_new_from_data((const GVariantType *)"ay",
+                                       in_param1->data, in_param1->len,
+                                       TRUE, NULL, NULL);
+               param2 = g_variant_new_from_data((const GVariantType *)"ay",
+                                       in_param2->data, in_param2->len,
+                                       TRUE, NULL, NULL);
+               param3 = g_variant_new_from_data((const GVariantType *)"ay",
+                                       in_param3->data, in_param3->len,
+                                       TRUE, NULL, NULL);
+               param4 = g_variant_new_from_data((const GVariantType *)"ay",
+                                       in_param4->data, in_param4->len,
+                                       TRUE, NULL, NULL);
+               param5 = g_variant_new_from_data((const GVariantType *)"ay",
+                                       in_param5->data, in_param5->len,
+                                       TRUE, NULL, NULL);
+
+               ret = g_dbus_proxy_call_sync(proxy, "service_request",
+                                       g_variant_new("(iii@ay@ay@ay@ay@ay)",
+                                               service_type, service_function,
+                                               BT_SYNC_REQ, param1,
+                                               param2, param3,
+                                               param4, param5),
+                                       G_DBUS_CALL_FLAGS_NONE, -1,
+                                       NULL, &error);
+
+               g_array_free(in_param5, TRUE);
+
+               if (ret == NULL) {
+                       if (error != NULL)
+                               g_clear_error(&error);
+                       BT_DBG("bt-service is not available");
+                       return BLUETOOTH_ERROR_INTERNAL;
+               }
+
+               param1 = NULL;
+//             param2 = NULL;
+
+               g_variant_get(ret, "(iv)", &result, &param1);
+
+               if (param1) {
+                       *out_param1 = g_array_new(TRUE, TRUE, sizeof(gchar));
+                       __bt_fill_garray_from_variant(param1, *out_param1);
+                       g_variant_unref(param1);
+               }
+
+//             if (param2) {
+//                     out_param2 = g_array_new(TRUE, TRUE, sizeof(gchar));
+//                     __bt_fill_garray_from_variant(param2, out_param2);
+//                     result = g_array_index(out_param2, int, 0);
+//                     g_variant_unref(param2);
+//                     g_array_free(out_param2, TRUE);
+//             } else {
+//                     result = BLUETOOTH_ERROR_INTERNAL;
+//             }
+
+               g_variant_unref(ret);
+               break;
+       default:
+               BT_ERR("Unknown service type");
+               return BLUETOOTH_ERROR_INTERNAL;
+       }
+
+       return result;
+}