IF("$ENV{CFLAGS}" MATCHES "-DEMUL")
ADD_SUBDIRECTORY(bt-service-emul)
ELSE()
+IF("$ENV{BT_INCLUDE_OAL}" STREQUAL "ENABLED")
+ADD_SUBDIRECTORY(bt-service-adaptation)
+ELSE("$ENV{BT_INCLUDE_OAL}" STREQUAL "ENABLED")
ADD_SUBDIRECTORY(bt-service)
+ENDIF("$ENV{BT_INCLUDE_OAL}" STREQUAL "ENABLED")
ENDIF()
ADD_SUBDIRECTORY(bt-httpproxy)
--- /dev/null
+CMAKE_MINIMUM_REQUIRED(VERSION 2.6)
+PROJECT(bt-service C)
+
+#ADD_SUBDIRECTORY(hal_lib)
+
+#Include Source files for bluetooth service common files only
+SET(SRCS
+marshal.c
+./services/bt-service-main.c
+./services/bt-service-common.c
+./services/bt-service-event-sender.c
+./services/bt-service-util.c
+./services/bt-request-handler.c
+)
+
+IF(LIBNOTIFY_SUPPORT)
+LIST(APPEND SRCS
+bt-popup.c
+)
+ENDIF(LIBNOTIFY_SUPPORT)
+
+IF(LIBNOTIFICATION_SUPPORT)
+LIST(APPEND SRCS
+bt-service-agent-notification.c
+)
+ENDIF(LIBNOTIFICATION_SUPPORT)
+
+IF("${CMAKE_BUILD_TYPE}" STREQUAL "")
+ SET(CMAKE_BUILD_TYPE "Release")
+ENDIF("${CMAKE_BUILD_TYPE}" STREQUAL "")
+MESSAGE("Build type: ${CMAKE_BUILD_TYPE}")
+
+INCLUDE_DIRECTORIES(${CMAKE_SOURCE_DIR}/include)
+INCLUDE_DIRECTORIES(${CMAKE_CURRENT_SOURCE_DIR}/services/include)
+
+SET(PKG_MODULES
+ vconf
+ aul
+ vconf
+ syspopup-caller
+ dbus-glib-1
+ dbus-1
+ gio-2.0
+ alarm-service
+ capi-content-mime-type
+ capi-network-connection
+ pkgmgr
+ cynara-client
+ cynara-creds-gdbus
+ eventsystem
+ storage
+)
+
+IF("$ENV{CFLAGS}" MATCHES "-DTIZEN_NETWORK_TETHERING_ENABLE")
+SET(PKG_MODULES ${PKG_MODULES}
+ capi-network-tethering
+)
+ENDIF()
+
+INCLUDE(FindPkgConfig)
+pkg_check_modules(service_pkgs REQUIRED ${PKG_MODULES})
+
+FOREACH(flag ${service_pkgs_CFLAGS})
+ SET(EXTRA_CFLAGS "${EXTRA_CFLAGS} ${flag} -Wall")
+ENDFOREACH(flag)
+
+SET(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} ${EXTRA_CFLAGS} -fPIC -Wall")
+SET(CMAKE_C_FLAGS_DEBUG "-O0 -g")
+SET(CMAKE_C_FLAGS_RELEASE "-O2")
+SET(APP_SYSCONFDIR /opt/var/lib/bluetooth)
+
+FIND_PROGRAM(UNAME NAMES uname)
+EXEC_PROGRAM("${UNAME}" ARGS "-m" OUTPUT_VARIABLE "ARCH")
+IF("${ARCH}" STREQUAL "arm")
+ ADD_DEFINITIONS("-DTARGET")
+ MESSAGE("add -DTARGET")
+ENDIF("${ARCH}" STREQUAL "arm")
+
+FIND_PROGRAM(MARSHALTOOL NAMES glib-genmarshal)
+EXEC_PROGRAM("${MARSHALTOOL}" ARGS "--prefix=marshal ${CMAKE_CURRENT_SOURCE_DIR}/marshal.list --header > ${CMAKE_CURRENT_SOURCE_DIR}/include/marshal.h")
+EXEC_PROGRAM("${MARSHALTOOL}" ARGS "--prefix=marshal ${CMAKE_CURRENT_SOURCE_DIR}/marshal.list --body > ${CMAKE_CURRENT_SOURCE_DIR}/marshal.c")
+
+FIND_PROGRAM(DBUS_BINDING_TOOL NAMES dbus-binding-tool)
+#EXEC_PROGRAM("${DBUS_BINDING_TOOL}" ARGS "--prefix=bt ${CMAKE_CURRENT_SOURCE_DIR}/bt-request-service.xml --mode=glib-server --output=${CMAKE_CURRENT_SOURCE_DIR}/include/bt-service-method.h")
+#EXEC_PROGRAM("${DBUS_BINDING_TOOL}" ARGS "--prefix=bt_obex_agent ${CMAKE_CURRENT_SOURCE_DIR}/bt-service-obex-agent.xml --mode=glib-server --output=${CMAKE_CURRENT_SOURCE_DIR}/include/bt-obex-agent-method.h")
+
+#EXEC_PROGRAM("${DBUS_BINDING_TOOL}" ARGS "--prefix=gap_agent ${CMAKE_CURRENT_SOURCE_DIR}/bt-service-gap-agent1.xml --mode=glib-server --output=${CMAKE_CURRENT_SOURCE_DIR}/include/bt-gap-agent-method.h")
+
+#EXEC_PROGRAM("${DBUS_BINDING_TOOL}" ARGS "--prefix=bt_media_agent ${CMAKE_CURRENT_SOURCE_DIR}/bt-service-media-agent.xml --mode=glib-server --output=${CMAKE_CURRENT_SOURCE_DIR}/include/bt-media-agent-method.h")
+
+ADD_DEFINITIONS("-DPREFIX=\"${CMAKE_INSTALL_PREFIX}\"")
+ADD_DEFINITIONS("-DVENDOR=\"${APP_VENDOR}\"")
+ADD_DEFINITIONS("-DAPPNAME=\"${APP_NAME}\"")
+ADD_DEFINITIONS("-DAPP_DIR=\"${APP_DIR}\"")
+ADD_DEFINITIONS("-DAPP_LOCALEDIR=\"${APP_LOCALEDIR}\"")
+ADD_DEFINITIONS("-DAPP_SYSCONFDIR=\"${APP_SYSCONFDIR}\"")
+ADD_DEFINITIONS("-DHPS_FEATURE")
+ADD_DEFINITIONS("-DTIZEN_DPM_ENABLE")
+
+IF(LIBNOTIFY_SUPPORT OR LIBNOTIFICATION_SUPPORT)
+ ADD_DEFINITIONS("-DDATA_DIR_ICON=\"${SHARE_INSTALL_PREFIX}\"")
+ MESSAGE("Icon used for notification is : ${SHARE_INSTALL_PREFIX}/icons/default/bt-icon.png")
+ENDIF(LIBNOTIFY_SUPPORT OR LIBNOTIFICATION_SUPPORT)
+
+SET(CMAKE_EXE_LINKER_FLAGS "-Wl,--as-needed -pie")
+
+ADD_EXECUTABLE(${PROJECT_NAME} ${SRCS})
+TARGET_LINK_LIBRARIES(${PROJECT_NAME} ${service_pkgs_LDFLAGS})
+
+# to permit usage of bluetooth_cancel_bonding in bt-popup.c. This build bluetooth-api first.
+IF(LIBNOTIFY_SUPPORT)
+ ADD_DEPENDENCIES(${PROJECT_NAME} bluetooth-api)
+ TARGET_LINK_LIBRARIES(${PROJECT_NAME} ${service_pkgs_LDFLAGS} bluetooth-api)
+ELSE(LIBNOTIFY_SUPPORT)
+ TARGET_LINK_LIBRARIES(${PROJECT_NAME} ${service_pkgs_LDFLAGS})
+ENDIF(LIBNOTIFY_SUPPORT)
+
+#CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/org.projectx.bt.service.in ${CMAKE_CURRENT_SOURCE_DIR}/org.projectx.bt.service)
+INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/org.projectx.bt.service DESTINATION share/dbus-1/system-services)
+INSTALL(TARGETS ${PROJECT_NAME} DESTINATION bin)
+
+INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/auto-pair-blacklist DESTINATION /opt/var/lib/bluetooth/)
+
+# install booting script
+CONFIGURE_FILE(${CMAKE_CURRENT_SOURCE_DIR}/bluetooth-frwk-service.conf.in ${CMAKE_CURRENT_SOURCE_DIR}/bluetooth-frwk-service.conf)
+
+IF (TIZEN_WEARABLE)
+ INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/wearable/stack_info DESTINATION /usr/etc/bluetooth/)
+ELSE ()
+ INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/mobile/stack_info DESTINATION /usr/etc/bluetooth/)
+ENDIF (TIZEN_WEARABLE)
+
+INSTALL(FILES ${CMAKE_CURRENT_SOURCE_DIR}/bluetooth-frwk-service.conf DESTINATION /etc/dbus-1/system.d)
+
+SET(PREFIX ${CMAKE_INSTALL_PREFIX})
--- /dev/null
+AddressBlacklist=00:02:C7,00:16:FE,00:19:C1,00:1B:FB,00:1E:3D,00:21:4F,00:23:06,00:24:33,00:A0:79,00:0E:6D,00:13:E0,00:21:E8,00:60:57,00:0E:9F,00:12:1C,00:18:91,00:18:96,00:13:04,00:16:FD,00:22:A0,00:0B:4C,00:60:6F,00:23:3D,00:C0:59,00:0A:30,00:1E:AE,00:1C:D7,00:80:F0,00:12:8A,00:09:93,00:80:37,00:26:7E,00:1A:1B,00:14:9A,00:0B:24,08:76:95,00:14:09,00:1E:B2\r
+ExactNameBlacklist=Motorola IHF1000,i.TechBlueBAND,X5 Stereo v1.3,KML_CAN,SYNC,UConnect\r
+PartialNameBlacklist=BMW,Audi,Parrot,HandsFreeLink,Car,MB PhoneSystem,CAR MULTIMEDIA,MB Bluetooth,Pama\r
+KeyboardAutoPair=00:0F:F6\r
--- /dev/null
+#!/bin/sh
+
+#
+# Script for running BT Service during booting time
+#
+
+if [ -x /usr/bin/bt-service ]; then
+ /usr/bin/bt-service &
+fi
--- /dev/null
+<!DOCTYPE busconfig PUBLIC "-//freedesktop//DTD D-BUS Bus Configuration 1.0//EN"
+ "http://www.freedesktop.org/standards/dbus/1.0/busconfig.dtd">
+<busconfig>
+ <policy group="system">
+ <allow own="org.projectx.bt"/>
+ <allow own="org.projectx.bt_event"/>
+ <allow own="org.projectx.bluetooth.share"/>
+ <allow own="org.bluez.ag_agent"/>
+ <allow own="org.tizen.csd.Call.Instance"/>
+ </policy>
+ <policy group="root">
+ <allow own="org.projectx.bt"/>
+ <allow own="org.projectx.bt_event"/>
+ <allow own="org.projectx.bluetooth.share"/>
+ <allow own="org.bluez.ag_agent"/>
+ <allow own="org.tizen.csd.Call.Instance"/>
+ </policy>
+ <policy at_console="true">
+ <allow send_destination="org.projectx.bt"/>
+ </policy>
+ <policy context="default">
+ <allow send_destination="org.projectx.bt"/>
+ </policy>
+</busconfig>
+
--- /dev/null
+<?xml version="1.0" encoding="UTF-8" ?>
+<node name="/org/projectx/bt_service">
+ <interface name="org.projectx.bt">
+ <method name="service_request">
+ <annotation name="org.freedesktop.DBus.GLib.Async" value="bt_service_request"/>
+ <!-- INPUT PARAMS FOR SERVICE FUNCTION -->
+ <arg type="i" name="service_type" direction="in" />
+ <arg type="i" name="service_function" direction="in" />
+ <arg type="i" name="request_type" direction="in" />
+ <arg type="ay" name="input_param1" direction="in" />
+ <arg type="ay" name="input_param2" direction="in" />
+ <arg type="ay" name="input_param3" direction="in" />
+ <arg type="ay" name="input_param4" direction="in" />
+ <arg type="ay" name="input_param5" direction="in" />
+ <!-- OUTPUT PARAMS FOR SERVICE FUNCTION -->
+ <arg type="ay" name="output_param1" direction="out" />
+ <arg type="ay" name="output_param2" direction="out" />
+ </method>
+ </interface>
+</node>
+
--- /dev/null
+# DBUS Signal argument converting list for bluetooth frwk lib
+VOID:STRING
+VOID:STRING,UINT,INT
+VOID:STRING,STRING
+VOID:STRING,STRING,INT
+VOID:UINT
+VOID:STRING,STRING,INT,UINT
+VOID:STRING,VARIANT
+# for BlueZ4
+VOID:STRING,BOXED
+# for obex
+VOID:STRING,STRING,UINT64
+VOID:UINT64
+VOID:STRING,STRING,STRING
+# for obexd
+VOID:OBJECT,BOOLEAN
+VOID:INT,INT
+
--- /dev/null
+Bluez 5.16,
+HFP AG 1.6
+HSP AG 1.2
+A2DP Source 1.2
+AVRCP Target 1.3
+GAVDP 1.2
+OPP 1.1
+PBAP PSE 1.1
+PAN NAP 1.0
+PAN USER 1.0
--- /dev/null
+[D-BUS Service]
+Name=org.projectx.bt
+Exec=/bin/false
+User=root
+SystemdService=bluetooth-frwk.service
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <string.h>
+#include <glib.h>
+#include <dlog.h>
+#include <gio/gio.h>
+#include <cynara-client.h>
+#include <cynara-creds-gdbus.h>
+
+#include "bluetooth-api.h"
+#include "bt-request-handler.h"
+#include "bt-service-common.h"
+#include "bt-service-util.h"
+
+static GDBusConnection *bt_service_conn;
+static guint owner_id = 0;
+cynara *p_cynara;
+cynara_configuration *conf;
+
+static const gchar bt_service_introspection_xml[] =
+"<node name='/org/projectx/bt_service'>"
+" <interface name='org.projectx.bt'>"
+" <method name='service_request'>"
+ /* Input Parameters */
+" <arg type='i' name='service_type' direction='in' />"
+" <arg type='i' name='service_function' direction='in' />"
+" <arg type='i' name='request_type' direction='in' />"
+" <arg type='ay' name='input_param1' direction='in' />"
+" <arg type='ay' name='input_param2' direction='in' />"
+" <arg type='ay' name='input_param3' direction='in' />"
+" <arg type='ay' name='input_param4' direction='in' />"
+" <arg type='ay' name='input_param5' direction='in' />"
+ /* Return Parameters */
+" <arg type='i' name='output_param1' direction='out' />"
+" <arg type='v' name='output_param2' direction='out' />"
+" </method>"
+" </interface>"
+"</node>";
+
+GDBusNodeInfo *node_info = NULL;
+
+static void __bt_service_method(GDBusConnection *connection,
+ const gchar *sender,
+ const gchar *object_path,
+ const gchar *interface_name,
+ const gchar *method_name,
+ GVariant *parameters,
+ GDBusMethodInvocation *invocation,
+ gpointer user_data);
+
+int __bt_bluez_request(int function_name,
+ int request_type,
+ int request_id,
+ GDBusMethodInvocation *context,
+ GVariant *in_param1,
+ GVariant *in_param2,
+ GVariant *in_param3,
+ GVariant *in_param4,
+ GArray **out_param1);
+int __bt_obexd_request(int function_name,
+ int request_type,
+ int request_id,
+ GDBusMethodInvocation *context,
+ GVariant *in_param1,
+ GVariant *in_param2,
+ GVariant *in_param3,
+ GVariant *in_param4,
+ GVariant *in_param5,
+ GArray **out_param1);
+int __bt_agent_request(int function_name,
+ int request_type,
+ int request_id,
+ GDBusMethodInvocation *context,
+ GVariant *in_param1,
+ GVariant *in_param2,
+ GVariant *in_param3,
+ GVariant *in_param4,
+ GArray **out_param1);
+int __bt_core_request(int function_name,
+ int request_type,
+ int request_id,
+ GDBusMethodInvocation *context,
+ GVariant *in_param1);
+
+gboolean __bt_service_check_privilege(int function_name,
+ int service_type,
+ const char *unique_name);
+
+/* Function definitions*/
+static void __bt_fill_garray_from_variant(GVariant *var, GArray *param)
+{
+ char *data;
+ int size;
+
+ size = g_variant_get_size(var);
+ if (size > 0) {
+ data = (char *)g_variant_get_data(var);
+ if (data)
+ param = g_array_append_vals(param, data, size);
+
+ }
+}
+
+static void __bt_service_get_parameters(GVariant *in_param,
+ void *value, int size)
+{
+ void *buf = NULL;
+ buf = (void *)g_variant_get_data(in_param);
+ memcpy(value, buf, size);
+}
+
+static void __bt_service_method(GDBusConnection *connection,
+ const gchar *sender,
+ const gchar *object_path,
+ const gchar *interface_name,
+ const gchar *method_name,
+ GVariant *parameters,
+ GDBusMethodInvocation *invocation,
+ gpointer user_data)
+{
+ FN_START;
+ BT_DBG("Method[%s] Object Path[%s] Interface Name[%s]",
+ method_name, object_path, interface_name);
+
+ if (g_strcmp0(method_name, "service_request") == 0) {
+ int service_type;
+ int service_function;
+ int request_type;
+ GVariant *param1 = NULL;
+ GVariant *param2 = NULL;
+ GVariant *param3 = NULL;
+ GVariant *param4 = NULL;
+ GVariant *param5 = NULL;
+ GArray *out_param1 = NULL;
+ GVariant *out_var = NULL;
+ int result = 0;
+ int request_id = -1;
+ const char *sender = NULL;
+
+ g_variant_get(parameters, "(iii@ay@ay@ay@ay@ay)", &service_type,
+ &service_function, &request_type,
+ ¶m1, ¶m2, ¶m3, ¶m4, ¶m5);
+
+ out_param1 = g_array_new(FALSE, FALSE, sizeof(gchar));
+
+ sender = g_dbus_method_invocation_get_sender(invocation);
+
+ if (service_type == BT_CORE_SERVICE) {
+ BT_DBG("No need to check privilege from bt-core");
+ } else if (__bt_service_check_privilege(service_function,
+ service_type, (const char *)sender) == FALSE) {
+ BT_ERR("Client don't have the privilege to excute this function");
+ result = BLUETOOTH_ERROR_PERMISSION_DEINED;
+ goto fail;
+ }
+
+ if (request_type == BT_ASYNC_REQ
+ || service_function == BT_OBEX_SERVER_ACCEPT_CONNECTION) {
+ /* Set the timer */
+ request_id = _bt_assign_request_id();
+ BT_DBG("Request ID: %d", request_id);
+
+ if (request_id < 0) {
+ BT_ERR("Fail to assign the request id");
+ result = BLUETOOTH_ERROR_INTERNAL;
+
+ goto fail;
+ }
+ }
+
+ BT_DBG("SERVICE TYPE [%d] SERVICE FUNC [%d]",
+ service_type, service_function);
+ switch (service_type) {
+ case BT_BLUEZ_SERVICE:
+ result = __bt_bluez_request(service_function,
+ request_type, request_id,
+ invocation, param1, param2,
+ param3, param4, &out_param1);
+ break;
+ case BT_OBEX_SERVICE:
+ result = __bt_obexd_request(service_function,
+ request_type, request_id,
+ invocation, param1,
+ param2, param3,
+ param4, param5, &out_param1);
+ break;
+ case BT_AGENT_SERVICE:
+ result = __bt_agent_request(service_function,
+ request_type, request_id,
+ invocation, param1,
+ param2, param3,
+ param4, &out_param1);
+ break;
+ case BT_CORE_SERVICE:
+ result = __bt_core_request(service_function,
+ request_type, request_id,
+ invocation, param1);
+ break;
+ case BT_CHECK_PRIVILEGE:
+ result = BLUETOOTH_ERROR_NONE;
+ break;
+ default:
+ BT_ERR("Unknown service type");
+ result = BLUETOOTH_ERROR_INTERNAL;
+ goto fail;
+ }
+
+ if (result != BLUETOOTH_ERROR_NONE) {
+ goto fail;
+ }
+
+ if ((request_type == BT_ASYNC_REQ ||
+ service_function == BT_OBEX_SERVER_ACCEPT_CONNECTION) &&
+ service_function != BT_OPP_PUSH_FILES) {
+ BT_DBG("INSERT INTO REQ LIST");
+ _bt_insert_request_list(request_id, service_function,
+ NULL, invocation);
+ } else {
+ /* Return result */
+ if (service_type == BT_CHECK_PRIVILEGE ||
+ service_function != BT_OPP_PUSH_FILES) {
+ out_var = g_variant_new_from_data((const GVariantType *)"ay",
+ out_param1->data, out_param1->len,
+ TRUE, NULL, NULL);
+
+ GVariant *temp = g_variant_new("(iv)", result, out_var);
+ g_dbus_method_invocation_return_value(invocation, temp);
+
+ g_array_free(out_param1, TRUE);
+ out_param1 = NULL;
+ }
+ }
+
+ g_variant_unref(param1);
+ g_variant_unref(param2);
+ g_variant_unref(param3);
+ g_variant_unref(param4);
+ g_variant_unref(param5);
+// g_free(sender);
+ FN_END;
+ return;
+fail:
+ BT_ERR_C("Request is failed [%s] [%x]",
+ _bt_convert_error_to_string(result), result);
+
+ out_var = g_variant_new_from_data((const GVariantType *)"ay",
+ out_param1->data, out_param1->len,
+ TRUE, NULL, NULL);
+
+ GVariant *temp = g_variant_new("(iv)", result, out_var);
+ g_dbus_method_invocation_return_value(invocation, temp);
+
+ g_array_free(out_param1, TRUE);
+ out_param1 = NULL;
+
+ if (request_type == BT_ASYNC_REQ)
+ _bt_delete_request_id(request_id);
+
+ g_variant_unref(param1);
+ g_variant_unref(param2);
+ g_variant_unref(param3);
+ g_variant_unref(param4);
+ g_variant_unref(param5);
+// g_free(sender);
+ }
+
+ FN_END;
+ return;
+}
+
+
+static const GDBusInterfaceVTable method_table = {
+ __bt_service_method,
+ NULL,
+ NULL,
+};
+
+int __bt_bluez_request(int function_name,
+ int request_type,
+ int request_id,
+ GDBusMethodInvocation *context,
+ GVariant *in_param1,
+ GVariant *in_param2,
+ GVariant *in_param3,
+ GVariant *in_param4,
+ GArray **out_param1)
+{
+ int result = BLUETOOTH_ERROR_NONE;
+
+ switch (function_name) {
+ case BT_ENABLE_ADAPTER:
+ /*TODO*/
+ break;
+ case BT_DISABLE_ADAPTER:
+ /*TODO*/
+ break;
+ }
+
+ return result;
+}
+
+int __bt_obexd_request(int function_name,
+ int request_type,
+ int request_id,
+ GDBusMethodInvocation *context,
+ GVariant *in_param1,
+ GVariant *in_param2,
+ GVariant *in_param3,
+ GVariant *in_param4,
+ GVariant *in_param5,
+ GArray **out_param1)
+{
+ BT_DBG("+");
+
+ int result = BLUETOOTH_ERROR_NONE;
+
+ BT_DBG("function_name : %x", function_name);
+
+ switch (function_name) {
+ /*TODO*/
+ }
+
+ FN_END;
+
+ return result;
+}
+
+int __bt_agent_request(int function_name,
+ int request_type,
+ int request_id,
+ GDBusMethodInvocation *context,
+ GVariant *in_param1,
+ GVariant *in_param2,
+ GVariant *in_param3,
+ GVariant *in_param4,
+ GArray **out_param1)
+{
+ BT_DBG("+");
+
+ int result = BLUETOOTH_ERROR_NONE;
+
+ switch (function_name) {
+ /*TODO*/
+ }
+
+ return result;
+}
+
+int __bt_core_request(int function_name,
+ int request_type,
+ int request_id,
+ GDBusMethodInvocation *context,
+ GVariant *in_param1)
+{
+ BT_DBG("+");
+
+ int result = BLUETOOTH_ERROR_NONE;
+
+ switch (function_name) {
+ /*TODO*/
+ }
+
+ return result;
+}
+
+gboolean __bt_service_check_privilege(int function_name,
+ int service_type,
+ const char *unique_name)
+{
+ int ret_val;
+ gboolean result = TRUE;
+ char *client_creds = NULL;
+ char *user_creds = NULL;
+ char *client_session = "";
+ enum cynara_client_creds client_creds_method = CLIENT_METHOD_SMACK;
+ enum cynara_user_creds user_creds_method = USER_METHOD_UID;
+ char err_msg[256] = {0, };
+
+ retv_if(unique_name == NULL, FALSE);
+
+ BT_DBG("unique_name: %s", unique_name);
+
+ retv_if(bt_service_conn == NULL, FALSE);
+
+ ret_val = cynara_creds_get_default_client_method(&client_creds_method);
+ if (ret_val != CYNARA_API_SUCCESS) {
+ cynara_strerror(ret_val, err_msg, sizeof(err_msg));
+ BT_ERR("Fail to get default client method: %s", err_msg);
+ return FALSE;
+ }
+
+ ret_val = cynara_creds_get_default_user_method(&user_creds_method);
+ if (ret_val != CYNARA_API_SUCCESS) {
+ cynara_strerror(ret_val, err_msg, sizeof(err_msg));
+ BT_ERR("Fail to get default user method: %s", err_msg);
+ return FALSE;
+ }
+
+ ret_val = cynara_creds_gdbus_get_client(bt_service_conn, unique_name, client_creds_method, &client_creds);
+ if (ret_val != CYNARA_API_SUCCESS) {
+ cynara_strerror(ret_val, err_msg, sizeof(err_msg));
+ BT_ERR("Fail to get client credential: %s", err_msg);
+ return FALSE;
+ }
+
+ BT_DBG("client_creds: %s", client_creds);
+
+ ret_val = cynara_creds_gdbus_get_user(bt_service_conn, unique_name, user_creds_method, &user_creds);
+ if (ret_val != CYNARA_API_SUCCESS) {
+ cynara_strerror(ret_val, err_msg, sizeof(err_msg));
+ BT_ERR("Fail to get user credential: %s", err_msg);
+ if (client_creds)
+ free(client_creds);
+ return FALSE;
+ }
+
+ BT_DBG("user_creds: %s", user_creds);
+
+ switch (function_name) {
+ case BT_SET_LOCAL_NAME:
+ case BT_START_DISCOVERY:
+ case BT_START_CUSTOM_DISCOVERY:
+ case BT_CANCEL_DISCOVERY:
+ case BT_OOB_ADD_REMOTE_DATA:
+ case BT_OOB_REMOVE_REMOTE_DATA:
+ case BT_SET_ADVERTISING:
+ case BT_SET_CUSTOM_ADVERTISING:
+ case BT_SET_ADVERTISING_PARAMETERS:
+ case BT_START_LE_DISCOVERY:
+ case BT_STOP_LE_DISCOVERY:
+
+ case BT_BOND_DEVICE:
+ case BT_CANCEL_BONDING:
+ case BT_UNBOND_DEVICE:
+ case BT_SET_ALIAS:
+ case BT_SET_AUTHORIZATION:
+ case BT_UNSET_AUTHORIZATION:
+ case BT_SEARCH_SERVICE:
+
+ case BT_RFCOMM_CLIENT_CONNECT:
+ case BT_RFCOMM_CLIENT_CANCEL_CONNECT:
+ case BT_RFCOMM_SOCKET_DISCONNECT:
+ case BT_RFCOMM_SOCKET_WRITE:
+ case BT_RFCOMM_CREATE_SOCKET:
+ case BT_RFCOMM_REMOVE_SOCKET:
+
+ case BT_OPP_PUSH_FILES:
+ case BT_OPP_CANCEL_PUSH:
+
+ case BT_OBEX_SERVER_ACCEPT_CONNECTION:
+ case BT_OBEX_SERVER_REJECT_CONNECTION:
+ case BT_OBEX_SERVER_ACCEPT_FILE:
+ case BT_OBEX_SERVER_REJECT_FILE:
+ case BT_OBEX_SERVER_SET_PATH:
+ case BT_OBEX_SERVER_SET_ROOT:
+ case BT_OBEX_SERVER_CANCEL_TRANSFER:
+ case BT_OBEX_SERVER_CANCEL_ALL_TRANSFERS:
+
+ case BT_AUDIO_CONNECT:
+ case BT_AUDIO_DISCONNECT:
+ case BT_AG_CONNECT:
+ case BT_AG_DISCONNECT:
+ case BT_AV_CONNECT:
+ case BT_AV_DISCONNECT:
+ case BT_AV_SOURCE_CONNECT:
+ case BT_AV_SOURCE_DISCONNECT:
+ case BT_AVRCP_CONTROL_CONNECT:
+ case BT_AVRCP_CONTROL_DISCONNECT:
+ case BT_AVRCP_HANDLE_CONTROL:
+ case BT_AVRCP_SET_TRACK_INFO:
+ case BT_AVRCP_SET_PROPERTY:
+ case BT_AVRCP_SET_PROPERTIES:
+ case BT_AVRCP_CONTROL_SET_PROPERTY:
+
+ case BT_HF_CONNECT:
+ case BT_HF_DISCONNECT:
+
+ case BT_HID_CONNECT:
+ case BT_HID_DISCONNECT:
+
+ case BT_HID_DEVICE_ACTIVATE:
+ case BT_HID_DEVICE_DEACTIVATE:
+ case BT_HID_DEVICE_CONNECT:
+ case BT_HID_DEVICE_DISCONNECT:
+ case BT_HID_DEVICE_SEND_MOUSE_EVENT:
+ case BT_HID_DEVICE_SEND_KEY_EVENT:
+ case BT_HID_DEVICE_SEND_REPLY_TO_REPORT:
+
+ case BT_CONNECT_LE:
+ case BT_DISCONNECT_LE:
+
+ case BT_SET_ADVERTISING_DATA:
+ case BT_SET_SCAN_RESPONSE_DATA:
+
+ case BT_HDP_CONNECT:
+ case BT_HDP_DISCONNECT:
+ case BT_HDP_SEND_DATA:
+ case BT_HDP_REGISTER_SINK_APP:
+ case BT_HDP_UNREGISTER_SINK_APP:
+
+ case BT_DPM_SET_ALLOW_BT_MODE:
+ case BT_DPM_GET_ALLOW_BT_MODE:
+ case BT_DPM_SET_DEVICE_RESTRITION:
+ case BT_DPM_GET_DEVICE_RESTRITION:
+ case BT_DPM_SET_UUID_RESTRITION:
+ case BT_DPM_GET_UUID_RESTRITION:
+ case BT_DPM_ADD_DEVICES_BLACKLIST:
+ case BT_DPM_ADD_DEVICES_WHITELIST:
+ case BT_DPM_ADD_UUIDS_BLACKLIST:
+ case BT_DPM_ADD_UUIDS_WHITELIST:
+ case BT_DPM_CLEAR_DEVICES_BLACKLIST:
+ case BT_DPM_CLEAR_DEVICES_WHITELIST:
+ case BT_DPM_CLEAR_UUIDS_BLACKLIST:
+ case BT_DPM_CLEAR_UUIDS_WHITELIST:
+ case BT_DPM_REMOVE_DEVICE_BLACKLIST:
+ case BT_DPM_REMOVE_DEVICE_WHITELIST:
+ case BT_DPM_REMOVE_UUID_BLACKLIST:
+ case BT_DPM_REMOVE_UUID_WHITELIST:
+ case BT_DPM_GET_DEVICES_BLACKLIST:
+ case BT_DPM_GET_DEVICES_WHITELIST:
+ case BT_DPM_GET_UUIDS_BLACKLIST:
+ case BT_DPM_GET_UUIDS_WHITELIST:
+ case BT_DPM_SET_ALLOW_OUTGOING_CALL:
+ case BT_DPM_GET_ALLOW_OUTGOING_CALL:
+ case BT_DPM_SET_PAIRING_STATE:
+ case BT_DPM_GET_PAIRING_STATE:
+ case BT_DPM_SET_PROFILE_STATE:
+ case BT_DPM_GET_PROFILE_STATE:
+ case BT_DPM_SET_DESKROP_CONNECTIVITY_STATE:
+ case BT_DPM_GET_DESKROP_CONNECTIVITY_STATE:
+ case BT_DPM_SET_DISCOVERABLE_STATE:
+ case BT_DPM_GET_DISCOVERABLE_STATE:
+ case BT_DPM_SET_LIMITED_DISCOVERABLE_STATE:
+ case BT_DPM_GET_LIMITED_DISCOVERABLE_STATE:
+ case BT_DPM_SET_DATA_TRANSFER_STATE:
+ case BT_DPM_GET_DATA_TRANSFER_STATE:
+
+ case BT_NETWORK_ACTIVATE:
+ case BT_NETWORK_DEACTIVATE:
+ case BT_NETWORK_CONNECT:
+ case BT_NETWORK_DISCONNECT:
+ case BT_NETWORK_SERVER_DISCONNECT:
+
+ case BT_GATT_GET_PRIMARY_SERVICES:
+ case BT_GATT_DISCOVER_CHARACTERISTICS:
+ case BT_GATT_SET_PROPERTY_REQUEST:
+ case BT_GATT_READ_CHARACTERISTIC:
+ case BT_GATT_DISCOVER_CHARACTERISTICS_DESCRIPTOR:
+ case BT_GATT_REGISTER_APPLICATION:
+ case BT_GATT_REGISTER_SERVICE:
+ case BT_GATT_SEND_RESPONSE:
+ case BT_PBAP_CONNECT:
+ case BT_PBAP_DISCONNECT:
+ case BT_PBAP_GET_PHONEBOOK_SIZE:
+ case BT_PBAP_GET_PHONEBOOK:
+ case BT_PBAP_GET_LIST:
+ case BT_PBAP_PULL_VCARD:
+ case BT_PBAP_PHONEBOOK_SEARCH:
+
+ ret_val = cynara_check(p_cynara, client_creds, client_session, user_creds,
+ BT_PRIVILEGE_PUBLIC);
+
+ if (ret_val != CYNARA_API_ACCESS_ALLOWED) {
+ BT_ERR("Fail to access: %s", BT_PRIVILEGE_PUBLIC);
+ result = FALSE;
+ }
+
+ /* Need to check mediastorage privilege */
+ if (function_name == BT_PBAP_GET_PHONEBOOK ||
+ function_name == BT_PBAP_PULL_VCARD) {
+ ret_val = cynara_check(p_cynara, client_creds, client_session, user_creds,
+ MEDIASTORAGE_PRIVILEGE);
+
+ if (ret_val != CYNARA_API_ACCESS_ALLOWED) {
+ BT_ERR("Fail to access: %s", MEDIASTORAGE_PRIVILEGE);
+ result = FALSE;
+ }
+ }
+ break;
+
+ case BT_ENABLE_ADAPTER:
+ case BT_DISABLE_ADAPTER:
+ case BT_RESET_ADAPTER:
+ case BT_RECOVER_ADAPTER:
+ case BT_ENABLE_ADAPTER_LE:
+ case BT_DISABLE_ADAPTER_LE:
+ case BT_SET_CONNECTABLE:
+ case BT_SET_DISCOVERABLE_MODE:
+ case BT_ADD_WHITE_LIST:
+ case BT_REMOVE_WHITE_LIST:
+ case BT_CLEAR_WHITE_LIST:
+ case BT_SET_MANUFACTURER_DATA:
+ case BT_SET_SCAN_PARAMETERS:
+
+ case BT_CANCEL_SEARCH_SERVICE:
+ case BT_ENABLE_RSSI:
+
+ case BT_RFCOMM_ACCEPT_CONNECTION:
+ case BT_RFCOMM_REJECT_CONNECTION:
+ case BT_RFCOMM_LISTEN:
+
+ case BT_AVRCP_CONTROL_GET_PROPERTY:
+ case BT_AVRCP_GET_TRACK_INFO:
+
+ case BT_SET_CONTENT_PROTECT:
+ case BT_BOND_DEVICE_BY_TYPE:
+ case BT_SET_LE_PRIVACY:
+ case BT_LE_CONN_UPDATE:
+ case BT_LE_READ_MAXIMUM_DATA_LENGTH:
+ case BT_LE_WRITE_HOST_SUGGESTED_DATA_LENGTH:
+ case BT_LE_READ_HOST_SUGGESTED_DATA_LENGTH:
+ case BT_LE_SET_DATA_LENGTH:
+
+ case BT_LE_IPSP_INIT:
+ case BT_LE_IPSP_DEINIT:
+ case BT_LE_IPSP_CONNECT:
+ case BT_LE_IPSP_DISCONNECT:
+ ret_val = cynara_check(p_cynara, client_creds, client_session, user_creds,
+ BT_PRIVILEGE_PLATFORM);
+
+ if (ret_val != CYNARA_API_ACCESS_ALLOWED) {
+ BT_ERR("Fail to access: %s", BT_PRIVILEGE_PLATFORM);
+ result = FALSE;
+ }
+ break;
+
+ case BT_CHECK_ADAPTER:
+ case BT_GET_RSSI:
+
+ case BT_GET_LOCAL_NAME:
+ case BT_GET_LOCAL_ADDRESS:
+ case BT_GET_LOCAL_VERSION:
+ case BT_IS_SERVICE_USED:
+ case BT_GET_DISCOVERABLE_MODE:
+ case BT_GET_DISCOVERABLE_TIME:
+ case BT_IS_DISCOVERYING:
+ case BT_IS_LE_DISCOVERYING:
+ case BT_IS_CONNECTABLE:
+ case BT_GET_BONDED_DEVICES:
+ case BT_GET_BONDED_DEVICE:
+ case BT_IS_DEVICE_CONNECTED:
+ case BT_GET_SPEAKER_GAIN:
+ case BT_SET_SPEAKER_GAIN:
+ case BT_OOB_READ_LOCAL_DATA:
+ case BT_RFCOMM_CLIENT_IS_CONNECTED:
+ case BT_RFCOMM_IS_UUID_AVAILABLE:
+ case BT_GET_ADVERTISING_DATA:
+ case BT_GET_SCAN_RESPONSE_DATA:
+ case BT_IS_ADVERTISING:
+
+ case BT_OBEX_SERVER_ALLOCATE:
+ case BT_OBEX_SERVER_DEALLOCATE:
+ /* Non-privilege control */
+ break;
+ default:
+ BT_ERR("Unknown function!");
+ result = FALSE;
+ break;
+ }
+
+ if (client_creds)
+ free(client_creds);
+
+ if (user_creds)
+ free(user_creds);
+
+ return result;
+}
+
+GDBusNodeInfo *__bt_service_create_method_node_info
+ (const gchar *introspection_data)
+{
+ GError *err = NULL;
+ GDBusNodeInfo *node_info = NULL;
+
+ if (introspection_data == NULL) {
+ BT_ERR("Introspection XML not present");
+ return NULL;
+ }
+
+ node_info = g_dbus_node_info_new_for_xml(introspection_data, &err);
+
+ if (err) {
+ BT_ERR("Unable to create node: %s", err->message);
+ g_clear_error(&err);
+ }
+ return node_info;
+}
+
+int __bt_service_register_object(GDBusConnection *conn,
+ GDBusNodeInfo *node_info, gboolean reg)
+{
+ static guint service_id = 0;
+ GError *error = NULL;
+
+ if (reg) {
+ if (node_info == NULL)
+ return -1;
+
+ service_id = g_dbus_connection_register_object(conn,
+ BT_SERVICE_PATH,
+ node_info->interfaces[0],
+ &method_table,
+ NULL, NULL, &error);
+ if (service_id == 0)
+ return -1;
+ } else {
+ if (service_id > 0) {
+ g_dbus_connection_unregister_object(conn,
+ service_id);
+ service_id = 0;
+ }
+ }
+
+ return 0;
+}
+
+int _bt_service_register(void)
+{
+ GDBusConnection *conn;
+ GError *err = NULL;
+ int result;
+
+ conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &err);
+ retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
+
+ owner_id = g_bus_own_name(G_BUS_TYPE_SYSTEM,
+ BT_SERVICE_NAME,
+ G_BUS_NAME_OWNER_FLAGS_NONE,
+ NULL, NULL, NULL,
+ NULL, NULL);
+ BT_DBG("owner_id is [%d]", owner_id);
+ if (owner_id == 0)
+ goto fail;
+
+ node_info = __bt_service_create_method_node_info(
+ bt_service_introspection_xml);
+
+ if (node_info == NULL)
+ goto fail;
+
+ result = __bt_service_register_object(conn, node_info, TRUE);
+ g_dbus_node_info_unref(node_info);
+ node_info = NULL;
+
+ if (result != BLUETOOTH_ERROR_NONE)
+ goto fail;
+
+ bt_service_conn = conn;
+
+ return BLUETOOTH_ERROR_NONE;
+
+fail:
+ if (bt_service_conn) {
+ g_object_unref(bt_service_conn);
+ bt_service_conn = NULL;
+ }
+
+ return BLUETOOTH_ERROR_INTERNAL;
+}
+
+void _bt_service_unregister(void)
+{
+ if (bt_service_conn) {
+ __bt_service_register_object(bt_service_conn, NULL, FALSE);
+ if (bt_service_conn) {
+ g_object_unref(bt_service_conn);
+ bt_service_conn = NULL;
+ }
+ if (node_info) {
+ g_dbus_node_info_unref(node_info);
+ node_info = NULL;
+ }
+ if (owner_id > 0) {
+ g_bus_unown_name(owner_id);
+ owner_id = 0;
+ }
+ }
+}
+
+int _bt_service_cynara_init(void)
+{
+ int result;
+ char err_msg[256] = {0, };
+
+ retv_if(p_cynara != NULL, BLUETOOTH_ERROR_ALREADY_INITIALIZED);
+
+ result = cynara_initialize(&p_cynara, conf);
+
+ if (result != CYNARA_API_SUCCESS) {
+ cynara_strerror(result, err_msg, sizeof(err_msg));
+ BT_ERR("Fail to initialize cynara: [%s]", err_msg);
+ return BLUETOOTH_ERROR_INTERNAL;
+ }
+
+ return BLUETOOTH_ERROR_NONE;
+}
+
+void _bt_service_cynara_deinit(void)
+{
+ int result;
+ char err_msg[256] = {0, };
+
+ ret_if(p_cynara == NULL);
+
+ result = cynara_finish(p_cynara);
+
+ if (result != CYNARA_API_SUCCESS) {
+ cynara_strerror(result, err_msg, sizeof(err_msg));
+ BT_ERR("Fail to finish cynara: [%s]", err_msg);
+ return;
+ }
+
+ p_cynara = NULL;
+ conf = NULL;
+}
+
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <stdio.h>
+#include <string.h>
+#include <glib.h>
+#include <dlog.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <termios.h>
+#include <net_connection.h>
+#include <dbus/dbus.h>
+#include <glib.h>
+#include <dlog.h>
+#include <fcntl.h>
+#include <errno.h>
+#include <termios.h>
+#include <net_connection.h>
+#include <bundle.h>
+#include <eventsystem.h>
+
+#include "bluetooth-api.h"
+#include "bt-service-common.h"
+
+static GDBusConnection *system_conn;
+static GDBusConnection *session_conn;
+static GDBusProxy *manager_proxy;
+static GDBusProxy *adapter_proxy;
+static void *net_conn;
+
+static GDBusProxy *adapter_properties_proxy;
+
+static GDBusConnection *system_gconn = NULL;
+
+GDBusConnection *_bt_gdbus_init_system_gconn(void)
+{
+ GError *error = NULL;
+
+ dbus_threads_init_default();
+
+ if (system_gconn != NULL)
+ return system_gconn;
+
+ system_gconn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error);
+
+ if (!system_gconn) {
+ BT_ERR("Unable to connect to dbus: %s", error->message);
+ g_clear_error(&error);
+ }
+
+ return system_gconn;
+}
+
+GDBusConnection *_bt_gdbus_get_system_gconn(void)
+{
+ GDBusConnection *local_system_gconn = NULL;
+ GError *error = NULL;
+
+ if (system_gconn == NULL) {
+ system_gconn = _bt_gdbus_init_system_gconn();
+ } else if (g_dbus_connection_is_closed(system_gconn)) {
+
+ local_system_gconn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &error);
+
+ if (!local_system_gconn) {
+ BT_ERR("Unable to connect to dbus: %s", error->message);
+ g_clear_error(&error);
+ }
+
+ system_gconn = local_system_gconn;
+ }
+
+ return system_gconn;
+}
+
+static GDBusProxy *__bt_init_manager_proxy(void)
+{
+ GDBusProxy *proxy;
+
+ if (system_conn == NULL) {
+ system_conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, NULL);
+ retv_if(system_conn == NULL, NULL);
+ }
+
+ proxy = g_dbus_proxy_new_sync(system_conn, G_DBUS_PROXY_FLAGS_NONE,
+ NULL, BT_BLUEZ_NAME,
+ BT_MANAGER_PATH, BT_MANAGER_INTERFACE, NULL, NULL);
+
+ retv_if(proxy == NULL, NULL);
+
+ manager_proxy = proxy;
+
+ return proxy;
+}
+
+static GDBusProxy *__bt_init_adapter_proxy(void)
+{
+ GDBusProxy *manager_proxy;
+ GDBusProxy *proxy;
+ char *adapter_path = NULL;
+
+ if (system_conn == NULL) {
+ system_conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, NULL);
+ retv_if(system_conn == NULL, NULL);
+ }
+
+ manager_proxy = _bt_get_manager_proxy();
+ retv_if(manager_proxy == NULL, NULL);
+
+ adapter_path = _bt_get_adapter_path();
+ retv_if(adapter_path == NULL, NULL);
+
+ proxy = g_dbus_proxy_new_sync(system_conn, G_DBUS_PROXY_FLAGS_NONE,
+ NULL, BT_BLUEZ_NAME,
+ adapter_path, BT_ADAPTER_INTERFACE, NULL, NULL);
+
+ g_free(adapter_path);
+
+ retv_if(proxy == NULL, NULL);
+
+ adapter_proxy = proxy;
+
+ return proxy;
+}
+
+static GDBusProxy *__bt_init_adapter_properties_proxy(void)
+{
+ GDBusProxy *manager_proxy;
+ GDBusProxy *proxy;
+ char *adapter_path = NULL;
+
+ if (system_conn == NULL) {
+ system_conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, NULL);
+ retv_if(system_conn == NULL, NULL);
+ }
+
+ manager_proxy = _bt_get_manager_proxy();
+ retv_if(manager_proxy == NULL, NULL);
+
+ adapter_path = _bt_get_adapter_path();
+ retv_if(adapter_path == NULL, NULL);
+
+ proxy = g_dbus_proxy_new_sync(system_conn, G_DBUS_PROXY_FLAGS_NONE,
+ NULL, BT_BLUEZ_NAME,
+ adapter_path, BT_PROPERTIES_INTERFACE, NULL, NULL);
+
+ g_free(adapter_path);
+
+ retv_if(proxy == NULL, NULL);
+
+ adapter_properties_proxy = proxy;
+
+ return proxy;
+}
+
+GDBusConnection *__bt_init_system_gconn(void)
+{
+ if (system_conn == NULL)
+ system_conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, NULL);
+
+ return system_conn;
+}
+
+GDBusConnection *__bt_init_session_conn(void)
+{
+ if (session_conn == NULL)
+ session_conn = g_bus_get_sync(G_BUS_TYPE_SESSION, NULL, NULL);
+
+ return session_conn;
+}
+
+GDBusConnection *_bt_get_session_gconn(void)
+{
+ return (session_conn) ? session_conn : __bt_init_session_conn();
+}
+
+GDBusConnection *_bt_get_system_gconn(void)
+{
+ return (system_conn) ? system_conn : __bt_init_system_gconn();
+}
+
+GDBusConnection *_bt_get_system_conn(void)
+{
+ GDBusConnection *g_conn;
+
+ if (system_conn == NULL) {
+ g_conn = __bt_init_system_gconn();
+ } else {
+ g_conn = system_conn;
+ }
+
+ retv_if(g_conn == NULL, NULL);
+
+ return g_conn;
+}
+
+GDBusProxy *_bt_get_manager_proxy(void)
+{
+ if (manager_proxy) {
+ const gchar *path = g_dbus_proxy_get_object_path(manager_proxy);
+ if (path == NULL) {
+ BT_ERR("Already proxy released hence creating new proxy");
+ return __bt_init_manager_proxy();
+ }
+ return manager_proxy;
+ }
+ return __bt_init_manager_proxy();
+}
+
+static void *__bt_init_net_conn(void)
+{
+ int result;
+ connection_h connection = NULL;
+
+ if (net_conn == NULL) {
+ result = connection_create(&connection);
+
+ if (result != CONNECTION_ERROR_NONE ||
+ connection == NULL) {
+ BT_DBG("connection_create() failed: %d", result);
+ net_conn = NULL;
+ return NULL;
+ }
+ net_conn = connection;
+ }
+ return net_conn;
+}
+
+void *_bt_get_net_conn(void)
+{
+ return (net_conn) ? net_conn : __bt_init_net_conn();
+}
+
+GDBusProxy *_bt_get_adapter_proxy(void)
+{
+ if (adapter_proxy) {
+ const char *path = g_dbus_proxy_get_object_path(adapter_proxy);
+ if (path == NULL) {
+ BT_ERR("Already proxy released hence creating new proxy");
+ return __bt_init_adapter_proxy();
+ }
+
+ return adapter_proxy;
+ }
+ return __bt_init_adapter_proxy();
+
+}
+
+GDBusProxy *_bt_get_adapter_properties_proxy(void)
+{
+ return (adapter_properties_proxy) ? adapter_properties_proxy :
+ __bt_init_adapter_properties_proxy();
+}
+
+static char *__bt_extract_adapter_path(GVariantIter *iter)
+{
+ char *object_path = NULL;
+ GVariantIter *interface_iter;
+ GVariantIter *svc_iter;
+ char *interface_str = NULL;
+
+ /* Parse the signature: oa{sa{sv}}} */
+ while (g_variant_iter_loop(iter, "{&oa{sa{sv}}}", &object_path,
+ &interface_iter)) {
+
+ if (object_path == NULL)
+ continue;
+
+ while (g_variant_iter_loop(interface_iter, "{&sa{sv}}",
+ &interface_str, &svc_iter)) {
+ if (g_strcmp0(interface_str, "org.bluez.Adapter1") != 0)
+ continue;
+
+ BT_DBG("Object Path: %s", object_path);
+ g_variant_iter_free(svc_iter);
+ g_variant_iter_free(interface_iter);
+ return g_strdup(object_path);
+ }
+ }
+ return NULL;
+}
+
+char *_bt_get_adapter_path(void)
+{
+ GDBusConnection *conn;
+ GDBusProxy *manager_proxy;
+ GVariant *result = NULL;
+ GVariantIter *iter = NULL;
+ char *adapter_path = NULL;
+
+ conn = _bt_get_system_conn();
+ retv_if(conn == NULL, NULL);
+
+ manager_proxy = _bt_get_manager_proxy();
+ retv_if(manager_proxy == NULL, NULL);
+
+ result = g_dbus_proxy_call_sync(manager_proxy, "GetManagedObjects",
+ NULL,
+ G_DBUS_CALL_FLAGS_NONE,
+ -1,
+ NULL,
+ NULL);
+ if (!result) {
+ BT_ERR("Can't get managed objects");
+ return NULL;
+ }
+
+ /* signature of GetManagedObjects: a{oa{sa{sv}}} */
+ g_variant_get(result, "(a{oa{sa{sv}}})", &iter);
+
+ adapter_path = __bt_extract_adapter_path(iter);
+ g_variant_iter_free(iter);
+ g_variant_unref(result);
+ return adapter_path;
+}
+
+void _bt_deinit_bluez_proxy(void)
+{
+ if (manager_proxy) {
+ g_object_unref(manager_proxy);
+ manager_proxy = NULL;
+ }
+
+ if (adapter_proxy) {
+ g_object_unref(adapter_proxy);
+ adapter_proxy = NULL;
+ }
+ if (adapter_properties_proxy) {
+ g_object_unref(adapter_properties_proxy);
+ adapter_properties_proxy = NULL;
+ }
+}
+
+void _bt_deinit_proxys(void)
+{
+ int ret;
+ _bt_deinit_bluez_proxy();
+
+ if (system_conn) {
+ g_object_unref(system_conn);
+ system_conn = NULL;
+ }
+
+ if (session_conn) {
+ g_object_unref(session_conn);
+ session_conn = NULL;
+ }
+
+ if (net_conn) {
+ ret = connection_destroy(net_conn);
+ net_conn = NULL;
+ if (ret != 0)
+ BT_ERR("connection_destroy failed : %d", ret);
+ }
+}
+
+void _bt_convert_device_path_to_address(const char *device_path,
+ char *device_address)
+{
+ char address[BT_ADDRESS_STRING_SIZE] = { 0 };
+ char *dev_addr;
+
+ ret_if(device_path == NULL);
+ ret_if(device_address == NULL);
+
+ dev_addr = strstr(device_path, "dev_");
+ if (dev_addr != NULL) {
+ char *pos = NULL;
+ dev_addr += 4;
+ g_strlcpy(address, dev_addr, sizeof(address));
+
+ while ((pos = strchr(address, '_')) != NULL) {
+ *pos = ':';
+ }
+
+ g_strlcpy(device_address, address, BT_ADDRESS_STRING_SIZE);
+ }
+}
+
+
+void _bt_convert_addr_string_to_type(unsigned char *addr,
+ const char *address)
+{
+ int i;
+ char *ptr = NULL;
+
+ ret_if(address == NULL);
+ ret_if(addr == NULL);
+
+ for (i = 0; i < BT_ADDRESS_LENGTH_MAX; i++) {
+ addr[i] = strtol(address, &ptr, 16);
+ if (ptr[0] != '\0') {
+ if (ptr[0] != ':')
+ return;
+
+ address = ptr + 1;
+ }
+ }
+}
+
+void _bt_convert_addr_type_to_string(char *address,
+ unsigned char *addr)
+{
+ ret_if(address == NULL);
+ ret_if(addr == NULL);
+
+ snprintf(address, BT_ADDRESS_STRING_SIZE,
+ "%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X",
+ addr[0], addr[1], addr[2],
+ addr[3], addr[4], addr[5]);
+}
+
+void _bt_print_device_address_t(const bluetooth_device_address_t *addr)
+{
+ BT_DBG("%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X\n", addr->addr[0], addr->addr[1], addr->addr[2],
+ addr->addr[3], addr->addr[4], addr->addr[5]);
+}
+
+void _bt_divide_device_class(bluetooth_device_class_t *device_class,
+ unsigned int cod)
+{
+ ret_if(device_class == NULL);
+
+ device_class->major_class = (unsigned short)(cod & 0x00001F00) >> 8;
+ device_class->minor_class = (unsigned short)((cod & 0x000000FC));
+ device_class->service_class = (unsigned long)((cod & 0x00FF0000));
+
+ if (cod & 0x002000) {
+ device_class->service_class |=
+ BLUETOOTH_DEVICE_SERVICE_CLASS_LIMITED_DISCOVERABLE_MODE;
+ }
+}
+
+void _bt_free_device_info(bt_remote_dev_info_t *dev_info)
+{
+ int i;
+
+ ret_if(dev_info == NULL);
+
+ g_free(dev_info->address);
+ g_free(dev_info->name);
+ g_free(dev_info->manufacturer_data);
+
+ if (dev_info->uuids) {
+ for (i = 0; i < dev_info->uuid_count && dev_info->uuids[i]; i++)
+ g_free(dev_info->uuids[i]);
+
+ g_free(dev_info->uuids);
+ }
+
+ g_free(dev_info);
+}
+
+void _bt_free_le_device_info(bt_remote_le_dev_info_t *le_dev_info)
+{
+ ret_if(le_dev_info == NULL);
+
+ g_free(le_dev_info->adv_data);
+ g_free(le_dev_info);
+}
+
+int _bt_copy_utf8_string(char *dest, const char *src, unsigned int length)
+{
+ int i;
+ const char *p = src;
+ char *next;
+ int count;
+
+ if (dest == NULL || src == NULL)
+ return BLUETOOTH_ERROR_INVALID_PARAM;
+
+ BT_DBG("+src : %s", src);
+ BT_DBG("+dest : %s", dest);
+
+ i = 0;
+ while (*p != '\0' && i < length) {
+ next = g_utf8_next_char(p);
+ count = next - p;
+
+ while (count > 0 && ((i + count) < length)) {
+ dest[i++] = *p;
+ p++;
+ count--;
+ }
+ p = next;
+ }
+ return BLUETOOTH_ERROR_NONE;
+}
+
+gboolean _bt_utf8_validate(char *name)
+{
+ BT_DBG("+");
+ gunichar2 *u16;
+ glong items_written = 0;
+
+ if (FALSE == g_utf8_validate(name, -1, NULL))
+ return FALSE;
+
+ u16 = g_utf8_to_utf16(name, -1, NULL, &items_written, NULL);
+ if (u16 == NULL)
+ return FALSE;
+
+ g_free(u16);
+
+ if (items_written != g_utf8_strlen(name, -1))
+ return FALSE;
+
+ BT_DBG("-");
+ return TRUE;
+}
+
+int _bt_set_socket_non_blocking(int socket_fd)
+{
+ /* Set Nonblocking */
+ long arg;
+
+ arg = fcntl(socket_fd, F_GETFL);
+
+ if (arg < 0)
+ return -errno;
+
+ if (arg & O_NONBLOCK) {
+ BT_ERR("Already Non-blocking \n");
+ }
+
+ arg |= O_NONBLOCK;
+
+ if (fcntl(socket_fd, F_SETFL, arg) < 0)
+ return -errno;
+
+ return BLUETOOTH_ERROR_NONE;
+}
+
+int _bt_set_non_blocking_tty(int sk)
+{
+ struct termios ti = {0,};
+ int err;
+
+ err = _bt_set_socket_non_blocking(sk);
+
+ if (err < 0) {
+ BT_ERR("Error in set non blocking!\n");
+ return err;
+ }
+
+ tcflush(sk, TCIOFLUSH);
+
+ /* Switch tty to RAW mode */
+ cfmakeraw(&ti);
+ tcsetattr(sk, TCSANOW, &ti);
+
+ return BLUETOOTH_ERROR_NONE;
+}
+
+static char *__bt_extract_device_path(GVariantIter *iter, char *address)
+{
+ char *object_path = NULL;
+ char device_address[BT_ADDRESS_STRING_SIZE] = { 0 };
+
+ /* Parse the signature: oa{sa{sv}}} */
+ while (g_variant_iter_loop(iter, "{&oa{sa{sv}}}", &object_path,
+ NULL)) {
+ retv_if(object_path == NULL, NULL);
+ _bt_convert_device_path_to_address(object_path, device_address);
+ if (g_strcmp0(address, device_address) == 0) {
+ return g_strdup(object_path);
+ }
+ }
+ return NULL;
+}
+
+char *_bt_get_device_object_path(char *address)
+{
+ char *object_path = NULL;
+ GDBusConnection *conn;
+ GDBusProxy *manager_proxy;
+ GVariant *result = NULL;
+ GVariantIter *iter = NULL;
+
+ conn = _bt_get_system_conn();
+ retv_if(conn == NULL, NULL);
+
+ manager_proxy = _bt_get_manager_proxy();
+ retv_if(manager_proxy == NULL, NULL);
+
+ result = g_dbus_proxy_call_sync(manager_proxy, "GetManagedObjects",
+ NULL,
+ G_DBUS_CALL_FLAGS_NONE,
+ -1,
+ NULL,
+ NULL);
+ if (!result) {
+ BT_ERR("Can't get managed objects");
+ return NULL;
+ }
+
+ /* signature of GetManagedObjects: a{oa{sa{sv}}} */
+ g_variant_get(result, "(a{oa{sa{sv}}})", &iter);
+ object_path = __bt_extract_device_path(iter, address);
+ g_variant_iter_free(iter);
+ g_variant_unref(result);
+ return object_path;
+}
+
+char *_bt_get_profile_uuid128(bt_profile_type_t profile_type)
+{
+ switch (profile_type) {
+ case BT_PROFILE_CONN_RFCOMM:
+ return strdup(RFCOMM_UUID_STR);
+ case BT_PROFILE_CONN_A2DP:
+ return strdup(A2DP_SINK_UUID);
+ case BT_PROFILE_CONN_A2DP_SINK:
+ return strdup(A2DP_SOURCE_UUID);
+ case BT_PROFILE_CONN_HSP:
+ return strdup(HFP_HS_UUID);
+ case BT_PROFILE_CONN_HID:
+ return strdup(HID_UUID);
+ case BT_PROFILE_CONN_NAP:
+ return strdup(NAP_UUID);
+ case BT_PROFILE_CONN_HFG:
+ return strdup(HFP_AG_UUID);
+ case BT_PROFILE_CONN_GATT:
+ case BT_PROFILE_CONN_ALL: /* NULL UUID will connect to both the audio profiles*/
+ default:
+ return NULL;
+ };
+}
+
+char *_bt_convert_error_to_string(int error)
+{
+ switch (error) {
+ case BLUETOOTH_ERROR_CANCEL:
+ return "CANCELLED";
+ case BLUETOOTH_ERROR_INVALID_PARAM:
+ return "INVALID_PARAMETER";
+ case BLUETOOTH_ERROR_INVALID_DATA:
+ return "INVALID DATA";
+ case BLUETOOTH_ERROR_MEMORY_ALLOCATION:
+ case BLUETOOTH_ERROR_OUT_OF_MEMORY:
+ return "OUT_OF_MEMORY";
+ case BLUETOOTH_ERROR_TIMEOUT:
+ return "TIMEOUT";
+ case BLUETOOTH_ERROR_NO_RESOURCES:
+ return "NO_RESOURCES";
+ case BLUETOOTH_ERROR_INTERNAL:
+ return "INTERNAL";
+ case BLUETOOTH_ERROR_NOT_SUPPORT:
+ return "NOT_SUPPORT";
+ case BLUETOOTH_ERROR_DEVICE_NOT_ENABLED:
+ return "NOT_ENABLED";
+ case BLUETOOTH_ERROR_DEVICE_ALREADY_ENABLED:
+ return "ALREADY_ENABLED";
+ case BLUETOOTH_ERROR_DEVICE_BUSY:
+ return "DEVICE_BUSY";
+ case BLUETOOTH_ERROR_ACCESS_DENIED:
+ return "ACCESS_DENIED";
+ case BLUETOOTH_ERROR_MAX_CLIENT:
+ return "MAX_CLIENT";
+ case BLUETOOTH_ERROR_NOT_FOUND:
+ return "NOT_FOUND";
+ case BLUETOOTH_ERROR_SERVICE_SEARCH_ERROR:
+ return "SERVICE_SEARCH_ERROR";
+ case BLUETOOTH_ERROR_PARING_FAILED:
+ return "PARING_FAILED";
+ case BLUETOOTH_ERROR_NOT_PAIRED:
+ return "NOT_PAIRED";
+ case BLUETOOTH_ERROR_SERVICE_NOT_FOUND:
+ return "SERVICE_NOT_FOUND";
+ case BLUETOOTH_ERROR_NOT_CONNECTED:
+ return "NOT_CONNECTED";
+ case BLUETOOTH_ERROR_ALREADY_CONNECT:
+ return "ALREADY_CONNECT";
+ case BLUETOOTH_ERROR_CONNECTION_BUSY:
+ return "CONNECTION_BUSY";
+ case BLUETOOTH_ERROR_CONNECTION_ERROR:
+ return "CONNECTION_ERROR";
+ case BLUETOOTH_ERROR_MAX_CONNECTION:
+ return "MAX_CONNECTION";
+ case BLUETOOTH_ERROR_NOT_IN_OPERATION:
+ return "NOT_IN_OPERATION";
+ case BLUETOOTH_ERROR_CANCEL_BY_USER:
+ return "CANCEL_BY_USER";
+ case BLUETOOTH_ERROR_REGISTRATION_FAILED:
+ return "REGISTRATION_FAILED";
+ case BLUETOOTH_ERROR_IN_PROGRESS:
+ return "IN_PROGRESS";
+ case BLUETOOTH_ERROR_AUTHENTICATION_FAILED:
+ return "AUTHENTICATION_FAILED";
+ case BLUETOOTH_ERROR_HOST_DOWN:
+ return "HOST_DOWN";
+ case BLUETOOTH_ERROR_END_OF_DEVICE_LIST:
+ return "END_OF_DEVICE_LIST";
+ case BLUETOOTH_ERROR_AGENT_ALREADY_EXIST:
+ return "AGENT_ALREADY_EXIST";
+ case BLUETOOTH_ERROR_AGENT_DOES_NOT_EXIST:
+ return "AGENT_DOES_NOT_EXIST";
+ case BLUETOOTH_ERROR_ALREADY_INITIALIZED:
+ return "ALREADY_INITIALIZED";
+ case BLUETOOTH_ERROR_PERMISSION_DEINED:
+ return "PERMISSION_DEINED";
+ case BLUETOOTH_ERROR_ALREADY_DEACTIVATED:
+ return "ALREADY_DEACTIVATED";
+ case BLUETOOTH_ERROR_NOT_INITIALIZED:
+ return "NOT_INITIALIZED";
+ default:
+ return "UNKNOWN";
+ }
+}
+
+char * _bt_convert_disc_reason_to_string(int reason)
+{
+ switch (reason) {
+ case 1:
+ return "Link loss";
+ case 2:
+ return "Connection terminated by local host";
+ case 3:
+ return "Remote user terminated connection";
+ case 0:
+ default:
+ return "Unknown";
+ }
+}
+
+void _bt_logging_connection(gboolean connect, int addr_type)
+{
+ static int le_conn = 0;
+ static int le_disc = 0;
+ static int edr_conn = 0;
+ static int edr_disc = 0;
+
+ if (connect) {
+ if (addr_type)
+ le_conn++;
+ else
+ edr_conn++;
+ } else {
+ if (addr_type)
+ le_disc++;
+ else
+ edr_disc++;
+ }
+
+ BT_INFO("[PM] Number of LE conn: %d disc: %d, Number of BR/EDR conn: %d disc: %d",
+ le_conn, le_disc, edr_conn, edr_disc);
+}
+
+int _bt_eventsystem_set_value(const char *event, const char *key, const char *value)
+{
+ int ret;
+ bundle *b = NULL;
+
+ b = bundle_create();
+
+ bundle_add_str(b, key, value);
+
+ ret = eventsystem_send_system_event(event, b);
+
+ BT_DBG("eventsystem_send_system_event result: %d", ret);
+
+ bundle_free(b);
+
+ return ret;
+}
+
+void _bt_swap_byte_ordering(char *data, int data_len)
+{
+ char temp;
+ int i, j;
+
+ ret_if(data == NULL);
+ /* Swap to opposite endian */
+ for (i = 0, j = data_len - 1; i < data_len; i++, j--) {
+ temp = data[i];
+ data[i] = data[j];
+ data[j] = temp;
+ }
+}
+
+int _bt_byte_arr_cmp(const char *data1, const char *data2, int data_len)
+{
+ int i;
+
+ retv_if(data1 == NULL, -1);
+ retv_if(data2 == NULL, -1);
+ for (i = 0; i < data_len; i++) {
+ if (data1[i] != data2[i])
+ return data1[i] - data2[i];
+ }
+ return 0;
+}
+int _bt_byte_arr_cmp_with_mask(const char *data1, const char *data2,
+ const char *mask, int data_len)
+{
+ int i;
+ char a, b;
+
+ retv_if(data1 == NULL, -1);
+ retv_if(data2 == NULL, -1);
+ retv_if(mask == NULL, -1);
+ for (i = 0; i < data_len; i++) {
+ a = data1[i] & mask[i];
+ b = data2[i] & mask[i];
+ if (a != b)
+ return (int)(a - b);
+ }
+ return 0;
+}
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <glib.h>
+#include <dlog.h>
+#include <gio/gio.h>
+#include "bluetooth-api.h"
+#include "bt-internal-types.h"
+
+#include "bt-service-common.h"
+#include "bt-service-event.h"
+
+static GDBusConnection *event_conn;
+static GDBusConnection *hf_local_term_event_conn;
+
+#ifdef HPS_FEATURE
+int _bt_send_to_hps(void)
+{
+ gboolean ret = FALSE;
+ GError *error = NULL;
+
+ BT_DBG(" ");
+
+ retv_if(event_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
+
+ ret = g_dbus_connection_emit_signal(event_conn, NULL,
+ "/org/projectx/httpproxy",
+ "org.projectx.httpproxy_service",
+ BT_LE_ENABLED,
+ NULL, &error);
+ if (!ret) {
+ if (error != NULL) {
+ BT_ERR("D-Bus API failure: errCode[%x], \
+ message[%s]",
+ error->code, error->message);
+ g_clear_error(&error);
+ }
+ return BLUETOOTH_ERROR_INTERNAL;
+ }
+
+ return BLUETOOTH_ERROR_NONE;
+}
+#endif
+
+int _bt_send_event(int event_type, int event, GVariant *param)
+{
+ BT_DBG("+");
+ char *path;
+ char *signal;
+ GDBusMessage *msg1 = NULL;
+
+ retv_if(event_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
+
+ BT_DBG("event_type [%d], event [%d]", event_type, event);
+
+ switch (event_type) {
+ case BT_ADAPTER_EVENT:
+ path = BT_ADAPTER_PATH;
+ break;
+ case BT_LE_ADAPTER_EVENT:
+ path = BT_LE_ADAPTER_PATH;
+ break;
+ case BT_DEVICE_EVENT:
+ path = BT_DEVICE_PATH;
+ break;
+ case BT_HID_EVENT:
+ path = BT_HID_PATH;
+ break;
+ case BT_HEADSET_EVENT:
+ path = BT_HEADSET_PATH;
+ break;
+ case BT_AVRCP_EVENT:
+ path = BT_AVRCP_PATH;
+ break;
+ case BT_AVRCP_CONTROL_EVENT:
+ path = BT_AVRCP_CONTROL_PATH;
+ break;
+ case BT_NETWORK_EVENT:
+ path = BT_NETWORK_PATH;
+ break;
+ case BT_OPP_CLIENT_EVENT:
+ path = BT_OPP_CLIENT_PATH;
+ break;
+ case BT_OPP_SERVER_EVENT:
+ path = BT_OPP_SERVER_PATH;
+ break;
+ case BT_PBAP_CLIENT_EVENT:
+ path = BT_PBAP_CLIENT_PATH;
+ break;
+ case BT_RFCOMM_CLIENT_EVENT:
+ path = BT_RFCOMM_CLIENT_PATH;
+ break;
+ case BT_RFCOMM_SERVER_EVENT:
+ path = BT_RFCOMM_SERVER_PATH;
+ break;
+ case BT_A2DP_SOURCE_EVENT:
+ path = BT_A2DP_SOURCE_PATH;
+ break;
+ default:
+ BT_ERR("Unknown event");
+ return BLUETOOTH_ERROR_INTERNAL;
+ }
+
+ switch (event) {
+ case BLUETOOTH_EVENT_ENABLED:
+ signal = BT_ENABLED;
+ break;
+ case BLUETOOTH_EVENT_DISABLED:
+ signal = BT_DISABLED;
+ break;
+ case BLUETOOTH_EVENT_LE_ENABLED:
+ signal = BT_LE_ENABLED;
+ break;
+ case BLUETOOTH_EVENT_LE_DISABLED:
+ signal = BT_LE_DISABLED;
+ break;
+ case BLUETOOTH_EVENT_LOCAL_NAME_CHANGED:
+ signal = BT_ADAPTER_NAME_CHANGED;
+ break;
+ case BLUETOOTH_EVENT_DISCOVERABLE_MODE_CHANGED:
+ signal = BT_DISCOVERABLE_MODE_CHANGED;
+ break;
+ case BLUETOOTH_EVENT_DISCOVERABLE_TIMEOUT_CHANGED:
+ signal = BT_DISCOVERABLE_TIMEOUT_CHANGED;
+ break;
+ case BLUETOOTH_EVENT_CONNECTABLE_CHANGED:
+ signal = BT_CONNECTABLE_CHANGED;
+ break;
+ case BLUETOOTH_EVENT_DISCOVERY_STARTED:
+ signal = BT_DISCOVERY_STARTED;
+ break;
+ case BLUETOOTH_EVENT_REMOTE_DEVICE_FOUND:
+ signal = BT_DEVICE_FOUND;
+ break;
+ case BLUETOOTH_EVENT_DISCOVERY_FINISHED:
+ signal = BT_DISCOVERY_FINISHED;
+ break;
+ case BLUETOOTH_EVENT_LE_DISCOVERY_STARTED:
+ signal = BT_LE_DISCOVERY_STARTED;
+ break;
+ case BLUETOOTH_EVENT_REMOTE_LE_DEVICE_FOUND:
+ signal = BT_LE_DEVICE_FOUND;
+ break;
+ case BLUETOOTH_EVENT_LE_DISCOVERY_FINISHED:
+ signal = BT_LE_DISCOVERY_FINISHED;
+ break;
+ case BLUETOOTH_EVENT_ADVERTISING_STARTED:
+ signal = BT_ADVERTISING_STARTED;
+ break;
+ case BLUETOOTH_EVENT_ADVERTISING_STOPPED:
+ signal = BT_ADVERTISING_STOPPED;
+ break;
+ case BLUETOOTH_EVENT_ADVERTISING_MANUFACTURER_DATA_CHANGED:
+ signal = BT_ADVERTISING_MANUFACTURER_DATA_CHANGED;
+ break;
+ case BLUETOOTH_EVENT_SCAN_RESPONSE_MANUFACTURER_DATA_CHANGED:
+ signal = BT_SCAN_RESPONSE_MANUFACTURER_DATA_CHANGED;
+ break;
+ case BLUETOOTH_EVENT_MANUFACTURER_DATA_CHANGED:
+ signal = BT_MANUFACTURER_DATA_CHANGED;
+ break;
+ case BLUETOOTH_EVENT_BONDING_FINISHED:
+ signal = BT_BOND_CREATED;
+ break;
+ case BLUETOOTH_EVENT_BONDED_DEVICE_REMOVED:
+ signal = BT_BOND_DESTROYED;
+ break;
+ case BLUETOOTH_EVENT_DEVICE_AUTHORIZED:
+ signal = BT_DEVICE_AUTHORIZED;
+ break;
+ case BLUETOOTH_EVENT_DEVICE_UNAUTHORIZED:
+ signal = BT_DEVICE_UNAUTHORIZED;
+ break;
+ case BLUETOOTH_EVENT_RSSI_ENABLED:
+ signal = BT_RSSI_MONITORING_ENABLED;
+ break;
+ case BLUETOOTH_EVENT_RSSI_ALERT:
+ signal = BT_RSSI_ALERT;
+ break;
+ case BLUETOOTH_EVENT_RAW_RSSI:
+ signal = BT_RAW_RSSI_EVENT;
+ break;
+ case BLUETOOTH_EVENT_KEYBOARD_PASSKEY_DISPLAY:
+ signal = BT_KBD_PASSKEY_DISPLAY_REQ_RECEIVED;
+ break;
+ case BLUETOOTH_EVENT_PIN_REQUEST:
+ signal = BT_PIN_REQ_RECEIVED;
+ break;
+ case BLUETOOTH_EVENT_PASSKEY_REQUEST:
+ signal = BT_PASSKEY_REQ_RECEIVED;
+ break;
+ case BLUETOOTH_EVENT_PASSKEY_CONFIRM_REQUEST:
+ signal = BT_PASSKEY_CFM_REQ_RECEIVED;
+ break;
+ case BLUETOOTH_EVENT_SERVICE_SEARCHED:
+ signal = BT_SERVICE_SEARCHED;
+ break;
+ case BLUETOOTH_HID_CONNECTED:
+ signal = BT_INPUT_CONNECTED;
+ BT_INFO_C("Connected [HID]");
+ break;
+ case BLUETOOTH_HID_DISCONNECTED:
+ signal = BT_INPUT_DISCONNECTED;
+ BT_INFO_C("Disconnected [HID]");
+ break;
+ case BLUETOOTH_PBAP_CONNECTED:
+ signal = BT_PBAP_CONNECTED;
+ BT_INFO_C("Connected [PBAP Client]");
+ break;
+ case BLUETOOTH_PBAP_DISCONNECTED:
+ signal = BT_PBAP_DISCONNECTED;
+ BT_INFO_C("Disconnected [PBAP Client]");
+ break;
+ case BLUETOOTH_PBAP_PHONEBOOK_SIZE:
+ signal = BT_PBAP_PHONEBOOK_SIZE;
+ break;
+ case BLUETOOTH_PBAP_PHONEBOOK_PULL:
+ signal = BT_PBAP_PHONEBOOK_PULL;
+ break;
+ case BLUETOOTH_PBAP_VCARD_LIST:
+ signal = BT_PBAP_VCARD_LIST;
+ break;
+ case BLUETOOTH_PBAP_VCARD_PULL:
+ signal = BT_PBAP_VCARD_PULL;
+ break;
+ case BLUETOOTH_PBAP_PHONEBOOK_SEARCH:
+ signal = BT_PBAP_SEARCH_PHONEBOOK;
+ break;
+ case BLUETOOTH_EVENT_AG_CONNECTED:
+ signal = BT_HEADSET_CONNECTED;
+ BT_INFO_C("Connected [HSP/HFP]");
+ break;
+ case BLUETOOTH_EVENT_AG_DISCONNECTED:
+ signal = BT_HEADSET_DISCONNECTED;
+ BT_INFO_C("Disconnected [HSP/HFP]");
+ break;
+ case BLUETOOTH_EVENT_AV_CONNECTED:
+ signal = BT_STEREO_HEADSET_CONNECTED;
+ BT_INFO_C("Connected [A2DP]");
+ break;
+ case BLUETOOTH_EVENT_AV_DISCONNECTED:
+ signal = BT_STEREO_HEADSET_DISCONNECTED;
+ BT_INFO_C("Disconnected [A2DP]");
+ break;
+ case BLUETOOTH_EVENT_AG_AUDIO_CONNECTED:
+ signal = BT_SCO_CONNECTED;
+ BT_INFO_C("Connected [SCO]");
+ break;
+ case BLUETOOTH_EVENT_AG_AUDIO_DISCONNECTED:
+ signal = BT_SCO_DISCONNECTED;
+ BT_INFO_C("Disonnected [SCO]");
+ break;
+ case BLUETOOTH_EVENT_AG_SPEAKER_GAIN:
+ signal = BT_SPEAKER_GAIN;
+ break;
+ case BLUETOOTH_EVENT_AG_MIC_GAIN:
+ signal = BT_MICROPHONE_GAIN;
+ break;
+ case BLUETOOTH_EVENT_NETWORK_CONNECTED:
+ signal = BT_NETWORK_CONNECTED;
+ BT_INFO_C("Connected [Newwork]");
+ break;
+ case BLUETOOTH_EVENT_NETWORK_DISCONNECTED:
+ signal = BT_NETWORK_DISCONNECTED;
+ BT_INFO_C("Disconnected [Newwork]");
+ break;
+ case BLUETOOTH_EVENT_NETWORK_SERVER_CONNECTED:
+ signal = BT_NETWORK_SERVER_CONNECTED;
+ BT_INFO_C("Connected [Network Server]");
+ break;
+ case BLUETOOTH_EVENT_NETWORK_SERVER_DISCONNECTED:
+ signal = BT_NETWORK_SERVER_DISCONNECTED;
+ BT_INFO_C("Disconnected [Network Server]");
+ break;
+ case BLUETOOTH_EVENT_OPC_CONNECTED:
+ signal = BT_OPP_CONNECTED;
+ BT_INFO_C("Connected [OPP]");
+ break;
+ case BLUETOOTH_EVENT_OPC_DISCONNECTED:
+ signal = BT_OPP_DISCONNECTED;
+ BT_INFO_C("Disconnected [OPP]");
+ break;
+ case BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_CONNECTED:
+ signal = BT_TRANSFER_CONNECTED;
+ break;
+ case BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_DISCONNECTED:
+ signal = BT_TRANSFER_DISCONNECTED;
+ break;
+ case BLUETOOTH_EVENT_OPC_TRANSFER_STARTED:
+ case BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_STARTED:
+ signal = BT_TRANSFER_STARTED;
+ break;
+ case BLUETOOTH_EVENT_OPC_TRANSFER_PROGRESS:
+ case BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_PROGRESS:
+ signal = BT_TRANSFER_PROGRESS;
+ break;
+ case BLUETOOTH_EVENT_OPC_TRANSFER_COMPLETE:
+ case BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_COMPLETED:
+ signal = BT_TRANSFER_COMPLETED;
+ break;
+ case BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_AUTHORIZE:
+ signal = BT_TRANSFER_AUTHORIZED;
+ break;
+ case BLUETOOTH_EVENT_OBEX_SERVER_CONNECTION_AUTHORIZE:
+ case BLUETOOTH_EVENT_RFCOMM_AUTHORIZE:
+ signal = BT_CONNECTION_AUTHORIZED;
+ break;
+ case BLUETOOTH_EVENT_RFCOMM_CONNECTED:
+ signal = BT_RFCOMM_CONNECTED;
+ break;
+ case BLUETOOTH_EVENT_RFCOMM_DISCONNECTED:
+ signal = BT_RFCOMM_DISCONNECTED;
+ break;
+ case BLUETOOTH_EVENT_RFCOMM_DATA_RECEIVED:
+ signal = BT_RFCOMM_DATA_RECEIVED;
+ break;
+ case BLUETOOTH_EVENT_RFCOMM_SERVER_REMOVED:
+ signal = BT_RFCOMM_SERVER_REMOVED;
+ break;
+ case BLUETOOTH_EVENT_DEVICE_CONNECTED:
+ signal = BT_DEVICE_CONNECTED;
+ break;
+ case BLUETOOTH_EVENT_DEVICE_DISCONNECTED:
+ signal = BT_DEVICE_DISCONNECTED;
+ break;
+ case BLUETOOTH_EVENT_AV_SOURCE_CONNECTED:
+ signal = BT_A2DP_SOURCE_CONNECTED;
+ BT_INFO_C("Connected [A2DP Source]");
+ break;
+ case BLUETOOTH_EVENT_AV_SOURCE_DISCONNECTED:
+ signal = BT_A2DP_SOURCE_DISCONNECTED;
+ BT_INFO_C("Disconnected [A2DP Source]");
+ break;
+ case BLUETOOTH_EVENT_AVRCP_CONNECTED:
+ case BLUETOOTH_EVENT_AVRCP_CONTROL_CONNECTED:
+ signal = BT_AVRCP_CONNECTED;
+ BT_INFO_C("Connected [AVRCP]");
+ break;
+ case BLUETOOTH_EVENT_AVRCP_DISCONNECTED:
+ case BLUETOOTH_EVENT_AVRCP_CONTROL_DISCONNECTED:
+ signal = BT_AVRCP_DISCONNECTED;
+ BT_INFO_C("Disconnected [AVRCP]");
+ break;
+ case BLUETOOTH_EVENT_AVRCP_SETTING_SHUFFLE_STATUS:
+ case BLUETOOTH_EVENT_AVRCP_CONTROL_SHUFFLE_STATUS:
+ signal = BT_MEDIA_SHUFFLE_STATUS;
+ break;
+ case BLUETOOTH_EVENT_AVRCP_SETTING_EQUALIZER_STATUS:
+ case BLUETOOTH_EVENT_AVRCP_CONTROL_EQUALIZER_STATUS:
+ signal = BT_MEDIA_EQUALIZER_STATUS;
+ break;
+ case BLUETOOTH_EVENT_AVRCP_SETTING_REPEAT_STATUS:
+ case BLUETOOTH_EVENT_AVRCP_CONTROL_REPEAT_STATUS:
+ signal = BT_MEDIA_REPEAT_STATUS;
+ break;
+ case BLUETOOTH_EVENT_AVRCP_SETTING_SCAN_STATUS:
+ case BLUETOOTH_EVENT_AVRCP_CONTROL_SCAN_STATUS:
+ signal = BT_MEDIA_SCAN_STATUS;
+ break;
+ case BLUETOOTH_EVENT_AVRCP_SONG_POSITION_STATUS:
+ signal = BT_MEDIA_POSITION_STATUS;
+ break;
+ case BLUETOOTH_EVENT_AVRCP_PLAY_STATUS_CHANGED:
+ signal = BT_MEDIA_PLAY_STATUS;
+ break;
+ case BLUETOOTH_EVENT_AVRCP_TRACK_CHANGED:
+ signal = BT_MEDIA_TRACK_CHANGE;
+ break;
+ case BLUETOOTH_EVENT_GATT_CONNECTED:
+ signal = BT_GATT_CONNECTED;
+ break;
+ case BLUETOOTH_EVENT_GATT_DISCONNECTED:
+ signal = BT_GATT_DISCONNECTED;
+ break;
+ case BLUETOOTH_EVENT_IPSP_INIT_STATE_CHANGED:
+ signal = BT_IPSP_INITIALIZED;
+ break;
+ case BLUETOOTH_EVENT_IPSP_CONNECTED:
+ signal = BT_IPSP_CONNECTED;
+ break;
+ case BLUETOOTH_EVENT_IPSP_DISCONNECTED:
+ signal = BT_IPSP_DISCONNECTED;
+ break;
+ case BLUETOOTH_EVENT_IPSP_BT_INTERFACE_INFO:
+ signal = BT_IPSP_BT_INTERFACE_INFO;
+ break;
+ case BLUETOOTH_EVENT_GATT_CHAR_VAL_CHANGED:
+ signal = BT_GATT_CHAR_VAL_CHANGED;
+ break;
+ case BLUETOOTH_EVENT_LE_DATA_LENGTH_CHANGED:
+ signal = BT_LE_DATA_LENGTH_CHANGED;
+ break;
+ default:
+ BT_ERR("Unknown event");
+ return BLUETOOTH_ERROR_INTERNAL;
+ }
+
+ BT_DBG("Path : %s", path);
+ BT_INFO_C("Signal : %s", signal);
+
+ msg1 = g_dbus_message_new_signal(path, BT_EVENT_SERVICE, signal);
+ g_dbus_message_set_body(msg1, param);
+ if (!g_dbus_connection_send_message(event_conn, msg1, G_DBUS_SEND_MESSAGE_FLAGS_NONE, 0, NULL)) {
+ BT_ERR("Error while sending");
+ }
+
+ g_object_unref(msg1);
+
+#ifdef HPS_FEATURE
+ if (g_strcmp0(signal, BT_LE_ENABLED) == 0)
+ _bt_send_to_hps();
+#endif
+
+ return BLUETOOTH_ERROR_NONE;
+}
+
+int _bt_send_event_to_dest(const char* dest, int event_type,
+ int event, GVariant *param)
+{
+ BT_DBG("+");
+ char *path;
+ char *signal;
+ GError *error = NULL;
+
+ retv_if(event_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
+
+ BT_DBG("dest : %s", dest);
+ BT_DBG("event_type [%d], event [%d]", event_type, event);
+
+ switch (event_type) {
+ case BT_ADAPTER_EVENT:
+ path = BT_ADAPTER_PATH;
+ break;
+ case BT_LE_ADAPTER_EVENT:
+ path = BT_LE_ADAPTER_PATH;
+ break;
+ case BT_DEVICE_EVENT:
+ path = BT_DEVICE_PATH;
+ break;
+ default:
+ BT_ERR("Unknown event");
+ return BLUETOOTH_ERROR_INTERNAL;
+ }
+
+ switch (event) {
+ case BLUETOOTH_EVENT_ADVERTISING_STARTED:
+ signal = BT_ADVERTISING_STARTED;
+ break;
+ case BLUETOOTH_EVENT_ADVERTISING_STOPPED:
+ signal = BT_ADVERTISING_STOPPED;
+ break;
+ case BLUETOOTH_EVENT_LE_DISCOVERY_STARTED:
+ signal = BT_LE_DISCOVERY_STARTED;
+ break;
+ case BLUETOOTH_EVENT_REMOTE_LE_DEVICE_FOUND:
+ signal = BT_LE_DEVICE_FOUND;
+ break;
+ case BLUETOOTH_EVENT_LE_DISCOVERY_FINISHED:
+ signal = BT_LE_DISCOVERY_FINISHED;
+ break;
+ case BLUETOOTH_EVENT_GATT_CHAR_VAL_CHANGED:
+ signal = BT_GATT_CHAR_VAL_CHANGED;
+ break;
+ default:
+ BT_ERR("Unknown event");
+ return BLUETOOTH_ERROR_INTERNAL;
+ }
+
+ BT_DBG("Path : %s", path);
+ BT_INFO_C("Signal : %s", signal);
+
+ if (!g_dbus_connection_emit_signal(event_conn, dest, path, BT_EVENT_SERVICE,
+ signal, param, &error)) {
+ BT_ERR("Error while sending Signal: %s", signal);
+ if (error) {
+ BT_ERR("Error Code [%d], Error Message [%s]",
+ error->code, error->message);
+ g_clear_error(&error);
+ }
+ }
+
+ BT_DBG("-");
+ return BLUETOOTH_ERROR_NONE;
+}
+
+int _bt_send_hf_local_term_event(char *address)
+{
+ GError *error = NULL;
+
+ retv_if(hf_local_term_event_conn == NULL, BLUETOOTH_ERROR_INTERNAL);
+
+ if (!g_dbus_connection_emit_signal(hf_local_term_event_conn, NULL,
+ BT_HF_LOCAL_TERM_EVENT_PATH,
+ BT_HF_LOCAL_TERM_EVENT_INTERFACE,
+ BT_HF_LOCAL_TERM, g_variant_new("s", address),
+ &error)) {
+ BT_ERR("Error while sending Signal: %s", signal);
+ if (error) {
+ BT_ERR("Error Code [%d], Error Message [%s]",
+ error->code, error->message);
+ g_clear_error(&error);
+ }
+ }
+
+ return BLUETOOTH_ERROR_NONE;
+}
+
+/* To send the event from service daemon to application*/
+int _bt_init_service_event_sender(void)
+{
+ GDBusConnection *conn;
+ GError *err = NULL;
+
+ if (event_conn) {
+ BT_ERR("Event handler is already exist");
+ return BLUETOOTH_ERROR_INTERNAL;
+ }
+
+ conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &err);
+ retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
+ if (conn == NULL) {
+ BT_ERR("conn == NULL");
+ if (err) {
+ BT_ERR("Code[%d], Message[%s]",
+ err->code, err->message);
+ g_clear_error(&err);
+ }
+
+ return BLUETOOTH_ERROR_INTERNAL;
+ }
+
+ event_conn = conn;
+ return BLUETOOTH_ERROR_NONE;
+}
+
+void _bt_deinit_service_event_sender(void)
+{
+ if (event_conn) {
+ g_object_unref(event_conn);
+ event_conn = NULL;
+ }
+}
+
+int _bt_init_hf_local_term_event_sender(void)
+{
+ GDBusConnection *conn;
+ GError *err = NULL;
+
+ if (hf_local_term_event_conn) {
+ BT_ERR("Event handler is already exist");
+ return BLUETOOTH_ERROR_INTERNAL;
+ }
+
+ conn = g_bus_get_sync(G_BUS_TYPE_SYSTEM, NULL, &err);
+ retv_if(conn == NULL, BLUETOOTH_ERROR_INTERNAL);
+ if (conn == NULL) {
+ BT_ERR("conn == NULL");
+ if (err) {
+ BT_ERR("Code[%d], Message[%s]",
+ err->code, err->message);
+ g_clear_error(&err);
+ }
+
+ return BLUETOOTH_ERROR_INTERNAL;
+ }
+
+ hf_local_term_event_conn = conn;
+
+ return BLUETOOTH_ERROR_NONE;
+}
+
+void _bt_deinit_hf_local_term_event_sender(void)
+{
+ if (hf_local_term_event_conn) {
+ g_object_unref(hf_local_term_event_conn);
+ hf_local_term_event_conn = NULL;
+ }
+}
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <glib.h>
+#include <dlog.h>
+#include <string.h>
+
+#include <bundle.h>
+#include <eventsystem.h>
+
+#include "bt-internal-types.h"
+#include "bt-service-common.h"
+#include "bt-request-handler.h"
+#include "bt-service-event.h"
+#include "bt-service-util.h"
+
+static GMainLoop *main_loop;
+static gboolean terminated = FALSE;
+
+gboolean _bt_terminate_service(gpointer user_data)
+{
+ /* TODO*/
+ return FALSE;
+}
+
+gboolean _bt_reliable_terminate_service(gpointer user_data)
+{
+ /* TODO*/
+ return FALSE;
+}
+
+static gboolean __bt_check_bt_service(void *data)
+{
+ /* TODO*/
+ return FALSE;
+}
+
+static void __bt_release_service(void)
+{
+ /* TODO*/
+}
+
+static void __bt_sigterm_handler(int signo, siginfo_t *info, void *data)
+{
+ /* TODO*/
+}
+
+static int __bt_service_load_hal_lib(void)
+{
+ int ret = BLUETOOTH_ERROR_NONE;
+ BT_INFO("+");
+ /* TODO: Pass oal event receiver handler */
+ return ret;
+}
+
+int main(void)
+{
+ struct sigaction sa;
+ BT_INFO_C("Starting the bt-service daemon!!!");
+
+ memset(&sa, 0, sizeof(sa));
+ sa.sa_sigaction = __bt_sigterm_handler;
+ sa.sa_flags = SA_SIGINFO;
+ sigaction(SIGINT, &sa, NULL);
+ sigaction(SIGTERM, &sa, NULL);
+
+ /* Security Initialization */
+ if (_bt_service_cynara_init() != BLUETOOTH_ERROR_NONE) {
+ BT_ERR("Fail to init cynara");
+ return EXIT_FAILURE;
+ }
+
+ /* Event sender Init */
+ if (_bt_init_service_event_sender() != BLUETOOTH_ERROR_NONE) {
+ BT_ERR("Fail to init event sender");
+ return 0;
+ }
+
+ if (_bt_init_hf_local_term_event_sender() != BLUETOOTH_ERROR_NONE) {
+ BT_ERR("Fail to init core event sender");
+ return 0;
+ }
+
+ if (_bt_service_register() != BLUETOOTH_ERROR_NONE) {
+ BT_ERR("Fail to register service");
+ return 0;
+ }
+
+ _bt_init_request_id();
+
+ _bt_init_request_list();
+
+ /* BT HAL library Load */
+ BT_ERR("Attempt to load BT HAL lib");
+ if (__bt_service_load_hal_lib() != BLUETOOTH_ERROR_NONE) {
+ BT_ERR("Fail to initialize BT HAL");
+ return 0;
+ }
+
+ g_timeout_add(500, (GSourceFunc)__bt_check_bt_service, NULL);
+
+ if (terminated == TRUE) {
+ __bt_release_service();
+ return 0;
+ }
+
+ main_loop = g_main_loop_new(NULL, FALSE);
+
+ g_main_loop_run(main_loop);
+ BT_DBG("g_main_loop_quit called!");
+
+ if (main_loop != NULL) {
+ g_main_loop_unref(main_loop);
+ }
+
+ if (terminated == FALSE)
+ __bt_release_service();
+
+ return 0;
+}
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+#include <string.h>
+#include <glib.h>
+#include <dlog.h>
+#include <gio/gio.h>
+
+#include "bluetooth-api.h"
+#include "bt-service-common.h"
+#include "bt-service-util.h"
+
+static GSList *req_list = NULL;
+
+/* available request id : 0 ~ 244 */
+#define BT_REQUEST_ID_RANGE_MAX 245
+
+static int assigned_id;
+static gboolean req_id_used[BT_REQUEST_ID_RANGE_MAX];
+
+void _bt_init_request_id(void)
+{
+ assigned_id = 0;
+ memset(req_id_used, 0x00, BT_REQUEST_ID_RANGE_MAX);
+}
+
+int _bt_assign_request_id(void)
+{
+ int index;
+
+ index = assigned_id + 1;
+
+ if (index >= BT_REQUEST_ID_RANGE_MAX)
+ index = 0;
+
+ while (req_id_used[index] == TRUE) {
+ if (index == assigned_id) {
+ /* No available ID */
+ BT_ERR("All request ID is used");
+ return -1;
+ }
+
+ index++;
+
+ if (index >= BT_REQUEST_ID_RANGE_MAX)
+ index = 0;
+ }
+
+ assigned_id = index;
+ req_id_used[index] = TRUE;
+
+ return assigned_id;
+}
+
+void _bt_delete_request_id(int request_id)
+{
+ ret_if(request_id >= BT_REQUEST_ID_RANGE_MAX);
+ ret_if(request_id < 0);
+
+ req_id_used[request_id] = FALSE;
+}
+
+void _bt_init_request_list(void)
+{
+ _bt_clear_request_list();
+}
+
+/* insert request next to head */
+int _bt_insert_request_list(int req_id, int service_function,
+ char *name, GDBusMethodInvocation *context)
+{
+ request_info_t *info;
+
+ info = g_malloc0(sizeof(request_info_t));
+ /* Fix : NULL_RETURNS */
+ retv_if(info == NULL, BLUETOOTH_ERROR_MEMORY_ALLOCATION);
+
+ info->req_id = req_id;
+ info->service_function = service_function;
+ info->context = context;
+
+ req_list = g_slist_append(req_list, info);
+
+ return BLUETOOTH_ERROR_NONE;
+}
+
+request_info_t *_bt_get_request_info(int req_id)
+{
+ GSList *l;
+ request_info_t *info;
+
+ for (l = req_list; l != NULL; l = g_slist_next(l)) {
+ info = l->data;
+ if (info == NULL)
+ continue;
+
+ if (info->req_id == req_id)
+ return info;
+ }
+
+ return NULL;
+}
+
+/* delete request which has the target req_id */
+int _bt_delete_request_list(int req_id)
+{
+ GSList *l;
+ request_info_t *info;
+
+ for (l = req_list; l != NULL; l = g_slist_next(l)) {
+ info = l->data;
+ if (info == NULL)
+ continue;
+
+ if (info->req_id == req_id) {
+ req_list = g_slist_remove(req_list, info);
+ _bt_delete_request_id(info->req_id);
+ g_free(info);
+ return BLUETOOTH_ERROR_NONE;
+ }
+ }
+
+ return BLUETOOTH_ERROR_NOT_FOUND;
+}
+
+void _bt_clear_request_list(void)
+{
+ if (req_list) {
+ g_slist_foreach(req_list, (GFunc)g_free, NULL);
+ g_slist_free(req_list);
+ req_list = NULL;
+ }
+}
+
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+
+#ifndef _BT_REQUEST_HANDLER_H_
+#define _BT_REQUEST_HANDLER_H_
+
+#include <sys/types.h>
+#include <glib.h>
+#include <glib-object.h>
+
+#include "bt-internal-types.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#define BT_SERVICE_NAME "org.projectx.bt"
+#define BT_SERVICE_PATH "/org/projectx/bt_service"
+
+int _bt_service_register(void);
+
+void _bt_service_unregister(void);
+
+int _bt_service_cynara_init(void);
+
+void _bt_service_cynara_deinit(void);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+#endif /*_BT_REQUEST_HANDLER_H_*/
+
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+
+#ifndef _BT_SERVICE_COMMON_H_
+#define _BT_SERVICE_COMMON_H_
+
+#include <sys/types.h>
+#include <dlog.h>
+#include <glib.h>
+#include <gio/gio.h>
+
+#include "bluetooth-api.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#undef LOG_TAG
+#define LOG_TAG "BLUETOOTH_FRWK_SERVICE"
+
+#ifdef FUNCTION_TRACE
+#define FN_START BT_DBG("[ENTER FUNC]")
+#define FN_END BT_DBG("[EXIT FUNC]")
+#else
+#define FN_START
+#define FN_END
+#endif
+
+#define LOG_COLOR_RESET "\033[0m"
+#define LOG_COLOR_RED "\033[31m"
+#define LOG_COLOR_YELLOW "\033[33m"
+#define LOG_COLOR_GREEN "\033[32m"
+#define LOG_COLOR_BLUE "\033[36m"
+#define LOG_COLOR_PURPLE "\033[35m"
+
+#define BT_DBG(fmt, args...) \
+ SLOGD(fmt, ##args)
+#define BT_INFO(fmt, args...) \
+ SLOGI(fmt, ##args)
+#define BT_ERR(fmt, args...) \
+ SLOGE(fmt, ##args)
+
+#define BT_INFO_C(fmt, arg...) \
+ SLOGI_IF(TRUE, LOG_COLOR_GREEN" "fmt" "LOG_COLOR_RESET, ##arg)
+#define BT_ERR_C(fmt, arg...) \
+ SLOGI_IF(TRUE, LOG_COLOR_RED" "fmt" "LOG_COLOR_RESET, ##arg)
+
+#define DBG_SECURE(fmt, args...) SECURE_SLOGD(fmt, ##args)
+#define ERR_SECURE(fmt, args...) SECURE_SLOGE(fmt, ##args)
+
+#define ret_if(expr) \
+ do { \
+ if (expr) { \
+ BT_ERR("(%s) return", #expr); \
+ return; \
+ } \
+ } while (0)
+
+#define retv_if(expr, val) \
+ do { \
+ if (expr) { \
+ BT_ERR("(%s) return", #expr); \
+ return (val); \
+ } \
+ } while (0)
+
+#define BT_CHECK_PARAMETER(arg, func) \
+ do { \
+ if (arg == NULL) { \
+ BT_ERR("%s is NULL", #arg); \
+ func BLUETOOTH_ERROR_INVALID_PARAM; \
+ } \
+ } while (0)
+
+
+#define BT_ADDRESS_LENGTH_MAX 6
+#define BT_ADDRESS_STRING_SIZE 18
+#define BT_RFCOMM_BUFFER_MAX 1024
+#define BT_LOWER_ADDRESS_LENGTH 9
+
+#define BT_AGENT_AUTO_PAIR_BLACKLIST_FILE (APP_SYSCONFDIR"/auto-pair-blacklist")
+#define BT_AGENT_NEW_LINE "\r\n"
+
+#define BT_MAX_DBUS_TIMEOUT 45000
+#ifndef TIZEN_TV
+#define BT_ENABLE_TIMEOUT 20000 /* 20 seconds */
+#else
+#define BT_ENABLE_TIMEOUT 5000 /* 5 seconds */
+#endif
+#define BT_DISCOVERY_FINISHED_DELAY 200
+
+#define MANAGER_EVENT_MATCH_RULE \
+ "type='signal'," \
+ "interface='%s'," \
+ "member='%s'"
+
+#define EVENT_MATCH_RULE \
+ "type='signal'," \
+ "interface='%s',"
+
+#define BT_TEMINATING_WAIT_TIME 200
+
+#define BT_TIMEOUT_MESSAGE "Did not receive a reply. Possible causes include: " \
+ "the remote application did not send a reply, " \
+ "the message bus security policy blocked the reply, " \
+ "the reply timeout expired, or the network connection " \
+ "was broken."
+
+#define BT_BLUEZ_NAME "org.bluez"
+
+#define BT_BLUEZ_PATH "/org/bluez"
+#define BT_BLUEZ_HCI_PATH "/org/bluez/hci0"
+#define BT_AGENT_NAME "org.bluez.frwk_agent"
+#define BT_AGENT_PATH "/org/bluez/agent/frwk_agent"
+#define BT_DEVICE_AGENT_PATH "/org/tizen/device_agent"
+#define BT_ADAPTER_AGENT_PATH "/org/tizen/adapter_agent"
+#define BT_MANAGER_PATH "/"
+
+
+#define BT_MANAGER_INTERFACE "org.freedesktop.DBus.ObjectManager"
+#define BT_ADAPTER_INTERFACE "org.bluez.Adapter1"
+#define BT_AGENT_INTERFACE "org.bluez.Agent1"
+#define BT_AGENT_MANAGER_INTERFACE "org.bluez.AgentManager1"
+#define BT_DEVICE_INTERFACE "org.bluez.Device1"
+#define BT_NETWORK_SERVER_INTERFACE "org.bluez.NetworkServer1"
+#define BT_MEDIA_INTERFACE "org.bluez.Media1"
+#define BT_MEDIA_PLAYER_INTERFACE "org.mpris.MediaPlayer2.Player"
+#define BT_MEDIATRANSPORT_INTERFACE "org.bluez.MediaTransport1"
+#define BT_MEDIA_CONTROL_INTERFACE "org.bluez.MediaControl1"
+#define BT_PLAYER_CONTROL_INTERFACE "org.bluez.MediaPlayer1"
+#define BT_GATT_CHAR_INTERFACE "org.bluez.GattCharacteristic1"
+
+#define BT_INPUT_INTERFACE "org.bluez.Input1"
+#define BT_NETWORK_INTERFACE "org.bluez.Network"
+#define BT_NETWORK_CLIENT_INTERFACE "org.bluez.Network1"
+#define BT_SERIAL_INTERFACE "org.bluez.Serial"
+#define BT_SERIAL_MANAGER_INTERFACE "org.bluez.SerialProxyManager"
+#define BT_SERIAL_PROXY_INTERFACE "org.bluez.SerialProxy"
+#define BT_SINK_INTERFACE "org.bluez.AudioSink"
+#define BT_AUDIO_INTERFACE "org.bluez.Audio"
+#define BT_HEADSET_INTERFACE "org.bluez.Headset"
+#define BT_OOB_INTERFACE "org.bluez.OutOfBand"
+#define BT_HANDSFREE_GATEWAY_INTERFACE "org.bluez.HandsfreeGateway"
+#define BT_OBEXD_INTERFACE "org.openobex"
+#define BT_OBEXD_MANAGER_INTERFACE "org.openobex.Manager"
+#define BT_OBEXD_TRANSFER_INTERFACE "org.openobex.Transfer"
+#define BT_A2DP_SOURCE_INTERFACE "org.bluez.AudioSource"
+
+#define BT_PROPERTIES_INTERFACE "org.freedesktop.DBus.Properties"
+
+
+#define BT_OBEX_SERVICE_NAME "org.bluez.obex"
+#define BT_OBEX_CLIENT_PATH "/org/bluez/obex"
+#define BT_OBEX_CLIENT_INTERFACE "org.bluez.obex.Client1"
+
+
+
+#define BT_OBEX_TRANSFER_INTERFACE "org.bluez.obex.Transfer1"
+#define BT_OBEX_AGENT_INTERFACE "org.bluez.obex.Agent1"
+
+
+
+#define BT_OBEXD_DBUS_NAME "org.bluez.obex"
+#define BT_OBEX_OBJECT_PUSH_INTERFACE "org.bluez.obex.ObjectPush1"
+
+
+#define BT_FREEDESKTOP_INTERFACE "org.freedesktop.DBus"
+#define BT_FREEDESKTOP_PATH "/org/freedesktop/DBus"
+
+
+#define BT_INTERFACES_ADDED "InterfacesAdded"
+#define BT_INTERFACES_REMOVED "InterfacesRemoved"
+#define BT_NAME_OWNER_CHANGED "NameOwnerChanged"
+#define BT_PROPERTIES_CHANGED "PropertiesChanged"
+
+
+
+#define BT_SESSION_BASEPATH_SERVER "/org/bluez/obex/server"
+#define BT_SESSION_BASEPATH_CLIENT "/org/bluez/obex/client"
+
+#define BT_SERVICE_ERR_MSG_NOT_SUPPORTED "Operation is not supported"
+
+/* UUID */
+#define GENERIC_AUDIO_UUID "00001203-0000-1000-8000-00805f9b34fb"
+
+#define OBEX_OPP_UUID "00001105-0000-1000-8000-00805f9b34fb"
+
+#define HSP_HS_UUID "00001108-0000-1000-8000-00805f9b34fb"
+#define HSP_AG_UUID "00001112-0000-1000-8000-00805f9b34fb"
+
+#define HFP_HS_UUID "0000111e-0000-1000-8000-00805f9b34fb"
+#define HFP_AG_UUID "0000111f-0000-1000-8000-00805f9b34fb"
+
+#define ADVANCED_AUDIO_UUID "0000110d-0000-1000-8000-00805f9b34fb"
+
+#define A2DP_SOURCE_UUID "0000110a-0000-1000-8000-00805f9b34fb"
+#define A2DP_SINK_UUID "0000110b-0000-1000-8000-00805f9b34fb"
+
+#define AVRCP_REMOTE_UUID "0000110e-0000-1000-8000-00805f9b34fb"
+#define AVRCP_TARGET_UUID "0000110c-0000-1000-8000-00805f9b34fb"
+
+#define HID_UUID "00001124-0000-1000-8000-00805f9b34fb"
+#define PNP_UUID "00001200-0000-1000-8000-00805f9b34fb"
+#define RFCOMM_UUID_STR "00000003-0000-1000-8000-00805f9b34fb"
+#define PANU_UUID "00001115-0000-1000-8000-00805f9b34fb"
+#define NAP_UUID "00001116-0000-1000-8000-00805f9b34fb"
+#define OBEX_PSE_UUID "0000112f-0000-1000-8000-00805f9b34fb"
+#define GATT_UUID "00001801-0000-1000-8000-00805f9b34fb"
+
+/* Privilege */
+#define BT_PRIVILEGE_PUBLIC "http://tizen.org/privilege/bluetooth"
+#define BT_PRIVILEGE_PLATFORM "http://tizen.org/privilege/bluetooth.admin"
+#define MEDIASTORAGE_PRIVILEGE "http://tizen.org/privilege/mediastorage"
+
+/* BD Address type */
+#define BDADDR_BREDR 0x00
+#define BDADDR_LE_PUBLIC 0x01
+#define BDADDR_LE_RANDOM 0x02
+
+/* Advertising report event types */
+#define BT_LE_ADV_IND 0x00
+#define BT_LE_ADV_DIRECT_IND 0x01
+#define BT_LE_ADV_SCAN_IND 0x02
+#define BT_LE_ADV_NONCONN_IND 0x03
+#define BT_LE_ADV_SCAN_RSP 0x04
+
+/* Profile states matched to btd_service_state_t of bluez service.h */
+typedef enum {
+ BT_PROFILE_STATE_UNAVAILABLE,
+ BT_PROFILE_STATE_DISCONNECTED,
+ BT_PROFILE_STATE_CONNECTING,
+ BT_PROFILE_STATE_CONNECTED,
+ BT_PROFILE_STATE_DISCONNECTING,
+} bt_profile_state_t;
+
+typedef enum {
+ BT_ADV_IND_INFO = 0x00,
+ BT_SCAN_RSP_INFO = 0x01,
+} bt_le_device_info_type_t;
+
+typedef enum {
+ BT_PROFILE_CONN_RFCOMM = 0x01,
+ BT_PROFILE_CONN_A2DP = 0x02,
+ BT_PROFILE_CONN_HSP = 0x04,
+ BT_PROFILE_CONN_HID = 0x08,
+ BT_PROFILE_CONN_NAP = 0x10,
+ BT_PROFILE_CONN_HFG = 0x20,
+ BT_PROFILE_CONN_GATT = 0x40,
+ BT_PROGILE_CONN_NAP = 0x80,
+ BT_PROFILE_CONN_A2DP_SINK = 0x100,
+ BT_PROFILE_CONN_ALL = 0xffffffff,
+} bt_profile_type_t;
+
+typedef struct {
+ char *address;
+ int addr_type;
+ int rssi;
+ int adv_type;
+ bt_le_device_info_type_t dev_type;
+ int adv_data_len;
+ char *adv_data;
+} bt_remote_le_dev_info_t;
+
+typedef struct {
+ int rssi;
+ int class;
+ char *address;
+ char *name;
+ char **uuids;
+ unsigned int uuid_count;
+ gboolean paired;
+ bluetooth_connected_link_t connected;
+ gboolean trust;
+ char *manufacturer_data;
+ int manufacturer_data_len;
+ guchar addr_type;
+#if 0 /* Should match with bt_dev_info_t in bluetooth-api.h */
+ bt_remote_le_dev_info_t le_dev_info;
+#endif
+} bt_remote_dev_info_t;
+
+/* RFCOMM client /server will use this structure*/
+typedef struct {
+ int fd;
+ GIOChannel *io_channel;
+ guint io_event;
+ char *dev_node;
+ char *address;
+ char *uuid;
+} bt_rfcomm_info_t;
+
+typedef struct {
+ int req_id;
+ char *address;
+} bt_function_data_t;
+
+GDBusConnection *_bt_get_system_conn(void);
+
+GDBusConnection *_bt_get_system_gconn(void);
+
+GDBusConnection *_bt_get_session_gconn(void);
+
+void *_bt_get_net_conn(void);
+
+GDBusProxy *_bt_get_manager_proxy(void);
+
+GDBusProxy *_bt_get_adapter_proxy(void);
+
+GDBusProxy *_bt_get_adapter_properties_proxy(void);
+
+char *_bt_get_device_object_path(char *address);
+
+char *_bt_get_profile_uuid128(bt_profile_type_t profile_type);
+
+char *_bt_convert_error_to_string(int error);
+
+char * _bt_convert_disc_reason_to_string(int reason);
+
+void _bt_logging_connection(gboolean connect, int addr_type);
+
+char *_bt_get_adapter_path(void);
+
+void _bt_deinit_proxys(void);
+
+void _bt_convert_device_path_to_address(const char *device_path,
+ char *device_address);
+
+void _bt_convert_addr_string_to_type(unsigned char *addr,
+ const char *address);
+
+void _bt_convert_addr_type_to_string(char *address,
+ unsigned char *addr);
+
+void _bt_swap_byte_ordering(char *data, int data_len);
+
+int _bt_byte_arr_cmp(const char *data1, const char *data2, int data_len);
+
+int _bt_byte_arr_cmp_with_mask(const char *data1, const char *data2,
+ const char *mask, int data_len);
+
+void _bt_print_device_address_t(const bluetooth_device_address_t *addr);
+
+void _bt_divide_device_class(bluetooth_device_class_t *device_class,
+ unsigned int cod);
+
+void _bt_free_device_info(bt_remote_dev_info_t *dev_info);
+
+void _bt_free_le_device_info(bt_remote_le_dev_info_t *le_dev_info);
+
+int _bt_copy_utf8_string(char *dest, const char *src, unsigned int length);
+
+gboolean _bt_utf8_validate(char *name);
+
+int _bt_register_osp_server_in_agent(int type, char *uuid, char *path, int fd);
+
+int _bt_unregister_osp_server_in_agent(int type, char *uuid);
+
+int _bt_set_socket_non_blocking(int socket_fd);
+
+int _bt_set_non_blocking_tty(int sk);
+
+void _bt_deinit_bluez_proxy(void);
+
+int _bt_eventsystem_set_value(const char *event, const char *key, const char *value);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+#endif /*_BT_COMMON_H_*/
+
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+
+#ifndef _BT_SERVICE_EVENT_H_
+#define _BT_SERVICE_EVENT_H_
+
+#include <sys/types.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+int _bt_send_event(int event_type, int event, GVariant *param);
+
+int _bt_send_event_to_dest(const char* dest, int event_type, int event, GVariant *param);
+
+int _bt_init_service_event_sender(void);
+void _bt_deinit_service_event_sender(void);
+
+int _bt_init_service_event_receiver(void);
+void _bt_deinit_service_event_receiver(void);
+
+int _bt_opp_client_event_init(void);
+void _bt_opp_client_event_deinit(void);
+
+int _bt_send_hf_local_term_event(char *address);
+int _bt_init_hf_local_term_event_sender(void);
+void _bt_deinit_hf_local_term_event_sender(void);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+#endif /*_BT_SERVICE_EVENT_H_*/
+
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+
+#ifndef _BT_SERVICE_MAIN_H_
+#define _BT_SERVICE_MAIN_H_
+
+#include <sys/types.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+gboolean _bt_terminate_service(gpointer user_data);
+
+gboolean _bt_reliable_terminate_service(gpointer user_data);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+#endif /*_BT_SERVICE_MAIN_H_*/
+
--- /dev/null
+/*
+ * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+
+#ifndef _BT_SERVICE_UTIL_H_
+#define _BT_SERVICE_UTIL_H_
+
+#include <sys/types.h>
+#include <gio/gio.h>
+
+#ifdef __cplusplus
+extern "C" {
+#endif /* __cplusplus */
+
+#define BT_NODE_NAME_LEN 50
+
+typedef struct {
+ int req_id;
+ int service_function;
+ char name[BT_NODE_NAME_LEN];
+ GDBusMethodInvocation *context;
+} request_info_t;
+
+
+void _bt_init_request_id(void);
+
+int _bt_assign_request_id(void);
+
+void _bt_delete_request_id(int request_id);
+
+
+void _bt_init_request_list(void);
+
+int _bt_insert_request_list(int req_id, int service_function,
+ char *name, GDBusMethodInvocation *context);
+
+int _bt_delete_request_list(int req_id);
+
+request_info_t *_bt_get_request_info(int req_id);
+
+void _bt_clear_request_list(void);
+
+#ifdef __cplusplus
+}
+#endif /* __cplusplus */
+#endif /*_BT_SERVICE_UTIL_H_*/
+
%if "%{?profile}" != "mobile"
Requires: bluetooth-tools
%endif
+
+%define bt_hal ENABLED
+%define bt_bluez_hal ENABLED
+
BuildRequires: pkgconfig(aul)
BuildRequires: pkgconfig(dbus-glib-1)
BuildRequires: pkgconfig(dlog)
export FFLAGS="$FFLAGS -DEMUL"
%endif
+%if %{bt_hal} == ENABLED
+export BT_INCLUDE_OAL=ENABLED
+%if %{bt_bluez_hal} == ENABLED
+export BT_INCLUDE_OAL_BLUEZ=ENABLED
+export CFLAGS="$CFLAGS -DTIZEN_BT_INCLUDE_OAL_BLUEZ"
+%else
+export BT_INCLUDE_OAL_BLUEZ=DISABLED
+%endif
+%else
+export BT_INCLUDE_OAL=DISABLED
+%endif
+
cmake . -DCMAKE_INSTALL_PREFIX=/usr \
-DCMAKE_LIB_DIR=%{_libdir} \
-DTZ_SYS_USER_GROUP=%TZ_SYS_USER_GROUP \
projects / platform / core / connectivity / bluetooth-frwk.git / commitdiff