include/bluetooth-api.h

   1 /*
   2  * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *              http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  *
  16  */
  17
  18 #ifndef _BLUETOOTH_API_H_
  19 #define _BLUETOOTH_API_H_
  20
  21 #include <stdlib.h>
  22 #include <unistd.h>
  23 #include <glib.h>
  24
  25 #ifdef __cplusplus
  26 extern "C" {
  27 #endif                          /* __cplusplus */
  28
  29 /**
  30  * @defgroup BLUETOOTHFW BluetoothFW
  31  *
  32  * A base library for bluetooth framework
  33  *
  34  * @addtogroup BLUETOOTHFW
  35  * @{
  36  */
  37
  38 #define BLUETOOTH_ADDRESS_LENGTH                6 /**< This specifies bluetooth device address length */
  39 #define BLUETOOTH_VERSION_LENGTH_MAX            30 /**< This specifies bluetooth device version length */
  40 #define BLUETOOTH_INTERFACE_NAME_LENGTH         16
  41 #define BLUETOOTH_DEVICE_NAME_LENGTH_MAX        248 /**< This specifies maximum device name length */
  42 #define BLUETOOTH_DEVICE_PASSKEY_LENGTH_MAX       50 /**< This specifies maximum length of the passkey */
  43 #define BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX   31 /**< This specifies maximum AD data length */
  44 #define BLUETOOTH_SCAN_RESP_DATA_LENGTH_MAX     31 /**< This specifies maximum LE Scan response data length */
  45 #define BLUETOOTH_MANUFACTURER_DATA_LENGTH_MAX  240 /**< This specifies maximum manufacturer data length */
  46
  47 #define BLUETOOTH_MAX_SERVICES_FOR_DEVICE       40  /**< This specifies maximum number of services
  48                                                         a device can support */
  49
  50 #define BLUETOOTH_MAX_ATT_MTU   512             /**< This specifies the maximum  ATT MTU Value*/
  51
  52 #define BLUETOOTH_UUID_STRING_MAX 50
  53 #define BLUETOOTH_PATH_STRING 50
  54
  55 #define BLUETOOTH_OOB_DATA_LENGTH 16
  56
  57 #define BLUETOOTH_PIN_CODE_MAX_LENGTH 16
  58
  59 /**
  60  * This is Bluetooth Connected event role
  61  */
  62 #define RFCOMM_ROLE_SERVER 1
  63 #define RFCOMM_ROLE_CLIENT 2
  64
  65 /**
  66  * This is RFCOMM default Channel Value
  67  */
  68 #define RFCOMM_DEFAULT_PROFILE_CHANNEL 0
  69
  70 /**
  71  * This is maximum length for search value string for PBAP Phonebook Search
  72  */
  73 #define BLUETOOTH_PBAP_MAX_SEARCH_VALUE_LENGTH 100
  74
  75
  76 #define BLUETOOTH_MAX_DPM_LIST 20       /**< This specifies maximum number of devices/uuids
  77                                                         dpm shall store */
  78
  79 /**
  80  * This is Bluetooth error code
  81  */
  82 #define BLUETOOTH_ERROR_BASE                   ((int)0)         /**< Error code base */
  83
  84 #define BLUETOOTH_ERROR_NONE                   ((int)0)         /**< No error #0 */
  85 #define BLUETOOTH_ERROR_CANCEL                 ((int)BLUETOOTH_ERROR_BASE - 0x01)
  86                                                                 /**< cancelled */
  87 #define BLUETOOTH_ERROR_INVALID_CALLBACK       ((int)BLUETOOTH_ERROR_BASE - 0x02)
  88                                                                 /**< Callback error */
  89 #define BLUETOOTH_ERROR_INVALID_PARAM          ((int)BLUETOOTH_ERROR_BASE - 0x03)
  90                                                                 /**< invalid paramerror */
  91 #define BLUETOOTH_ERROR_INVALID_DATA           ((int)BLUETOOTH_ERROR_BASE - 0x04)
  92                                                                 /**< invalid data error */
  93 #define BLUETOOTH_ERROR_MEMORY_ALLOCATION      ((int)BLUETOOTH_ERROR_BASE - 0x05)
  94                                                                 /**< Memory allocation error */
  95 #define BLUETOOTH_ERROR_OUT_OF_MEMORY          ((int)BLUETOOTH_ERROR_BASE - 0x06)
  96                                                                 /**< out of memory error */
  97 #define BLUETOOTH_ERROR_TIMEOUT                ((int)BLUETOOTH_ERROR_BASE - 0x07)
  98                                                                 /**< timeout error */
  99 #define BLUETOOTH_ERROR_NO_RESOURCES           ((int)BLUETOOTH_ERROR_BASE - 0x08)
 100                                                                 /**< No resource error */
 101 #define BLUETOOTH_ERROR_INTERNAL               ((int)BLUETOOTH_ERROR_BASE - 0x09)
 102                                                                 /**< internal error */
 103 #define BLUETOOTH_ERROR_NOT_SUPPORT            ((int)BLUETOOTH_ERROR_BASE - 0x0a)
 104                                                                 /**< Not supported error */
 105 #define BLUETOOTH_ERROR_DEVICE_NOT_ENABLED     ((int)BLUETOOTH_ERROR_BASE - 0x0b)
 106                                                                 /**< Operation is failed because
 107                                                                 of not enabled BT Adapter */
 108 #define BLUETOOTH_ERROR_DEVICE_ALREADY_ENABLED  ((int)BLUETOOTH_ERROR_BASE - 0x0c)
 109                                                                 /**< Enabling is failed because of
 110                                                                 already enabled BT Adapter */
 111 #define BLUETOOTH_ERROR_DEVICE_BUSY            ((int)BLUETOOTH_ERROR_BASE - 0x0d)
 112                                                                 /**< Operation is failed because of
 113                                                                 other on going operation */
 114 #define BLUETOOTH_ERROR_ACCESS_DENIED          ((int)BLUETOOTH_ERROR_BASE - 0x0e)
 115                                                                 /**< access denied error */
 116 #define BLUETOOTH_ERROR_MAX_CLIENT             ((int)BLUETOOTH_ERROR_BASE - 0x0f)
 117                                                                 /**< max client error */
 118 #define BLUETOOTH_ERROR_NOT_FOUND              ((int)BLUETOOTH_ERROR_BASE - 0x10)
 119                                                                 /**< not found error */
 120 #define BLUETOOTH_ERROR_SERVICE_SEARCH_ERROR   ((int)BLUETOOTH_ERROR_BASE - 0x11)
 121                                                                 /**< service search fail */
 122 #define BLUETOOTH_ERROR_PARING_FAILED          ((int)BLUETOOTH_ERROR_BASE - 0x12)
 123                                                                 /**< pairing failed error */
 124 #define BLUETOOTH_ERROR_NOT_PAIRED             ((int)BLUETOOTH_ERROR_BASE - 0x13)
 125                                                                 /**< Not paired error */
 126 #define BLUETOOTH_ERROR_SERVICE_NOT_FOUND      ((int)BLUETOOTH_ERROR_BASE - 0x14)
 127                                                                 /**< no service error */
 128 #define BLUETOOTH_ERROR_NOT_CONNECTED          ((int)BLUETOOTH_ERROR_BASE - 0x15)
 129                                                                 /**< no connection error */
 130 #define BLUETOOTH_ERROR_ALREADY_CONNECT        ((int)BLUETOOTH_ERROR_BASE - 0x16)
 131                                                                 /**< alread connected error */
 132 #define BLUETOOTH_ERROR_CONNECTION_BUSY        ((int)BLUETOOTH_ERROR_BASE - 0x17)
 133                                                                 /**< connection busy error */
 134 #define BLUETOOTH_ERROR_CONNECTION_ERROR       ((int)BLUETOOTH_ERROR_BASE - 0x18)
 135                                                                 /**< connection error */
 136 #define BLUETOOTH_ERROR_MAX_CONNECTION         ((int)BLUETOOTH_ERROR_BASE - 0x19)
 137                                                                 /**< max connection error*/
 138 #define BLUETOOTH_ERROR_NOT_IN_OPERATION       ((int)BLUETOOTH_ERROR_BASE - 0x1a)
 139                                                                 /**< Not in operation */
 140 #define BLUETOOTH_ERROR_CANCEL_BY_USER         ((int)BLUETOOTH_ERROR_BASE - 0x1b)
 141                                                                 /**< Cancelled by user */
 142 #define BLUETOOTH_ERROR_REGISTRATION_FAILED    ((int)BLUETOOTH_ERROR_BASE - 0x1c)
 143                                                                 /**< Service record registration failed */
 144 #define BLUETOOTH_ERROR_IN_PROGRESS            ((int)BLUETOOTH_ERROR_BASE - 0x1d)
 145                                                                 /**< Operation in progress */
 146 #define BLUETOOTH_ERROR_AUTHENTICATION_FAILED  ((int)BLUETOOTH_ERROR_BASE - 0x1e)
 147                                                                 /**< authentication failed error when paring*/
 148 #define BLUETOOTH_ERROR_HOST_DOWN              ((int)BLUETOOTH_ERROR_BASE - 0x1f)
 149                                                                 /**< Remote host is down */
 150 #define BLUETOOTH_ERROR_END_OF_DEVICE_LIST     ((int)BLUETOOTH_ERROR_BASE - 0x20)
 151                                                                 /**< End of device list */
 152
 153 #define BLUETOOTH_ERROR_AGENT_ALREADY_EXIST      ((int)BLUETOOTH_ERROR_BASE - 0x21)
 154                                                                 /**< Obex agent already exists */
 155 #define BLUETOOTH_ERROR_AGENT_DOES_NOT_EXIST    ((int)BLUETOOTH_ERROR_BASE - 0x22)
 156                                                                 /**< Obex agent does not exist */
 157
 158 #define BLUETOOTH_ERROR_ALREADY_INITIALIZED    ((int)BLUETOOTH_ERROR_BASE - 0x23)
 159                                                                 /**< Already initialized */
 160
 161 #define BLUETOOTH_ERROR_PERMISSION_DEINED    ((int)BLUETOOTH_ERROR_BASE - 0x24)
 162                                                                 /**< Permission deined */
 163
 164 #define BLUETOOTH_ERROR_ALREADY_DEACTIVATED    ((int)BLUETOOTH_ERROR_BASE - 0x25)
 165                                                                 /**< Nap already done */
 166
 167 #define BLUETOOTH_ERROR_NOT_INITIALIZED    ((int)BLUETOOTH_ERROR_BASE - 0x26)
 168                                                                 /**< Not initialized */
 169
 170 #define BLUETOOTH_ERROR_AUTHENTICATION_REJECTED ((int)BLUETOOTH_ERROR_BASE - 0x27)
 171                                                                 /**< Authentication rejected */
 172
 173 #define BLUETOOTH_ERROR_DEVICE_POLICY_RESTRICTION    ((int)BLUETOOTH_ERROR_BASE - 0x28)
 174                                                                 /**< Device Policy Restricted */
 175
 176 /**
 177  * Device disconnection reasons; received from stack
 178  */
 179 #define BLUETOOTH_ERROR_PAGE_TIMEOUT    0x04
 180 #define BLUETOOTH_ERROR_AUTH_FAILURE    0x05
 181 #define BLUETOOTH_ERROR_PIN_OR_KEY_MISSING      0x06
 182 #define BLUETOOTH_ERROR_CONNECTION_TIMEOUT      0x08
 183 #define BLUETOOTH_ERROR_REMOTE_USER_TERM        0x13
 184 #define BLUETOOTH_ERROR_REMOTE_LOW_RESOURCES    0x14
 185 #define BLUETOOTH_ERROR_REMOTE_POWER_OFF        0x15
 186 #define BLUETOOTH_ERROR_LOCAL_HOST_TERM 0x16
 187 #define BLUETOOTH_ERROR_REPEATED_ATTEMPTS       0x17
 188 #define BLUETOOTH_ERROR_LMP_RESPONSE_TIMEOUT 0x22
 189 #define BLUETOOTH_ERROR_CONNECTION_FAILED_TO_BE_ESTABLISHED     0x3e
 190
 191
 192
 193 /**
 194 * Device disconnect reason
 195 */
 196 typedef enum {
 197         BLUETOOTH_DEVICE_DISCONNECT_UNKNOWN,
 198         BLUETOOTH_DEVICE_DISCONNECT_TIMEOUT,
 199         BLUETOOTH_DEVICE_DISCONNECT_LOCAL_HOST,
 200         BLUETOOTH_DEVICE_DISCONNECT_REMOTE,
 201 } bluetooth_device_disconnect_reason_t;
 202
 203 /**
 204  * This is Bluetooth device address type, fixed to 6 bytes ##:##:##:##:##:##
 205  */
 206 typedef struct {
 207         unsigned char addr[BLUETOOTH_ADDRESS_LENGTH];
 208 } bluetooth_device_address_t;
 209
 210 /**
 211  * This is Bluetooth device address type
 212  */
 213 typedef enum {
 214         BLUETOOTH_DEVICE_PUBLIC_ADDRESS = 0x00,
 215         BLUETOOTH_DEVICE_RANDOM_ADDRESS
 216 } bluetooth_device_address_type_t;
 217
 218 /**
 219  * This is Bluetooth version
 220  */
 221 typedef struct {
 222         char version[BLUETOOTH_VERSION_LENGTH_MAX + 1];
 223 } bluetooth_version_t;
 224
 225 /**
 226  * This is Bluetooth device name type, maximum size of Bluetooth device name is 248 bytes
 227  */
 228 typedef struct {
 229         char name[BLUETOOTH_DEVICE_NAME_LENGTH_MAX + 1];
 230 } bluetooth_device_name_t;
 231
 232 /**
 233  * This is Bluetooth manufacturer specific data, maximum size of data is 240 bytes
 234  */
 235 typedef struct {
 236         int data_len;           /**< manafacturer specific data length */
 237         char data[BLUETOOTH_MANUFACTURER_DATA_LENGTH_MAX];
 238 } bluetooth_manufacturer_data_t;
 239
 240 typedef struct {
 241         char pin_code[BLUETOOTH_PIN_CODE_MAX_LENGTH + 1];
 242 } bluetooth_device_pin_code_t;
 243
 244 /**
 245  * Adapter state
 246  */
 247 typedef enum {
 248         BLUETOOTH_ADAPTER_DISABLED,         /**< Bluetooth adapter is disabled */
 249         BLUETOOTH_ADAPTER_ENABLED,          /**< Bluetooth adapter is enabled */
 250         BLUETOOTH_ADAPTER_CHANGING_ENABLE,  /**< Bluetooth adapter is currently enabling */
 251         BLUETOOTH_ADAPTER_CHANGING_DISABLE, /**< Bluetooth adapter is currently disabling */
 252 } bluetooth_adapter_state_t;
 253
 254 /**
 255  * Adapter state
 256  */
 257 typedef enum {
 258         BLUETOOTH_ADAPTER_LE_DISABLED,      /**< Bluetooth adapter le is disabled */
 259         BLUETOOTH_ADAPTER_LE_ENABLED,       /**< Bluetooth adapter le is enabled */
 260         BLUETOOTH_ADAPTER_LE_CHANGING_ENABLE,  /**< Bluetooth adapter le is currently enabling */
 261         BLUETOOTH_ADAPTER_LE_CHANGING_DISABLE, /**< Bluetooth adapter le is currently disabling */
 262 } bluetooth_adapter_le_state_t;
 263
 264 /**
 265  * Discoverable mode
 266  */
 267 typedef enum {
 268         BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE,         /**< Non discoverable mode */
 269         /*Changed the order to make it compatable with old method */
 270         BLUETOOTH_DISCOVERABLE_MODE_GENERAL_DISCOVERABLE,/**< Discoverable mode */
 271         BLUETOOTH_DISCOVERABLE_MODE_TIME_LIMITED_DISCOVERABLE,
 272                                                          /**< Discoverable mode with time limit
 273                                                         After specific timeout, it is changed
 274                                                                 to non discoverable mode */
 275 } bluetooth_discoverable_mode_t;
 276
 277 /**
 278  * Network connect mode
 279  */
 280 typedef enum {
 281         BLUETOOTH_NETWORK_PANU_ROLE,
 282                                  /**< PAN user */
 283         BLUETOOTH_NETWORK_NAP_ROLE,/**< Network Access Point */
 284         BLUETOOTH_NETWORK_GN_ROLE,  /**< Group ad-hoc Network */
 285         BLUETOOTH_NETWORK_CUSTOM_UUID, /**< Custom role */
 286 } bluetooth_network_role_t;
 287
 288 /**
 289  * Service type
 290  */
 291 typedef enum {
 292         BLUETOOTH_RFCOMM_SERVICE = 0x01,
 293         BLUETOOTH_A2DP_SERVICE = 0x02,
 294         BLUETOOTH_HSP_SERVICE = 0x04,
 295         BLUETOOTH_HID_SERVICE = 0x08,
 296         BLUETOOTH_NAP_SERVICE = 0x10,
 297         BLUETOOTH_HFG_SERVICE = 0x20,
 298         BLUETOOTH_GATT_SERVICE = 0x40,
 299         BLUETOOTH_NAP_SERVER_SERVICE = 0x80,
 300         BLUETOOTH_A2DP_SINK_SERVICE = 0x100,
 301         BLUETOOTH_PBAP_SERVICE = 0x200,
 302 } bluetooth_service_type_t;
 303
 304 /**
 305  * Service type
 306  */
 307 typedef enum {
 308         BLUETOOTH_DEV_CONN_DEFAULT = 0xFF,
 309         /* represents that connection
 310          * type can both BR/EDR and LE */
 311         BLUETOOTH_DEV_CONN_BREDR = 0x00,
 312         BLUETOOTH_DEV_CONN_LE = 0x01,
 313 } bluetooth_conn_type_t;
 314
 315 /**
 316  * Service type
 317  */
 318 typedef enum {
 319         BLUETOOTH_CODEC_ID_CVSD = 0x01,
 320         BLUETOOTH_CODEC_ID_MSBC = 0x02,
 321 } bluetooth_codec_type_t;
 322
 323 /**
 324  * Service type
 325  */
 326 typedef enum {
 327         BLUETOOTH_HF_AUDIO_DISCONNECTED = 0x00,
 328         BLUETOOTH_HF_AUDIO_CONNECTED = 0x01,
 329 } bluetooth_hf_audio_connected_type_t;
 330
 331 /**
 332  * Advertising data
 333  */
 334 typedef struct {
 335         guint8 data[BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX];
 336 } bluetooth_advertising_data_t;
 337
 338 /**
 339  * Scan response data
 340  */
 341 typedef struct {
 342         guint8 data[BLUETOOTH_SCAN_RESP_DATA_LENGTH_MAX];
 343 } bluetooth_scan_resp_data_t;
 344
 345 /**
 346  * Advertising filter policy
 347  */
 348 typedef enum {
 349         BLUETOOTH_ALLOW_SCAN_CONN_ALL = 0x00,
 350         BLUETOOTH_ALLOW_CONN_ALL_SCAN_WHITE_LIST = 0x01,
 351         BLUETOOTH_ALLOW_SCAN_ALL_CONN_WHITE_LIST = 0x02,
 352         BLUETOOTH_ALLOW_SCAN_CONN_WHITE_LIST = 0x03,
 353 } bluetooth_advertising_filter_policy_t;
 354
 355 /**
 356  * Advertising type
 357  */
 358 typedef enum {
 359         BLUETOOTH_ADV_CONNECTABLE = 0x00, /* ADV_IND */
 360         BLUETOOTH_ADV_CONNECTABLE_DIRECT_HIGH = 0x01, /* ADV_DIRECT_IND, high duty cycle */
 361         BLUETOOTH_ADV_SCANNABLE = 0x02, /* ADV_SCAN_IND */
 362         BLUETOOTH_ADV_NON_CONNECTABLE = 0x03, /* ADV_NONCOND_IND */
 363         BLUETOOTH_ADV_CONNECTABLE_DIRECT_LOW = 0x04, /* ADV_DIRECT_IND, low duty cycle */
 364 } bluetooth_advertising_type_t;
 365
 366 typedef enum {
 367         BLUETOOTH_GATT_SERVICE_CHANGE_TYPE_ADD = 0x01,
 368         BLUETOOTH_GATT_SERVICE_CHANGE_TYPE_REMOVE = 0x02,
 369 } bluetooth_gatt_service_change_type_t;
 370
 371 typedef enum {
 372         BLUETOOTH_GATT_PERMISSION_READ = 0x01,
 373         BLUETOOTH_GATT_PERMISSION_WRITE = 0x02,
 374         BLUETOOTH_GATT_PERMISSION_ENCRYPT_READ = 0x04,
 375         BLUETOOTH_GATT_PERMISSION_ENCRYPT_WRITE = 0x08,
 376         BLUETOOTH_GATT_PERMISSION_ENCRYPT_AUTHENTICATED_READ = 0x10,
 377         BLUETOOTH_GATT_PERMISSION_ENCRYPT_AUTHENTICATED_WRITE = 0x20,
 378 } bt_gatt_permission_t;
 379
 380 typedef enum {
 381         BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_BROADCAST = 0x01,
 382         BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_READ = 0x02,
 383         BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_WRITE_NO_RESPONSE = 0x04,
 384         BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_WRITE = 0x08,
 385         BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_NOTIFY = 0x10,
 386         BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_INDICATE = 0x20,
 387         BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_SIGNED_WRITE = 0x40,
 388         BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_RELIABLE_WRITE = 0x80,
 389         BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_WRITABLE_AUXILIARIES = 0x100,
 390         BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_ENCRYPT_READ = 0x200,
 391         BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_ENCRYPT_WRITE = 0x400,
 392         BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_ENCRYPT_AUTHENTICATED_READ = 0x800,
 393         BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_ENCRYPT_AUTHENTICATED_WRITE = 0x1000,
 394         BLUETOOTH_GATT_CHARACTERISTIC_PROPERTY_EXTENDED_PROPS = 0xffff,
 395 } bt_gatt_characteristic_property_t;
 396
 397 /**
 398 * Remote device request types for attributes
 399 */
 400 typedef enum {
 401         BLUETOOTH_GATT_ATT_REQUEST_TYPE_READ = 0x00, /* Read Requested*/
 402         BLUETOOTH_GATT_ATT_REQUEST_TYPE_WRITE = 0x01, /* Write Requested*/
 403 } bluetooth_gatt_att_request_tyep_t;
 404
 405 /**
 406  * Proximity Property Type
 407  */
 408 typedef enum {
 409                 BLUETOOTH_PXP_PROPERTY_LLS = 0x01,      /* Link Loss Alert Proeprty */
 410                 BLUETOOTH_PXP_PROPERTY_IAS = 0x02,      /* Immediate Alert Proeprty */
 411                 BLUETOOTH_PXP_PROPERTY_TX_POWER = 0x04, /* TX Power */
 412 } bluetooth_pxp_poperty_t;
 413
 414 /**
 415 * Advertising parameters
 416 */
 417 typedef struct {
 418         float interval_min;
 419         float interval_max;
 420         guint8 filter_policy;
 421         guint8 type;
 422 } bluetooth_advertising_params_t;
 423
 424 /**
 425 * LE Scan parameters
 426 */
 427 typedef struct {
 428         int type;  /**< passive 0, active 1 */
 429         float interval;  /**< LE scan interval */
 430         float window;  /**< LE scan window */
 431 } bluetooth_le_scan_params_t;
 432
 433 /*
 434         LE Connection Update
 435  */
 436 typedef struct {
 437         float interval_min;
 438         float interval_max;
 439         guint16 latency;
 440         guint16 timeout;
 441 } bluetooth_le_connection_param_t;
 442
 443 /*
 444         LE Read Maximum Data Length
 445  */
 446 typedef struct {
 447         guint16 max_tx_octets;
 448         guint16 max_tx_time;
 449         guint16 max_rx_octets;
 450         guint16 max_rx_time;
 451 } bluetooth_le_read_maximum_data_length_t;
 452
 453 /*
 454         LE Read Host suggested default Data Length
 455  */
 456 typedef struct {
 457         guint16 def_tx_octets;
 458         guint16 def_tx_time;
 459 } bluetooth_le_read_host_suggested_data_length_t;
 460
 461 /**
 462  * Samsung XSAT Vendor dependent command
 463  */
 464 typedef struct {
 465         gint app_id;
 466         char *message;
 467 } bluetooth_vendor_dep_at_cmd_t;
 468
 469 /**
 470  * Transfer Types
 471  */
 472 typedef enum {
 473         BLUETOOTH_TRANSFER_INBOUND,         /**< Inbound Transfer Type */
 474         BLUETOOTH_TRANSFER_OUTBOUND,        /**< Outbound Transfer Type */
 475 } bluetooth_opp_transfer_type_t;
 476
 477 typedef struct {
 478         gint event;
 479         gint value;
 480 } bluetooth_hf_ciev_device_event_t;
 481
 482 #define BLUETOOTH_EVENT_BASE            ((int)(0x0000))         /**< No event */
 483 #define BLUETOOTH_EVENT_GAP_BASE        ((int)(BLUETOOTH_EVENT_BASE + 0x0010))
 484                                                                 /**< Base ID for GAP Event */
 485 #define BLUETOOTH_EVENT_SDP_BASE        ((int)(BLUETOOTH_EVENT_GAP_BASE + 0x0020))
 486                                                                 /**< Base ID for SDP events */
 487 #define BLUETOOTH_EVENT_RFCOMM_BASE     ((int)(BLUETOOTH_EVENT_SDP_BASE + 0x0020))
 488                                                                 /**< Base ID for RFCOMM events */
 489 #define BLUETOOTH_EVENT_NETWORK_BASE     ((int)(BLUETOOTH_EVENT_RFCOMM_BASE + 0x0020))
 490                                                                 /**< Base ID for NETWORK events */
 491 #define BLUETOOTH_EVENT_HDP_BASE     ((int)(BLUETOOTH_EVENT_NETWORK_BASE + 0x0020))
 492                                                                 /**< Base ID for HDP events */
 493 #define BLUETOOTH_EVENT_OPC_BASE  ((int)(BLUETOOTH_EVENT_HDP_BASE + 0x0020))
 494                                                                 /**< Base ID for OPC events */
 495 #define BLUETOOTH_EVENT_OBEX_SERVER_BASE ((int)(BLUETOOTH_EVENT_OPC_BASE + 0x0020))
 496                                                                 /**< Base ID for Obex Server events */
 497 #define BLUETOOTH_EVENT_GATT_BASE ((int)(BLUETOOTH_EVENT_OBEX_SERVER_BASE + 0x0020))
 498                                                                 /**< Base ID for GATT events */
 499
 500 #define BLUETOOTH_EVENT_AUDIO_BASE ((int)(BLUETOOTH_EVENT_GATT_BASE + 0x0020))
 501                                                                 /**< Base ID for Audio events */
 502 #define BLUETOOTH_EVENT_HID_BASE ((int)(BLUETOOTH_EVENT_AUDIO_BASE + 0x0030))
 503                                                                 /**< Base ID for HID events */
 504 #define BLUETOOTH_EVENT_ADVERTISING_BASE ((int)(BLUETOOTH_EVENT_HID_BASE + 0x0020))
 505                                                                 /**< Base ID for Advertising events */
 506 #define BLUETOOTH_EVENT_PBAP_CLIENT_BASE ((int)(BLUETOOTH_EVENT_ADVERTISING_BASE + 0x0020))
 507                                                                 /**< Base ID for PBAP Client events */
 508 #define BLUETOOTH_EVENT_AVRCP_CONTROL_BASE ((int)(BLUETOOTH_EVENT_PBAP_CLIENT_BASE + 0x0020))
 509                                                                 /**< Base ID for AVRCP events */
 510 #define BLUETOOTH_EVENT_IPSP_BASE ((int)(BLUETOOTH_EVENT_AVRCP_CONTROL_BASE + 0x0020))
 511                                                                 /**< Base ID for IPSP events */
 512
 513 /**
 514  * Bluetooth event type
 515  */
 516 typedef enum {
 517         BLUETOOTH_EVENT_NONE = BLUETOOTH_EVENT_BASE,/**< No event */
 518
 519         BLUETOOTH_EVENT_ENABLED,                    /**< Bluetooth event adpater enabled */
 520         BLUETOOTH_EVENT_DISABLED,                   /**< Bluetooth event adpater disabled */
 521         BLUETOOTH_EVENT_LE_ENABLED,                 /**< Bluetooth event adpater enabled */
 522         BLUETOOTH_EVENT_LE_DISABLED,                /**< Bluetooth event adpater disabled */
 523         BLUETOOTH_EVENT_LOCAL_NAME_CHANGED,         /**< Bluetooth event local name changed*/
 524         BLUETOOTH_EVENT_DISCOVERABLE_TIMEOUT_REQUESTED,
 525                                         /**< Bluetooth event Discoverable timeout requested*/
 526         BLUETOOTH_EVENT_DISCOVERABLE_MODE_CHANGED,  /**< Bluetooth event mode changed */
 527         BLUETOOTH_EVENT_DISCOVERY_OPTION_REQUESTED, /**< Bluetooth event discovery option */
 528         BLUETOOTH_EVENT_DISCOVERY_STARTED,          /**< Bluetooth event discovery started */
 529         BLUETOOTH_EVENT_DISCOVERY_FINISHED,         /**< Bluetooth event discovery finished */
 530         BLUETOOTH_EVENT_REMOTE_DEVICE_FOUND,        /**< Bluetooth event remote deice found */
 531         BLUETOOTH_EVENT_LE_DISCOVERY_STARTED,           /**< Bluetooth event LE discovery started */
 532         BLUETOOTH_EVENT_LE_DISCOVERY_FINISHED,  /**< Bluetooth event LE discovery finished */
 533         BLUETOOTH_EVENT_REMOTE_LE_DEVICE_FOUND,     /**< Bluetooth event remote deice found (LE dev) */
 534         BLUETOOTH_EVENT_REMOTE_DEVICE_NAME_UPDATED,/**< Bluetooth event remote device name updated*/
 535         BLUETOOTH_EVENT_BONDING_FINISHED,           /**< Bluetooth event bonding completed */
 536         BLUETOOTH_EVENT_BONDED_DEVICE_REMOVED,      /**< Bluetooth event bonding removed */
 537         BLUETOOTH_EVENT_BONDED_DEVICE_FOUND,        /**< Bluetooth event paired device found */
 538         BLUETOOTH_EVENT_REMOTE_DEVICE_READ,         /**< Bluetooth event read remote device */
 539         BLUETOOTH_EVENT_DEVICE_AUTHORIZED,          /**< Bluetooth event authorize device */
 540         BLUETOOTH_EVENT_DEVICE_UNAUTHORIZED,        /**< Bluetooth event unauthorize device */
 541         BLUETOOTH_EVENT_DISCOVERABLE_TIMEOUT_CHANGED,  /**< Bluetooth event mode changed */
 542         BLUETOOTH_EVENT_KEYBOARD_PASSKEY_DISPLAY,       /**Bluetooth event for displaying keyboard  passkey to user*/
 543         BLUETOOTH_EVENT_PIN_REQUEST,    /**Bluetooth event for PIN input by user*/
 544         BLUETOOTH_EVENT_PASSKEY_REQUEST,        /**Bluetooth event for entering Passkey by user*/
 545         BLUETOOTH_EVENT_PASSKEY_CONFIRM_REQUEST,        /**Bluetooth event for Passkey confirmation by user*/
 546         BLUETOOTH_EVENT_CONNECTABLE_CHANGED,        /**< Bluetooth event connectable changed */
 547
 548         BLUETOOTH_EVENT_RSSI_ENABLED,           /**< Bluetooth event RSSI monitoring enabled */
 549         BLUETOOTH_EVENT_RSSI_ALERT,                             /**< Bluetooth event RSSI Alert */
 550         BLUETOOTH_EVENT_RAW_RSSI,                               /**< Bluetooth event Raw RSSI */
 551         BLUETOOTH_EVENT_SUPPORTED_PROFILE_TRUSTED,      /**< Bluetooth event Supported Profile Trusted */
 552         BLUETOOTH_EVENT_PASSKEY_NOTIFICATION,       /**< Bluetooth event passkey notification */
 553
 554         BLUETOOTH_EVENT_SERVICE_SEARCHED = BLUETOOTH_EVENT_SDP_BASE,
 555                                                     /**< Bluetooth event serice search base id */
 556         BLUETOOTH_EVENT_SERVICE_SEARCH_CANCELLED,   /**< Bluetooth event service search cancelled */
 557         BLUETOOTH_EVENT_RFCOMM_DATA_RECEIVED = BLUETOOTH_EVENT_RFCOMM_BASE,
 558                                                         /**< RFCOMM data receive event */
 559         BLUETOOTH_EVENT_RFCOMM_CONNECTED,               /**< Rfcomm server incomming connection */
 560         BLUETOOTH_EVENT_RFCOMM_DISCONNECTED,            /**< Rfcomm server/client disconnect */
 561
 562         BLUETOOTH_EVENT_RFCOMM_AUTHORIZE,
 563
 564         BLUETOOTH_EVENT_DEVICE_CONNECTED,           /**< Bluetooth event device connected */
 565         BLUETOOTH_EVENT_DEVICE_DISCONNECTED,        /**< Bluetooth event device disconnected */
 566
 567         BLUETOOTH_EVENT_RFCOMM_SERVER_REMOVED,
 568
 569         BLUETOOTH_EVENT_NETWORK_SERVER_ACTIVATED = BLUETOOTH_EVENT_NETWORK_BASE,
 570                                                                 /**< Bluetooth Network event */
 571         BLUETOOTH_EVENT_NETWORK_SERVER_DEACTIVATED, /**< Network server deactivated */
 572         BLUETOOTH_EVENT_NETWORK_SERVER_CONNECTED,     /**< Network connected event in server */
 573         BLUETOOTH_EVENT_NETWORK_SERVER_DISCONNECTED,
 574                                                    /**< Network disconnected evnet in server */
 575
 576         BLUETOOTH_EVENT_NETWORK_CONNECTED,              /**< Network connected event in client*/
 577         BLUETOOTH_EVENT_NETWORK_DISCONNECTED,           /**< Network disconnected evnet in client*/
 578
 579         BLUETOOTH_EVENT_HDP_CONNECTED
 580                         = BLUETOOTH_EVENT_HDP_BASE,                /**<HDP Connect>*/
 581         BLUETOOTH_EVENT_HDP_DISCONNECTED,          /**<HDP Disconnect>*/
 582         BLUETOOTH_EVENT_HDP_DATA_RECEIVED,         /**<HDP Data Indication>*/
 583
 584         BLUETOOTH_EVENT_OPC_CONNECTED = BLUETOOTH_EVENT_OPC_BASE,
 585                                                                 /* OPC Connected event */
 586         BLUETOOTH_EVENT_OPC_DISCONNECTED,               /* OPC Disonnected event */
 587         BLUETOOTH_EVENT_OPC_TRANSFER_STARTED,   /* OPC Transfer started event */
 588         BLUETOOTH_EVENT_OPC_TRANSFER_PROGRESS,  /* OPC Transfer progress event */
 589         BLUETOOTH_EVENT_OPC_TRANSFER_COMPLETE,  /* OPC Transfer Complete event */
 590
 591         BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_AUTHORIZE = BLUETOOTH_EVENT_OBEX_SERVER_BASE,
 592                                                                 /* Obex server authorize event*/
 593         BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_STARTED,   /* Obex Server transfer started event*/
 594         BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_PROGRESS,/* Obex Server transfer progress event*/
 595         BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_COMPLETED,/* Obex Server transfer complete event*/
 596         BLUETOOTH_EVENT_OBEX_SERVER_CONNECTION_AUTHORIZE,
 597         BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_CONNECTED, /* Obex Transfer connected event */
 598         BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_DISCONNECTED, /* Obex Transfer disconnected event */
 599
 600         BLUETOOTH_EVENT_GATT_SVC_CHAR_DISCOVERED = BLUETOOTH_EVENT_GATT_BASE,
 601                                 /**<Discovered GATT service characteristics event*/
 602         BLUETOOTH_EVENT_GATT_CHAR_VAL_CHANGED,
 603                                 /**<Remote GATT charateristic value changed event*/
 604         BLUETOOTH_EVENT_GATT_GET_CHAR_FROM_UUID,
 605         BLUETOOTH_EVENT_GATT_READ_CHAR, /**<Gatt Read Characteristic Value */
 606         BLUETOOTH_EVENT_GATT_WRITE_CHAR, /**<Gatt Write Characteristic Value */
 607         BLUETOOTH_EVENT_GATT_READ_DESC, /**<Gatt Read Characteristic Descriptor Value */
 608         BLUETOOTH_EVENT_GATT_WRITE_DESC, /**<Gatt Write Characteristic Descriptor Value */
 609         BLUETOOTH_EVENT_GATT_SVC_CHAR_DESC_DISCOVERED, /**<Gatt Char Descriptors Discovered Event*/
 610         BLUETOOTH_EVENT_GATT_CONNECTED,/**<Gatt connected event */
 611         BLUETOOTH_EVENT_GATT_DISCONNECTED, /**<Gatt Disconnected event */
 612         BLUETOOTH_EVENT_GATT_ATT_MTU_CHANGED, /**<Attribute protocol MTU changed event */
 613         BLUETOOTH_EVENT_GATT_SERVER_CHARACTERISTIC_VALUE_CHANGED, /**<Gatt Char write callback event */
 614         BLUETOOTH_EVENT_GATT_SERVER_READ_REQUESTED, /** <GATT Characteristic/Descriptor Read Request event */
 615         BLUETOOTH_EVENT_GATT_SERVER_VALUE_CHANGED, /** <GATT Characteristic/Descriptor Value change event */
 616         BLUETOOTH_EVENT_GATT_SERVER_NOTIFICATION_STATE_CHANGED, /** <GATT Characteristic Notification change event */
 617         BLUETOOTH_EVENT_GATT_SERVER_NOTIFICATION_COMPLETED, /** <GATT Characteristic Notification or Indication completed event */
 618         BLUETOOTH_EVENT_GATT_CLIENT_SERVICE_CHANGED, /** <GATT Client service change event */
 619
 620         BLUETOOTH_EVENT_AG_CONNECTED = BLUETOOTH_EVENT_AUDIO_BASE, /**<AG service connected event*/
 621         BLUETOOTH_EVENT_AG_DISCONNECTED, /**<AG service disconnected event*/
 622         BLUETOOTH_EVENT_AG_SPEAKER_GAIN, /**<Speaker gain request event*/
 623         BLUETOOTH_EVENT_AG_MIC_GAIN, /**<Mic gain request event*/
 624         BLUETOOTH_EVENT_AG_AUDIO_CONNECTED, /**<AV & AG service connected event*/
 625         BLUETOOTH_EVENT_AG_AUDIO_DISCONNECTED,  /**<AV & AG service disconnected event*/
 626         BLUETOOTH_EVENT_AV_CONNECTED, /**<AV service connected event*/
 627         BLUETOOTH_EVENT_AV_DISCONNECTED, /**<AV service disconnected event*/
 628         BLUETOOTH_EVENT_AV_SOURCE_CONNECTED, /**<AV Source device connected event */
 629         BLUETOOTH_EVENT_AV_SOURCE_DISCONNECTED, /**<AV Source device disconnected event */
 630         BLUETOOTH_EVENT_AVRCP_CONNECTED, /**<AVRCP service connected event*/
 631         BLUETOOTH_EVENT_AVRCP_DISCONNECTED, /**<AVRCP service disconnected event*/
 632         BLUETOOTH_EVENT_AVRCP_SETTING_SHUFFLE_STATUS, /**<AVRCP service player suffle  status event*/
 633         BLUETOOTH_EVENT_AVRCP_SETTING_EQUALIZER_STATUS, /**<AVRCP service player equalizer status event*/
 634         BLUETOOTH_EVENT_AVRCP_SETTING_REPEAT_STATUS, /**<AVRCP service player repeat status event*/
 635         BLUETOOTH_EVENT_AVRCP_SETTING_SCAN_STATUS, /**<AVRCP service player scan status event*/
 636         BLUETOOTH_EVENT_HF_CONNECTED,
 637         BLUETOOTH_EVENT_HF_DISCONNECTED,
 638         BLUETOOTH_EVENT_HF_AUDIO_CONNECTED,
 639         BLUETOOTH_EVENT_HF_AUDIO_DISCONNECTED,
 640         BLUETOOTH_EVENT_HF_RING_INDICATOR,
 641         BLUETOOTH_EVENT_HF_CALL_WAITING,
 642         BLUETOOTH_EVENT_HF_CALL_TERMINATED,
 643         BLUETOOTH_EVENT_HF_CALL_STARTED,
 644         BLUETOOTH_EVENT_HF_CALL_ENDED,
 645         BLUETOOTH_EVENT_HF_CALL_UNHOLD,
 646         BLUETOOTH_EVENT_HF_CALL_SWAPPED,
 647         BLUETOOTH_EVENT_HF_CALL_ON_HOLD,
 648         BLUETOOTH_EVENT_HF_CALL_STATUS,
 649         BLUETOOTH_EVENT_HF_VOICE_RECOGNITION_ENABLED,
 650         BLUETOOTH_EVENT_HF_VOICE_RECOGNITION_DISABLED,
 651         BLUETOOTH_EVENT_HF_VOLUME_SPEAKER,
 652         BLUETOOTH_EVENT_HF_VENDOR_DEP_CMD,
 653         BLUETOOTH_EVENT_HF_CALLSETUP_INCOMING,
 654         BLUETOOTH_EVENT_HF_CALL_FAILED_TO_DIAL,
 655         BLUETOOTH_EVENT_HF_CALL_IDLE,
 656         BLUETOOTH_EVENT_HF_CALLSETUP_DIALING,
 657         BLUETOOTH_EVENT_HF_CALLSETUP_ALERTING,
 658         BLUETOOTH_EVENT_HF_CIEV_DEVICE_STATUS_CHANGED,
 659
 660         BLUETOOTH_HID_CONNECTED = BLUETOOTH_EVENT_HID_BASE, /**< Input connectd event*/
 661         BLUETOOTH_HID_DISCONNECTED, /**< Input disconnectd event*/
 662         BLUETOOTH_HID_DEVICE_CONNECTED, /**< HID Device connected event*/
 663         BLUETOOTH_HID_DEVICE_DISCONNECTED, /**< HID Device disconnected event*/
 664         BLUETOOTH_HID_DEVICE_DATA_RECEIVED, /**< HID Device data received event*/
 665
 666         BLUETOOTH_EVENT_ADVERTISING_STARTED = BLUETOOTH_EVENT_ADVERTISING_BASE, /**< Advertising started event */
 667         BLUETOOTH_EVENT_ADVERTISING_STOPPED, /**< Advertising stopped event */
 668         BLUETOOTH_EVENT_ADVERTISING_MANUFACTURER_DATA_CHANGED, /**< Advertising manufacturer data changed event */
 669         BLUETOOTH_EVENT_SCAN_RESPONSE_MANUFACTURER_DATA_CHANGED, /**< Scan response manufacturer data changed event */
 670         BLUETOOTH_EVENT_MANUFACTURER_DATA_CHANGED, /**< Manufacturer data changed event */
 671         BLUETOOTH_EVENT_DEVICE_ERROR, /**< Hardware error */
 672         BLUETOOTH_EVENT_TX_TIMEOUT_ERROR, /** TX Timeout Error*/
 673         BLUETOOTH_EVENT_MAX, /**< Bluetooth event Max value */
 674
 675         BLUETOOTH_PBAP_CONNECTED = BLUETOOTH_EVENT_PBAP_CLIENT_BASE, /**< PBAP connected event*/
 676         BLUETOOTH_PBAP_DISCONNECTED, /**< PBAP disconnectd event*/
 677         BLUETOOTH_PBAP_PHONEBOOK_SIZE, /**< PBAP Phonebook Size event*/
 678         BLUETOOTH_PBAP_PHONEBOOK_PULL, /**< PBAP Phonebook Pull event*/
 679         BLUETOOTH_PBAP_VCARD_LIST, /**< PBAP vCard List event*/
 680         BLUETOOTH_PBAP_VCARD_PULL, /**< PBAP vCard Pull event*/
 681         BLUETOOTH_PBAP_PHONEBOOK_SEARCH, /**< PBAP Phonebook Search event*/
 682
 683         BLUETOOTH_EVENT_AVRCP_CONTROL_CONNECTED = BLUETOOTH_EVENT_AVRCP_CONTROL_BASE, /**<AVRCP service connected event*/
 684         BLUETOOTH_EVENT_AVRCP_CONTROL_DISCONNECTED, /**<AVRCP service disconnected event*/
 685         BLUETOOTH_EVENT_AVRCP_CONTROL_SHUFFLE_STATUS, /**<AVRCP control suffle  status event*/
 686         BLUETOOTH_EVENT_AVRCP_CONTROL_EQUALIZER_STATUS, /**<AVRCP control equalizer status event*/
 687         BLUETOOTH_EVENT_AVRCP_CONTROL_REPEAT_STATUS, /**<AVRCP control repeat status event*/
 688         BLUETOOTH_EVENT_AVRCP_CONTROL_SCAN_STATUS, /**<AVRCP control scan status event*/
 689         BLUETOOTH_EVENT_AVRCP_SONG_POSITION_STATUS, /**<AVRCP control play Postion status event*/
 690         BLUETOOTH_EVENT_AVRCP_PLAY_STATUS_CHANGED, /**<AVRCP control play status event*/
 691         BLUETOOTH_EVENT_AVRCP_TRACK_CHANGED, /**<AVRCP control song metadata event*/
 692
 693         BLUETOOTH_EVENT_IPSP_INIT_STATE_CHANGED = BLUETOOTH_EVENT_IPSP_BASE, /**<IPSP init event*/
 694         BLUETOOTH_EVENT_IPSP_CONNECTED, /**< IPSP connected event  */
 695         BLUETOOTH_EVENT_IPSP_DISCONNECTED, /**< IPSP Disconnected event */
 696         BLUETOOTH_EVENT_IPSP_INTERFACE_INFO, /** IPSP BT Interface Info after connection */
 697         BLUETOOTH_EVENT_LE_DATA_LENGTH_CHANGED,  /** LE data length values changed */
 698         BLUETOOTH_EVENT_PXP_PROPERTY_CHANGED, /** Proximity property changed */
 699 } bluetooth_event_type_t;
 700
 701  /**
 702  * This bt_service_uuid_list_t  enum  indicates service uuid list .
 703  * This values is stored the service_list_array in bt_sdp_info_t and bluetooth_device_info_t.
 704  */
 705
 706 typedef enum {
 707         BLUETOOTH_SPP_PROFILE_UUID = ((unsigned short)0x1101),                  /**<SPP*/
 708         BLUETOOTH_LAP_PROFILE_UUID = ((unsigned short)0x1102),                  /**<LAP*/
 709         BLUETOOTH_DUN_PROFILE_UUID = ((unsigned short)0x1103),                  /**<DUN*/
 710         BLUETOOTH_OBEX_IR_MC_SYNC_SERVICE_UUID = ((unsigned short)0x1104),      /**<OBEX IR MC SYNC*/
 711         BLUETOOTH_OBEX_OBJECT_PUSH_SERVICE_UUID = ((unsigned short)0x1105),     /**<OPP*/
 712         BLUETOOTH_OBEX_FILE_TRANSFER_UUID = ((unsigned short)0x1106),           /**<FTP*/
 713         BLUETOOTH_IRMC_SYNC_COMMAND_UUID = ((unsigned short)0x1107),            /**<IRMC SYNC COMMAND*/
 714         BLUETOOTH_HS_PROFILE_UUID = ((unsigned short)0x1108),                   /**<HS*/
 715         BLUETOOTH_CTP_PROFILE_UUID = ((unsigned short)0x1109),                  /**<CTP*/
 716         BLUETOOTH_AUDIO_SOURCE_UUID = ((unsigned short)0x110A),                 /**<AUDIO SOURCE*/
 717         BLUETOOTH_AUDIO_SINK_UUID = ((unsigned short)0x110B),                   /**<AUDIO SINK*/
 718         BLUETOOTH_AV_REMOTE_CONTROL_TARGET_UUID = ((unsigned short)0x110C),     /**<AV REMOTE CONTROL
 719                                                                                 TARGET*/
 720         BLUETOOTH_ADVANCED_AUDIO_PROFILE_UUID = ((unsigned short)0x110D),       /**<A2DP*/
 721         BLUETOOTH_AV_REMOTE_CONTROL_UUID = ((unsigned short)0x110E),            /**<AV REMOTE CONTROL UUID*/
 722         BLUETOOTH_AV_REMOTE_CONTROL_CONTROLLER_UUID = ((unsigned short)0x110F), /**<AV REMOTE CONTROLLER UUID*/
 723         BLUETOOTH_ICP_PROFILE_UUID = ((unsigned short)0x1110),                  /**<ICP*/
 724         BLUETOOTH_FAX_PROFILE_UUID = ((unsigned short)0x1111),                  /**<FAX*/
 725         BLUETOOTH_HEADSET_AG_SERVICE_UUID = ((unsigned short)0x1112),           /**<HS AG */
 726         BLUETOOTH_PAN_PANU_PROFILE_UUID = ((unsigned short)0x1115),             /**<PAN*/
 727         BLUETOOTH_PAN_NAP_PROFILE_UUID = ((unsigned short)0x1116),              /**<PAN*/
 728         BLUETOOTH_PAN_GN_PROFILE_UUID = ((unsigned short)0x1117),               /**<PAN*/
 729         BLUETOOTH_DIRECT_PRINTING = ((unsigned short)0x1118),
 730         BLUETOOTH_OBEX_BPPS_PROFILE_UUID = ((unsigned short)0x1118),            /**<OBEX BPPS*/ /* Will be removed */
 731         BLUETOOTH_REFERENCE_PRINTING = ((unsigned short)0x1119),
 732         BLUETOOTH_OBEX_IMAGING_UUID = ((unsigned short)0x111A),                 /**<OBEX_IMAGING*/
 733         BLUETOOTH_OBEX_IMAGING_RESPONDER_UUID = ((unsigned short)0x111B),       /**<OBEX_IMAGING
 734                                                                                 RESPONDER*/
 735         BLUETOOTH_IMAGING_AUTOMATIC_ARCHIVE_UUID = ((unsigned short)0x111C),    /**<IMAGING AUTOMATIC ARCHIVE*/
 736         BLUETOOTH_IMAGING_REFERENCED_OBJECTS_UUID = ((unsigned short)0x111D),   /**<IMAGING REFERENCED OBJECTS*/
 737         BLUETOOTH_HF_PROFILE_UUID = ((unsigned short)0x111E),                   /**<HF*/
 738         BLUETOOTH_HFG_PROFILE_UUID = ((unsigned short)0x111F),                  /**<HFG*/
 739         BLUETOOTH_DIRECT_PRINTING_REFERENCE_OBJ_UUID = ((unsigned short)0x1120),
 740                                                                         /**<DIRECT PRINTING*/
 741         BLUETOOTH_REFLECTED_UI = ((unsigned short)0x1121),              /**<REFLECTED UI*/
 742         BLUETOOTH_BASIC_PRINTING = ((unsigned short)0x1122),            /**<BASIC PRINTING*/
 743         BLUETOOTH_PRINTING_STATUS = ((unsigned short)0x1123),           /**<PRINTING  STATUS*/
 744         BLUETOOTH_OBEX_PRINTING_STATUS_UUID = ((unsigned short)0x1123), /**<OBEX PRINTING STATUS*/ /* Will be removed */
 745         BLUETOOTH_HID_PROFILE_UUID = ((unsigned short)0x1124),          /**<HID*/
 746         BLUETOOTH_HCR_PROFILE_UUID = ((unsigned short)0x1125),          /**<HCRP*/
 747         BLUETOOTH_HCR_PRINT_UUID = ((unsigned short)0x1126),            /**<HCR PRINT*/
 748         BLUETOOTH_HCR_SCAN_UUID = ((unsigned short)0x1127),             /**<HCR SCAN*/
 749         BLUETOOTH_SIM_ACCESS_PROFILE_UUID = ((unsigned short)0x112D),   /**<SIM ACCESS PROFILE*/
 750         BLUETOOTH_PBAP_PCE_UUID = ((unsigned short)0x112E),             /**<PBAP - PCE*/
 751         BLUETOOTH_PBAP_PSE_UUID = ((unsigned short)0x112F),             /**<OBEX PBA*/
 752         BLUETOOTH_OBEX_PBA_PROFILE_UUID = ((unsigned short)0x112F),     /**<OBEX PBA*/ /* Will be removed */
 753         BLUETOOTH_OBEX_PBAP_UUID = ((unsigned short)0x1130),            /**<OBEX PBA*/
 754         BLUETOOTH_HEADSET_HS_UUID = ((unsigned short)0x1131),           /**<HEADSET HS*/
 755         BLUETOOTH_MESSAGE_ACCESS_SERVER_UUID = ((unsigned short)0x1132),/**<MESSAGE ACCESS SERVER*/
 756         BLUETOOTH_MESSAGE_NOTIFICATION_SERVER_UUID = ((unsigned short)0x1133),/**<MESSAGE NOTIFICATION SERVER*/
 757         BLUETOOTH_MESSAGE_ACCESS_PROFILE_UUID = ((unsigned short)0x1134),/**<MESSAGE ACCESS PROFILE*/
 758         BLUETOOTH_PNP_INFORMATION_UUID = ((unsigned short)0x1200),      /**<PNP*/
 759         BLUETOOTH_GENERIC_NETWORKING_UUID = ((unsigned short)0x1201),   /**<GENERIC NETWORKING*/
 760         BLUETOOTH_GENERIC_FILE_TRANSFER_UUID = ((unsigned short)0x1202),/**<GENERIC FILE TRANSFER*/
 761         BLUETOOTH_GENERIC_AUDIO_UUID = ((unsigned short)0x1203),        /**<GENERIC AUDIO*/
 762         BLUETOOTH_GENERIC_TELEPHONY_UUID = ((unsigned short)0x1204),    /**<GENERIC TELEPHONY*/
 763         BLUETOOTH_VIDEO_SOURCE_UUID = ((unsigned short)0x1303), /**<VEDIO SOURCE*/
 764         BLUETOOTH_VIDEO_SINK_UUID = ((unsigned short)0x1304),           /**<VEDIO SINK*/
 765         BLUETOOTH_VIDEO_DISTRIBUTION_UUID = ((unsigned short)0x1305),   /**<VEDIO DISTRIBUTION*/
 766         BLUETOOTH_HDP_UUID = ((unsigned short)0x1400),                  /**<HDP*/
 767         BLUETOOTH_HDP_SOURCE_UUID = ((unsigned short)0x1401),           /**<HDP SOURCE*/
 768         BLUETOOTH_HDP_SINK_UUID = ((unsigned short)0x1402),             /**<HDP SINK*/
 769         BLUETOOTH_OBEX_SYNCML_TRANSFER_UUID = ((unsigned short)0x0000)  /**<OBEX_SYNC*/ /* Will be removed */
 770 } bluetooth_service_uuid_list_t;
 771
 772 /**
 773 * Service class part of class of device returned from device discovery
 774 */
 775 typedef enum {
 776         BLUETOOTH_DEVICE_SERVICE_CLASS_LIMITED_DISCOVERABLE_MODE = 0x002000,
 777         BLUETOOTH_DEVICE_SERVICE_CLASS_POSITIONING = 0x010000,                  /**<  */
 778         BLUETOOTH_DEVICE_SERVICE_CLASS_NETWORKING = 0x020000,                   /**<  */
 779         BLUETOOTH_DEVICE_SERVICE_CLASS_RENDERING = 0x040000,                    /**<  */
 780         BLUETOOTH_DEVICE_SERVICE_CLASS_CAPTURING = 0x080000,                    /**<  */
 781         BLUETOOTH_DEVICE_SERVICE_CLASS_OBJECT_TRANSFER = 0x100000,              /**<  */
 782         BLUETOOTH_DEVICE_SERVICE_CLASS_AUDIO = 0x200000,                        /**<  */
 783         BLUETOOTH_DEVICE_SERVICE_CLASS_TELEPHONY = 0x400000,                    /**<  */
 784         BLUETOOTH_DEVICE_SERVICE_CLASS_INFORMATION = 0x800000,                  /**<  */
 785 } bluetooth_device_service_class_t;
 786
 787
 788 /**
 789  * Major device mask (For device discovery)
 790  */
 791 typedef enum {
 792         BLUETOOTH_DEVICE_MAJOR_MASK_MISC = 0x00,
 793         BLUETOOTH_DEVICE_MAJOR_MASK_COMPUTER = 0x0001,
 794         BLUETOOTH_DEVICE_MAJOR_MASK_PHONE = 0x0002,
 795         BLUETOOTH_DEVICE_MAJOR_MASK_LAN_ACCESS_POINT = 0x0004,
 796         BLUETOOTH_DEVICE_MAJOR_MASK_AUDIO = 0x0008,
 797         BLUETOOTH_DEVICE_MAJOR_MASK_PERIPHERAL = 0x0010,
 798         BLUETOOTH_DEVICE_MAJOR_MASK_IMAGING = 0x0020,
 799         BLUETOOTH_DEVICE_MAJOR_MASK_WEARABLE = 0x0040,
 800         BLUETOOTH_DEVICE_MAJOR_MASK_TOY = 0x0080,
 801         BLUETOOTH_DEVICE_MAJOR_MASK_HEALTH = 0x0100,
 802 } bluetooth_device_major_mask_t;
 803
 804
 805 /**
 806  * Major device class (part of Class of Device)
 807  */
 808 typedef enum {
 809         BLUETOOTH_DEVICE_MAJOR_CLASS_MISC = 0x00,       /**< Miscellaneous major device class*/
 810         BLUETOOTH_DEVICE_MAJOR_CLASS_COMPUTER = 0x01,           /**< Computer major device class*/
 811         BLUETOOTH_DEVICE_MAJOR_CLASS_PHONE = 0x02,              /**< Phone major device class*/
 812         BLUETOOTH_DEVICE_MAJOR_CLASS_LAN_ACCESS_POINT = 0x03,   /**< LAN major device class*/
 813         BLUETOOTH_DEVICE_MAJOR_CLASS_AUDIO = 0x04,              /**< AUDIO major device class*/
 814         BLUETOOTH_DEVICE_MAJOR_CLASS_PERIPHERAL = 0x05,         /**< Peripheral major device class*/
 815         BLUETOOTH_DEVICE_MAJOR_CLASS_IMAGING = 0x06,            /**< Imaging major device class*/
 816         BLUETOOTH_DEVICE_MAJOR_CLASS_WEARABLE = 0x07,           /**< Wearable device class*/
 817         BLUETOOTH_DEVICE_MAJOR_CLASS_TOY = 0x08,                /**< Toy device class*/
 818         BLUETOOTH_DEVICE_MAJOR_CLASS_HEALTH = 0x09,             /**< Health device class*/
 819         BLUETOOTH_DEVICE_MAJOR_CLASS_UNCLASSIFIED = 0x1F        /**< Unknown major device class*/
 820 } bluetooth_device_major_class_t;
 821
 822 typedef enum {
 823         BLUETOOTH_DEVICE_MINOR_CLASS_UNCLASSIFIED = 0x00,       /**< unclassified minor class */
 824
 825         /* About Computer Major class */
 826         BLUETOOTH_DEVICE_MINOR_CLASS_DESKTOP_WORKSTATION = 0x04,        /**< desktop workstation
 827                                                                         minor class */
 828         BLUETOOTH_DEVICE_MINOR_CLASS_SERVER_CLASS_COMPUTER = 0x08,      /**< server minor class */
 829         BLUETOOTH_DEVICE_MINOR_CLASS_LAPTOP = 0x0C,                     /**< laptop minor class */
 830         BLUETOOTH_DEVICE_MINOR_CLASS_HANDHELD_PC_OR_PDA = 0x10,         /**< PDA minor class */
 831         BLUETOOTH_DEVICE_MINOR_CLASS_PALM_SIZED_PC_OR_PDA = 0x14,       /**< PALM minor class */
 832         BLUETOOTH_DEVICE_MINOR_CLASS_WEARABLE_COMPUTER = 0x18,  /**< Wearable PC minor class */
 833
 834         /* About Phone Major class */
 835         BLUETOOTH_DEVICE_MINOR_CLASS_CELLULAR = 0x04,                   /**< Cellular minor class */
 836         BLUETOOTH_DEVICE_MINOR_CLASS_CORDLESS = 0x08,                   /**< cordless minor class */
 837         BLUETOOTH_DEVICE_MINOR_CLASS_SMART_PHONE = 0x0C,        /**< smart phone minor class */
 838         BLUETOOTH_DEVICE_MINOR_CLASS_WIRED_MODEM_OR_VOICE_GATEWAY = 0x10,
 839                                                                 /**< voice gateway minor class */
 840         BLUETOOTH_DEVICE_MINOR_CLASS_COMMON_ISDN_ACCESS = 0x14,         /**< ISDN minor class */
 841
 842         /* About LAN/Network Access Point Major class */
 843         BLUETOOTH_DEVICE_MINOR_CLASS_FULLY_AVAILABLE = 0x04,            /**< Fully available minor class */
 844         BLUETOOTH_DEVICE_MINOR_CLASS_1_TO_17_PERCENT_UTILIZED = 0x20,   /**< 1-17% utilized minor class */
 845         BLUETOOTH_DEVICE_MINOR_CLASS_17_TO_33_PERCENT_UTILIZED = 0x40,  /**< 17-33% utilized minor class */
 846         BLUETOOTH_DEVICE_MINOR_CLASS_33_TO_50_PERCENT_UTILIZED = 0x60,  /**< 33-50% utilized minor class */
 847         BLUETOOTH_DEVICE_MINOR_CLASS_50_to_67_PERCENT_UTILIZED = 0x80,  /**< 50-67% utilized minor class */
 848         BLUETOOTH_DEVICE_MINOR_CLASS_67_TO_83_PERCENT_UTILIZED = 0xA0,  /**< 67-83% utilized minor class */
 849         BLUETOOTH_DEVICE_MINOR_CLASS_83_TO_99_PERCENT_UTILIZED = 0xC0,  /**< 83-99% utilized minor class */
 850         BLUETOOTH_DEVICE_MINOR_CLASS_NO_SERVICE_AVAILABLE = 0xE0,               /**< No service available minor class */
 851
 852         /* About Audio/Video Major class */
 853         BLUETOOTH_DEVICE_MINOR_CLASS_HEADSET_PROFILE = 0x04,            /**< Headset minor class */
 854         BLUETOOTH_DEVICE_MINOR_CLASS_HANDSFREE = 0x08,                  /**< Handsfree minor class*/
 855
 856         BLUETOOTH_DEVICE_MINOR_CLASS_MICROPHONE = 0x10,         /**< Microphone minor class */
 857         BLUETOOTH_DEVICE_MINOR_CLASS_LOUD_SPEAKER = 0x14,       /**< Loud Speaker minor class */
 858         BLUETOOTH_DEVICE_MINOR_CLASS_HEADPHONES = 0x18,         /**< Headphones minor class */
 859         BLUETOOTH_DEVICE_MINOR_CLASS_PORTABLE_AUDIO = 0x1C,     /**< Portable Audio minor class */
 860         BLUETOOTH_DEVICE_MINOR_CLASS_CAR_AUDIO = 0x20,           /**< Car Audio minor class */
 861         BLUETOOTH_DEVICE_MINOR_CLASS_SET_TOP_BOX = 0x24,        /**< Set top box minor class */
 862         BLUETOOTH_DEVICE_MINOR_CLASS_HIFI_AUDIO_DEVICE = 0x28,  /**< Hifi minor class */
 863         BLUETOOTH_DEVICE_MINOR_CLASS_VCR = 0x2C,                /**< VCR minor class */
 864         BLUETOOTH_DEVICE_MINOR_CLASS_VIDEO_CAMERA = 0x30,       /**< Video Camera minor class */
 865         BLUETOOTH_DEVICE_MINOR_CLASS_CAM_CORDER = 0x34,         /**< CAM Corder minor class */
 866         BLUETOOTH_DEVICE_MINOR_CLASS_VIDEO_MONITOR = 0x38,      /**<Video Monitor minor class */
 867         BLUETOOTH_DEVICE_MINOR_CLASS_VIDEO_DISPLAY_AND_LOUD_SPEAKER = 0x3C,
 868                                                                         /**< Video Display and Loud
 869                                                                         Speaker minor class */
 870         BLUETOOTH_DEVICE_MINOR_CLASS_VIDEO_CONFERENCING = 0x40, /**< Video Conferencing minor
 871                                                                 class */
 872
 873         BLUETOOTH_DEVICE_MINOR_CLASS_GAMING_OR_TOY = 0x48,      /**< Gaming or toy minor class */
 874
 875         /* About Peripheral Major class */
 876         BLUETOOTH_DEVICE_MINOR_CLASS_KEY_BOARD = 0x40,          /**< Key board minor class */
 877         BLUETOOTH_DEVICE_MINOR_CLASS_POINTING_DEVICE = 0x80,    /**< Pointing Device minor class */
 878         BLUETOOTH_DEVICE_MINOR_CLASS_COMBO_KEYBOARD_OR_POINTING_DEVICE = 0xC0,
 879                                                                 /**< Combo Keyboard or pointing
 880                                                                 device minorclass */
 881
 882         BLUETOOTH_DEVICE_MINOR_CLASS_JOYSTICK = 0x04,           /**< JoyStick minor class */
 883         BLUETOOTH_DEVICE_MINOR_CLASS_GAME_PAD = 0x08,           /**< Game Pad minor class */
 884         BLUETOOTH_DEVICE_MINOR_CLASS_REMOTE_CONTROL = 0x0C,     /**< Remote Control minor class */
 885         BLUETOOTH_DEVICE_MINOR_CLASS_SENSING_DEVICE = 0x10,     /**< Sensing Device minor class */
 886         BLUETOOTH_DEVICE_MINOR_CLASS_DIGITIZER_TABLET = 0x14,   /**< Digitizer minor class */
 887         BLUETOOTH_DEVICE_MINOR_CLASS_CARD_READER = 0x18,        /**< Card Reader minor class */
 888         BLUETOOTH_DEVICE_MINOR_CLASS_DIGITAL_PEN = 0x1C,        /**< Digital pen minor class */
 889         BLUETOOTH_DEVICE_MINOR_CLASS_HANDHELD_SCANNER = 0x20,   /**< Handheld scanner for bar-codes, RFID minor class */
 890         BLUETOOTH_DEVICE_MINOR_CLASS_HANDHELD_GESTURAL_INPUT_DEVICE = 0x24,     /**< Handheld gestural input device minor class */
 891
 892         /* About Imaging Major class */
 893         BLUETOOTH_DEVICE_MINOR_CLASS_DISPLAY = 0x10,            /**< Display minor class */
 894         BLUETOOTH_DEVICE_MINOR_CLASS_CAMERA = 0x20,             /**< Camera minor class */
 895         BLUETOOTH_DEVICE_MINOR_CLASS_SCANNER = 0x40,            /**< Scanner minor class */
 896         BLUETOOTH_DEVICE_MINOR_CLASS_PRINTER = 0x80,            /**< Printer minor class */
 897
 898         /* About Wearable Major class */
 899         BLUETOOTH_DEVICE_MINOR_CLASS_WRIST_WATCH = 0x04,        /**< Wrist watch minor class */
 900         BLUETOOTH_DEVICE_MINOR_CLASS_PAGER = 0x08,              /**< Pager minor class */
 901         BLUETOOTH_DEVICE_MINOR_CLASS_JACKET = 0x0C,             /**< Jacket minor class */
 902         BLUETOOTH_DEVICE_MINOR_CLASS_HELMET = 0x10,             /**< Helmet minor class */
 903         BLUETOOTH_DEVICE_MINOR_CLASS_GLASSES = 0x14,            /**< Glasses minor class */
 904
 905         /* About Toy Major class */
 906         BLUETOOTH_DEVICE_MINOR_CLASS_ROBOT = 0x04,              /**< Robot minor class */
 907         BLUETOOTH_DEVICE_MINOR_CLASS_VEHICLE = 0x08,            /**< Vehicle minor class */
 908         BLUETOOTH_DEVICE_MINOR_CLASS_DOLL_OR_ACTION = 0x0C,     /**< Doll or Action minor class */
 909         BLUETOOTH_DEVICE_MINOR_CLASS_CONTROLLER = 0x10,         /**< Controller minor class */
 910         BLUETOOTH_DEVICE_MINOR_CLASS_GAME = 0x14,               /**< Game minor class */
 911
 912         /* About Health Major class */
 913         BLUETOOTH_DEVICE_MINOR_CLASS_BLOOD_PRESSURE_MONITOR = 0x04,     /**< Blood Pressure minor class */
 914         BLUETOOTH_DEVICE_MINOR_CLASS_THERMOMETER = 0x08,                /**< Thermometer minor class */
 915         BLUETOOTH_DEVICE_MINOR_CLASS_WEIGHING_SCALE = 0x0C,             /**< Weighing Scale minor class */
 916         BLUETOOTH_DEVICE_MINOR_CLASS_GLUCOSE_METER = 0x10,              /**< Glucose minor class */
 917         BLUETOOTH_DEVICE_MINOR_CLASS_PULSE_OXIMETER = 0x14,             /**< Pulse Oximeter minor class */
 918         BLUETOOTH_DEVICE_MINOR_CLASS_HEART_OR_PULSE_RATE_MONITOR = 0x18,/**< Heart or pulse rate monitor minor class */
 919         BLUETOOTH_DEVICE_MINOR_CLASS_MEDICAL_DATA_DISPLAY = 0x1C,       /**< Medical minor class */
 920         BLUETOOTH_DEVICE_MINOR_CLASS_STEP_COUNTER = 0x20,               /**< Step Counter minor class */
 921         BLUETOOTH_DEVICE_MINOR_CLASS_BODY_COMPOSITION_ANALYZER = 0x24,  /**< Body composition analyzer minor class */
 922         BLUETOOTH_DEVICE_MINOR_CLASS_PEAK_FLOW_MONITOR = 0x28,  /**< Peak flow monitor minor class */
 923         BLUETOOTH_DEVICE_MINOR_CLASS_MEDICATION_MONITOR = 0x2C, /**< Medication monitor minor class */
 924         BLUETOOTH_DEVICE_MINOR_CLASS_KNEE_PROSTHESIS = 0x30,    /**< Knee prosthesis minor class */
 925         BLUETOOTH_DEVICE_MINOR_CLASS_ANKLE_PROSTHESIS = 0x34,   /**< Ankle prosthesis minor class */
 926 } bluetooth_device_minor_class_t;
 927
 928 /**
 929  * structure to hold the device information
 930  */
 931 typedef struct {
 932         bluetooth_device_major_class_t major_class; /**< major device class */
 933         bluetooth_device_minor_class_t minor_class; /**< minor device class */
 934         bluetooth_device_service_class_t service_class;
 935                                                     /**< service device class */
 936 } bluetooth_device_class_t;
 937
 938 /**
 939  * Discovery Role types
 940  */
 941 typedef enum {
 942         DISCOVERY_ROLE_BREDR = 0x1,
 943         DISCOVERY_ROLE_LE,
 944         DISCOVERY_ROLE_LE_BREDR
 945 } bt_discovery_role_type_t;
 946
 947 /**
 948  * Connected state types
 949  */
 950 typedef enum {
 951         BLUETOOTH_CONNECTED_LINK_NONE = 0x00,
 952         BLUETOOTH_CONNECTED_LINK_BREDR = 0x01,
 953         BLUETOOTH_CONNECTED_LINK_LE = 0x02,
 954         BLUETOOTH_CONNECTED_LINK_BREDR_LE = 0x03,
 955 } bluetooth_connected_link_t;
 956
 957 /**
 958 * Scan filter entry
 959 */
 960 typedef enum {
 961         BLUETOOTH_LE_SCAN_FILTER_FEATURE_DEVICE_ADDRESS = 0x01,                 /**< device address */
 962         BLUETOOTH_LE_SCAN_FILTER_FEATURE_SERVICE_UUID = 0x04,                   /**< service uuid */
 963         BLUETOOTH_LE_SCAN_FILTER_FEATURE_SERVICE_SOLICITATION_UUID = 0x08,      /**< service solicitation uuid */
 964         BLUETOOTH_LE_SCAN_FILTER_FEATURE_DEVICE_NAME = 0x10,                    /**< device name */
 965         BLUETOOTH_LE_SCAN_FILTER_FEATURE_MANUFACTURER_DATA = 0x20,              /**< manufacturer data */
 966         BLUETOOTH_LE_SCAN_FILTER_FEATURE_SERVICE_DATA = 0x40,                   /**< service data */
 967 } bluetooth_le_scan_filter_feature_t;
 968
 969 /**
 970  * LE connection mode
 971  */
 972 typedef enum {
 973         BLUETOOTH_LE_CONNECTION_MODE_BALANCED,
 974         BLUETOOTH_LE_CONNECTION_MODE_LOW_LATENCY,
 975         BLUETOOTH_LE_CONNECTION_MODE_LOW_POWER
 976 } bluetooth_le_connection_mode_t;
 977
 978 /**
 979 * structure to hold the device information
 980 */
 981 typedef struct {
 982         bluetooth_device_address_t device_address;      /**< device address */
 983         bluetooth_device_name_t device_name;    /**< device name */
 984         bluetooth_device_class_t device_class;  /**< device class */
 985         char uuids[BLUETOOTH_MAX_SERVICES_FOR_DEVICE][BLUETOOTH_UUID_STRING_MAX];
 986         unsigned int service_list_array[BLUETOOTH_MAX_SERVICES_FOR_DEVICE]; /**< Use enum values in bt_service_uuid_list_t */
 987         int service_index;
 988         int rssi;                               /**< received strength signal*/
 989         gboolean paired;                        /**< paired flag */
 990         bluetooth_connected_link_t connected;   /**< connected link type */
 991         gboolean trust;                         /**< trust flag */
 992         gboolean is_alias_set;          /** is device alias set flag**/
 993         bluetooth_manufacturer_data_t manufacturer_data;        /**< manafacturer specific class */
 994 } bluetooth_device_info_t;
 995
 996 /**
 997 * structure to hold the LE device information
 998 */
 999 typedef struct {
1000         int data_len;           /**< manafacturer specific data length */
1001         bluetooth_advertising_data_t data;              /**< manafacturer specific data */
1002 } bluetooth_le_advertising_data_t;
1003
1004 typedef struct {
1005         bluetooth_device_address_t device_address;      /**< device address */
1006         int addr_type;                  /**< address type*/
1007         int rssi;                       /**< received strength signal*/
1008         bluetooth_le_advertising_data_t adv_ind_data;
1009         bluetooth_le_advertising_data_t scan_resp_data;
1010 } bluetooth_le_device_info_t;
1011
1012 typedef struct {
1013         int slot_id;
1014         bluetooth_le_scan_filter_feature_t added_features;              /**< added features */
1015         bluetooth_device_address_t device_address;                      /**< device address */
1016         char device_name[BLUETOOTH_ADVERTISING_DATA_LENGTH_MAX];        /**< device name */
1017         bluetooth_le_advertising_data_t service_uuid;                   /**< service uuid */
1018         bluetooth_le_advertising_data_t service_uuid_mask;              /**< service uuid mask */
1019         bluetooth_le_advertising_data_t service_solicitation_uuid;      /**< service solicitation uuid */
1020         bluetooth_le_advertising_data_t service_solicitation_uuid_mask; /**< service solicitation uuid mask */
1021         bluetooth_le_advertising_data_t service_data;                   /**< service data */
1022         bluetooth_le_advertising_data_t service_data_mask;              /**< service data mask */
1023         int manufacturer_id;                                            /**< manufacturer ID */
1024         bluetooth_le_advertising_data_t manufacturer_data;              /**< manufacturer data */
1025         bluetooth_le_advertising_data_t manufacturer_data_mask;         /**< manufacturer data mask */
1026 } bluetooth_le_scan_filter_t;
1027
1028 typedef struct {
1029         bluetooth_device_address_t device_address;      /**< device address */
1030         unsigned int mtu;       /** < MTU set for the ATT connection */
1031         unsigned int status; /** < status of the MTU exchange */
1032 } bluetooth_le_att_mtu_info_t;
1033
1034 /**
1035  * structure to hold the paired device information
1036  */
1037 typedef struct {
1038         bluetooth_device_address_t device_address;  /**< paired device address */
1039         bluetooth_device_name_t device_name;        /**< device name */
1040         bluetooth_device_class_t device_class;      /**< device class */
1041 } bluetooth_paired_device_info_t;
1042
1043 /**
1044 * structure to hold the paired device information
1045 */
1046 typedef struct {
1047         bluetooth_device_address_t device_address;
1048                                                /**< device address */
1049         char interface_name[BLUETOOTH_INTERFACE_NAME_LENGTH + 1];
1050                                                           /**< network interface name */
1051 } bluetooth_network_device_info_t;
1052
1053 /**
1054  * Authentication event types
1055  */
1056
1057 typedef enum {
1058         BLUETOOTH_AUTH_KEYBOARD_PASSKEY_REQUEST = 0,
1059         BLUETOOTH_AUTH_PIN_REQUEST,
1060         BLUETOOTH_AUTH_PASSKEY_REQUEST,
1061         BLUETOOTH_AUTH_PASSKEY_CONFIRM_REQUEST,
1062 } bluetooth_auth_type_t;
1063
1064 /**
1065 * structure to hold the pincode/pass-key req informations
1066 */
1067 typedef struct {
1068         bluetooth_device_address_t device_address;  /**< remote device address */
1069         bluetooth_device_name_t device_name;        /**< device name */
1070         char str_passkey[BLUETOOTH_DEVICE_PASSKEY_LENGTH_MAX]; /**< pass-key string */
1071 } bluetooth_authentication_request_info_t;
1072
1073 /**
1074 * Stucture to hold discovery option
1075 */
1076 typedef struct {
1077         unsigned short max_response;    /**< the number of maximum response */
1078         unsigned short discovery_duration;
1079                                         /**< duration of discovery (seconds) */
1080         unsigned int classOfDeviceMask; /**<  mask for values of class of device. to be used with
1081                                         classOfDevice variable */
1082 } bluetooth_discovery_option_t;
1083
1084 /**
1085  * Stucture to hold event information
1086  */
1087 typedef struct {
1088         int event;      /**< event type */
1089         int result;     /**< Success or error value */
1090         void *param_data;
1091                         /**<parameter data pointer */
1092         void *user_data;
1093 } bluetooth_event_param_t;
1094
1095 typedef struct {
1096         bluetooth_device_address_t device_addr;
1097         char uuids[BLUETOOTH_MAX_SERVICES_FOR_DEVICE][BLUETOOTH_UUID_STRING_MAX];
1098         unsigned int service_list_array[BLUETOOTH_MAX_SERVICES_FOR_DEVICE]; /**< Use enum values in bt_service_uuid_list_t */
1099         unsigned int service_name_array[BLUETOOTH_MAX_SERVICES_FOR_DEVICE];
1100         int service_index;
1101 } bt_sdp_info_t;
1102
1103 typedef struct {
1104         bluetooth_device_address_t device_addr;
1105         unsigned char addr_type;
1106         int disc_reason;
1107 } bt_connection_info_t;
1108
1109 /**
1110  * Stucture to rfcomm receive data
1111  */
1112
1113 typedef struct {
1114         int socket_fd;
1115                 /**< the socket fd */
1116         int buffer_size;/**< the length of the receive buffer */
1117         char *buffer;
1118                 /**< the receive data buffer */
1119 } bluetooth_rfcomm_received_data_t;
1120
1121 /**
1122  * HID Header type
1123  */
1124 typedef enum {
1125         HTYPE_TRANS_HANDSHAKE,
1126         HTYPE_TRANS_HID_CONTROL,
1127         HTYPE_TRANS_GET_REPORT,
1128         HTYPE_TRANS_SET_REPORT,
1129         HTYPE_TRANS_GET_PROTOCOL,
1130         HTYPE_TRANS_SET_PROTOCOL,
1131         HTYPE_TRANS_DATA,
1132         HTYPE_TRANS_UNKNOWN
1133 } bt_hid_header_type_t;
1134
1135 /**
1136  * HID Param type
1137  */
1138 typedef enum {
1139         PTYPE_DATA_RTYPE_INPUT,
1140         PTYPE_DATA_RTYPE_OUTPUT
1141 } bt_hid_param_type_t;
1142
1143 /**
1144  * Stucture to hid receive data
1145  */
1146 typedef struct {
1147         const char *address;
1148         bt_hid_header_type_t type;
1149                 /**< Header type containing */
1150         bt_hid_param_type_t param;
1151                 /**< Param type in header like INPUT Report or OutPut Report */
1152         int buffer_size;/**< the length of the receive buffer */
1153         char *buffer;
1154                 /**< the receive data buffer */
1155 } bluetooth_hid_received_data_t;
1156
1157 /**
1158 * Stucture to rfcomm connection
1159 */
1160
1161 typedef struct {
1162         int socket_fd; /**< the socket fd */
1163         int server_id; /* Server id */
1164         int device_role; /** < Device role - RFCOMM_ROLE_SERVER or RFCOMM_ROLE_CLIENT */
1165         bluetooth_device_address_t device_addr;
1166                                               /**< device address */
1167         char uuid[BLUETOOTH_UUID_STRING_MAX];
1168 } bluetooth_rfcomm_connection_t;
1169
1170 /**
1171  * Stucture to rfcomm disconnection
1172  */
1173 typedef struct {
1174         int socket_fd;
1175                 /**< the socket fd */
1176         int device_role;/** < Device role - RFCOMM_ROLE_SERVER or RFCOMM_ROLE_CLIENT */
1177         bluetooth_device_address_t device_addr;
1178                                               /**< device address */
1179         char uuid[BLUETOOTH_UUID_STRING_MAX];
1180 } bluetooth_rfcomm_disconnection_t;
1181
1182 typedef struct {
1183         int socket_fd;
1184                 /**< the socket fd */
1185         bluetooth_device_address_t device_addr;
1186                                               /**< device address */
1187 } bluetooth_rfcomm_connection_request_t;
1188
1189 typedef struct {
1190         int socket_fd;
1191                 /**< the socket fd */
1192         bluetooth_device_address_t device_addr;
1193                                               /**< device address */
1194 } bluetooth_hid_request_t;
1195
1196 /**
1197  * HDP QOS types
1198  */
1199 typedef enum {
1200         HDP_QOS_RELIABLE,
1201         HDP_QOS_STREAMING,
1202         HDP_QOS_ANY
1203 } bt_hdp_qos_type_t;
1204
1205 /**
1206  * HDP Role types
1207  */
1208 typedef enum {
1209         HDP_ROLE_SOURCE = 0x0,
1210         HDP_ROLE_SINK
1211 } bt_hdp_role_type_t;
1212
1213
1214 /**
1215  * Stucture to HDP connected
1216  */
1217 typedef struct {
1218         const char *app_handle; /**< the application handle */
1219         unsigned int channel_id;        /**< the channel id */
1220         bt_hdp_qos_type_t type; /**< the QOS type */
1221         bluetooth_device_address_t device_address; /**< the remote address */
1222 } bt_hdp_connected_t;
1223
1224 /**
1225  * Stucture to HDP disconnected
1226  */
1227 typedef struct {
1228         unsigned int channel_id; /**< the channel id */
1229         bluetooth_device_address_t device_address; /**< the remote address */
1230 } bt_hdp_disconnected_t;
1231
1232 /**
1233  * Stucture to HDP data indication
1234  */
1235 typedef struct {
1236         unsigned int channel_id;         /**< the channel id */
1237         const char *buffer;      /**< the RX data buffer */
1238         unsigned int size;       /**< the RX data size */
1239 } bt_hdp_data_ind_t;
1240
1241 /**
1242  * Stucture to OPP client transfer information
1243  */
1244 typedef struct {
1245         char *device_addr;
1246         char *filename;
1247         unsigned long size;
1248         int percentage;
1249 } bt_opc_transfer_info_t;
1250
1251 /* Obex Server transfer type */
1252 #define TRANSFER_PUT "PUT"
1253 #define TRANSFER_GET "GET"
1254 /**
1255  * Stucture to OPP/FTP Server authorize information
1256  */
1257 typedef struct {
1258         char *filename;
1259         int length;
1260         char *address;
1261         char *name;
1262 } bt_obex_server_authorize_into_t;
1263
1264 /**
1265  * Server type
1266  */
1267 typedef enum {
1268         OPP_SERVER = 0x0,
1269         FTP_SERVER
1270 } bt_obex_server_type_t;
1271
1272 /**
1273  * Stucture to OPP/FTP server transfer information
1274  */
1275 typedef struct {
1276         char *filename;
1277         char *device_name;
1278         char *file_path;
1279         char *type;
1280         int transfer_id;
1281         unsigned long file_size;
1282         int percentage;
1283         bt_obex_server_type_t server_type;
1284         char *address;
1285         unsigned char *contact_auth_info;
1286 } bt_obex_server_transfer_info_t;
1287
1288 /**
1289  * Stucture to OPP/FTP server connection/disconnection information
1290  */
1291 typedef struct {
1292         char *address;
1293         char *device_name;
1294         int transfer_id;
1295 } bt_obex_server_connection_info_t;
1296
1297
1298 /**
1299  * Stucture to OOB data
1300  */
1301
1302 typedef struct {
1303         unsigned char hash[BLUETOOTH_OOB_DATA_LENGTH];
1304         unsigned char randomizer[BLUETOOTH_OOB_DATA_LENGTH];
1305         unsigned int hash_len;
1306         unsigned int randomizer_len;
1307
1308         unsigned char hash256[BLUETOOTH_OOB_DATA_LENGTH];
1309         unsigned char randomizer256[BLUETOOTH_OOB_DATA_LENGTH];
1310         unsigned int hash256_len;
1311         unsigned int randomizer256_len;
1312 } bt_oob_data_t;
1313
1314 /**
1315  * Structure to GATT attribute handle data
1316  */
1317
1318 typedef struct {
1319         int count;
1320         char **handle;
1321 } bt_gatt_handle_info_t;
1322
1323 /**
1324  * Structure to GATT Remote service data
1325  */
1326
1327 typedef struct {
1328         char *uuid;
1329         char *handle;
1330         gboolean primary;
1331         bt_gatt_handle_info_t include_handles;
1332         bt_gatt_handle_info_t char_handle;
1333 } bt_gatt_service_property_t;
1334
1335 /**
1336  * Structure to GATT Remote characteristic data
1337  */
1338
1339 typedef struct {
1340         char *service_handle;
1341         bt_gatt_handle_info_t handle_info;
1342 } bt_gatt_discovered_char_t;
1343
1344 /**
1345  * Structure to format of GATT Characteristic Value
1346  */
1347
1348 typedef struct {
1349         unsigned char format;
1350         unsigned char exponent;
1351         unsigned short unit;
1352         unsigned char name_space;
1353         unsigned short description;
1354 } bt_gatt_char_format_t;
1355
1356 /**
1357  * Structure to GATT Characteristic property
1358  */
1359
1360 typedef struct {
1361         char *handle;
1362         char *uuid;
1363         char *name;
1364         char *description;
1365         bt_gatt_char_format_t format;
1366         unsigned char *val;
1367         unsigned int val_len;
1368         unsigned int permission;
1369         char *representation;
1370         bt_gatt_handle_info_t char_desc_handle;
1371 } bt_gatt_char_property_t;
1372
1373 /**
1374  * Structure to GATT Characteristic descriptor property
1375  */
1376
1377 typedef struct {
1378         char *handle;
1379         char *uuid;
1380         unsigned char *val;
1381         unsigned int val_len;
1382 } bt_gatt_char_descriptor_property_t;
1383
1384 /**
1385  * Structure to GATT Characteristic value
1386  */
1387
1388 typedef struct {
1389         char *char_handle;
1390         guint8 *char_value;
1391         guint32 val_len;
1392 } bt_gatt_char_value_t;
1393
1394 /**
1395  * Structure to GATT Read Request
1396  */
1397 typedef struct {
1398         char *att_handle;
1399         char *service_handle;
1400         char *address;
1401         guint16 offset;
1402         guint8 req_id;
1403 } bt_gatt_read_req_t;
1404
1405 /**
1406  * Structure to GATT Value change
1407  */
1408 typedef struct {
1409         char *att_handle;
1410         char *service_handle;
1411         char *address;
1412         guint8 req_id;
1413         guint16 offset;
1414         guint8 *att_value;
1415         guint32 val_len;
1416 } bt_gatt_value_change_t;
1417
1418 typedef struct {
1419         bluetooth_device_address_t device_addr;
1420         char *svc_path;
1421         bluetooth_gatt_service_change_type_t change_type;
1422 } bt_gatt_service_change_t;
1423
1424 /**
1425  * Structure to GATT characteristc Notification change
1426  */
1427 typedef struct {
1428         char *att_handle;
1429         char *service_handle;
1430         gboolean att_notify;
1431 } bt_gatt_char_notify_change_t;
1432
1433 /**
1434  * Structure to Indication confirmation
1435  */
1436 typedef struct {
1437         char *att_handle;
1438         char *service_handle;
1439         char *address;
1440         gboolean complete;
1441 } bt_gatt_indicate_confirm_t;
1442
1443 /**
1444  * Structure to RSSI Signal Strength Alert
1445  */
1446
1447 typedef struct {
1448         char *address;
1449         int link_type;
1450         int alert_type;
1451         int rssi_dbm;
1452 } bt_rssi_alert_t;
1453
1454 /**
1455  * Structure to RSSI Signal Strength
1456  */
1457
1458 typedef struct {
1459         char *address;
1460         int link_type;
1461         int rssi_dbm;
1462 } bt_raw_rssi_t;
1463
1464 /**
1465  * Structure for RSSI Enabled or Disabled
1466  */
1467
1468 typedef struct {
1469         char *address;
1470         int link_type;
1471         gboolean rssi_enabled;
1472 } bt_rssi_enabled_t;
1473
1474 /**
1475  * Structure for RSSI Threshold
1476  */
1477
1478 typedef struct {
1479         int low_threshold;
1480         int in_range_threshold;
1481         int high_threshold;
1482 } bt_rssi_threshold_t;
1483
1484
1485 /**
1486  * Structure for Suppoted Profiles and Trusted Profiles
1487  */
1488 typedef struct {
1489         char *address;
1490         int profile;
1491         gboolean supported;
1492         gboolean trusted;
1493 } bt_supported_profile_trusted_t;
1494
1495 /**
1496  * Structure for PBAP Folder Parameters
1497  */
1498 typedef struct {
1499         unsigned char addressbook;
1500         unsigned char folder_type;
1501 } bt_pbap_folder_t;
1502
1503 /**
1504  * Structure for PBAP Pull application Parameters
1505  */
1506 typedef struct {
1507         unsigned char format;
1508         unsigned char order;
1509         unsigned short offset;
1510         unsigned short maxlist;
1511         long long unsigned fields;
1512 } bt_pbap_pull_parameters_t;
1513
1514 /**
1515  * Structure for PBAP List application Parameters
1516  */
1517 typedef struct {
1518         unsigned char order;
1519         unsigned short offset;
1520         unsigned short maxlist;
1521 } bt_pbap_list_parameters_t;
1522
1523 /**
1524  * Structure for PBAP Pull vCard application Parameters
1525  */
1526 typedef struct {
1527         unsigned char format;
1528         long long unsigned fields;
1529         int index;
1530 } bt_pbap_pull_vcard_parameters_t;
1531
1532 /**
1533  * Structure for PBAP Search application Parameters
1534  */
1535 typedef struct {
1536         unsigned char order;
1537         unsigned short offset;
1538         unsigned short maxlist;
1539         unsigned char search_attribute;
1540         char search_value[BLUETOOTH_PBAP_MAX_SEARCH_VALUE_LENGTH];
1541 } bt_pbap_search_parameters_t;
1542
1543 /**
1544  * Structure for PBAP Connection Status
1545  */
1546 typedef struct {
1547         bluetooth_device_address_t btaddr;
1548         int connected;
1549 } bt_pbap_connected_t;
1550
1551 /**
1552  * Structure for PBAP Phonebook Size
1553  */
1554 typedef struct {
1555         bluetooth_device_address_t btaddr;
1556         int size;
1557 } bt_pbap_phonebook_size_t;
1558
1559 /**
1560  * Structure for PBAP Phonebook Pull
1561  */
1562 typedef struct {
1563         bluetooth_device_address_t btaddr;
1564         char *vcf_file;
1565         int success;
1566 } bt_pbap_phonebook_pull_t;
1567
1568 /**
1569  * Structure for PBAP vCard List
1570  */
1571 typedef struct {
1572         bluetooth_device_address_t btaddr;
1573         char **vcards;
1574         int length;
1575         int success;
1576 } bt_pbap_vcard_list_t;
1577
1578 /**
1579  * Structure for PBAP vCard Pull
1580  */
1581 typedef struct {
1582         bluetooth_device_address_t btaddr;
1583         char *vcf_file;
1584         int success;
1585 } bt_pbap_vcard_pull_t;
1586
1587 /**
1588  * Structure for PBAP Phonebook search List
1589  */
1590 typedef struct {
1591         bluetooth_device_address_t btaddr;
1592         char **vcards;
1593         int length;
1594         int success;
1595 } bt_pbap_phonebook_search_list_t;
1596
1597 /**
1598  * Stucture to HF Call status information
1599  */
1600
1601 typedef struct {
1602         char *number; /*Phone Number */
1603         int direction; /*Direction :Incoming(1), Outgoing(0)*/
1604         int status; /* Call Status :Active(0), Held(1), Waiting(5), Dailing(2)*/
1605         int mpart; /*Multiparty/conf call: Yes(1), No(0) */
1606         int idx; /*Call index/ID */
1607 } bt_hf_call_status_info_t;
1608
1609 typedef struct {
1610         GList *list;
1611         int count;
1612 } bt_hf_call_list_s;
1613
1614 /**
1615  * Profile types
1616  */
1617 typedef enum {
1618         TRUSTED_PROFILE_PBAP = 1,
1619         TRUSTED_PROFILE_MAP,
1620         TRUSTED_PROFILE_SAP,
1621         TRUSTED_PROFILE_ALL = 0xFFFFFFFF,
1622 } bluetooth_trusted_profile_t;
1623
1624 /**
1625  * Restricted Profile types
1626  */
1627 typedef enum {
1628         RESTRICTED_PROFILE_HFP_HS = 1,
1629         RESTRICTED_PROFILE_A2DP,
1630 } bluetooth_restricted_profile_t;
1631
1632 /**
1633  * Structure for LE data length change params
1634  */
1635 typedef struct {
1636         bluetooth_device_address_t device_address;
1637         guint16 max_tx_octets;
1638         guint16 max_tx_time;
1639         guint16 max_rx_octets;
1640         guint16 max_rx_time;
1641 } bt_le_data_length_params_t;
1642
1643 /**
1644  * Structure for proximity property change params
1645  */
1646 typedef struct {
1647         bluetooth_device_address_t device_address;
1648         int role;
1649         int service_type;
1650         int alert_lvl;
1651 } bt_pxp_property_changed_params_t;
1652
1653  /**
1654  * @brief DPM BT allowance state
1655  * @see
1656  */
1657 typedef enum {
1658         BLUETOOTH_DPM_ERROR      = -1,   /**< bluetooth allowance error */
1659         BLUETOOTH_DPM_BT_ALLOWED,                /**< bluetooth allowance allowed */
1660         BLUETOOTH_DPM_HANDSFREE_ONLY,  /**< bluetooth allowance handsfree only */
1661         BLUETOOTH_DPM_BT_RESTRICTED,  /**< bluetooth allowance restricted */
1662 } bt_dpm_allow_t;
1663
1664  /**
1665  * @brief DPM API result
1666  * @see
1667  */
1668 typedef enum {
1669         BLUETOOTH_DPM_RESULT_SERVICE_NOT_ENABLED = -5,  /**< DPM API result service not enabled. */
1670         BLUETOOTH_DPM_RESULT_ACCESS_DENIED = -4,                        /**< DPM API result access denied. */
1671         BLUETOOTH_DPM_RESULT_INVALID_PARAM = -3,                        /**< DPM API result invalid parameter. */
1672         BLUETOOTH_DPM_RESULT_NOT_SUPPORTED = -2,                        /**< DPM API result not supported. */
1673         BLUETOOTH_DPM_RESULT_FAIL        = -1,                          /**< DPM API result fail. */
1674         BLUETOOTH_DPM_RESULT_SUCCESS     = 0,                           /**< DPM API result success. */
1675 } bt_dpm_result_t;
1676
1677 /**
1678  * @brief DPM Policy status
1679  * @see
1680  */
1681 typedef enum {
1682         BLUETOOTH_DPM_STATUS_ERROR      = -1,
1683
1684         BLUETOOTH_DPM_ALLOWED           = 0,    /**< DPM Policy status allowed. */
1685         BLUETOOTH_DPM_RESTRICTED                = 1,    /**< DPM Policy status restricted. */
1686
1687         BLUETOOTH_DPM_ENABLE                    = 1,    /**< DPM Policy status enabled. */
1688         BLUETOOTH_DPM_DISABLE   = 0,    /**< DPM Policy status disabled. */
1689
1690         BLUETOOTH_DPM_FALSE                     = 0,    /**< DPM Policy status false. */
1691         BLUETOOTH_DPM_TRUE                      = 1,    /**< DPM Policy status true. */
1692 } bt_dpm_status_t;
1693
1694 typedef enum {
1695         /* policy-group : BLUETOOTH */
1696         BLUETOOTH_DPM_POLICY_ALLOW,
1697         BLUETOOTH_DPM_POLICY_DEVICE_RESTRICTION,
1698         BLUETOOTH_DPM_POLICY_UUID_RESTRICTION,
1699         BLUETOOTH_DPM_POLICY_DEVICES_WHITELIST,
1700         BLUETOOTH_DPM_POLICY_DEVICES_BLACKLIST,
1701         BLUETOOTH_DPM_POLICY_UUIDS_WHITELIST,
1702         BLUETOOTH_DPM_POLICY_UUIDS_BLACKLIST,
1703         BLUETOOTH_DPM_POLICY_ALLOW_OUTGOING_CALL,
1704         BLUETOOTH_DPM_POLICY_PAIRING_STATE,
1705         BLUETOOTH_DPM_POLICY_DESKTOP_CONNECTIVITY_STATE,
1706         BLUETOOTH_DPM_POLICY_DISCOVERABLE_STATE,
1707         BLUETOOTH_DPM_POLICY_LIMITED_DISCOVERABLE_STATE,
1708         BLUETOOTH_DPM_POLICY_DATA_TRANSFER_STATE,
1709         BLUETOOTH_DPM_POLICY_END,
1710 } bt_dpm_policy_cmd_t;
1711
1712
1713 struct bt_dpm_policy {
1714         union {
1715                 int value;
1716                 GSList *list;
1717         };
1718 };
1719 typedef struct bt_dpm_policy bt_dpm_policy_t;
1720
1721 typedef enum {
1722         BLUETOOTH_DPM_POLICY_A2DP_PROFILE_STATE,
1723         BLUETOOTH_DPM_POLICY_AVRCP_PROFILE_STATE,
1724         BLUETOOTH_DPM_POLICY_BPP_PROFILE_STATE,
1725         BLUETOOTH_DPM_POLICY_DUN_PROFILE_STATE,
1726         BLUETOOTH_DPM_POLICY_FTP_PROFILE_STATE,
1727         BLUETOOTH_DPM_POLICY_HFP_PROFILE_STATE,
1728         BLUETOOTH_DPM_POLICY_HSP_PROFILE_STATE,
1729         BLUETOOTH_DPM_POLICY_PBAP_PROFILE_STATE,
1730         BLUETOOTH_DPM_POLICY_SAP_PROFILE_STATE,
1731         BLUETOOTH_DPM_POLICY_SPP_PROFILE_STATE,
1732         BLUETOOTH_DPM_PROFILE_NONE,
1733 } bt_dpm_profile_t;
1734
1735 struct bt_dpm_profile_val {
1736                 int value; /* tells whether the profile is enabled or disabled */
1737 };
1738 typedef struct dpm_profile_val dpm_profile_state_t;
1739
1740 /**
1741  * Structure to DPM device list
1742  */
1743 typedef struct {
1744         int count;
1745         bluetooth_device_address_t addresses[BLUETOOTH_MAX_DPM_LIST];
1746 } bt_dpm_device_list_t;
1747
1748 /**
1749  * Structure to DPM uuid list
1750  */
1751 typedef struct {
1752         int count;
1753         char uuids[BLUETOOTH_MAX_DPM_LIST][BLUETOOTH_UUID_STRING_MAX];
1754 } bt_dpm_uuids_list_t;
1755
1756 /**
1757  * Structure for IPSP Interface Info
1758  */
1759 typedef struct {
1760         bluetooth_device_address_t btaddr;
1761         char if_name[16];
1762 } bt_ipsp_connection_info_t;
1763
1764 /**
1765  * Callback pointer type
1766  */
1767 typedef void (*bluetooth_cb_func_ptr) (int, bluetooth_event_param_t *, void *);
1768
1769 /**
1770  * @fn int bluetooth_register_callback(bluetooth_cb_func_ptr callback_ptr, void *user_data)
1771  * @brief Set the callback function pointer for bluetooth event
1772  *
1773  *
1774  * This API will register the callback function, when any response and event are received from
1775  * bluetooth framework. @n
1776  * this registered callback function will be get called with appropriate event and data structures.
1777  * This function is a synchronous call. An application developer can call
1778  * bluetooth_register_callback() function to register a callback function of bluetooth_cb_func_ptr
1779  * type. This registered function will receive events of bluetooth_event_type_t type along with
1780  * data any.
1781  *
1782  *
1783  * @param[in]   callback_ptr    A pointer to the callback function
1784  * @param[in]   user_data    A pointer to user data
1785  * @return      BLUETOOTH_ERROR_NONE - Success
1786  * @remark      None
1787  * @see         None
1788 @code
1789 void bt_event_callback(int event, bluetooth_event_param_t *param, void *user_data)
1790 {
1791         GMainLoop *main_loop = (GMainLoop*) user_data;
1792
1793         switch(event)
1794         {
1795                 // Code for each event
1796                 default:
1797                         g_main_loop_quit(main_loop);
1798                         break;
1799         }
1800 }
1801
1802 int main()
1803 {
1804         GMainLoop *main_loop = NULL;
1805         int ret = 0;
1806         g_type_init();
1807         main_loop = g_main_loop_new(NULL, FALSE);
1808         ret = bluetooth_register_callback(bt_event_callback, (void*)main_loop);
1809         if (ret >= BLUETOOTH_ERROR_NONE)
1810         {
1811                 // bluetooth_register_callback returned Success
1812         }
1813         else
1814         {
1815                 // bluetooth_register_callback returned failiure
1816         }
1817         g_main_loop_run(main_loop);
1818 }
1819 @endcode
1820  */
1821 int bluetooth_register_callback(bluetooth_cb_func_ptr callback_ptr, void *user_data);
1822
1823 /**
1824  * @fn int bluetooth_le_register_callback(bluetooth_cb_func_ptr callback_ptr, void *user_data)
1825  * @brief Set the callback function pointer for bluetooth le event
1826  *
1827  *
1828  * This API will register the callback function, when any response and event are received from
1829  * bluetooth framework. @n
1830  * this registered callback function will be get called with appropriate event and data structures.
1831  * This function is a synchronous call. An application developer can call
1832  * bluetooth_le_register_callback() function to register a callback function of bluetooth_cb_func_ptr
1833  * type. This registered function will receive events of bluetooth_event_type_t type along with
1834  * data any.
1835  *
1836  *
1837  * @param[in]   callback_ptr    A pointer to the callback function
1838  * @param[in]   user_data    A pointer to user data
1839  * @return      BLUETOOTH_ERROR_NONE - Success
1840  * @remark      None
1841  * @see         None
1842  * */
1843 int bluetooth_le_register_callback(bluetooth_cb_func_ptr callback_ptr, void *user_data);
1844
1845 /**
1846  * @fn int bluetooth_le_unregister_callback(void)
1847  * @brief Set the callback function pointer for bluetooth le event
1848  *
1849  *
1850  * This API will register the callback function, when any response and event are received from
1851  * bluetooth framework. @n
1852  * this registered callback function will be get called with appropriate event and data structures.
1853  * This function is a synchronous call. An application developer can call
1854  * bluetooth_le_register_callback() function to register a callback function of bluetooth_cb_func_ptr
1855  * type. This registered function will receive events of bluetooth_event_type_t type along with
1856  * data any.
1857  *
1858  *
1859  * @param[in]   none
1860  * @return      BLUETOOTH_ERROR_NONE - Success
1861  * @remark      None
1862  * @see         None
1863  * */
1864 int bluetooth_le_unregister_callback(void);
1865
1866 /**
1867  * @fn int bluetooth_deregister_callback(bluetooth_cb_func_ptr callback_ptr)
1868  * @brief Set the callback function pointer for bluetooth event
1869  *
1870  *
1871  * This API will register the callback function, when any response and event are received from
1872  * bluetooth framework. @n
1873  * this registered callback function will be get called with appropriate event and data structures.
1874  * This function is a synchronous call. An application developer can call
1875  * bluetooth_register_callback() function to register a callback function of bluetooth_cb_func_ptr
1876  * type. This registered function will receive events of bluetooth_event_type_t type along with
1877  * data any.
1878  *
1879  *
1880  * @param[in]   none
1881  * @return      BLUETOOTH_ERROR_NONE - Success
1882  * @remark      None
1883  * @see         None
1884 @code
1885 void bt_event_callback(int event, bluetooth_event_param_t *param, void *user_data)
1886 {
1887         GMainLoop *main_loop = (GMainLoop*) user_data;
1888
1889         switch(event)
1890         {
1891                 // Code for each event
1892                 default:
1893                         g_main_loop_quit(main_loop);
1894                         break;
1895         }
1896 }
1897
1898 int main()
1899 {
1900         GMainLoop *main_loop = NULL;
1901         int ret = 0;
1902         g_type_init();
1903         main_loop = g_main_loop_new(NULL, FALSE);
1904         ret = bluetooth_register_callback(bt_event_callback, (void*)main_loop);
1905         if (ret >= BLUETOOTH_ERROR_NONE)
1906         {
1907                 // bluetooth_register_callback returned Success
1908         }
1909         else
1910         {
1911                 // bluetooth_register_callback returned failiure
1912         }
1913         ret = bluetooth_deregister_callback(void);
1914         g_main_loop_run(main_loop);
1915 }
1916 @endcode
1917  */
1918 int bluetooth_unregister_callback(void);
1919
1920 /**
1921  * @fn int bluetooth_enable_adapter(void)
1922  * @brief Enable the Bluetooth H/W
1923  *
1924  *
1925  * This API can be used to activate Bluetooth. It initializes Bluetooth protocol stack for use and
1926  * send request to bluetooth chip for activation.
1927  * This function is typically called at startup or when Bluetooth services are required.  This
1928  * function must be called before calling any other API of Bluetooth operations.
1929  *
1930  * Before performing any operations like Device discover, service search etc.., the adapter must be
1931  * enabled.
1932  *
1933  * This function is a asynchronous call.
1934  * If the call is success then the application will receive BLUETOOTH_EVENT_ENABLED event
1935  * through registered callback function with appropriate result code
1936  *                      BLUETOOTH_CHANGE_STATUS_TIMEOUT - Timeout has happen \n
1937  *                      BLUETOOTH_ERROR_NONE - Success \n
1938  *
1939  * If the adpter is not enabled with in 30 seconds then BLUETOOTH_EVENT_ENABLED with result code
1940  * BLUETOOTH_CHANGE_STATUS_TIMEOUT will come
1941  *
1942  * @return      BLUETOOTH_ERROR_NONE - Success\n
1943  *              BLUETOOTH_ERROR_DEVICE_ALREADY_ENABLED - Adapter already enabled\n
1944  *              BLUETOOTH_ERROR_ACCESS_DENIED - Enabling adapter is not allowed by MDM policy\n
1945  *              BLUETOOTH_ERROR_IN_PROGRESS - Adapter is activating or deactivating\n
1946  * @exception   BLUETOOTH_ERROR_INTERNAL - Dbus proxy call is fail
1947  * @remark      None
1948  * @see         bluetooth_check_adapter, bluetooth_disable_adapter
1949 @code
1950 void bt_event_callback(int event, bluetooth_event_param_t *param)
1951 {
1952         switch(event)
1953         {
1954                 case BLUETOOTH_EVENT_ENABLED:
1955                         if (param->result == BLUETOOTH_ERROR_NONE)
1956                         {
1957                                 // Successfully Enabled
1958                         }
1959                         else
1960                         {
1961                                 // Failed
1962                         }
1963                         break;
1964         }
1965 }
1966
1967 ...
1968
1969 int ret = 0;
1970 ret = bluetooth_enable_adapter();
1971
1972 @endcode
1973  */
1974 int bluetooth_enable_adapter(void);
1975
1976 /**
1977  * @fn int bluetooth_disable_adapter(void)
1978  * @brief Disable the Bluetooth H/W
1979  *
1980  *
1981  * This function disables Bluetooth protocol stack and hardware. This function is called when
1982  * Bluetooth is no longer used. It will internally free all resources and power off the RF radio.
1983  *
1984  * Bluetooth adapter should be disabled to switch off Bluetooth chip (and thereby saving power).
1985  * bluetooth_disable_adapter() API will do that job for you. After switching off Bluetooth,
1986  * BLUETOOTH_EVENT_DISABLED will be sent by SDK to application for confirmation with appropriate
1987  * error code.
1988  * The various error codes are BLUETOOTH_ERROR_NONE for success and BLUETOOTH_ERROR_INTERNAL for
1989  * internal error.
1990  *
1991  * This function is a asynchronous call.
1992  * If this call is success then the applications will receive BLUETOOTH_EVENT_DISABLED event
1993  * through registered callback function.
1994  *
1995  *
1996  * @return      BLUETOOTH_ERROR_NONE - Success\n
1997  *              BLUETOOTH_ERROR_IN_PROGRESS - Adapter is activating or deactivating\n
1998  *              BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Bluetooth adapter is not enabled\n
1999  * @exception   BLUETOOTH_ERROR_INTERNAL - Dbus proxy call is fail
2000  * @remark      None
2001  * @see         bluetooth_check_adapter, bluetooth_enable_adapter
2002 @code
2003 void bt_event_callback(int event, bluetooth_event_param_t *param)
2004 {
2005         switch(event)
2006         {
2007                 case BLUETOOTH_EVENT_DISABLED:
2008                         if (param->result == BLUETOOTH_ERROR_NONE)
2009                         {
2010                                 // Successfully disabled
2011                         }
2012                         else
2013                         {
2014                                 // Failed
2015                         }
2016                         break;
2017         }
2018 }
2019
2020 ...
2021
2022 int ret = 0;
2023 ret = bluetooth_disable_adapter();
2024 @endcode
2025  */
2026 int bluetooth_disable_adapter(void);
2027 int bluetooth_recover_adapter(void);
2028 int bluetooth_check_adapter_le(void);
2029 int bluetooth_enable_adapter_le(void);
2030
2031 int bluetooth_disable_adapter_le(void);
2032
2033 /**
2034  * @fn int bluetooth_reset_adapter(void)
2035  * @brief Reset the Bluetooth H/W and values
2036  *
2037  *
2038  * This function resets Bluetooth protocol stack and hardware. This function is called when
2039  * an user want to initialize Bluetooth environment.
2040  *
2041  * The various error codes are BLUETOOTH_ERROR_NONE for success and BLUETOOTH_ERROR_INTERNAL for
2042  * internal error.
2043  *
2044  * This function is a synchronous call.
2045  *
2046  * @return      BLUETOOTH_ERROR_NONE - Success\n
2047  * @exception   BLUETOOTH_ERROR_INTERNAL - Dbus proxy call is fail
2048  * @remark      None
2049  * @see         bluetooth_check_adapter, bluetooth_enable_adapter
2050 @code
2051 ...
2052
2053 int ret = 0;
2054 ret = bluetooth_reset_adapter();
2055 @endcode
2056  */
2057 int bluetooth_reset_adapter(void);
2058
2059 /**
2060  * @fn int bluetooth_is_supported(void)
2061  * @brief Check if the bluetooth is supported or not by the current target
2062  *
2063  * This API checks whether the bluetooth is supported or not.
2064  * This API only run by root permission.
2065  *
2066  * This function is a synchronous call.
2067  *
2068  * @return      0 - if bluetooth is not supported\n
2069  *              1 - if bluetooth is supported\n
2070  *              BLUETOOTH_ERROR_INTERNAL - Error in API internal
2071  * @remark      None
2072 @code
2073
2074 int ret = 0;
2075 ret = bluetooth_is_supported();
2076 @endcode
2077  */
2078 int bluetooth_is_supported(void);
2079
2080
2081 /**
2082  * @fn int bluetooth_check_adapter(void)
2083  * @brief Check the current status of the Bluetooth adapter
2084  *
2085  *
2086  * This API checks whether the Bluetooth adapter is enabled or not. Before performing any operations
2087  * the bluetooth adapter should be enabled. This API helps to find out the current state of the
2088  * bluetooth adapter.
2089  * This API get the adapter internal data structure and check current adapter status.
2090  *
2091  * This function is a synchronous call.
2092  *
2093  *
2094  * @return      BLUETOOTH_ADAPTER_DISABLED - if bluetooth adapter is disabled\n
2095  *              BLUETOOTH_ADAPTER_ENABLED - if bluetooth adapter is enabled\n
2096  * @remark      None
2097  * @see         bluetooth_enable_adapter, bluetooth_disable_adapter
2098 @code
2099
2100 int ret = 0;
2101 ret = bluetooth_check_adapter();
2102 @endcode
2103  */
2104 int bluetooth_check_adapter(void);
2105
2106 /**
2107  * @fn int bluetooth_get_local_address(bluetooth_device_address_t *local_address)
2108  * @brief Get the local adapter bluetooth address
2109  *
2110  *
2111  * This API is used, get the device address of the local bluetooth adapter. Before calling this API,
2112  * the adapter should be enabled.
2113  * In its output parameter, you can receive bluetooth_device_address_t type of pointer which will
2114  * contain Bluetooth address.
2115  * Since its inconvenient for user to remember the address, Bluetooth provides a method to have a
2116  * friendly name for each device.
2117  * There is no event callback for this API.
2118  *
2119  * This function is a synchronous call.
2120  *
2121  *
2122  * @return      BLUETOOTH_ERROR_NONE - Succeess \n
2123  *              BLUETOOTH_ERROR_INVALID_PARAM -  Invalid parameter (NULL buffer) \n
2124  *              BLUETOOTH_ERROR_DEVICE_NOT_ENABLED -  Adapter is disabled \n
2125  * @param[out]  local_address   a device address of local bluetooth adapter
2126  * @remark      None
2127  * @see         None
2128 @code
2129
2130 bluetooth_device_address_t local_address={0,};
2131 int ret = 0;
2132
2133 ret = bluetooth_get_local_address(&local_address);
2134 @endcode
2135  */
2136 int bluetooth_get_local_address(bluetooth_device_address_t *local_address);
2137
2138 /**
2139  * @fn int bluetooth_get_local_version(bluetooth_version_t *version)
2140  * @brief Get the hci version
2141  *
2142  *
2143  * This function is used to get the bluetooth hci version
2144  * Before calling this API make sure that the adapter is enabled.
2145  *
2146  * This function is a synchronous call.
2147  *
2148  *
2149  * @return      BLUETOOTH_ERROR_NONE - Success \n
2150  *              BLUETOOTH_ERROR_INTERNAL - Internal IPC error \n
2151  * @param[out]  timeout   remain visibility timeout value
2152  * @remark      None
2153  @code
2154 bluetooth_version_t *version;
2155  int ret = 0;
2156  ret = bluetooth_get_local_version (&version);
2157  @endcode
2158  */
2159 int bluetooth_get_local_version(bluetooth_version_t *version);
2160
2161 /**
2162  * @fn int bluetooth_get_local_name(bluetooth_device_name_t* local_name)
2163  * @brief Get the local device name
2164  *
2165  *
2166  * This function is used, get the local device name. Since its difficult to remember the Adapter
2167  * address, the friendly name can be assigned to the adapter and we can get it using this API. This
2168  * friendly name is retrived by the remote device and displaying.
2169  * Before calling this API, the adapter should be enabled. There is no event callback for this API.
2170  *
2171  * This function is a synchronous call.
2172  *
2173  *
2174  * @return      BLUETOOTH_ERROR_NONE - Success \n
2175  *              BLUETOOTH_ERROR_INVALID_PARAM - Invalid parameter (NULL buffer)\n
2176  * @param[out]  local_name      a local device name
2177  * @remark      None
2178  * @see         None
2179 @code
2180 bluetooth_device_name_t local_name={0,}
2181 int ret = 0;
2182 ret = bluetooth_get_local_name (&local_name);
2183 @endcode
2184  */
2185 int bluetooth_get_local_name(bluetooth_device_name_t *local_name);
2186
2187 /**
2188  * @fn int bluetooth_set_local_name(const bluetooth_device_name_t *local_name)
2189  * @brief Set the local device name
2190  *
2191  *
2192  * This function is used to set the local device name. This is a human friendly name whose
2193  * length can be BLUETOOTH_DEVICE_NAME_LENGTH_MAX maximum
2194  *
2195  * This function is a synchronous call.
2196  *
2197  * @param[in]   local_name   bluetooth device name to set local device
2198  *
2199  * @return      BLUETOOTH_ERROR_NONE - Success \n
2200  *              BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is not enabled \n
2201  *              BLUETOOTH_ERROR_INVALID_PARAM - Bluetooth name parameter is incorrect \n
2202  *              BLUETOOTH_ERROR_INVALID_DATA - Device address provided is incorrect \n
2203  *              BLUETOOTH_ERROR_NO_RESOURCES - Pre-allocated memory error \n
2204  *              BLUETOOTH_ERROR_INTERNAL - The dbus method call is fail \n
2205  *
2206  * @remark      None
2207
2208 @code
2209 bluetooth_device_name_t local_name={0,}
2210 int ret = 0;
2211 ret = bluetooth_set_local_name (&local_name);
2212 @endcode
2213  */
2214 int bluetooth_set_local_name(const bluetooth_device_name_t *local_name);
2215
2216
2217 /**
2218  * @fn int bluetooth_is_service_used(const char *service_uuid, gboolean *used)
2219  * @brief Check if the uuid is used or not
2220  *
2221  * This function is used to check if the uuid is used or not.
2222  *
2223  * This function is a synchronous call.
2224  *
2225  * @param[in]   service_uuid   service uuid (UUID 128 bit as string)
2226  * @param[out] used  if the uuid is used or not
2227  *
2228  * @return      BLUETOOTH_ERROR_NONE - Success \n
2229  *              BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is not enabled \n
2230  *              BLUETOOTH_ERROR_INVALID_PARAM - Bluetooth name parameter is incorrect \n
2231  *              BLUETOOTH_ERROR_INTERNAL - The dbus method call is fail \n
2232  *
2233  * @remark      None
2234  *
2235 @code
2236 gboolean used = FALSE;
2237 const char *uuid ="00001101-0000-1000-8000-00805F9B34FB";
2238 ret = bluetooth_is_service_used(uuid, &used);
2239 @endcode
2240  */
2241 int bluetooth_is_service_used(const char *service_uuid, gboolean *used);
2242
2243 /**
2244  * @fn int bluetooth_is_device_connected(const bluetooth_device_address_t *device_address, bluetooth_service_type_t type, gboolean *is_connected)
2245  * @brief Check if the device is connected to the specific service
2246  *
2247  * This function is used to check if if the device is connected to the specific service.
2248  *
2249  * This function is a synchronous call.
2250  *
2251  * @param[in]   local_address   a device address of remote bluetooth device
2252  * @param[in]   type the service type
2253  * @param[out] is_connected  if the device is connected or not
2254  *
2255  * @return      BLUETOOTH_ERROR_NONE - Success \n
2256  *              BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is not enabled \n
2257  *              BLUETOOTH_ERROR_INVALID_PARAM - Bluetooth name parameter is incorrect \n
2258  *              BLUETOOTH_ERROR_INTERNAL - The dbus method call is fail \n
2259  *
2260  * @remark      None
2261  *
2262 @code
2263 gboolean is_connected = FALSE;
2264 bluetooth_device_address_t device_address={{0x00,0x0D,0xFD,0x24,0x5E,0xFF}};
2265 ret = bluetooth_is_device_connected(&device_address, BLUETOOTH_HSP_SERVICE, &used);
2266 @endcode
2267  */
2268 int bluetooth_is_device_connected(const bluetooth_device_address_t *device_address,
2269                                 bluetooth_service_type_t type,
2270                                 gboolean *is_connected);
2271
2272 /**
2273  * @fn int bluetooth_get_connected_link_type(const bluetooth_device_address_t *device_address, bluetooth_connected_link_t *connected_link)
2274  * @brief Gets device's connected link type
2275  *
2276  * This function is used to get device's connected link type
2277  *
2278  * This function is a synchronous call.
2279  *
2280  * @param[in]   device_address  a device address of remote bluetooth device
2281  * @param[out]  connected_link  a device's connected link type
2282  *
2283  * @return      BLUETOOTH_ERROR_NONE - Success \n
2284  *              BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is not enabled \n
2285  *              BLUETOOTH_ERROR_INVALID_PARAM - Bluetooth name parameter is incorrect \n
2286  *              BLUETOOTH_ERROR_INTERNAL - The dbus method call is fail \n
2287  *
2288  * @remark      None
2289  *
2290 @code
2291 bluetooth_connected_link_t *connected_link = BLUETOOTH_CONNECTED_LINK_NONE;
2292 bluetooth_device_address_t device_address={{0x00,0x0D,0xFD,0x24,0x5E,0xFF}};
2293 ret = bluetooth_get_connected_link(&device_address, &connected_link);
2294 @endcode
2295  */
2296 int bluetooth_get_connected_link_type(const bluetooth_device_address_t *device_address,
2297                                 bluetooth_connected_link_t *connected_link);
2298
2299 /**
2300  * @fn int bluetooth_set_profile_trusted(const bluetooth_device_address_t *device_address, int profile, int trust)
2301  * @brief Sets a profile trusted for a device
2302  *
2303  * This function is used to Set a profile as trusted for a device
2304  *
2305  * This function is a synchronous call.
2306  *
2307  * @param[in]   device_address  a device address of remote bluetooth device
2308  * @param[in]   profile profile which is to be set as trusted[0-PBAP, 1-MAP, 2-SAP]
2309  * @param[in]   trust   to set as trusted or untrusted[1-trusted 0-untrusted]
2310  *
2311  * @return      BLUETOOTH_ERROR_NONE - Success \n
2312  *              BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is not enabled \n
2313  *              BLUETOOTH_ERROR_INVALID_PARAM - Bluetooth name parameter is incorrect \n
2314  *              BLUETOOTH_ERROR_INTERNAL - The dbus method call is fail \n
2315  *
2316  * @remark      None
2317  */
2318 int bluetooth_set_profile_trusted(
2319                 const bluetooth_device_address_t *device_address,
2320                 int profile, int trust);
2321
2322 /**
2323  * @fn int bluetooth_get_profile_trusted(const bluetooth_device_address_t *device_address, int profile, int *trust)
2324  * @brief Gets a profile is trusted for a device
2325  *
2326  * This function is used to Get a profile is trusted or not for a device
2327  *
2328  * This function is a synchronous call.
2329  *
2330  * @param[in]   device_address  a device address of remote bluetooth device
2331  * @param[in]   profile profile whose trust status is needed[0-PBAP, 1-MAP, 2-SAP]
2332  * @param[out]  trust   profile is set as trusted or untrusted[1-trusted 0-untrusted]
2333  *
2334  * @return      BLUETOOTH_ERROR_NONE - Success \n
2335  *              BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is not enabled \n
2336  *              BLUETOOTH_ERROR_INVALID_PARAM - Bluetooth name parameter is incorrect \n
2337  *              BLUETOOTH_ERROR_INTERNAL - The dbus method call is fail \n
2338  *
2339  * @remark      None
2340  */
2341 int bluetooth_get_profile_trusted(
2342                 const bluetooth_device_address_t *device_address,
2343                 int profile, int *trust);
2344
2345 /**
2346  * @fn int bluetooth_set_profile_restricted(const bluetooth_device_address_t *device_address, int profile, int restricted)
2347  * @brief Sets a profile restricted connection for a device
2348  *
2349  * This function is used to Set a profile as restricted for a device
2350  *
2351  * This function is a synchronous call.
2352  *
2353  * @param[in]   device_address  a device address of remote bluetooth device
2354  * @param[in]   profile profile which is to be set as restricted[1-HFP_HS, 2-A2DP]
2355  * @param[in]   restricted      to set as restricted or not[1-restricted 0-permitted]
2356  *
2357  * @return      BLUETOOTH_ERROR_NONE - Success \n
2358  *              BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is not enabled \n
2359  *              BLUETOOTH_ERROR_INVALID_PARAM - Bluetooth name parameter is incorrect \n
2360  *              BLUETOOTH_ERROR_INTERNAL - The dbus method call is fail \n
2361  *
2362  * @remark      None
2363  */
2364 int bluetooth_set_profile_restricted(
2365                 const bluetooth_device_address_t *device_address,
2366                 int profile, int restricted);
2367
2368 /**
2369  * @fn int bluetooth_get_profile_restricted(const bluetooth_device_address_t *device_address, int profile, int *restricted)
2370  * @brief Gets a restricted connection state
2371  *
2372  * This function is used to Get a profile is restricted or not for a device
2373  *
2374  * This function is a synchronous call.
2375  *
2376  * @param[in]   device_address  a device address of remote bluetooth device
2377  * @param[in]   profile profile whose restricted status is needed[1-HFP_HS, 2-A2DP]
2378  * @param[out]  restricted      profile is set as restricted or not[1-restricted 0-permitted]
2379  *
2380  * @return      BLUETOOTH_ERROR_NONE - Success \n
2381  *              BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is not enabled \n
2382  *              BLUETOOTH_ERROR_INVALID_PARAM - Bluetooth name parameter is incorrect \n
2383  *              BLUETOOTH_ERROR_INTERNAL - The dbus method call is fail \n
2384  *
2385  * @remark      None
2386  */
2387 int bluetooth_get_profile_restricted(
2388                 const bluetooth_device_address_t *device_address,
2389                 int profile, int *restricted);
2390
2391 /**
2392  * @fn int bluetooth_get_discoverable_mode(bluetooth_discoverable_mode_t *discoverable_mode_ptr)
2393  * @brief Get the visibility mode
2394  *
2395  *
2396  * This function is used to get the discoverable mode (Visibility option). Depending upon the
2397  * visibity mode, the property of the device is determined whether it can be discoverable, non
2398  * discoverable, connectable etc. Before calling this API make sure that the adapter is enabled.
2399  *
2400  * This function is a synchronous call.
2401  *
2402  *
2403  * @return      BLUETOOTH_ERROR_NONE - Success \n
2404  *              BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is not enabled \n
2405  *              BLUETOOTH_ERROR_INVALID_DATA - Invalid data \n
2406  *              BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is not enabled \n
2407  *              BLUETOOTH_ERROR_INTERNAL - Internal IPC error \n
2408  * @param[out]  discoverable_mode   current bluetooth discoverable mode
2409  * @remark      None
2410  * @see         bluetooth_set_discoverable_mode
2411  @code
2412  bluetooth_discoverable_mode_t discoverable_mode_ptr;
2413  int ret = 0;
2414  ret = bluetooth_get_discoverable_mode (&discoverable_mode_ptr);
2415  @endcode
2416  */
2417 int bluetooth_get_discoverable_mode(bluetooth_discoverable_mode_t *discoverable_mode_ptr);
2418
2419 /**
2420  * @fn int bluetooth_set_discoverable_mode(bluetooth_discoverable_mode_t discoverable_mode,
2421  *                                              int timeout)
2422  * @brief Set the visibility mode
2423  *
2424  *
2425  * This function is used to set the discoverable mode (Visibility option).
2426  *
2427  * Many times user may want to keep his device discoverable so that when peer device is performing
2428  * device search, he/she can find user's device. Application programmer can keep the mode as
2429  * BLUETOOTH_DISCOVERABLE_MODE_GENERAL_DISCOVERABLE or
2430  * BLUETOOTH_DISCOVERABLE_MODE_TIME_LIMITED_DISCOVERABLE for the same purpose. However, all these
2431  * modes cause bluetooth adapter to consume more battery. Hence developer should generally
2432  * keep discoverable mode as BLUETOOTH_DISCOVERABLE_MODE_CONNECTABLE.
2433  *
2434  * This function is a synchronous call.
2435  *
2436  * @return      BLUETOOTH_ERROR_NONE - Success \n
2437  *              BLUETOOTH_ERROR_NOT_SUPPORT - Requested mode is not supported \n
2438  *
2439  * @param[in]  discoverable_mode   the bluetooth discoverable mode to set
2440  * @param[in]  timeout   discoverable time in only limited discoverable mode (second), default: 0
2441  * @remark      None
2442  * @see         bluetooth_get_discoverable_mode
2443
2444 @code
2445
2446 bluetooth_discoverable_mode_t mode;
2447 int ret = 0;
2448 mode= BLUETOOTH_DISCOVERABLE_MODE_TIME_LIMITED_DISCOVERABLE;
2449 ret = bluetooth_set_discoverable_mode (mode, 180);
2450
2451 @endcode
2452  */
2453 int bluetooth_set_discoverable_mode(bluetooth_discoverable_mode_t discoverable_mode,
2454                                             int timeout);
2455
2456
2457 /**
2458  * @fn int bluetooth_get_timeout_value(int *timeout)
2459  * @brief Get the visibility timeout value
2460  *
2461  *
2462  * This function is used to get the visibility timeout
2463  * Before calling this API make sure that the adapter is enabled.
2464  *
2465  * This function is a synchronous call.
2466  *
2467  *
2468  * @return      BLUETOOTH_ERROR_NONE - Success \n
2469  *              BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is not enabled \n
2470  *              BLUETOOTH_ERROR_INVALID_DATA - Invalid data \n
2471  *              BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is not enabled \n
2472  *              BLUETOOTH_ERROR_INTERNAL - Internal IPC error \n
2473  * @param[out]  timeout   remain visibility timeout value
2474  * @remark      None
2475  * @see         bluetooth_set_discoverable_mode
2476  @code
2477  int timeout;
2478  int ret = 0;
2479  ret = bluetooth_get_timeout_value (&timeout);
2480  @endcode
2481  */
2482 int bluetooth_get_timeout_value(int *timeout);
2483
2484
2485 /**
2486  * @fn int bluetooth_start_discovery(unsigned short max_response, unsigned short discovery_duration,
2487  *                                      unsigned int  classOfDeviceMask)
2488  * @brief Start the generic device discovery which finds both the BR/EDR and LE devices.
2489  *
2490  * To connect connect to peer bluetooth device, you will need to know its bluetooth address and its
2491  * name. You can search for Bluetooth devices in vicinity by bluetooth_start_discovery() API. It
2492  * first performs an inquiry and try to find both the BREDR and LE devices. For each device found
2493  * from the inquiry it gets the remote name of the device. Bluetooth device address and name are
2494  * given to Application via BLUETOOTH_EVENT_REMOTE_DEVICE_FOUND event. In param_data of
2495  * bluetooth_event_param_t, you will receive a pointer to a structure of bluetooth_device_info_t type.
2496  * You will receive device address, device name, device class, rssi (received signal strength indicator).
2497  * please see bluetooth_device_info_t for more details.
2498  *
2499  *
2500  * This API provides searching options like max responses, discovery duration in seconds and class
2501  * of device mask to filter device search. some times there may be too many bluetooth devices in
2502  * vicinity of your device.in such scenario, application can request to reduce number of responces
2503  * (BLUETOOTH_EVENT_REMOTE_DEVICE_FOUND event) with help of max_response parameter. However if you
2504  * pass zero, bluetooth adapter will not restrict number of responses. you can also specify duration
2505  * of the seach in discovery_duration. bluetooth adapter will automatically stop device search after
2506  * application defined time. please note that discovery_duration should be mentioned in seconds.
2507  * Also note that search will end after 180 seconds automatically if you pass 0 in discovery
2508  * duration.
2509  *
2510  * Sometimes user may want to search for a particular kind of device. for ex, mobile or pc. in such
2511  * case, you can use classOfDeviceMask parameter. please see bluetooth_device_service_class_t,
2512  * bluetooth_device_major_class_t and bluetooth_device_minor_class_t enums
2513  *
2514  * This function is a asynchronous call.
2515  * If the call is success then the application will receive BLUETOOTH_EVENT_DISCOVERY_STARTED event
2516  * through registered callback function.
2517  *
2518  * The discovery is responded by an BLUETOOTH_EVENT_REMOTE_DEVICE_FOUND event for each device it
2519  * found and a BLUETOOTH_EVENT_REMOTE_DEVICE_NAME_UPDATED event for its name updation.
2520  *
2521  * The completion or cancellation of the discovery is indicated by an
2522  * BLUETOOTH_EVENT_DISCOVERY_FINISHED event.
2523  *
2524  * The device discovery can be cancelled by calling bluetooth_stop_discovery().
2525  *
2526  *
2527  * @return      BLUETOOTH_ERROR_NONE - Success \n
2528  *              BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Bluetooth adapter is not enabled \n
2529  *              BLUETOOTH_ERROR_DEVICE_BUSY - Bluetooth adapter is busy doing some operation \n
2530  *              BLUETOOTH_ERROR_INTERNAL - System error like heap full has occured or bluetooth
2531                                                 agent is not running \n
2532  *
2533  * @param[in] max_response              define the maximum response of the number of founded devices
2534                                         (0 means unlimited)
2535  * @param[in] discovery_duration        define bluetooth discovery duration (0 means 180s )
2536  * @param[in] classOfDeviceMask         define classes of the device mask which user wants
2537                                         (refer to class of device)
2538  * @remark      None
2539  * @see         bluetooth_start_custom_discovery(), bluetooth_cancel_discovery, bluetooth_device_info_t
2540
2541 @code
2542 void bt_event_callback(int event, bluetooth_event_param_t *param)
2543 {
2544         switch(event)
2545         {
2546                 case BLUETOOTH_EVENT_REMOTE_DEVICE_FOUND:
2547                 {
2548                         bluetooth_device_info_t *device_info = NULL;
2549                         printf("BLUETOOTH_EVENT_REMOTE_DEVICE_FOUND, result [0x%04x]",
2550                                         param->result);
2551                         device_info  = (bluetooth_device_info_t *)param->param_data;
2552                         memcpy(&searched_device, &device_info->device_address,
2553                                                 sizeof(bluetooth_device_address_t));
2554                         printf("dev [%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X]",
2555                                 device_info->device_address.addr[0],
2556                                 device_info->device_address.addr[1],
2557                                 device_info->device_address.addr[2],
2558                                 device_info->device_address.addr[3],
2559                                 device_info->device_address.addr[4],
2560                                 device_info->device_address.addr[5]);
2561                         break;
2562                 }
2563                 case BLUETOOTH_EVENT_REMOTE_DEVICE_NAME_UPDATED:
2564                 {
2565                         bluetooth_device_info_t *device_info = NULL;
2566                         printf("BLUETOOTH_EVENT_REMOTE_DEVICE_NAME_UPDATED, result [0x%04x]",
2567                                                                                 param->result);
2568                         device_info  = (bluetooth_device_info_t *)param->param_data;
2569                         memcpy(&searched_device, &device_info->device_address,
2570                                                                 sizeof(bluetooth_device_address_t));
2571                         printf("dev [%s] [%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X]",
2572                                                         device_info->device_name.name,
2573                                                         device_info->device_address.addr[0],
2574                                                         device_info->device_address.addr[1],
2575                                                         device_info->device_address.addr[2],
2576                                                         device_info->device_address.addr[3],
2577                                                         device_info->device_address.addr[4],
2578                                                         device_info->device_address.addr[5]);
2579                         break;
2580                 }
2581
2582                 case BLUETOOTH_EVENT_DISCOVERY_FINISHED:
2583                         printf("BLUETOOTH_EVENT_DISCOVERY_FINISHED, result[0x%04x]", param->result);
2584                         break;
2585         }
2586 }
2587
2588 unsigned short max_response;
2589 unsigned short discovery_duration;
2590 unsigned classOfDeviceMask;
2591 int ret = 0;
2592
2593 max_response =0;
2594 discovery_duration =0;
2595 classOfDeviceMask =0;
2596
2597 ret = bluetooth_start_discovery(max_response,discovery_duration,classOfDeviceMask);
2598
2599 @endcode
2600  *
2601  */
2602 int bluetooth_start_discovery(unsigned short max_response,
2603                                       unsigned short discovery_duration,
2604                                       unsigned int classOfDeviceMask);
2605
2606 /**
2607  * @fn int bluetooth_start_custom_discovery(bt_discovery_role_type_t role
2608  *                                      unsigned short max_response,
2609  *                                      unsigned short discovery_duration,
2610  *                                      unsigned int  classOfDeviceMask)
2611  * @brief Start the custom device discovery with specific type such as BR/EDR, LE, LE+BR/EDR etc.
2612  *
2613  * Sometimes user may want to search for a particular kind of device. for ex, LE only or BR/EDR only.
2614  * In such case, you can use type parameter. This API is similar to that of bluetooth_start_discovery().
2615  * Please see bluetooth_start_discovery() for other parameters description.
2616  *
2617  * This function is a asynchronous call.
2618  * If the call is success then the application will receive BLUETOOTH_EVENT_DISCOVERY_STARTED event
2619  * through registered callback function.
2620  *
2621  * The discovery is responded by an BLUETOOTH_EVENT_REMOTE_DEVICE_FOUND event for each device it
2622  * found and a BLUETOOTH_EVENT_REMOTE_DEVICE_NAME_UPDATED event for its name updation.
2623  *
2624  * The completion or cancellation of the discovery is indicated by an
2625  * BLUETOOTH_EVENT_DISCOVERY_FINISHED event.
2626  *
2627  * The device discovery can be cancelled by calling bluetooth_stop_discovery().
2628  *
2629  *
2630  * @return      BLUETOOTH_ERROR_NONE - Success \n
2631  *              BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Bluetooth adapter is not enabled \n
2632  *              BLUETOOTH_ERROR_INVALID_PARAM - Invalid parameter \n
2633  *              BLUETOOTH_ERROR_IN_PROGRESS - Bluetooth adapter is busy with another discovery \n
2634  *              BLUETOOTH_ERROR_INTERNAL - System error like heap full has occured or bluetooth
2635                                                 agent is not running \n
2636  *
2637  * @param[in] role              define the role type of devices to be discovered. See enum bt_discovery_role_type_t.
2638                                         (DISCOVERY_ROLE_BREDR means BREDR only, DISCOVERY_ROLE_LE mean Low Energy only,
2639                                         DISCOVERY_ROLE_LE_BREDR means LE & BREDR - same as bluetooth_start_discovery())
2640  * @param[in] max_response              define the maximum response of the number of founded devices
2641                                         (0 means unlimited)
2642  * @param[in] discovery_duration        define bluetooth discovery duration (0 means 180s )
2643  * @param[in] classOfDeviceMask         define classes of the device mask which user wants
2644                                         (refer to class of device)
2645  * @remark      None
2646  * @see         bluetooth_start_discovery(), bluetooth_cancel_discovery, bluetooth_device_info_t
2647
2648 @code
2649 unsigned short type;
2650 unsigned short max_response;
2651 unsigned short discovery_duration;
2652 unsigned classOfDeviceMask;
2653 int ret = 0;
2654
2655 type = 1;
2656 max_response =0;
2657 discovery_duration =0;
2658 classOfDeviceMask =0;
2659
2660 ret = bluetooth_start_custom_discovery(type, max_response, discovery_duration, classOfDeviceMask);
2661
2662 @endcode
2663  *
2664  */
2665 int bluetooth_start_custom_discovery(bt_discovery_role_type_t role,
2666                                                 unsigned short max_response,
2667                                                 unsigned short discovery_duration,
2668                                                 unsigned int classOfDeviceMask);
2669
2670 /**
2671  * @fn int bluetooth_cancel_discovery (void)
2672  * @brief Cancel the on-going device discovery operation
2673  *
2674  *
2675  * This function stops the on-going device discovery operation. This API has to be called after the
2676  * bluetooth_start_discovery API and before the BLUETOOTH_EVENT_DISCOVERY_FINISHED event comes of
2677  * the bluetooth_start_discovery API
2678  *
2679  * Normally the device discovery takes a more time (~10.24 seconds) to get all the devices in its
2680  * vicinity and it recevies as BLUETOOTH_EVENT_REMOTE_DEVICE_FOUND event. This API helps us to
2681  * cancel the discover request once the user received the device to which he wish to connect.
2682  *
2683  * This function is a asynchronous call.
2684  * If the call is success to cancel discovey then the application will receive
2685  * BLUETOOTH_EVENT_DISCOVERY_FINISHED event through registered callback function
2686  * with an error code BLUETOOTH_ERROR_CANCEL. In the case of failure the error code will be
2687  * BLUETOOTH_ERROR_NONE
2688  *
2689  *
2690  * @return      BLUETOOTH_ERROR_NONE - Success \n
2691  *              BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is not enabled \n
2692  *              BLUETOOTH_ERROR_NOT_IN_OPERATION - No Discovery operation in progess to cancel \n
2693  *              BLUETOOTH_ERROR_ACCESS_DENIED - Currently in discovery but it is requested from
2694                                                 other application \n
2695  *              BLUETOOTH_ERROR_INTERNAL - Internel IPC error \n
2696  * @remark      None
2697  * @see         bluetooth_start_discovery
2698 @code
2699 void bt_event_callback(int event, bluetooth_event_param_t *param)
2700 {
2701         switch(event)
2702         {
2703                 case BLUETOOTH_EVENT_DISCOVERY_FINISHED:
2704                         TC_PRT("BLUETOOTH_EVENT_DISCOVERY_FINISHED, result[0x%04x]", param->result);
2705                         break;
2706         }
2707 }
2708
2709 ..
2710
2711 int ret = 0;
2712
2713 ret = bluetooth_cancel_discovery();
2714 @endcode
2715  */
2716 int bluetooth_cancel_discovery(void);
2717
2718 /**
2719  * @fn int bluetooth_start_le_discovery(void)
2720  * @brief Start the generic device discovery which finds the LE devices.
2721  *
2722  * To connect connect to peer bluetooth device, you will need to know its bluetooth address and its
2723  * name. You can search for Bluetooth devices in vicinity by bluetooth_start_le_discovery() API.
2724  * It try to find LE devices. Bluetooth device address and name are
2725  * given to Application via BLUETOOTH_EVENT_REMOTE_LE_DEVICE_FOUND event. In param_data of
2726  * bluetooth_event_param_t, you will receive a pointer to a structure of bluetooth_device_info_t type.
2727  * You will receive device address, device name, device class, rssi (received signal strength indicator).
2728  * please see bluetooth_device_info_t for more details.
2729  *
2730  * This function is a asynchronous call.
2731  * If the call is success then the application will receive BLUETOOTH_EVENT_LE_DISCOVERY_STARTED event
2732  * through registered callback function.
2733  *
2734  * The discovery is responded by an BLUETOOTH_EVENT_REMOTE_LE_DEVICE_FOUND event for each device it
2735  * found.
2736  *
2737  * The completion or cancellation of the discovery is indicated by an
2738  * BLUETOOTH_EVENT_LE_DISCOVERY_FINISHED event.
2739  *
2740  * The device discovery can be cancelled by calling bluetooth_stop_le_discovery().
2741  *
2742  *
2743  * @return      BLUETOOTH_ERROR_NONE - Success \n
2744  *              BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Bluetooth adapter is not enabled \n
2745  *              BLUETOOTH_ERROR_DEVICE_BUSY - Bluetooth adapter is busy doing some operation \n
2746  *              BLUETOOTH_ERROR_INTERNAL - System error like heap full has occured or bluetooth
2747                                                 agent is not running \n
2748  *
2749  * @remark      None
2750  * @see         bluetooth_stop_le_discovery, bluetooth_device_info_t
2751
2752 @code
2753 void bt_event_callback(int event, bluetooth_event_param_t *param)
2754 {
2755         switch(event)
2756         {
2757                 case BLUETOOTH_EVENT_REMOTE_LE_DEVICE_FOUND:
2758                 {
2759                         bluetooth_device_info_t *device_info = NULL;
2760                         printf("BLUETOOTH_EVENT_REMOTE_DEVICE_FOUND, result [0x%04x]",
2761                                         param->result);
2762                         device_info  = (bluetooth_device_info_t *)param->param_data;
2763                         memcpy(&searched_device, &device_info->device_address,
2764                                                 sizeof(bluetooth_device_address_t));
2765                         printf("dev [%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X]",
2766                                 device_info->device_address.addr[0],
2767                                 device_info->device_address.addr[1],
2768                                 device_info->device_address.addr[2],
2769                                 device_info->device_address.addr[3],
2770                                 device_info->device_address.addr[4],
2771                                 device_info->device_address.addr[5]);
2772                         break;
2773                 }
2774
2775                 case BLUETOOTH_EVENT_LE_DISCOVERY_FINISHED:
2776                         printf("BLUETOOTH_EVENT_LE_DISCOVERY_FINISHED, result[0x%04x]", param->result);
2777                         break;
2778         }
2779 }
2780
2781 int ret = 0;
2782 ret = bluetooth_start_discovery();
2783
2784 @endcode
2785  *
2786  */
2787 int bluetooth_start_le_discovery(void);
2788
2789 /**
2790  * @fn int bluetooth_stop_le_discovery (void)
2791  * @brief Cancel the on-going device LE discovery operation
2792  *
2793  *
2794  * This function stops the on-going device discovery operation. This API has to be called after the
2795  * bluetooth_start_le_discovery API and before the BLUETOOTH_EVENT_LE_DISCOVERY_FINISHED event comes of
2796  * the bluetooth_start_le_discovery API
2797  *
2798  *
2799  * This function is a asynchronous call.
2800  * If the call is success to cancel discovey then the application will receive
2801  * BLUETOOTH_EVENT_LE_DISCOVERY_FINISHED event through registered callback function
2802  * with an error code BLUETOOTH_ERROR_CANCEL. In the case of failure the error code will be
2803  * BLUETOOTH_ERROR_NONE
2804  *
2805  *
2806  * @return      BLUETOOTH_ERROR_NONE - Success \n
2807  *              BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is not enabled \n
2808  *              BLUETOOTH_ERROR_NOT_IN_OPERATION - No Discovery operation in progess to cancel \n
2809  *              BLUETOOTH_ERROR_ACCESS_DENIED - Currently in discovery but it is requested from
2810                                                 other application \n
2811  *              BLUETOOTH_ERROR_INTERNAL - Internel IPC error \n
2812  * @remark      None
2813  * @see         bluetooth_start_discovery
2814 @code
2815 void bt_event_callback(int event, bluetooth_event_param_t *param)
2816 {
2817         switch(event)
2818         {
2819                 case BLUETOOTH_EVENT_LE_DISCOVERY_FINISHED:
2820                         TC_PRT("BLUETOOTH_EVENT_LE_DISCOVERY_FINISHED, result[0x%04x]", param->result);
2821                         break;
2822         }
2823 }
2824
2825 ..
2826
2827 int ret = 0;
2828
2829 ret = bluetooth_stop_le_discovery();
2830 @endcode
2831  */
2832 int bluetooth_stop_le_discovery(void);
2833
2834 /**
2835  * @fn int bluetooth_is_discovering(void)
2836  * @brief Check for the device discovery is in-progress or not.
2837  *
2838  * This API is used to check the current status of the Discovery operation.If discovery is in\
2839  * progress normally other operations are not allowed.
2840  * If a device discovery is in progress, we have to either cancel the discovery operation or wait
2841  * for the BLUETOOTH_EVENT_DISCOVERY_FINISHED
2842  * event before performing other operations. This API is used to get for the current discovery
2843  * operation status and using bluetooth_cancel_discovery()
2844  * we can cancell the ongoing discovery process.
2845  * Before calling this API, make sure that the adapter is enabled. There is no callback event for
2846  * this API.
2847  *
2848  * This function checks whether the device discovery is started or not.
2849  *
2850  * This function is a synchronous call.
2851  *
2852  *
2853  * @return      BLUETOOTH_ERROR_NONE - Discovery is not in progress \n
2854  *              BLUETOOTH_ERROR_NONE+1 - Discovery in progress \n
2855  *              BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is not enabled \n
2856  *
2857  * @remark      None
2858  * @see         bluetooth_start_discovery, bluetooth_cancel_discovery
2859
2860 @code
2861 int ret = 0;
2862 ret = bluetooth_is_discovering ();
2863 @endcode
2864  */
2865 int bluetooth_is_discovering(void);
2866
2867 /**
2868  * @fn int bluetooth_is_le_discovering(void)
2869  * @brief Check for the device LE discovery is in-progress or not.
2870  *
2871  * This API is used to check the current status of the LE Discovery operation.If discovery is in\
2872  * progress normally other operations are not allowed.
2873  * If a device discovery is in progress, we have to either cancel the discovery operation or wait
2874  * for the BLUETOOTH_EVENT_LE_DISCOVERY_FINISHED
2875  * event before performing other operations. This API is used to get for the current discovery
2876  * operation status and using bluetooth_stop_le_discovery()
2877  * we can cancell the ongoing LE discovery process.
2878  * Before calling this API, make sure that the adapter is enabled. There is no callback event for
2879  * this API.
2880  *
2881  * This function checks whether the device  LE discovery is started or not.
2882  *
2883  * This function is a synchronous call.
2884  *
2885  *
2886  * @return      BLUETOOTH_ERROR_NONE - Discovery is not in progress \n
2887  *              BLUETOOTH_ERROR_NONE+1 - Discovery in progress \n
2888  *              BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is not enabled \n
2889  *
2890  * @remark      None
2891  * @see         bluetooth_start_le_discovery, bluetooth_stop_le_discovery
2892
2893 @code
2894 int ret = 0;
2895 ret = bluetooth_is_le_discovering ();
2896 @endcode
2897  */
2898 int bluetooth_is_le_discovering(void);
2899
2900 /**
2901  * @fn int bluetooth_is_le_scanning(void)
2902  * @brief Check for the device LE scan is in-progress or not.
2903  *
2904  * This API is used to check the current status of the LE Scan operation.If discovery is in\
2905  * progress normally other operations are not allowed.
2906  *
2907  * This function checks whether the device  LE Scan is started or not.
2908  *
2909  * This function is a synchronous call.
2910  *
2911  * @return   TRUE  - LE Scan in progress \n
2912  *              FALSE - LE Scan is not in progress \n
2913  *
2914  * @remark      None
2915
2916 @code
2917 gboolean is_le_scanning = 0;
2918 is_le_scanning = bluetooth_is_le_scanning ();
2919 @endcode
2920  */
2921 gboolean bluetooth_is_le_scanning(void);
2922
2923 gboolean bluetooth_is_scan_filter_supported(void);
2924
2925 /**
2926  * @fn int bluetooth_force_hcidump(int timeout)
2927  * @brief Enable /disable force-hcidump
2928  *
2929  * This function control force-hcidump.
2930  *
2931  * This function is a synchronous call.
2932  *
2933  * @return      BLUETOOTH_ERROR_NONE - Success \n
2934  *              BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is not enabled \n
2935  *              BLUETOOTH_ERROR_INTERNAL - Internal IPC error \n
2936  *
2937  * @param[in]   start  To enable or disable force-hcidump[TRUE / FALSE]
2938  *
2939  *
2940  * @remark      None
2941  */
2942 int bluetooth_force_hcidump(int timeout);
2943
2944 /**
2945  * @fn int bluetooth_register_scan_filter(bluetooth_le_scan_filter_t *filter, int *slot_id)
2946  * @brief Register scan filter.
2947  *
2948  * This function registers the scan filter.
2949  *
2950  * This function is a synchronous call.
2951  *
2952  * @return      BLUETOOTH_ERROR_NONE - Success \n
2953  *
2954  * @param[in]   filter   scan filter to register
2955  * @param[out]  slot_id  the slot ID of scan filter
2956  *
2957  * @remark      None
2958  */
2959 int bluetooth_register_scan_filter(bluetooth_le_scan_filter_t *filter, int *slot_id);
2960
2961 /**
2962  * @fn int bluetooth_unregister_scan_filter(int slot_id)
2963  * @brief Register scan filter.
2964  *
2965  * This function unregisters the scan filter.
2966  *
2967  * This function is a synchronous call.
2968  *
2969  * @return      BLUETOOTH_ERROR_NONE - Success \n
2970  *
2971  * @param[in]   slot_id  the slot ID of scan filter
2972  *
2973  * @remark      None
2974  */
2975 int bluetooth_unregister_scan_filter(int slot_id);
2976
2977 /**
2978  * @fn int bluetooth_unregister_all_scan_filters(void)
2979  * @brief Register scan filter.
2980  *
2981  * This function usregisters all scan filters.
2982  *
2983  * This function is a synchronous call.
2984  *
2985  * @return      BLUETOOTH_ERROR_NONE - Success \n
2986  *
2987  * @remark      None
2988  */
2989 int bluetooth_unregister_all_scan_filters(void);
2990
2991 /**
2992  * @fn int bluetooth_enable_rssi(const bluetooth_device_address_t *remote_address,
2993                 int link_type, bt_rssi_threshold_t rssi_threshold)
2994  * @brief Enable RSSI monitoring
2995  *
2996  * This function enables RSSI monitoring and sets threshold for a connection
2997  *
2998  * @return      BLUETOOTH_ERROR_NONE - Success \n
2999  *
3000  * @remark      None
3001  * @see bluetooth_get_rssi_strength
3002  */
3003 int bluetooth_enable_rssi(const bluetooth_device_address_t *remote_address,
3004                 int link_type, bt_rssi_threshold_t *rssi_threshold);
3005
3006 /**
3007  * @fn int bluetooth_get_rssi_strength(const bluetooth_device_address_t *remote_address, int link_type)
3008  * @brief Gets Raw RSSI signal Strength
3009  *
3010  * This function gives the Raw RSSI signal strength for a connection.
3011  *
3012  * @return      BLUETOOTH_ERROR_NONE - Success \n
3013  *
3014  * @remark      None
3015  * @see bluetooth_enable_rssi
3016  */
3017 int bluetooth_get_rssi_strength(const bluetooth_device_address_t *remote_address, int link_type);
3018
3019 int bluetooth_set_connectable(gboolean is_connectable);
3020
3021 int bluetooth_is_connectable(gboolean *is_connectable);
3022
3023 /**
3024  * @fn int bluetooth_bond_device(const bluetooth_device_address_t *device_address)
3025  * @brief Initiate a bonding process
3026  *
3027  *
3028  * This function initiates a bonding procedure with a peer device.  The bonding procedure
3029  * enables authentication and optionally encryption on the Bluetooth link.
3030  *
3031  * Bonding is applied to the discovered device to which we need a secure connection. We cannot
3032  * inititate the bonding request to the devices already in the paired list.
3033  *
3034  * Usually we call this API after the device discovery.
3035  * This function is a asynchronous call.
3036  *
3037  * Response will be received through BLUETOOTH_EVENT_BONDING_FINISHED event. It can any of the below
3038  * mentioed result code
3039  * BLUETOOTH_ERROR_PARING_FAILED - Pairing faied \n
3040  * BLUETOOTH_ERROR_ACCESS_DENIED - Authetication rejected \n
3041  * BLUETOOTH_ERROR_CANCEL_BY_USER - Cancelled by the user \n
3042  * BLUETOOTH_ERROR_PARING_FAILED - Pairing failed \n
3043  * BLUETOOTH_ERROR_TIMEOUT - Timeout has haapened \n
3044  *
3045  * If the remote user is not responding with in a specific time(60 seconds), then a timeout happens
3046  * and BLUETOOTH_EVENT_BONDING_FINISHED callback event is called with and BLUETOOTH_ERROR_TIMEOUT
3047  * result code
3048  *
3049  * The bonding operation can be cancelled by calling bluetooth_cancel_bonding().
3050  *
3051  *
3052  * @return      BLUETOOTH_ERROR_NONE - Success \n
3053  *              BLUETOOTH_ERROR_INVALID_PARAM - Invalid parameter \n
3054  *              BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is not enabled \n
3055  *              BLUETOOTH_ERROR_DEVICE_BUSY - Adapter is busy or Discovery is in Progress \n
3056  *              BLUETOOTH_ERROR_INVALID_DATA - Invalid BD address \n
3057  * @exception   None
3058  * @param[in]   device_address   This indicates an address of the device with which the pairing
3059  *                                      should be initiated
3060  * @remark      None
3061  * @see         bluetooth_cancel_bonding
3062  @code
3063 void bt_event_callback(int event, bluetooth_event_param_t *param)
3064 {
3065         switch(event)
3066         {
3067                 case BLUETOOTH_EVENT_BONDING_FINISHED:
3068                 {
3069                         TC_PRT("BLUETOOTH_EVENT_BONDING_FINISHED, result [0x%04x]", param->result);
3070                         if (param->result >= BLUETOOTH_ERROR_NONE)
3071                         {
3072                                 bluetooth_device_info_t *device_info = NULL;
3073                                 device_info  = (bluetooth_device_info_t *)param->param_data;
3074                                 printf("dev [%s] [%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X]
3075                                                         mjr[%#x] min[%#x] srv[%#x]",
3076                                                         device_info->device_name.name,
3077                                                         device_info->device_address.addr[0],
3078                                                         device_info->device_address.addr[1],
3079                                                         device_info->device_address.addr[2],
3080                                                         device_info->device_address.addr[3],
3081                                                         device_info->device_address.addr[4],
3082                                                         device_info->device_address.addr[5],
3083                                                         device_info->device_class.major_class,
3084                                                         device_info->device_class.minor_class,
3085                                                         device_info->device_class.service_class);
3086                         }
3087                         else
3088                         {
3089                                 //bonding failed
3090                         }
3091                         break;
3092                 }
3093         }
3094 }
3095
3096 ...
3097
3098 int ret = 0;
3099 bluetooth_device_address_t device_address={{0}};
3100
3101 ret = bluetooth_bond_device(&device_address);
3102
3103 @endcode
3104  */
3105 int bluetooth_bond_device(const bluetooth_device_address_t *device_address);
3106
3107 /**
3108  * @fn int bluetooth_bond_device_by_type(const bluetooth_device_address_t *device_address,
3109  *                              bluetooth_conn_type_t conn_type)
3110  * @brief Initiate a bonding process
3111  *
3112  *
3113  * This function initiates a bonding procedure with a peer device on the basis of connection type (BLE or BREDR).
3114  * The bonding procedure enables authentication and optionally encryption on the Bluetooth link.
3115  *
3116  * Bonding is applied to the discovered device to which we need a secure connection. We cannot
3117  * inititate the bonding request to the devices already in the paired list.
3118  *
3119  * Usually we call this API after the device discovery.
3120  * This function is a asynchronous call.
3121  *
3122  * Response will be received through BLUETOOTH_EVENT_BONDING_FINISHED event. It can any of the below
3123  * mentioed result code
3124  * BLUETOOTH_ERROR_PARING_FAILED - Pairing faied \n
3125  * BLUETOOTH_ERROR_ACCESS_DENIED - Authetication rejected \n
3126  * BLUETOOTH_ERROR_CANCEL_BY_USER - Cancelled by the user \n
3127  * BLUETOOTH_ERROR_PARING_FAILED - Pairing failed \n
3128  * BLUETOOTH_ERROR_TIMEOUT - Timeout has haapened \n
3129  *
3130  * If the remote user is not responding with in a specific time(60 seconds), then a timeout happens
3131  * and BLUETOOTH_EVENT_BONDING_FINISHED callback event is called with and BLUETOOTH_ERROR_TIMEOUT
3132  * result code
3133  *
3134  * The bonding operation can be cancelled by calling bluetooth_cancel_bonding().
3135  *
3136  *
3137  * @return BLUETOOTH_ERROR_NONE - Success \n
3138  *             BLUETOOTH_ERROR_INVALID_PARAM - Invalid parameter \n
3139  *             BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is not enabled \n
3140  *             BLUETOOTH_ERROR_DEVICE_BUSY - Adapter is busy or Discovery is in Progress \n
3141  *             BLUETOOTH_ERROR_INVALID_DATA - Invalid BD address \n
3142  * @exception None
3143  * @param[in] device_address This indicates an address of the device with which pairing
3144  *                                        should be initiated
3145  * @param[in] conn_type This Indicates the connection type to be used for pairing in case of
3146  *                                 dual mode devices
3147  * @remark None
3148  * @see bluetooth_cancel_bonding
3149  */
3150 int bluetooth_bond_device_by_type(const bluetooth_device_address_t *device_address,
3151                                 bluetooth_conn_type_t conn_type);
3152
3153 /**
3154  * @fn int bluetooth_cancel_bonding(void)
3155  * @brief Cancel the on-going bonding process
3156  *
3157  * This API is called to cancel the on-going bonding procedure. It should be called before the
3158  * BLUETOOTH_EVENT_BONDING_FINISHED event comes.
3159  * This API is useful when the remote device is not responding to the bond request or we wish to
3160  * cancel the bonding request. In this case we need not wait for the timeout to happen.
3161  *
3162  * This function is a synchronous call.
3163  *
3164  * @return      BLUETOOTH_ERROR_NONE - Success \n
3165  *              BLUETOOTH_ERROR_NOT_IN_OPERATION - No bonding request in progress \n
3166  *              BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is not enabled \n
3167  * @exception   None
3168  * @remark      None
3169  * @see         bluetooth_bond_device
3170 @code
3171 ...
3172
3173 int ret = 0;
3174
3175 ret = bluetooth_cancel_bonding();
3176 @endcode
3177  */
3178 int bluetooth_cancel_bonding(void);
3179
3180 /**
3181  * @fn int bluetooth_unbond_device(const bluetooth_device_address_t *device_address)
3182  * @brief Remove bonding
3183  *
3184  *
3185  * To communicate with remote device over bluetooth link, user should bond with peer device.
3186  * After bonding is over, peer device is added to list of bonded devices. bluetooth_unbond_device()
3187  * API is used to remove peer device from the list. Please note that after removing the device
3188  * from bonded device list, you cannot communication with peer device until bonding happens again.
3189  *
3190  * User can call this function by passing bluetooth device address of any bonded device. Please note
3191  * that after successful return of this function, any bluetooth application running on your device
3192  * will not be able to communicate with unbonded device until bond operation happens again using
3193  * bluetooth_bond_device()
3194  *
3195  *
3196  * This function is a asynchronous call. The request to remove the specified device from the bonded
3197  * list is responded by an BLUETOOTH_EVENT_BONDED_DEVICE_REMOVED event. if the operation is success,
3198  * you will receive BLUETOOTH_ERROR_NONE. BLUETOOTH_ERROR_NOT_PAIRED may be received in result code
3199  * in case if there is a problem in locating given bluetooth device address in bonded devices list
3200  *
3201  *
3202  *
3203  * @return      BLUETOOTH_ERROR_NONE - Success \n
3204  *              BLUETOOTH_ERROR_INVALID_PARAM - Device address is not valid \n
3205  *              BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Bluetooth adapter is not enabled \n
3206  *              BLUETOOTH_ERROR_DEVICE_BUSY     - Bluetooth adapter is busy doing some operation \n
3207  *              BLUETOOTH_ERROR_INVALID_DATA - Device address provided is incorrect \n
3208  *              BLUETOOTH_ERROR_INTERNAL - System error like heap full has occured or bluetooth
3209  *                                              agent is not running \n
3210  *              BLUETOOTH_ERROR_NOT_PAIRED - Device address mentioned in the argument is not a
3211  *                                              bonded device \n
3212  *
3213  * @param[in]   device_address   This indicates an address of the device to remove bonding
3214  *
3215  * @remark      None
3216  *
3217  * @see         bluetooth_bond_device, bluetooth_cancel_bonding
3218  *
3219 @code
3220 void bt_event_callback(int event, bluetooth_event_param_t *param)
3221 {
3222         switch(event) {
3223                 case BLUETOOTH_EVENT_BONDED_DEVICE_REMOVED: {
3224                         bluetooth_device_address_t *dev_addr = NULL;
3225
3226                         if (param->result == BLUETOOTH_ERROR_NONE) {
3227                                 dev_addr = (bluetooth_device_address_t *)param->param_data;
3228                                 //Unbound scuccess
3229                                 printf("%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X\n",
3230                                         dev_addr->addr[0], dev_addr->addr[1]
3231                                         dev_addr->addr[2], dev_addr->addr[3]
3232                                         dev_addr->addr[4], dev_addr->addr[5]
3233                         } else {
3234                                 //unbound failure
3235                         }
3236                 }
3237         }
3238 }
3239
3240 ...
3241
3242 int ret = 0;
3243 bluetooth_device_address_t *device_address;
3244
3245 // copy valid device address in device_address
3246
3247 ret = bluetooth_unbond_device(device_address);
3248 @endcode
3249  */
3250 int bluetooth_unbond_device(const bluetooth_device_address_t *device_address);
3251
3252 /**
3253  * @fn int bluetooth_get_bonded_device_list(GPtrArray **dev_list)
3254  * @brief Get bonded(paired) device list
3255  *
3256  *
3257  * This API gets all bonded device list.
3258  * The devices in the bonded device list further can be used to perform the authorization by calling
3259  * bluetooth_authorize_device API.
3260  *
3261  * This function is a synchronous call.
3262  * Information for bonded devices can be obtained when result code is BLUETOOTH_ERROR_NONE. If not,
3263  * there is no valid information in the dev_list.
3264  * The len field in the dev_list represents the number of bonded devices. The data structure for
3265  * bonded device information is bluetooth_device_info_t.
3266  *
3267  *
3268  * @return      BLUETOOTH_ERROR_NONE - Success \n
3269  *              BLUETOOTH_ERROR_NOT_SUPPORT - Opreation not supported \n
3270  * @remark      None
3271  * @see         bluetooth_bond_device, bluetooth_unbond_device, bluetooth_authorize_device
3272  @code
3273 void bt_get_bonded_devices(void)
3274 {
3275 ...
3276         int i;
3277         GPtrArray *devinfo = NULL;
3278         bluetooth_device_info_t *ptr;
3279
3280         // allocate the g_pointer_array
3281         devinfo = g_ptr_array_new();
3282
3283         ret = bluetooth_get_bonded_device_list(&devinfo);
3284         if (ret != BLUETOOTH_ERROR_NONE)
3285         {
3286                 printf("bluetooth_get_bonded_device_list failed with [%d]",ret);
3287         }
3288         else
3289         {
3290                 printf("g pointer arrary count : [%d]", devinfo->len);
3291                 for (i=0; i<devinfo->len; i++)
3292                 {
3293                         ptr = g_ptr_array_index(devinfo, i);
3294                         if (ptr != NULL)
3295                         {
3296                                 printf("Name [%s]\n", ptr->device_name.name);
3297                                 printf("Major Class [%d]\n", ptr->device_class.major_class);
3298                                 printf("Minor Class [%d]\n", ptr->device_class.minor_class);
3299                                 printf("Service Class [%d]\n", ptr->device_class.service_class);
3300                                 printf("%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X\n",
3301                                                                 ptr->device_address.addr[0],
3302                                 ptr->device_address.addr[1], ptr->device_address.addr[2],
3303                                                                 ptr->device_address.addr[3],
3304                                 ptr->device_address.addr[4], ptr->device_address.addr[5]);
3305
3306                                 // handle
3307                                 ...
3308                         }
3309                 }
3310         }
3311         // free g_pointer_array
3312         g_ptr_array_free(devinfo, TRUE);
3313 }
3314
3315 @endcode
3316  */
3317 int bluetooth_get_bonded_device_list(GPtrArray **dev_list);
3318
3319 int bluetooth_get_profile_connected_device_list(
3320                 const char *profile_uuid, GPtrArray **addr_list);
3321
3322 /**
3323  * @fn int bluetooth_get_bonded_device(const bluetooth_device_address_t *device_address,
3324  *                                      bluetooth_device_info_t *dev_info)
3325  * @brief Get a bonded(paired) device
3326  *
3327  *
3328  * This API gets a bonded device.
3329  *
3330  * This function is a synchronous call.
3331  * Information for bonded devices can be obtained when result code is BLUETOOTH_ERROR_NONE. If not,
3332  * there is no valid information in the dev_info.
3333  * The data structure for bonded device information is bluetooth_device_info_t.
3334  *
3335  *
3336  * @return      BLUETOOTH_ERROR_NONE - Success \n
3337  *              BLUETOOTH_ERROR_NOT_SUPPORT - Opreation not supported \n
3338  * @remark      None
3339  * @see         bluetooth_bond_device, bluetooth_unbond_device, bluetooth_authorize_device
3340  @code
3341 void bt_get_bonded_device(void)
3342 {
3343 ...
3344         int i;
3345         bluetooth_device_info_t devinfo = {0};
3346         bluetooth_device_address_t device_address={{0x00,0x1C,0x43,0x2B,0x1A,0xE5}};
3347
3348         ret = bluetooth_get_bonded_device(&device_address, &devinfo);
3349         if (ret != BLUETOOTH_ERROR_NONE)
3350         {
3351                 printf("bluetooth_get_bonded_device failed with [%d]",ret);
3352         }
3353         else
3354         {
3355                 printf("Name [%s]\n", devinfo.device_name.name);
3356                 printf("Major Class [%d]\n", devinfo.device_class.major_class);
3357                 printf("Minor Class [%d]\n", devinfo.device_class.minor_class);
3358                 printf("Service Class [%d]\n", devinfo.device_class.service_class);
3359                 printf("%2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X\n", devinfo.device_address.addr[0],
3360                 devinfo.device_address.addr[1], devinfo.device_address.addr[2],
3361                 devinfo.device_address.addr[3], devinfo.device_address.addr[4],
3362                 devinfo.device_address.addr[5]);
3363
3364                 // handle
3365                 ...
3366         }
3367 }
3368
3369 @endcode
3370  */
3371 int bluetooth_get_bonded_device(const bluetooth_device_address_t *device_address,
3372                                         bluetooth_device_info_t *dev_info);
3373
3374
3375 /**
3376  * @fn int bluetooth_get_is_alias_set(const bluetooth_device_address_t *device_address,
3377  *                                      gboolean *is_alias_set)
3378  * @brief Get is_alias_set property of device
3379  *
3380  * This API gets is_alias_set property of a bonded device.
3381  *
3382  * This function is a synchronous call.
3383  * Information for is_alias_set property can be obtained only when result code is BLUETOOTH_ERROR_NONE.
3384  * If not,there is no valid information in the is_alias_set.
3385  *
3386  * @return      BLUETOOTH_ERROR_NONE - Success \n
3387  *                      BLUETOOTH_ERROR_NOT_SUPPORT - Opreation not supported \n
3388  * @remark None
3389  @code
3390         int ret = 0;
3391         gboolean alias_set;
3392         bluetooth_device_address_t device_address = {{0x00,0x1C,0x43,0x2B,0x1A,0xE5}};
3393
3394         ret = bluetooth_get_is_alias_set(&device_address, &alias_set);
3395  @endcode
3396  */
3397 int bluetooth_get_is_alias_set(const bluetooth_device_address_t *device_address,
3398                                 gboolean *is_alias_set);
3399
3400 /**
3401  * @fn int bluetooth_set_alias(const bluetooth_device_address_t *device_address, const char *alias)
3402  * @brief set alias for bonded device
3403  *
3404  *
3405  * This function set alias for bonded device.
3406  *
3407  * This function is a synchronous call.
3408  *
3409  *
3410  * @return      BLUETOOTH_ERROR_NONE - Success \n
3411  *              BLUETOOTH_ERROR_INVALID_PARAM - Invalid parameter \n
3412  * @param[in]   device_address   This indicates an address of the remote device
3413  * @param[in]   alias                   This indicates an alias to set
3414  * @remark      None
3415  * @see         None
3416 @code
3417 int ret = 0;
3418 ret = bluetooth_set_alias(&remote_address);
3419 @endcode
3420  */
3421 int bluetooth_set_alias(const bluetooth_device_address_t *device_address,
3422                                 const char *alias);
3423
3424 /**
3425  * @fn int bluetooth_get_remote_device(const bluetooth_device_address_t *device_address)
3426  * @brief Get remote deivice
3427  *
3428  *
3429  * This function gets specific remote device.
3430  *
3431  * This function is a asynchronous call.
3432  * This API is responded by an BLUETOOTH_EVENT_REMOTE_DEVICE_READ event.
3433  *
3434  *
3435  * @return      BLUETOOTH_ERROR_NONE - Success \n
3436  *              BLUETOOTH_ERROR_NOT_SUPPORT - Operation not supported \n
3437  * @param[in]   device_address   This indicates an address of the remote device
3438  * @remark      None
3439  * @see         None
3440 @code
3441 int ret = 0;
3442 ret = bluetooth_get_remote_device(&remote_address);
3443 @endcode
3444  */
3445 int bluetooth_get_remote_device(const bluetooth_device_address_t *device_address);
3446
3447 /**
3448  * @fn int bluetooth_authorize_device(const bluetooth_device_address_t *device_address,
3449  *                                      gboolean authorized)
3450  * @brief Authorize/Unauthorize a bonded device
3451  *
3452  *
3453  * This function authorizes/unauthorize a bonded device. It decides the device to connect
3454  * with/without user confirmation.
3455  *
3456  * If we select a paired device and make it authorized by calling this API with the authorized
3457  * parameter to TRUE, then it will not ask for the user conformation before connecting. Similarly
3458  * if we unauthorize the paired device by calling this API with the authorized parameter to FALSE,
3459  * then it will ask for the user conformation before the connection.
3460  *
3461  * This API supposed to be called on the paired devices. Which means we have to use this API only
3462  * after successful pairing.
3463  *
3464  * This function is a asynchronous call.
3465  * Response will be received through BLUETOOTH_EVENT_DEVICE_AUTHORIZED event.
3466  *
3467  * @return      BLUETOOTH_ERROR_NONE - Success \n
3468  * @exception   BLUETOOTH_ERROR_INTERNAL - Cannot get the interal DBUS proxy \n
3469  * @param[in]   device_address   This indicates an address of the device to authorize \n
3470  * @param[in]   authorized      TRUE : authorize FALSE: unauthorize
3471  * @remark      None
3472  * @see         bluetooth_get_bonded_device_list
3473 @code
3474 void bt_event_callback(int event, bluetooth_event_param_t *param)
3475 {
3476         switch(event)
3477         {
3478                 case BLUETOOTH_EVENT_DEVICE_AUTHORIZED :
3479                 {
3480                         if (param->result == BLUETOOTH_ERROR_NONE)
3481                         {
3482                                 //Device authorized
3483                         }
3484                         //device authorization failed failure
3485                 }
3486         }
3487 }
3488
3489 ...
3490
3491 int ret = 0;
3492 bluetooth_device_address_t device_address={{0}};
3493 gboolean authorized;
3494
3495 authorized =TRUE;
3496
3497 ret = bluetooth_authorize_device(&device_address,authorized);
3498 @endcode
3499  */
3500 int bluetooth_authorize_device(const bluetooth_device_address_t *device_address,
3501                                        gboolean authorized);
3502
3503 int bluetooth_set_pin_code(const bluetooth_device_address_t *device_address,
3504                                 const bluetooth_device_pin_code_t *pin_code);
3505
3506 int bluetooth_unset_pin_code(const bluetooth_device_address_t *device_address);
3507
3508 /**
3509  * @fn int bluetooth_passkey_reply(char *passkey, gboolean reply)
3510  *
3511  * @brief Receives Legacy Passkey\pin with following authentication response types
3512  *
3513  * @param[in]   passkey : This is the PIN or PASSKEY string required for remote device authentication
3514  * @param[in]   reply    TRUE : Accept AUthentication FALSE: Cancels authentication
3515  *
3516  */
3517 int bluetooth_passkey_reply(char *passkey, gboolean reply);
3518
3519 /**
3520  * @fn int bluetooth_passkey_confirmation_reply(gboolean reply);
3521  *
3522  * @brief This API sends user confirmation reply to the local adapter.
3523  *
3524  * @param[in] reply TRUE : Accept AUthentication FALSE: Cancels authentication
3525  *
3526  */
3527 int bluetooth_passkey_confirmation_reply(gboolean reply);
3528
3529 /**
3530  * @fn int bluetooth_search_service(const bluetooth_device_address_t *device_address)
3531  * @brief Get all services supported by remote device
3532  *
3533  *
3534  * This API call initiates the search for the services supported by the specified device. Normally
3535  * the service search will take a couple of seconds to get it completed. Before calling this API
3536  * make sure that the Adapter is enabled. We have to give the device address of the remote device to
3537  * perform the service search. We can get the device address by doing a device discovery operation.
3538  *
3539  *
3540  * This function is a asynchronous call.
3541  * The service search request is responded by BLUETOOTH_EVENT_SERVICE_SEARCHED event.
3542  *
3543  * There is a timeout associated with the service search. The default time out is 40 seconds. If the
3544  * remove device did not respond with in the time out period the BLUETOOTH_EVENT_SERVICE_SEARCHED
3545  * event is generated with appropriate result code.
3546  *
3547  * @return      BLUETOOTH_ERROR_NONE - Success \n
3548  *              BLUETOOTH_ERROR_SERVICE_SEARCH_ERROR - Service search error (NULL device address) \n
3549  *              BLUETOOTH_ERROR_INTERNAL - Internal IPC error \n
3550  * @param[in]   device_address   This indicates an address of the device
3551  *                               whose services need to be found
3552  * @remark      None
3553  * @see         bluetooth_cancel_service_search
3554  */
3555 int bluetooth_search_service(const bluetooth_device_address_t *device_address);
3556
3557 /**
3558  * @fn int bluetooth_cancel_service_search(void)
3559  * @brief Cancel the ongoing service search operation
3560  *
3561  *
3562  * This function cancel the ongoing service search operation. This API is usually calling after the
3563  * bluetooth_search_service API.
3564  * Normally service search will take a more time (> 5 seconds) to complete. This API will be called
3565  * if the user wish to cancel the Ongoing service search operation.
3566  *
3567  * This API should be called just after the bluetooth_search_service API and before the
3568  * BLUETOOTH_EVENT_SERVICE_SEARCHED event
3569  *
3570  * This function is a synchronous call.
3571  *
3572  * @return      BLUETOOTH_ERROR_NONE - Success \n
3573  *              BLUETOOTH_ERROR_CANCEL - Error in service search cancel operation \n
3574  *              BLUETOOTH_ERROR_NOT_PAIRED - Not paired device \n
3575  *              BLUETOOTH_ERROR_NOT_IN_OPERATION - Searching service is not in operation \n
3576  *
3577  * @remark      None
3578  * @see         bluetooth_search_service
3579 @code
3580 ...
3581
3582 int ret = 0;
3583 ret = bluetooth_cancel_service_search();
3584 @endcode
3585 */
3586 int bluetooth_cancel_service_search(void);
3587
3588 /**
3589  * @fn int bluetooth_rfcomm_create_socket(const char *uuid)
3590  * @brief Register rfcomm socket with a specific uuid
3591  *
3592  *
3593  * This API register rfcomm socket with the given UUID. The return value of this API is the socket
3594  * descriptor of the server.
3595  * This is the first API which is called to create the server. Once we created the server socket,
3596  * we will listen on that return socket.
3597  * So a bluetooth_rfcomm_listen_and_accept should follow this API call. This is a synchronous call.
3598  *
3599  *
3600  * @return  socket FD on Success \n
3601  *              BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Device is not enabled \n
3602  *              BLUETOOTH_ERROR_INTERNAL - Internal error\n
3603  *              BLUETOOTH_ERROR_MAX_CONNECTION - Maximum connection reached\n
3604  *              BLUETOOTH_ERROR_INVALID_PARAM - Invalid parameter \n
3605  * @param[in]   UUID (128 bits)
3606  *
3607  * @remark      None
3608  * @see       bluetooth_rfcomm_listen_and_accept, bluetooth_rfcomm_remove_socket
3609  *
3610  @code
3611
3612   const char *rfcomm_test_uuid="00001101-0000-1000-8000-00805F9B34FB";
3613   fd  = bluetooth_rfcomm_create_socket(rfcomm_test_uuid);
3614
3615  @endcode
3616  */
3617 int bluetooth_rfcomm_create_socket(const char *uuid);
3618
3619 /**
3620  * @fn int bluetooth_rfcomm_create_socket_ex(const char *uuid, const char *bus_name, const char *path)
3621  * @brief Register rfcomm socket with a specific uuid
3622  *
3623  *
3624  * This API register rfcomm socket with the given UUID. The return value of this API is the socket
3625  * descriptor of the server.
3626  * This is the first API which is called to create the server. Once we created the server socket,
3627  * we will listen on that return socket.
3628  * So a bluetooth_rfcomm_listen_and_accept_ex should follow this API call. This is a synchronous call.
3629  *
3630  *
3631  * @return  socket FD on Success \n
3632  *              BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Device is not enabled \n
3633  *              BLUETOOTH_ERROR_INTERNAL - Internal error\n
3634  *              BLUETOOTH_ERROR_MAX_CONNECTION - Maximum connection reached\n
3635  *              BLUETOOTH_ERROR_INVALID_PARAM - Invalid parameter \n
3636  * @param[in]   UUID (128 bits)
3637  * @param[in]   bus_name (const char)
3638  * @param[in]   path (const char)
3639  *
3640  * @remark      None
3641  * @see       bluetooth_rfcomm_listen_and_accept_ex, bluetooth_rfcomm_remove_socket
3642  *
3643  @code
3644
3645   const char *rfcomm_test_uuid="00001101-0000-1000-8000-00805F9B34FB";
3646   fd  = bluetooth_rfcomm_create_socket_ex(rfcomm_test_uuid, bus_name, path);
3647
3648  @endcode
3649  */
3650 int bluetooth_rfcomm_create_socket_ex(const char *uuid, const char *bus_name, const char *path);
3651
3652 /**
3653  * @fn int bluetooth_rfcomm_remove_socket(int socket_fd, const char *uuid)
3654  * @brief De-register the rfcomm socket
3655  *
3656  *
3657  * This API deregister rfcomm socket with the given socket fd and  UUID. If the remote device is
3658  * already connected then we will receive the BLUETOOTH_EVENT_RFCOMM_DISCONNECTED with socket
3659  * descriptor else no event will come. We will call this API only after the
3660  * bluetooth_rfcomm_listen_and_accept.
3661  * This is a synchronous call.
3662  *
3663  * @return   BLUETOOTH_ERROR_NONE - Success \n
3664  *               BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Device is not enabled \n
3665  *               BLUETOOTH_ERROR_NOT_FOUND - Cannot find the proxy\n
3666  *               BLUETOOTH_ERROR_INVALID_PARAM - Invalid parameter \n
3667  * @param[in]  int socket_fd
3668  *
3669  * @remark      None
3670  * @see       bluetooth_rfcomm_create_socket, bluetooth_rfcomm_listen_and_accept
3671  *
3672  @code
3673  void bt_event_callback(int event, bluetooth_event_param_t *param)
3674  {
3675         switch(event)
3676         {
3677                 case BLUETOOTH_EVENT_RFCOMM_DISCONNECTED:
3678                 {
3679                         bluetooth_rfcomm_connection_t *discon_ind =
3680                                         (bluetooth_rfcomm_connection_t *)param->param_data;
3681
3682                         printf("\nDisconnected from FD %d",  discon_ind->socket_fd);
3683                 }
3684         }
3685  }
3686
3687  ...
3688
3689  int ret = 0;
3690  fd  = bluetooth_rfcomm_create_socket(rfcomm_test_uuid);
3691  ret = bluetooth_rfcomm_listen_and_accept(fd, 1);
3692  ....
3693  ret = bluetooth_rfcomm_remove_socket(fd);
3694  @endcode
3695  */
3696 int bluetooth_rfcomm_remove_socket(int socket_fd);
3697
3698 /**
3699  * @fn int bluetooth_rfcomm_remove_socket(const char *uuid)
3700  * @brief De-register the rfcomm socket
3701  *
3702  *
3703  * This API deregister rfcomm socket with the given socket UUID. If the remote device is
3704  * already connected then we will receive the BLUETOOTH_EVENT_RFCOMM_DISCONNECTED with socket
3705  * descriptor else no event will come. We will call this API only after the
3706  * bluetooth_rfcomm_listen_and_accept_ex.
3707  * This is a synchronous call.
3708  *
3709  * @return   BLUETOOTH_ERROR_NONE - Success \n
3710  *               BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Device is not enabled \n
3711  *               BLUETOOTH_ERROR_NOT_FOUND - Cannot find the proxy\n
3712  *               BLUETOOTH_ERROR_INVALID_PARAM - Invalid parameter \n
3713  * @param[in]   UUID (128 bits)
3714  *
3715  * @remark      None
3716  * @see       bluetooth_rfcomm_create_socket_ex, bluetooth_rfcomm_listen_and_accept_ex
3717  *
3718  @code
3719  void bt_event_callback(int event, bluetooth_event_param_t *param)
3720  {
3721         switch(event)
3722         {
3723                 case BLUETOOTH_EVENT_RFCOMM_DISCONNECTED:
3724                 {
3725                         bluetooth_rfcomm_connection_t *discon_ind =
3726                                         (bluetooth_rfcomm_connection_t *)param->param_data;
3727
3728                         printf("\nDisconnected from FD %d",  discon_ind->socket_fd);
3729                 }
3730         }
3731  }
3732
3733  ...
3734
3735  int ret = 0;
3736  fd  = bluetooth_rfcomm_create_socket_ex(rfcomm_test_uuid, path, bus_name);
3737  ret = bluetooth_rfcomm_listen_and_accept_ex(rfcomm_test_uuid, 1, bus_name, path);
3738  ....
3739  ret = bluetooth_rfcomm_remove_socket_ex(rfcomm_test_uuid);
3740  @endcode
3741  */
3742 int bluetooth_rfcomm_remove_socket_ex(const char *uuid);
3743
3744 /**
3745  * @fn int bluetooth_rfcomm_server_disconnect(int socket_fd)
3746  * @brief Disconnect rfcomm connection
3747  *
3748  *
3749  * Disconnect a specific(device node fd)  RFCOMM connection. This is a Synchronous call and there
3750  * is no cabbback events for this API. We have to provice the valid client fd to disconnect from the
3751  * remote server.
3752  *
3753  * @return   BLUETOOTH_ERROR_NONE  - Success \n
3754  *              BLUETOOTH_ERROR_INVALID_PARAM - Invalid parameter \n
3755  *              BLUETOOTH_ERROR_NOT_CONNECTED - Not connected \n
3756  * @param[in]  int socket_fd the sending socket fd
3757  *
3758  * @remark      None
3759  *
3760  @code
3761
3762   ret = bluetooth_rfcomm_server_disconnect(g_ret_fd);
3763   if (ret < 0)
3764         printf("Disconnection failed");
3765   else
3766   printf("Disconnection Success");
3767
3768  @endcode
3769  */
3770 int bluetooth_rfcomm_server_disconnect(int socket_fd);
3771
3772 /**
3773  * @fn int bluetooth_rfcomm_listen_and_accept(int socket_fd,int max_pending_connection)
3774  * @brief Rfcomm socket listen
3775  *
3776  *
3777  * This API make rfcomm socket listen and accept with socket. We will call this API immediatly
3778  * after the bluetooth_rfcomm_create_socket API.
3779  * This API listen for the incomming connection and once it receives a connection, it will give
3780  * BLUETOOTH_EVENT_RFCOMM_CONNECTED
3781  * event to the application. This is an Asynchronous API call.
3782  *
3783  *
3784  * @return  BLUETOOTH_ERROR_NONE - Success \n
3785  *              BLUETOOTH_ERROR_INVALID_PARAM - Invalid parameter \n
3786  *              BLUETOOTH_ERROR_CONNECTION_ERROR - Listen failed \n
3787
3788  * @param[in]  int socket_fd
3789  * @param[in]  max pending connection.
3790  *
3791  * @remark      None
3792  * @see       bluetooth_rfcomm_create_socket
3793  *
3794   @code
3795   void bt_event_callback(int event, bluetooth_event_param_t* param)
3796  {
3797         switch(event)
3798         {
3799                 case BLUETOOTH_EVENT_RFCOMM_CONNECTED:
3800                 {
3801                         bluetooth_rfcomm_connection_t *conn_ind =
3802                                                 (bluetooth_rfcomm_connection_t *)param->param_data;
3803
3804                         printf("\nConnected from FD %d",  conn_ind->socket_fd);
3805                 }
3806         }
3807  }
3808
3809  ...
3810
3811  int ret = 0;
3812  fd  = bluetooth_rfcomm_create_socket(rfcomm_test_uuid);
3813  ret = bluetooth_rfcomm_listen_and_accept(fd, 1);
3814
3815  @endcode
3816  */
3817 int bluetooth_rfcomm_listen_and_accept(int socket_fd, int max_pending_connection);
3818
3819 /**
3820  * @fn int bluetooth_rfcomm_listen_and_accept_ex(const char *uuid, int max_pending_connection, const char *bus_name, const char *path)
3821  * @brief Rfcomm socket listen
3822  *
3823  *
3824  * This API make rfcomm socket listen and accept with socket. We will call this API immediatly
3825  * after the bluetooth_rfcomm_create_socket API.
3826  * This API listen for the incomming connection and once it receives a connection, it will give
3827  * BLUETOOTH_EVENT_RFCOMM_CONNECTED
3828  * event to the application. This is an Asynchronous API call.
3829  *
3830  *
3831  * @return  BLUETOOTH_ERROR_NONE - Success \n
3832  *              BLUETOOTH_ERROR_INVALID_PARAM - Invalid parameter \n
3833  *              BLUETOOTH_ERROR_CONNECTION_ERROR - Listen failed \n
3834
3835  * @param[in]  int socket_fd
3836  * @param[in]  max pending connection.
3837  * @param[in]  name
3838  * @param[in]  path
3839  *
3840  * @remark      None
3841  * @see       bluetooth_rfcomm_create_socket_ex
3842  *
3843   @code
3844   void bt_event_callback(int event, bluetooth_event_param_t* param)
3845  {
3846         switch(event)
3847         {
3848                 case BLUETOOTH_EVENT_RFCOMM_CONNECTED:
3849                 {
3850                         bluetooth_rfcomm_connection_t *conn_ind =
3851                                                 (bluetooth_rfcomm_connection_t *)param->param_data;
3852
3853                         printf("\nConnected from FD %d",  conn_ind->socket_fd);
3854                 }
3855         }
3856  }
3857
3858  ...
3859
3860  int ret = 0;
3861  fd  = bluetooth_rfcomm_create_socket_ex(rfcomm_test_uuid);
3862  ret = bluetooth_rfcomm_listen_and_accept_ex(rfcomm_test_uuid, 1, bus_name, path);
3863
3864  @endcode
3865  */
3866
3867 int bluetooth_rfcomm_listen_and_accept_ex(const char *uuid, int max_pending_connection, const char *bus_name, const char *path);
3868
3869 /**
3870  * @fn int bluetooth_rfcomm_listen(int socket_fd,int max_pending_connection)
3871  * @brief Rfcomm socket listen
3872  *
3873  *
3874  * This API make rfcomm socket listen and accept with socket. We will call this API immediatly
3875  * after the bluetooth_rfcomm_create_socket API.
3876  * This API listen for the incomming connection and once it receives a connection, it will give
3877  * BLUETOOTH_EVENT_RFCOMM_AUTHORIZE
3878  * event to the application. This is an Asynchronous API call.
3879  *
3880  *
3881  * @return  BLUETOOTH_ERROR_NONE - Success \n
3882  *              BLUETOOTH_ERROR_INVALID_PARAM - Invalid parameter \n
3883  *              BLUETOOTH_ERROR_CONNECTION_ERROR - Listen failed \n
3884
3885  * @param[in]  int socket_fd
3886  * @param[in]  max pending connection.
3887  *
3888  * @remark      None
3889  * @see       bluetooth_rfcomm_create_socket
3890  *
3891   @code
3892   void bt_event_callback(int event, bluetooth_event_param_t* param)
3893  {
3894         switch(event)
3895         {
3896                 case BLUETOOTH_EVENT_RFCOMM_AUTHORIZE:
3897                 {
3898                         char *name = (char *)param->param_data;
3899
3900                         printf("\nConnected from %s",  name);
3901
3902                         bluetooth_rfcomm_accept_connection();
3903                 }
3904         }
3905  }
3906
3907  ...
3908
3909  int ret = 0;
3910  fd  = bluetooth_rfcomm_create_socket(rfcomm_test_uuid);
3911  ret = bluetooth_rfcomm_listen(fd, 1);
3912
3913  @endcode
3914  */
3915 int bluetooth_rfcomm_listen(int socket_fd, int max_pending_connection);
3916
3917 /**
3918  * @fn int bluetooth_rfcomm_accept_connection()
3919  * @brief Accepts the authorization request indicated by the event
3920   * BLUETOOTH_EVENT_RFCOMM_AUTHORIZE.
3921  *
3922  * This function is a synchronous call.
3923  *
3924  * @return   BLUETOOTH_ERROR_NONE  - Success \n
3925  *              BLUETOOTH_ERROR_INTERNAL - Internal error \n
3926  *
3927  * @param[in]  the socket fd of the server
3928  * @param[out]  the socket fd of the client
3929  *
3930  * @exception   None
3931  * @remark       None
3932  * @see bluetooth_rfcomm_reject_connection
3933  */
3934 int bluetooth_rfcomm_accept_connection(int server_fd);
3935
3936 /**
3937  * @fn int bluetooth_rfcomm_reject_connection()
3938  * @brief Rejects the authorization request indicated by the event
3939   * BLUETOOTH_EVENT_RFCOMM_AUTHORIZE.
3940  *
3941  * This function is a synchronous call.
3942  *
3943  * @return   BLUETOOTH_ERROR_NONE  - Success \n
3944  *              BLUETOOTH_ERROR_INTERNAL - Internal error \n
3945  *
3946  * @param[in]  the socket fd of the server
3947  *
3948  * @exception   None
3949  * @remark       None
3950  * @see bluetooth_rfcomm_accept_connection
3951  */
3952 int bluetooth_rfcomm_reject_connection(int server_fd);
3953
3954 /**
3955  * @fn gboolean bluetooth_rfcomm_is_server_uuid_available(const char *uuid)
3956  * @brief Informs whether rfcomm server uuid is available or not.
3957  *
3958  * This function is a synchronous call.
3959  *
3960  * @return   TRUE  - RFCOMM uuid is available \n
3961  *              FALSE - RFCOMM uuid is not available \n
3962  *
3963  * @param[in]  uuid UUID string
3964  *
3965  * @exception   None
3966  *
3967  * @remark       None
3968  */
3969 gboolean bluetooth_rfcomm_is_server_uuid_available(const char *uuid);
3970
3971 /**
3972  * @fn int bluetooth_rfcomm_connect(const bluetooth_device_address_t  *remote_bt_address,
3973  *                                                                      const char *remote_uuid)
3974  * @brief Connect to the remote device rfcomm *
3975  *
3976  * Connect to a specific RFCOMM based service on a remote device UUID. This is a Async call. Once
3977  * the connection is successful callback BLUETOOTH_EVENT_RFCOMM_CONNECTED events is generated,
3978  * which contains the socket_fd, device role (RFCOMM_ROLE_SERVER/RFCOMM_ROLE_CLIENT), device addess
3979  * etc. The socket_fd can be further used to send the data. It better to do a sevice search before
3980  * initiating a connection.
3981  *
3982  * @return  BLUETOOTH_ERROR_NONE  - Success \n
3983  *              BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Device is not enabled \n
3984  *              BLUETOOTH_ERROR_INVALID_PARAM - Invalid parameter \n
3985  *              BLUETOOTH_ERROR_CONNECTION_BUSY - Connection in progress \n
3986  *              BLUETOOTH_ERROR_INTERNAL - Internal Error\n
3987  * @param[in]  bluetooth_device_address_t remote bt_address
3988  * @param[in]  char remote uuid
3989  * @remark      None
3990  * @see         bluetooth_rfcomm_disconnect, bluetooth_rfcomm_write, bluetooth_search_service
3991  *
3992  @code
3993
3994  void bt_event_callback(int event, bluetooth_event_param_t *param)
3995  {
3996         switch(event)
3997         {
3998                 case BLUETOOTH_EVENT_SERVICE_SEARCHED:
3999                 {
4000                         if (param->result >= BLUETOOTH_ERROR_NONE)
4001                         {
4002                                 bt_sdp_info_t *bt_sdp_info=param->param_data;
4003
4004                                 printf("Dev add = %2.2X:%2.2X:%2.2X:%2.2X:%2.2X:%2.2X\n",
4005                                         bt_sdp_info->device_addr.addr[0],
4006                                         bt_sdp_info->device_addr.addr[1],
4007                                         bt_sdp_info->device_addr.addr[2],
4008                                         bt_sdp_info->device_addr.addr[3],
4009                                         bt_sdp_info->device_addr.addr[4],
4010                                         bt_sdp_info->device_addr.addr[5]);
4011
4012                                         printf("Supported service list:\n");
4013                                         for(i=0; i<bt_sdp_info->service_index; i++)
4014                                                 printf("[%#x]\n",
4015                                                         bt_sdp_info->service_list_array[i]);
4016
4017                                 //Alternate method
4018                                 //ret = bluetooth_rfcomm_connect(bt_sdp_info->device_addr,
4019                                                                                 //rfcomm_test_uuid);
4020                         }
4021                         break;
4022                 }
4023                 case BLUETOOTH_EVENT_RFCOMM_CONNECTED:
4024                 {
4025                         bluetooth_rfcomm_connection_t *conn_ind =
4026                                                 (bluetooth_rfcomm_connection_t *)param->param_data;
4027
4028                         printf("\nConnected from FD %d, Role = %s",  conn_ind->socket_fd,
4029                                                 (conn_ind->device_role == RFCOMM_ROLE_SERVER) ?
4030                                                                         "SERVER" : "CLIENT");
4031                 }
4032         }
4033  }
4034
4035   bluetooth_device_address_t remote_address = {{0},};
4036   remote_address.addr[0] = 0x0; remote_address.addr[1] = 0x0A; remote_address.addr[2] = 0x3A;
4037   remote_address.addr[3]= 0x54; remote_address.addr[4] = 0x19;  remote_address.addr[5]= 0x36;
4038   ret = bluetooth_search_service(&remote_address);
4039  if (ret < 0)
4040         printf("Seach failed, Reason = %d", ret);
4041   else
4042          printf("Search Success, Ret = %d", ret);
4043
4044   ret = bluetooth_rfcomm_connect(&remote_address, rfcomm_test_uuid);
4045   if (ret < 0)
4046         printf("Connection failed, Reason = %d", ret);
4047   else
4048          printf("Connection Success, Ret = %d", ret);
4049
4050   @endcode
4051   */
4052 int bluetooth_rfcomm_connect(const bluetooth_device_address_t *remote_bt_address,
4053                                      const char *remote_uuid);
4054
4055 /**
4056  * @fn int bluetooth_rfcomm_disconnect(int socket_fd)
4057  * @brief Disconnect rfcomm connection
4058  *
4059  *
4060  * Disconnect a specific(device node fd)  RFCOMM connection. This is a Synchronous call and there
4061  * is no cabbback events for this API. We have to provice the valid client fd to disconnect from the
4062  * remote server.
4063  *
4064  * @return   BLUETOOTH_ERROR_NONE  - Success \n
4065  *              BLUETOOTH_ERROR_INVALID_PARAM - Invalid parameter \n
4066  *              BLUETOOTH_ERROR_NOT_CONNECTED - Not connected \n
4067  * @param[in]  char remote bt_address
4068  *
4069  * @remark      None
4070  * @see         bluetooth_rfcomm_connect
4071  *
4072  @code
4073
4074   ret = bluetooth_rfcomm_disconnect(g_ret_fd);
4075   if (ret < 0)
4076         printf("Disconnection failed");
4077   else
4078   printf("Disconnection Success");
4079
4080  @endcode
4081  */
4082
4083 int bluetooth_rfcomm_disconnect(int socket_fd);
4084
4085 /**
4086  * @fn int bluetooth_rfcomm_write (int fd, const char *buff, int length)
4087  * @brief Write to rfcomm connection
4088  *
4089  *
4090  * This API is used to send the data over the rfcomm connection. This is a synchronous API. The same
4091  * API is used to send the data for server and the client.
4092  *
4093  * @return  BLUETOOTH_ERROR_NONE  - Success \n
4094  *              BLUETOOTH_ERROR_INVALID_PARAM - Invalid parameter \n
4095  *              BLUETOOTH_ERROR_NOT_IN_OPERATION - The Fd is currently not in operation\n
4096  * @param[in]  int fd
4097  * @param[in]  const char *buff  Data buffer to send
4098  * @param[in]  int length Length of the data
4099  *
4100  * @remark      None
4101  * @see         bluetooth_rfcomm_connect
4102  *
4103   @code
4104   char *buff = "Test data 123456789"
4105   ret =  bluetooth_rfcomm_write(g_ret_fd, buff, 15);
4106   if (ret < 0)
4107         printf("Send failed");
4108   else
4109    printf("Send success");
4110
4111  @endcode
4112  */
4113 int bluetooth_rfcomm_write(int fd, const char *buf, int length);
4114
4115 /**
4116  * @fn gboolean bluetooth_rfcomm_is_client_connected(void)
4117  * @brief Informs whether rfcomm client is connected.
4118  *
4119  * This function is a synchronous call.
4120  *
4121  * @return   TRUE  - RFCOMM client is connected \n
4122  *              FALSE - RFCOMM client is not connected \n
4123  *
4124  * @exception   None
4125  *
4126  * @remark       None
4127  */
4128 gboolean bluetooth_rfcomm_is_client_connected(void);
4129 int bluetooth_rfcomm_client_is_connected(const bluetooth_device_address_t *device_address, gboolean *connected);
4130 int bluetooth_rfcomm_server_is_connected(const bluetooth_device_address_t *device_address, gboolean *connected);
4131
4132 /**
4133  * @fn int bluetooth_network_activate_server(void)
4134  * @brief Activate the NAP (Network Access Point) service
4135  *
4136  * This function is a asynchronous call.
4137  * The activate server request is responded by BLUETOOTH_EVENT_NETWORK_SERVER_ACTIVATED event.
4138  *
4139  * @return   BLUETOOTH_ERROR_NONE  - Success \n
4140  *              BLUETOOTH_ERROR_INVALID_PARAM - Invalid parameter \n
4141  *              BLUETOOTH_ERROR_INTERNAL - Internal Error \n
4142  *              BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Not enabled \n
4143  *
4144  * @remark      None
4145   * @see        bluetooth_network_deactivate_server
4146  *
4147  */
4148 int bluetooth_network_activate_server(void);
4149
4150 /**
4151  * @fn int bluetooth_network_deactivate_server(void)
4152  * @brief Deactivate the NAP (Network Access Point) service
4153  *
4154  * This function is a asynchronous call.
4155  * The deactivate server request is responded by BLUETOOTH_EVENT_NETWORK_SERVER_DEACTIVATED event.
4156  *
4157  * @return   BLUETOOTH_ERROR_NONE  - Success \n
4158  *              BLUETOOTH_ERROR_INVALID_PARAM - Invalid parameter \n
4159  *              BLUETOOTH_ERROR_INTERNAL - Internal Error \n
4160  *              BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Not enabled \n
4161  *
4162  * @remark      None
4163  * @see         bluetooth_network_activate_server
4164  *
4165  */
4166 int bluetooth_network_deactivate_server(void);
4167
4168 /**
4169  * @fn int bluetooth_network_connect(const bluetooth_device_address_t *device_address,
4170  *                                      bluetooth_network_role_t role,
4171  *                                      char  custom_uuid)
4172  * @brief Connect the network server in the peer
4173  *
4174  * This function is a asynchronous call.
4175  * The network connect request is responded by BLUETOOTH_EVENT_NETWORK_CONNECTED event.
4176  *
4177  * @return   BLUETOOTH_ERROR_NONE  - Success \n
4178  *              BLUETOOTH_ERROR_INVALID_PARAM - Invalid parameter \n
4179  *              BLUETOOTH_ERROR_INTERNAL - Internal Error \n
4180  *              BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Not enabled \n
4181  *
4182  * @exception   None
4183  * @param[in]  device_address   This indicates an address of the device with which the pairing
4184  *                              should be initiated
4185  * @param[in]  role   The role to connect. PANU / GN / NAP / CUSTOM. If use the CUSTOM value,
4186  *                      need to use the third parameter.
4187  * @param[in]  custom_uuid   If use the CUSTOM value in second parameter, use this parameter to
4188  *                              connect. UUID string
4189  * @remark      None
4190  * @see         bluetooth_network_disconnect
4191  */
4192 int bluetooth_network_connect(const bluetooth_device_address_t *device_address,
4193                                       bluetooth_network_role_t role, char *custom_uuid);
4194
4195 /**
4196  * @fn int bluetooth_network_disconnect(const bluetooth_device_address_t *device_address,
4197  *                                                      bluetooth_network_role_t role,
4198  *                                                        char *custom_uuid)
4199  * @brief Connect the network server in the peer
4200  *
4201  * This function is a asynchronous call.
4202  * The network disconnect request is responded by BLUETOOTH_EVENT_NETWORK_CONNECTED event.
4203  *
4204  * @return   BLUETOOTH_ERROR_NONE  - Success \n
4205  *              BLUETOOTH_ERROR_INVALID_PARAM - Invalid parameter \n
4206  *              BLUETOOTH_ERROR_INTERNAL - Internal Error \n
4207  *              BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Not enabled \n
4208  *
4209  * @exception   None
4210  * @param[in]   device_address   This indicates an address of the device with which the pairing
4211  *                                      should be initiated
4212  * @remark       None
4213  * @see         bluetooth_network_connect
4214  */
4215 int bluetooth_network_disconnect(const bluetooth_device_address_t *device_address);
4216
4217 /**
4218  * @fn int bluetooth_network_server_disconnect(const bluetooth_device_address_t *device_address)
4219  * @brief Disconnect the device from the network
4220  *
4221  * This function is an asynchronous call.
4222  * The network server disconnect request is responded by
4223  * BLUETOOTH_EVENT_NETWORK_SERVER_DISCONNECTED event.
4224  *
4225  * @return   BLUETOOTH_ERROR_NONE  - Success \n
4226  *              BLUETOOTH_ERROR_INVALID_PARAM - Invalid parameter \n
4227  *              BLUETOOTH_ERROR_INTERNAL - Internal Error \n
4228  *              BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Not enabled \n
4229  *
4230  * @exception   None
4231  * @param[in]   device_address   This indicates an address of the connected client device
4232  * @remark       None
4233  * @see         bluetooth_network_activate_server
4234  */
4235 int bluetooth_network_server_disconnect(const bluetooth_device_address_t *device_address);
4236
4237 /*HDP - API's*/
4238
4239 /**
4240  * @fn int bluetooth_hdp_activate(unsigned short  data_type,
4241  *                                      bt_hdp_role_type_t role,
4242  *                                      bt_hdp_qos_type_t channel_type,
4243  *                                      char **app_handle)
4244  * @brief Activate the HDP service for a particular data type
4245  *
4246  * This function is a synchronous call.
4247  *
4248  * @return   BLUETOOTH_ERROR_NONE  - Success \n
4249  *              BLUETOOTH_ERROR_INVALID_PARAM - Invalid parameter \n
4250  *              BLUETOOTH_ERROR_INTERNAL - Internal Error \n
4251  *              BLUETOOTH_ERROR_NO_RESOURCES - Not resource available \n
4252  *
4253  * @exception   None
4254  * @param[in]  data_type   The data type against corresponding service
4255  * @param[in]  role   The role of HDP. HDP_ROLE_SOURCE/HDP_ROLE_SINK.
4256  * @param[in]  channel_type   The QOS type for the channel.
4257  *                              HDP_QOS_RELIABLE/HDP_QOS_STREAMING/HDP_QOS_ANY.
4258  *                              For role = HDP_ROLE_SINK, the channel_type
4259  *                              should be HDP_QOS_ANY.
4260  * @param[out]  app_handle    The application handler against corresponding service
4261  * @remark       None
4262  * @see bluetooth_hdp_deactivate
4263  */
4264 int bluetooth_hdp_activate(unsigned short  data_type,
4265                                 bt_hdp_role_type_t role,
4266                                 bt_hdp_qos_type_t channel_type,
4267                                 char **app_handle);
4268 /**
4269  * @fn int bluetooth_hdp_deactivate(const char *app_handle)
4270  * @brief Deactivate the HDP service for a particular service using the handler
4271  *
4272  * This function is a synchronous call.
4273  *
4274  * @return   BLUETOOTH_ERROR_NONE  - Success \n
4275  *              BLUETOOTH_ERROR_INVALID_PARAM - Invalid parameter \n
4276  *              BLUETOOTH_ERROR_INTERNAL - Internal Error \n
4277  *              BLUETOOTH_ERROR_NO_RESOURCES - Not resource available \n
4278  *
4279  * @exception   None
4280  * @param[in]  app_handle   The application handler against corresponding service
4281  * @remark       None
4282  * @see bluetooth_hdp_deactivate
4283  */
4284 int bluetooth_hdp_deactivate(const char *app_handle);
4285
4286 /**
4287  * @fn int bluetooth_hdp_send_data(unsigned int channel_id,
4288  *                                      const char *buffer, unsigned int size)
4289  * @brief Send data to the remote HDP device
4290  *
4291  * This function is a synchronous call.
4292  *
4293  * @return   BLUETOOTH_ERROR_NONE  - Success \n
4294  *             BLUETOOTH_ERROR_INVALID_PARAM - Invalid parameter \n
4295  *             BLUETOOTH_ERROR_INTERNAL - Internal Error \n
4296  *             BLUETOOTH_ERROR_NO_RESOURCES - Not resource available \n
4297  *             BLUETOOTH_ERROR_NOT_IN_OPERATION - FD is invalid  \n
4298  *
4299  * @exception   None
4300  * @param[in]  channel_id   The channel id for the connection.
4301  * @param[in]  buffer   The pdu buffer.
4302  * @param[in]  size   Size of the buffer.
4303  * @remark       None
4304  * @see bluetooth_hdp_connect
4305  */
4306 int bluetooth_hdp_send_data(unsigned int channel_id,
4307                                 const char *buffer, unsigned int size);
4308 /**
4309  * @fn int bluetooth_hdp_connect(const char *app_handle,
4310  *                              bt_hdp_qos_type_t channel_type,
4311  *                              const bluetooth_device_address_t *device_address)
4312  * @brief Connect to the remote device(Mainly used by source)
4313  *
4314  * This function is a asynchronous call.
4315  * The HDP activate is responded by BLUETOOTH_EVENT_HDP_CONNECTED event.
4316  *
4317  * @return   BLUETOOTH_ERROR_NONE  - Success \n
4318  *              BLUETOOTH_ERROR_INVALID_PARAM - Invalid parameter \n
4319  *              BLUETOOTH_ERROR_INTERNAL - Internal Error \n
4320  *              BLUETOOTH_ERROR_NO_RESOURCES - Not resource available \n
4321  *              BLUETOOTH_ERROR_MEMORY_ALLOCATION -Memory allocation failed \n
4322  *
4323  * @exception   None
4324  * @param[in]  app_handle   The application handler against corresponding service
4325  * @param[in]  channel_type   The QOS type for the channel.
4326  *                              HDP_QOS_RELIABLE/HDP_QOS_STREAMING.
4327  * @param[in]  device_address   The remote device Bd address.
4328  *
4329  * @remark       None
4330  * @see bluetooth_hdp_disconnect
4331  */
4332 int bluetooth_hdp_connect(const char *app_handle,
4333                         bt_hdp_qos_type_t channel_type,
4334                         const bluetooth_device_address_t *device_address);
4335 /**
4336  * @fn int bluetooth_hdp_disconnect(unsigned int channel_id,
4337  *                      const bluetooth_device_address_t *device_address)
4338  * @brief Disconnect from the remote device(Mainly used by source)
4339  *
4340  * This function is a asynchronous call.
4341  * The HDP activate is responded by BLUETOOTH_EVENT_HDP_DISCONNECTED event.
4342  *
4343  * @return   BLUETOOTH_ERROR_NONE  - Success \n
4344  *              BLUETOOTH_ERROR_INVALID_PARAM - Invalid parameter \n
4345  *              BLUETOOTH_ERROR_INTERNAL - Internal Error \n
4346  *              BLUETOOTH_ERROR_NO_RESOURCES - Not resource available \n
4347   *              BLUETOOTH_ERROR_MEMORY_ALLOCATION -Memory allocation failed \n
4348  *
4349  * @exception   None
4350  * @param[in]  channel_id    The channel id for the connection.
4351  * @param[in]  device_address   The remote device Bd address.
4352  *
4353  * @remark       None
4354  * @see bluetooth_hdp_connect
4355  */
4356 int bluetooth_hdp_disconnect(unsigned int channel_id,
4357                         const bluetooth_device_address_t  *device_address);
4358
4359
4360 /**
4361  * @fn int bluetooth_opc_init(void)
4362  * @brief Initialize OPP client.
4363  *
4364  * This function is a synchronous call.
4365  * No event corresponding to this api
4366  *
4367  * @return   BLUETOOTH_ERROR_NONE  - Success \n
4368  *              BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Device is not enabled \n
4369  *              BLUETOOTH_ERROR_INTERNAL - Internal Error \n
4370  *              BLUETOOTH_ERROR_NO_RESOURCES - Not resource available \n
4371   *             BLUETOOTH_ERROR_ACCESS_DENIED -Memory allocation failed \n
4372  *
4373  * @exception   None
4374  *
4375  * @remark       None
4376  * @see bluetooth_opc_deinit
4377  */
4378 int bluetooth_opc_init(void);
4379
4380 /**
4381  * @fn int bluetooth_opc_deinit(void)
4382  * @brief Deinitialize OPP client.
4383  *
4384  * This function is a synchronous call.
4385  * No event corresponding to this api
4386  *
4387  * @return   BLUETOOTH_ERROR_NONE  - Success \n
4388  *              BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Device is not enabled \n
4389  *              BLUETOOTH_ERROR_ACCESS_DENIED -Memory allocation failed \n
4390  *
4391  * @exception   None
4392  *
4393  * @remark       None
4394  * @see bluetooth_opc_init
4395  */
4396
4397 int bluetooth_opc_deinit(void);
4398
4399 /**
4400  * @fn int bluetooth_opc_push_files(bluetooth_device_address_t *remote_address,
4401                                         char **file_name_array)
4402  * @brief Send multiple files to a remote device.
4403  *
4404  * This function is a asynchronous call.
4405  * This api  is responded by BLUETOOTH_EVENT_OPC_CONNECTED event.
4406  *
4407  * @return   BLUETOOTH_ERROR_NONE  - Success \n
4408  *              BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Device is not enabled \n
4409  *              BLUETOOTH_ERROR_INVALID_PARAM - Invalid parameter \n
4410  *              BLUETOOTH_ERROR_INTERNAL - Internal Error \n
4411  *              BLUETOOTH_ERROR_NO_RESOURCES - Not resource available \n
4412  *              BLUETOOTH_ERROR_IN_PROGRESS -Already one push in progress \n
4413  *              BLUETOOTH_ERROR_ACCESS_DENIED - Not allowed by MDM policy \n
4414  *
4415  * @exception   None
4416  * @param[in]  device_address   The remote device Bd address.
4417  * @param[in]  file_name_array  Array of filepaths to be sent.
4418  *
4419  * @remark       None
4420  * @see bluetooth_opc_cancel_push
4421  */
4422
4423 int bluetooth_opc_push_files(bluetooth_device_address_t *remote_address,
4424                                 char **file_name_array);
4425
4426 /**
4427  * @fn int bluetooth_opc_cancel_push(void)
4428  * @brief Cancels the ongoing file push.
4429  *
4430  * This function is a asynchronous call.
4431  * This api is responded with either BLUETOOTH_EVENT_OPC_CONNECTED or
4432  * BLUETOOTH_EVENT_OPC_TRANSFER_COMPLETED event.
4433  *
4434  * @return   BLUETOOTH_ERROR_NONE  - Success \n
4435  *              BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Device is not enabled \n
4436  *              BLUETOOTH_ERROR_ACCESS_DENIED - No push in progress \n
4437  *
4438  * @exception   None
4439  *
4440  * @remark       None
4441  * @see bluetooth_opc_push_files
4442  */
4443
4444 int bluetooth_opc_cancel_push(void);
4445
4446 /**
4447  * @fn gboolean bluetooth_opc_session_is_exist(void)
4448  * @brief Informs whether opc session exists or not.
4449  *
4450  * This function is a synchronous call.
4451  *
4452  * @return   TRUE  - OPC session exists \n
4453  *              FALSE - OPC session does not exist \n
4454  *
4455  * @exception   None
4456  *
4457  * @remark       None
4458  * @see None
4459  */
4460
4461 gboolean bluetooth_opc_session_is_exist(void);
4462
4463 /**
4464  * @fn int bluetooth_opc_is_sending(gboolean *is_sending)
4465  * @brief Informs whether opc session exists or not.
4466  *
4467  * This function is a synchronous call.
4468  *
4469  * @return   BLUETOOTH_ERROR_NONE  - Success \n
4470  *               BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Not enabled \n
4471  *               BLUETOOTH_ERROR_INTERNAL \n
4472  *
4473  * @exception   None
4474  * @param[out] is_sending The sending status: (@c TRUE = in sending , @c  false = not in sending)
4475  *
4476  * @remark       None
4477  * @see            None
4478  */
4479 int bluetooth_opc_is_sending(gboolean *is_sending);
4480
4481 /**
4482  * @fn int bluetooth_opp_get_transfer_progress(bluetooth_opp_transfer_type_t transfer_type,
4483                 int transfer_id, unsigned char *progress)
4484  * @brief Gets the percentage progress for ongoing transfers.
4485  *
4486  * This function is a synchronous call.
4487  *
4488  * @return   BLUETOOTH_ERROR_NONE  - Success \n
4489  *               BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Not enabled \n
4490  *               BLUETOOTH_ERROR_NOT_FOUND - Not found \n
4491  *
4492  * @exception   None
4493  * @param[in] transfer_type     Transfer Type: (@c BLUETOOTH_TRANSFER_INBOUND = receiving , @c  BLUETOOTH_TRANSFER_OUTBOUND = sending)
4494  * @param[in] transfer_id       Transfer ID
4495  * @param[out] progress         Percentage Progress
4496  * @remark       None
4497  * @see            None
4498  */
4499 int bluetooth_opp_get_transfer_progress(bluetooth_opp_transfer_type_t transfer_type,
4500                 int transfer_id, unsigned char *progress);
4501
4502 /**
4503  * @fn int bluetooth_obex_server_init(const char *dst_path)
4504  * @brief Initialize OPP and FTP server.
4505  *
4506  * This function is a synchronous call.
4507  * No event corresponding to this api
4508  *
4509  * @return   BLUETOOTH_ERROR_NONE  - Success \n
4510  *              BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Device is not enabled \n
4511  *              BLUETOOTH_ERROR_NO_RESOURCES - Not resource available \n
4512  *              BLUETOOTH_ERROR_AGENT_ALREADY_EXIST - Obex agent already registered \n
4513  *              BLUETOOTH_ERROR_INVALID_PARAM - Invalid parameter \n
4514  *
4515  * @exception   None
4516  * @param[in]  dst_path   OPS destination file path.
4517  * @remark       None
4518  * @see bluetooth_obex_server_deinit
4519  */
4520 int bluetooth_obex_server_init(const char *dst_path);
4521
4522
4523 /**
4524  * @fn int bluetooth_obex_server_deinit(void)
4525  * @brief Deinitialize OPP and FTP server.
4526  *
4527  * This function is a synchronous call.
4528  * No event corresponding to this api
4529  *
4530  * @return   BLUETOOTH_ERROR_NONE  - Success \n
4531  *              BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Device is not enabled \n
4532  *              BLUETOOTH_ERROR_AGENT_DOES_NOT_EXIST -Obex agent not registered \n
4533  *
4534  * @exception   None
4535  *
4536  * @remark       None
4537  * @see bluetooth_obex_server_init
4538  */
4539 int bluetooth_obex_server_deinit(void);
4540
4541
4542 /**
4543  * @fn gboolean bluetooth_obex_server_is_activated(void)
4544  * @brief Informs whether obex server is activated or not.
4545  *
4546  * This function is a synchronous call.
4547  *
4548  * @return   TRUE  - OBEX server is activated \n
4549  *              FALSE - OBEX server is not activated \n
4550  *
4551  * @exception   None
4552  *
4553  * @remark       None
4554  */
4555
4556 gboolean bluetooth_obex_server_is_activated(void);
4557
4558
4559 /**
4560  * @fn int bluetooth_obex_server_init_without_agent(const char *dst_path)
4561  * @brief Initialize OPP and FTP server without the conneciton authorization of the agent
4562  *
4563  * This function is a synchronous call.
4564  * No event corresponding to this api
4565  *
4566  * @return   BLUETOOTH_ERROR_NONE  - Success \n
4567  *              BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Device is not enabled \n
4568  *              BLUETOOTH_ERROR_NO_RESOURCES - Not resource available \n
4569  *              BLUETOOTH_ERROR_AGENT_ALREADY_EXIST - Obex agent already registered \n
4570  *              BLUETOOTH_ERROR_INVALID_PARAM - Invalid parameter \n
4571  *
4572  *
4573  * @exception   None
4574  * @param[in]  dst_path   OPS destination file path.
4575  * @remark       None
4576  * @see bluetooth_obex_server_deinit_without_agent
4577  */
4578 int bluetooth_obex_server_init_without_agent(const char *dst_path);
4579
4580
4581 /**
4582  * @fn int bluetooth_obex_server_deinit_without_agent(void)
4583  * @brief Deinitialize OPP and FTP server without the conneciton authorization of the agent
4584  *
4585  * This function is a synchronous call.
4586  * No event corresponding to this api
4587  *
4588  * @return   BLUETOOTH_ERROR_NONE  - Success \n
4589  *              BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Device is not enabled \n
4590  *              BLUETOOTH_ERROR_AGENT_DOES_NOT_EXIST -Obex agent not registered \n
4591  *
4592  * @exception   None
4593  *
4594  * @remark       None
4595  * @see bluetooth_obex_server_init_without_agent
4596  */
4597 int bluetooth_obex_server_deinit_without_agent(void);
4598
4599
4600 /**
4601  * @fn int bluetooth_obex_server_accept_connection(void)
4602  * @brief Accepts the authorization request indicated by the event
4603   * BLUETOOTH_EVENT_OBEX_SERVER_CONNECTION_AUTHORIZE.
4604  *
4605  * This function is a synchronous call.
4606  *
4607  * @return   BLUETOOTH_ERROR_NONE  - Success \n
4608  *              BLUETOOTH_ERROR_NO_RESOURCES - Not resource available \n
4609  *              BLUETOOTH_ERROR_INTERNAL - Internal error \n
4610  *
4611  * @exception   None
4612  * @remark       None
4613  * @see bluetooth_obex_server_reject_authorize
4614  */
4615 int bluetooth_obex_server_accept_connection(void);
4616
4617
4618 /**
4619  * @fn int bluetooth_obex_server_reject_connection(void)
4620  * @brief Rejects the authorization request indicated by the event
4621   * BLUETOOTH_EVENT_OBEX_SERVER_CONNECTION_AUTHORIZE.
4622  *
4623  * This function is a synchronous call.
4624  *
4625  * @return   BLUETOOTH_ERROR_NONE  - Success \n
4626  *              BLUETOOTH_ERROR_NO_RESOURCES - Not resource available \n
4627  *              BLUETOOTH_ERROR_INTERNAL - Internal error \n
4628  *
4629  * @exception   None
4630  * @remark       None
4631  * @see bluetooth_obex_server_reject_authorize
4632  */
4633 int bluetooth_obex_server_reject_connection(void);
4634
4635
4636 /**
4637  * @fn int bluetooth_obex_server_accept_authorize(const char *filename)
4638  * @brief Accepts the authorization request indicated by the event
4639   * BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_AUTHORIZE.
4640  *
4641  * This function is a asynchronous call.
4642  * This api will be responded with the event BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_STARTED.
4643  *
4644  * @return   BLUETOOTH_ERROR_NONE  - Success \n
4645  *              BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Device is not enabled \n
4646  *              BLUETOOTH_ERROR_INVALID_PARAM - Invalid parameter \n
4647  *              BLUETOOTH_ERROR_AGENT_DOES_NOT_EXIST -Obex agent not registered \n
4648  *
4649  * @exception   None
4650  * @param[in]  filename   Authorized filename.
4651
4652  * @remark       None
4653  * @see bluetooth_obex_server_reject_authorize
4654  */
4655
4656 int bluetooth_obex_server_accept_authorize(const char *filename);
4657
4658 /**
4659  * @fn int bluetooth_obex_server_reject_authorize(void)
4660  * @brief Reject the authorization request indicated by the event
4661   * BLUETOOTH_EVENT_OBEX_SERVER_TRANSFER_AUTHORIZE.
4662  *
4663  * This function is a asynchronous call.
4664  * No event for this api..
4665  *
4666  * @return   BLUETOOTH_ERROR_NONE  - Success \n
4667  *              BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Device is not enabled \n
4668  *              BLUETOOTH_ERROR_AGENT_DOES_NOT_EXIST -Obex agent not registered \n
4669  *
4670  * @exception   None
4671
4672  * @remark       None
4673  * @see bluetooth_obex_server_accept_authorize
4674  */
4675
4676 int bluetooth_obex_server_reject_authorize(void);
4677
4678 /**
4679  * @fn int bluetooth_obex_server_set_destination_path(const char *dst_path)
4680  * @brief Set the OPS destination file path..
4681  *
4682  * This function is a asynchronous call.
4683  * No event for this api..
4684  *
4685  * @return   BLUETOOTH_ERROR_NONE  - Success \n
4686  *              BLUETOOTH_ERROR_NO_RESOURCES - Not resource available \n
4687  *              BLUETOOTH_ERROR_AGENT_DOES_NOT_EXIST -Obex agent not registered \n
4688  *              BLUETOOTH_ERROR_INVALID_PARAM - Invalid Param \n
4689  *
4690  * @exception   None
4691  * @param[in]  dst_path   OPS destination file path.
4692
4693  * @remark       None
4694  * @see None
4695  */
4696
4697 int bluetooth_obex_server_set_destination_path(const char *dst_path);
4698
4699 /**
4700  * @fn int bluetooth_obex_server_set_root(const char *root)
4701  * @brief Set the FTS root folder..
4702  *
4703  * This function is a asynchronous call.
4704  * No event for this api..
4705  *
4706  * @return   BLUETOOTH_ERROR_NONE  - Success \n
4707  *              BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Device is not enabled \n
4708  *              BLUETOOTH_ERROR_NO_RESOURCES - Not resource available \n
4709  *              BLUETOOTH_ERROR_ACCESS_DENIED - Operation not allowed \n
4710  *              BLUETOOTH_ERROR_INVALID_PARAM - Invalid parameter \n
4711  *              BLUETOOTH_ERROR_INTERNAL - Internal Error \n
4712  *
4713  * @exception  None
4714  * @param[in]   root   FTS root folder.
4715
4716  * @remark       None
4717  * @see None
4718  */
4719
4720 int bluetooth_obex_server_set_root(const char *root);
4721
4722 /**
4723  * @fn int bluetooth_obex_server_cancel_transfer(int transfer_id)
4724  * @brief Cancel the transfer on server
4725  *
4726  * This function is an asynchronous call.
4727  * If the function call that cancels transfer is successful, the application would receive
4728  * BLUETOOTH_EVENT_TRANSFER_COMPLETED event through registered callback
4729  * function with an error code BLUETOOTH_ERROR_CANCEL. In the case of failure
4730  * the error code will be BLUETOOTH_ERROR_NONE
4731  *
4732  * @return   BLUETOOTH_ERROR_NONE  - Success \n
4733  *               BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Not enabled \n
4734  *               BLUETOOTH_ERROR_AGENT_DOES_NOT_EXIST -Obex agent not registered \n
4735  *               BLUETOOTH_ERROR_INTERNAL - internal error (proxy does not exist) \n
4736  *               BLUETOOTH_ERROR_NOT_FOUND - The transfer is not found \n
4737  *
4738  * @exception None
4739  * @param[in] transfer_id transfer ID
4740
4741  * @remark       None
4742  * @see None
4743  */
4744 int bluetooth_obex_server_cancel_transfer(int transfer_id);
4745
4746
4747 /**
4748  * @fn int bluetooth_obex_server_cancel_all_transfers(void)
4749  * @brief Cancel the transfer on server
4750  *
4751  * This function is an asynchronous call.
4752  * If the function call that cancels transfer is successful, the application would receive
4753  * BLUETOOTH_EVENT_TRANSFER_COMPLETED event through registered callback
4754  * function with an error code BLUETOOTH_ERROR_CANCEL. In the case of failure
4755  * the error code will be BLUETOOTH_ERROR_NONE
4756  *
4757  * @return   BLUETOOTH_ERROR_NONE  - Success \n
4758  *               BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Not enabled \n
4759  *               BLUETOOTH_ERROR_AGENT_DOES_NOT_EXIST -Obex agent not registered \n
4760  *               BLUETOOTH_ERROR_INTERNAL - internal error (proxy does not exist) \n
4761  *               BLUETOOTH_ERROR_NOT_FOUND - The transfer is not found \n
4762  *
4763  * @exception None
4764  *
4765  * @remark       None
4766  * @see None
4767  */
4768 int bluetooth_obex_server_cancel_all_transfers(void);
4769
4770
4771 /**
4772  * @fn int bluetooth_obex_server_is_receiving(gboolean *is_receiving)
4773  * @brief Informs whether obex server is receiving or not.
4774  *
4775  * This function is a synchronous call.
4776  *
4777  * @return   BLUETOOTH_ERROR_NONE  - Success \n
4778  *               BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Not enabled \n
4779  *               BLUETOOTH_ERROR_INTERNAL \n
4780  *
4781  * @exception   None
4782  * @param[out] is_receiving The receiving status: (@c TRUE = in receiving , @c  false = not in receiving)
4783  *
4784  * @remark       None
4785  * @see None
4786  */
4787 int bluetooth_obex_server_is_receiving(gboolean *is_receiving);
4788
4789
4790 /**
4791  * @fn int bluetooth_oob_read_local_data(bt_oob_data_t *local_oob_data)
4792  * @brief Read the local Hash and Randmizer.
4793  *
4794  * This function is a synchronous call.
4795  *
4796  * @return   BLUETOOTH_ERROR_NONE  - Success \n
4797  *           BLUETOOTH_ERROR_INTERNAL - Internal Error \n
4798  *
4799  * @exception  None
4800  * @param[in]  None.
4801  * @param[out] local_oob_data - Pointer to the local OOB data
4802  *
4803  * @remark       None
4804  * @see None
4805  */
4806
4807 int bluetooth_oob_read_local_data(bt_oob_data_t *local_oob_data);
4808
4809
4810 /**
4811  * @fn int bluetooth_oob_add_remote_data(
4812  *                      const bluetooth_device_address_t *remote_device_address,
4813  *                      bt_oob_data_t *oob_data)
4814  * @brief Add/updated the remote device  Hash and Randmizer.
4815  *
4816  * This function is a synchronous call.
4817  * No event for this api..
4818  *
4819  * @return   BLUETOOTH_ERROR_NONE  - Success \n
4820  *           BLUETOOTH_ERROR_INTERNAL - Internal Error \n
4821  *
4822  * @exception   None
4823  * @param[in] remote_device_address - Remote device address
4824  *            remote_oob_data - Ponter to Hash and Randomizer oob data structure
4825  *
4826  * @remark      None
4827  * @see         None
4828  */
4829
4830 int bluetooth_oob_add_remote_data(
4831                    const bluetooth_device_address_t *remote_device_address,
4832                    bt_oob_data_t *remote_oob_data);
4833
4834
4835 /**
4836  * @fn int bluetooth_oob_remove_remote_data(
4837  *                      const bluetooth_device_address_t *remote_device_address)
4838  * @brief Delete the Hash and Randomizer w.r.t the remote device address.
4839  *
4840  * This function is a synchronous call.
4841  * No event for this api..
4842  *
4843  * @return   BLUETOOTH_ERROR_NONE  - Success \n
4844  *           BLUETOOTH_ERROR_INTERNAL - Internal Error \n
4845  *
4846  * @exception  None
4847  * @param[in] remote_device_address - Remote device address
4848  *
4849  * @remark       None
4850  * @see None
4851  */
4852
4853 int bluetooth_oob_remove_remote_data(
4854                         const bluetooth_device_address_t *remote_device_address);
4855
4856 /**
4857  * @fn int bluetooth_gatt_get_primary_services(const bluetooth_device_address_t *address,
4858  *                                              bt_gatt_handle_info_t *prim_svc);
4859  *
4860  * @brief Gets the GATT based primary services handle supported by remote device
4861  *
4862  * This function is a synchronous call.
4863  * The output parameter needs to be freed by calling bluetooth_gatt_free_primary_services()
4864  *
4865  * @return   BLUETOOTH_ERROR_NONE  - Success \n
4866  *              BLUETOOTH_ERROR_INTERNAL - Internal Error \n
4867  *              BLUETOOTH_ERROR_INVALID_PARAM -Invalid Parameters \n
4868  *              BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is disabled \n
4869  *
4870  * @exception    None
4871  * @param[in]    address - Remote device address
4872  * @param[out] prim_svc - Structure containing remote service count and handle list.
4873  *
4874  * @remark      None
4875  * @see         bluetooth_gatt_free_primary_services()
4876  */
4877 int bluetooth_gatt_get_primary_services(const bluetooth_device_address_t *address,
4878                                                 bt_gatt_handle_info_t *prim_svc);
4879
4880 /**
4881  * @fn int bluetooth_gatt_discover_service_characteristics(const char *service_handle)
4882  *
4883  * @brief Discovers the characteristics of GATT based service of remote device
4884  *
4885  * This function is an asynchronous call.
4886  * This API is responded with BLUETOOTH_EVENT_GATT_SVC_CHAR_DISCOVERED
4887  *
4888  * @return   BLUETOOTH_ERROR_NONE  - Success \n
4889  *              BLUETOOTH_ERROR_INTERNAL - Internal Error \n
4890  *              BLUETOOTH_ERROR_INVALID_PARAM -Invalid Parameters \n
4891  *              BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is disabled \n
4892  *
4893  * @exception   None
4894  * @param[in]   service_handle - Handle for remote service.
4895  *
4896  * @remark      None
4897  * @see         None
4898  */
4899 int bluetooth_gatt_discover_service_characteristics(const char *service_handle);
4900
4901 int bluetooth_gatt_set_service_change_watcher(
4902                 const bluetooth_device_address_t *address, gboolean enable);
4903
4904 /**
4905  * @fn int bluetooth_gatt_get_service_property(const char *service_handle,
4906  *                                              bt_gatt_service_property_t *service);
4907  *
4908  * @brief Gets the properties of GATT based service of remote device
4909  *
4910  * This function is a synchronous call.
4911  * The output parameter needs to be freed by calling bluetooth_gatt_free_primary_services()
4912  *
4913  * @return   BLUETOOTH_ERROR_NONE  - Success \n
4914  *              BLUETOOTH_ERROR_INTERNAL - Internal Error \n
4915  *              BLUETOOTH_ERROR_INVALID_PARAM -Invalid Parameters \n
4916  *              BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is disabled \n
4917  *
4918  * @exception   None
4919  * @param[in]   service_handle - Handle for remote service.
4920  * @param[out]  service - Structure containing remote service property.
4921  *
4922  * @remark      None
4923  * @see         bluetooth_gatt_free_service_property()
4924  */
4925 int bluetooth_gatt_get_service_property(const char *service_handle,
4926                                                 bt_gatt_service_property_t *service);
4927
4928 /**
4929  * @fn int bluetooth_gatt_watch_characteristics(const char *service_handle)
4930  *
4931  * @brief Register to GATT based service to receive value change notification/indication.
4932  *
4933  * This function is a synchronous call.
4934  * No event for this api.
4935  *
4936  * @return   BLUETOOTH_ERROR_NONE  - Success \n
4937  *              BLUETOOTH_ERROR_INTERNAL - Internal Error \n
4938  *              BLUETOOTH_ERROR_INVALID_PARAM -Invalid Parameters \n
4939  *              BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is disabled \n
4940  *
4941  * @exception   None
4942  * @param[in]   service_handle - Handle for remote service.
4943  *
4944  * @remark      None
4945  * @see None
4946  */
4947 int bluetooth_gatt_watch_characteristics(const char *service_handle);
4948
4949 /**
4950  * @fn int bluetooth_gatt_unwatch_characteristics(const char *service_handle)
4951  *
4952  * @brief Unregister GATT based service to receive value change notification/indication.
4953  *
4954  * This function is a synchronous call.
4955  * No event for this api.
4956  *
4957  * @return   BLUETOOTH_ERROR_NONE  - Success \n
4958  *              BLUETOOTH_ERROR_INTERNAL - Internal Error \n
4959  *              BLUETOOTH_ERROR_INVALID_PARAM -Invalid Parameters \n
4960  *              BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is disabled \n
4961  *
4962  * @exception   None
4963  * @param[in]   service_handle - Handle for remote service.
4964  *
4965  * @remark      None
4966  * @see         None
4967  */
4968 int bluetooth_gatt_unwatch_characteristics(const char *service_handle);
4969
4970 /**
4971  * @fn int bluetooth_gatt_get_characteristics_property(const char *char_handle,
4972  *                                              bt_gatt_char_property_t *characteristic);
4973  *
4974  * @brief Provides characteristic value along with properties.
4975  *
4976  * This function is a synchronous call.
4977  * The output parameter needs to be freed by calling bluetooth_gatt_free_char_property()
4978  *
4979  * @return   BLUETOOTH_ERROR_NONE  - Success \n
4980  *              BLUETOOTH_ERROR_INTERNAL - Internal Error \n
4981  *              BLUETOOTH_ERROR_INVALID_PARAM -Invalid Parameters \n
4982  *              BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is disabled \n
4983  *
4984  * @exception   None
4985  * @param[in]   char_handle - Handle for Characteristic property.
4986  * @param[out] characteristic - Structure containing remote characteristic property.
4987  *
4988  * @remark      None
4989  * @see         bluetooth_gatt_free_char_property()
4990  */
4991 int bluetooth_gatt_get_characteristics_property(const char *char_handle,
4992                                                 bt_gatt_char_property_t *characteristic);
4993
4994 /**
4995  * @fn int bluetooth_gatt_get_char_descriptor_property(const char *char_handle,
4996  *                                              bt_gatt_char_property_t *characteristic);
4997  *
4998  * @brief Provides characteristic descriptor value along with its UUID.
4999  *
5000  * This function is a synchronous call.
5001  * The output parameter needs to be freed by calling bluetooth_gatt_free_desc_property()
5002  *
5003  * @return   BLUETOOTH_ERROR_NONE  - Success \n
5004  *              BLUETOOTH_ERROR_INTERNAL - Internal Error \n
5005  *              BLUETOOTH_ERROR_INVALID_PARAM -Invalid Parameters \n
5006  *              BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is disabled \n
5007  *
5008  * @exception   None
5009  * @param[in]   desc_handle - Handle for Characteristic descriptor.
5010  * @param[out] descriptor - Structure containing remote characteristic descriptor property.
5011  *
5012  * @remark      None
5013  * @see         bluetooth_gatt_free_desc_property()
5014  */
5015 int bluetooth_gatt_get_char_descriptor_property(const char *desc_handle,
5016                                                 bt_gatt_char_descriptor_property_t *descriptor);
5017
5018
5019 /**
5020  * @fn int bluetooth_gatt_set_characteristics_value(const char *char_handle,
5021  *                                              const guint8 *value, int length)
5022  *
5023  * @brief Set characteristic value.
5024  *
5025  * This function is a synchronous call.
5026  *
5027  * @return   BLUETOOTH_ERROR_NONE  - Success \n
5028  *              BLUETOOTH_ERROR_INTERNAL - Internal Error \n
5029  *              BLUETOOTH_ERROR_INVALID_PARAM -Invalid Parameters \n
5030  *              BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is disabled \n
5031  *
5032  * @exception   None
5033  * @param[in]   char_handle - Handle for Characteristic property.
5034  * @param[in]   value - New value to set for characteristic property.
5035  * @param[in]   length - Length of the value to be set.
5036  *
5037  * @remark      None
5038  * @see         None
5039  */
5040 int bluetooth_gatt_set_characteristics_value(const char *char_handle,
5041                                                 const guint8 *value, int length);
5042
5043 /**
5044  * @fn int bluetooth_gatt_set_characteristics_value_by_type(const char *char_handle,
5045  *                              const guint8 *value, int length, guint8 write_type)
5046  *
5047  * @brief Set characteristic value by write type.
5048  *
5049  * This function is a synchronous call if write type is "write without resonse"
5050  * and it is an asynchronous call if write type is "write with response"
5051  *
5052  * @return   BLUETOOTH_ERROR_NONE  - Success \n
5053  *              BLUETOOTH_ERROR_INTERNAL - Internal Error \n
5054  *              BLUETOOTH_ERROR_INVALID_PARAM -Invalid Parameters \n
5055  *              BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is disabled \n
5056  *
5057  * @exception   None
5058  * @param[in]   char_handle - Handle for Characteristic property.
5059  * @param[in]   value - New value to set for characteristic property.
5060  * @param[in]   length - Length of the value to be set.
5061  * @param[in]   write_type - Type of write.
5062  *
5063  * @remark      None
5064  * @see         None
5065  */
5066 int bluetooth_gatt_set_characteristics_value_by_type(const char *char_handle,
5067                                 const guint8 *value, int length, guint8 write_type);
5068
5069
5070 /**
5071  * @fn int bluetooth_gatt_set_characteristics_value_request(const char *char_handle,
5072  *                                              const guint8 *value, int length)
5073  *
5074  * @brief Set characteristic value request.
5075  *
5076  * This function is an asynchronous call.
5077  *
5078  * @return   BLUETOOTH_ERROR_NONE  - Success \n
5079  *              BLUETOOTH_ERROR_INTERNAL - Internal Error \n
5080  *              BLUETOOTH_ERROR_INVALID_PARAM -Invalid Parameters \n
5081  *              BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is disabled \n
5082  *
5083  * @exception   None
5084  * @param[in]   char_handle - Handle for Characteristic property.
5085  * @param[in]   value - New value to set for characteristic property.
5086  * @param[in]   length - Length of the value to be set.
5087   *
5088  * @remark      None
5089  * @see         None
5090  */
5091 int bluetooth_gatt_set_characteristics_value_request(const char *char_handle,
5092                                                 const guint8 *value, int length);
5093
5094 /**
5095  * @fn int bluetooth_gatt_read_characteristic_value(const char *char_handle)
5096  *
5097  * @brief Read characteristic value.
5098  *
5099  * This function is a asynchronous call.
5100  *
5101  * @return   BLUETOOTH_ERROR_NONE  - Success \n
5102  *             BLUETOOTH_ERROR_INTERNAL - Internal Error \n
5103  *             BLUETOOTH_ERROR_INVALID_PARAM -Invalid Parameters \n
5104  *             BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is disabled \n
5105  *
5106  * @exception  None
5107  * @param[in]  char_handle - Handle for Characteristic property.
5108  *
5109  * @remark     None
5110  * @see        None
5111  */
5112 int bluetooth_gatt_read_characteristic_value(const char *char_handle);
5113
5114 /**
5115  * @fn int bluetooth_gatt_get_service_from_uuid(bluetooth_device_address_t *address,
5116  *                                      const char *service_uuid,
5117  *                                      bt_gatt_service_property_t *service)
5118  *
5119  * @brief Gets the service property from a device based on a particular uuid
5120  *
5121  * This function is a synchronous call.
5122  *
5123  * @return   BLUETOOTH_ERROR_NONE  - Success \n
5124  *              BLUETOOTH_ERROR_INTERNAL - Internal Error \n
5125  *              BLUETOOTH_ERROR_INVALID_PARAM -Invalid Parameters \n
5126  *              BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is disabled \n
5127  *
5128  * @exception   None
5129  * @param[in]   address - BD address of the remote device
5130  * @param[in]   service_uuid - uuid of the service.
5131  * @param[out] service - Structure containing the service property.
5132  *
5133  * @remark      None
5134  * @see         None
5135  */
5136 int bluetooth_gatt_get_service_from_uuid(bluetooth_device_address_t *address,
5137                                         const char *service_uuid,
5138                                         bt_gatt_service_property_t *service);
5139
5140 /**
5141  * @fn int bluetooth_gatt_get_char_from_uuid(const char *service_handle,
5142  *                                                      const char *char_uuid)
5143  *
5144  * @brief Gets the characteristic property from a service based on a particular char uuid
5145  *
5146  * This function is an asynchronous call.
5147  * This API is responded with BLUETOOTH_EVENT_GATT_GET_CHAR_FROM_UUID
5148  *
5149  * @return   BLUETOOTH_ERROR_NONE  - Success \n
5150  *              BLUETOOTH_ERROR_INTERNAL - Internal Error \n
5151  *              BLUETOOTH_ERROR_INVALID_PARAM -Invalid Parameters \n
5152  *              BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is disabled \n
5153  *
5154  * @exception   None
5155  * @param[in]   service_handle - Service handle.
5156  * @param[in]   uuid - Characteristic uuid.
5157  *
5158  * @remark      None
5159  * @see         None
5160  */
5161 int bluetooth_gatt_get_char_from_uuid(const char *service_handle,
5162                                                 const char *char_uuid);
5163
5164 /**
5165  * @fn int bluetooth_gatt_free_primary_services(bt_gatt_handle_info_t *prim_svc);
5166  *
5167  * @brief Releases the memory allocated by bluetooth_gatt_get_primary_services()
5168  *
5169  * This function is a synchronous call.
5170  * The input parameter is obtained by calling bluetooth_gatt_get_primary_services()
5171  *
5172  * @return   BLUETOOTH_ERROR_NONE  - Success \n
5173  *              BLUETOOTH_ERROR_INVALID_PARAM -Invalid Parameters \n
5174  *
5175  * @exception   None
5176  * @param[in]   prim_svc - GATT handle info structure
5177  *
5178  * @remark      None
5179  * @see         bluetooth_gatt_get_primary_services()
5180  */
5181 int bluetooth_gatt_free_primary_services(bt_gatt_handle_info_t *prim_svc);
5182
5183 /**
5184  * @fn int bluetooth_gatt_free_service_property(bt_gatt_service_property_t *svc_pty);
5185  *
5186  * @brief  Releases the memory allocated by bluetooth_gatt_get_service_property()
5187  *
5188  * This function is a synchronous call.
5189  * The input parameter is obtained by calling bluetooth_gatt_get_service_property()
5190  *
5191  * @return   BLUETOOTH_ERROR_NONE  - Success \n
5192  *              BLUETOOTH_ERROR_INVALID_PARAM -Invalid Parameters \n
5193  *
5194  * @exception   None
5195  * @param[in]   svc_pty - GATT service property structure.
5196  *
5197  * @remark      None
5198  * @see         bluetooth_gatt_get_service_property()
5199  */
5200 int bluetooth_gatt_free_service_property(bt_gatt_service_property_t *svc_pty);
5201
5202 /**
5203  * @fn int bluetooth_gatt_free_char_property(bt_gatt_char_property_t *char_pty);
5204  *
5205  * @brief Provides characteristic value along with properties.
5206  *
5207  * This function is a synchronous call.
5208  * The input parameter is obtained by calling bluetooth_gatt_get_characteristics_property()
5209  *
5210  * @return   BLUETOOTH_ERROR_NONE  - Success \n
5211  *              BLUETOOTH_ERROR_INVALID_PARAM -Invalid Parameters \n
5212  *
5213  * @exception   None
5214  * @param[in]   char_pty - GATT characteristics property structure.
5215  *
5216  * @remark      None
5217  * @see         bluetooth_gatt_get_characteristics_property()
5218  */
5219 int bluetooth_gatt_free_char_property(bt_gatt_char_property_t *char_pty);
5220
5221 /**
5222  * @fn int bluetooth_gatt_free_desc_property(bt_gatt_char_descriptor_property_t *desc_pty);
5223  *
5224  * @brief Releases the memory allocated by bluetooth_gatt_get_char_descriptor_property()
5225  *
5226  * This function is a synchronous call.
5227  * The input parameter is obtained by calling bluetooth_gatt_get_char_descriptor_property()
5228  *
5229  * @return   BLUETOOTH_ERROR_NONE  - Success \n
5230  *              BLUETOOTH_ERROR_INVALID_PARAM -Invalid Parameters \n
5231  *
5232  * @exception   None
5233  * @param[in]   desc_pty - GATT characteristics descriptor property structure.
5234  *
5235  * @remark      None
5236  * @see         bluetooth_gatt_get_char_descriptor_property()
5237  */
5238 int bluetooth_gatt_free_desc_property(bt_gatt_char_descriptor_property_t *desc_pty);
5239
5240 int bluetooth_connect_le(const bluetooth_device_address_t *device_address, gboolean auto_connect);
5241
5242 int bluetooth_disconnect_le(const bluetooth_device_address_t *device_address);
5243
5244  /**
5245  * @fn int bluetooth_gatt_discover_characteristic_descriptor(const char *characteristic_handle);
5246  *
5247  * @brief Discovers the characteristic descriptor value of a characteristic within its definition, asynchronously
5248  *
5249  * The input parameter is obtained by calling bluetooth_gatt_get_characteristics_property()
5250  *
5251  * @return  BLUETOOTH_ERROR_NONE  - Success \n
5252  *                      BLUETOOTH_ERROR_INVALID_PARAM -Invalid Parameters \n
5253  *
5254  * @exception   None
5255  * @param[in]   characteristic_handle - The characteristic handle for which characteristic descriptor has to be discovered.
5256  *
5257  * @remark      None
5258  */
5259 int bluetooth_gatt_discover_characteristic_descriptor(const char *characteristic_handle);
5260
5261 /**
5262  * @fn int bluetooth_gatt_read_descriptor_value(const char *desc_handle)
5263  *
5264  * @brief Read characteristic descriptor value.
5265  *
5266  * This function is a asynchronous call.
5267  *
5268  * @return   BLUETOOTH_ERROR_NONE  - Success \n
5269  *             BLUETOOTH_ERROR_INTERNAL - Internal Error \n
5270  *             BLUETOOTH_ERROR_INVALID_PARAM -Invalid Parameters \n
5271  *             BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is disabled \n
5272  *
5273  * @exception  None
5274  * @param[in]  desc_handle - Handle for Characteristic descriptor
5275  *
5276  * @remark     None
5277  * @see        None
5278  */
5279 int bluetooth_gatt_read_descriptor_value(const char *desc_handle);
5280
5281 /**
5282  * @fn int bluetooth_gatt_write_descriptor_value(const char *desc_handle,
5283  *                      const guint8 *value, int length);
5284  *
5285  * @brief Set characteristic descriptor value.
5286  *
5287  * This function is a asynchronous call.
5288  *
5289  * @return   BLUETOOTH_ERROR_NONE  - Success \n
5290  *             BLUETOOTH_ERROR_INTERNAL - Internal Error \n
5291  *             BLUETOOTH_ERROR_INVALID_PARAM -Invalid Parameters \n
5292  *             BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is disabled \n
5293  *
5294  * @exception  None
5295  * @param[in]  desc_handle - Handle for Characteristic descriptor
5296  * @param[in]  value - New value to set for characteristic descriptor
5297  * @param[in]  length - Length of the value to be set.
5298  *
5299  * @remark     None
5300  * @see        None
5301  */
5302 int bluetooth_gatt_write_descriptor_value(const char *desc_handle,
5303                         const guint8 *value, int length);
5304
5305 /* @fn int bluetooth_gatt_init(void)
5306 *
5307 * @brief Initializes the gatt service.
5308 *
5309 * This function is a synchronous call.
5310 * @return   BLUETOOTH_ERROR_NONE        - Success \n
5311 *       BLUETOOTH_ERROR_INTERNAL - Internal Error \n
5312 *       BLUETOOTH_ERROR_INVALID_PARAM -Invalid Parameters \n
5313 *       BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is disabled \n
5314 *
5315 * @exception     None
5316 * @remark  Adapter should be enabled
5317 * @see  bluetooth_gatt_deinit()
5318 */
5319 int bluetooth_gatt_init(void);
5320
5321 /* @fn int bluetooth_gatt_init(void)
5322 *
5323 * @brief DeInitializes the gatt service.
5324 *
5325 * This function is a synchronous call.
5326 * @return   BLUETOOTH_ERROR_NONE        - Success \n
5327 *       BLUETOOTH_ERROR_INTERNAL - Internal Error \n
5328 *       BLUETOOTH_ERROR_INVALID_PARAM -Invalid Parameters \n
5329 *       BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is disabled \n
5330 *
5331 * @exception     None
5332 * @remark  Adapter should be enabled
5333 * @see  bluetooth_gatt_init()
5334 */
5335 int bluetooth_gatt_deinit(void);
5336
5337 /* @fn int bluetooth_gatt_add_service(const char *svc_uuid,
5338                         unsigned char **svc_path)
5339 *
5340 * @brief Exports a new gatt service to the service interface.
5341 *
5342 * This function is a synchronous call.
5343 *
5344 * @return       BLUETOOTH_ERROR_NONE    - Success \n
5345 *        BLUETOOTH_ERROR_INTERNAL - Internal Error \n
5346 *        BLUETOOTH_ERROR_INVALID_PARAM -Invalid Parameters \n
5347 *        BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is disabled \n
5348 *
5349 * @exception     None
5350 * @param[in]   svc_uuid  Gatt service uuid.
5351 * @param[out] svc_path  service object path of the exported service.
5352 * @remark  Adapter should be enabled
5353 * @see  bluetooth_gatt_init()
5354 */
5355 int bluetooth_gatt_add_service(const char *svc_uuid,
5356                         char **svc_path);
5357
5358 /* @fn int bluetooth_gatt_add_new_characteristic(
5359                         const char *svc_path, const char *char_uuid,
5360                         bt_gatt_permission_t permissions,
5361                         bt_gatt_characteristic_property_t properties,
5362                         int flags_length, char **char_path);;
5363 *
5364 * @brief Exports a new gatt characteristic to the characteristic interface.
5365 *
5366 * This function is a synchronous call.
5367 * @return       BLUETOOTH_ERROR_NONE    - Success \n
5368 *        BLUETOOTH_ERROR_INTERNAL - Internal Error \n
5369 *        BLUETOOTH_ERROR_INVALID_PARAM -Invalid Parameters \n
5370 *        BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is disabled \n
5371 * @exception     None
5372 * @param[in]   svc_path service object path of the exported service.
5373 * @param[in]   char_uuid  Gatt service uuid.
5374 * @param[in]   properties       GATT characteristic properties.
5375 * @param[out] char_path characteristic object path of the exported characteristic.
5376 *
5377 * @remark  Adapter should be enabled
5378 * @see  bluetooth_gatt_add_service()
5379 */
5380 int bluetooth_gatt_add_new_characteristic(
5381                         const char *svc_path, const char *char_uuid,
5382                         bt_gatt_permission_t permissions,
5383                         bt_gatt_characteristic_property_t properties,
5384                         char **char_path);
5385
5386 /* @fn bluetooth_gatt_set_characteristic_value(
5387                         const char *characteristic, const char *char_value,
5388                         int value_length);
5389 *
5390 * @brief adds gatt charactertisic value to the given charactertistic path.
5391 *
5392 * This function is a synchronous call.
5393 * @return       BLUETOOTH_ERROR_NONE    - Success \n
5394 *        BLUETOOTH_ERROR_INTERNAL - Internal Error \n
5395 *        BLUETOOTH_ERROR_INVALID_PARAM -Invalid Parameters \n
5396 *        BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is disabled \n
5397 * @exception     None
5398 * @param[in]   char_value Value of the GATT characteristic to be added.
5399 * @param[in]   value_length length of the chantacteristic value..
5400 * @param[out] characteristic characteristic object path..
5401 *
5402 * @remark  Adapter should be enabled
5403 * @see  bluetooth_gatt_add_service()
5404 */
5405 int bluetooth_gatt_set_characteristic_value(
5406                         const char *characteristic, const char *char_value,
5407                         int value_length);
5408
5409 /* @fn  int bluetooth_gatt_add_descriptor(
5410                         const char *char_path, const char *desc_uuid,
5411                         bt_gatt_permission_t permissions,
5412                         char **desc_path);
5413 *
5414 * @brief Exports a new gatt descriptor to the descriptor interface.
5415 *
5416 * This function is a synchronous call.
5417 *
5418 * @return       BLUETOOTH_ERROR_NONE    - Success \n
5419 *        BLUETOOTH_ERROR_INTERNAL - Internal Error \n
5420 *        BLUETOOTH_ERROR_INVALID_PARAM -Invalid Parameters \n
5421 *        BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is disabled \n
5422 *
5423 * @exception    None
5424 * @param[in]    desc_uuid  Gatt descriptor uuid.
5425 * @param[in]    desc_value      GATT descriptor value.
5426 * @param[in]    value_length    Length of GATT descriptor value.
5427 * @param[in]    permissions     descriptor permissions.
5428 * @param[in]    properties      GATT descriptor properties.
5429 * @param[in]    char_path       characteristics object path of the exported character.
5430 *
5431 * @remark  Adapter should be enabled
5432 * @see  bluetooth_gatt_add_service()
5433 * @see  bluetooth_gatt_add_characteristics()
5434 */
5435 int bluetooth_gatt_add_descriptor(
5436                         const char *char_path, const char *desc_uuid,
5437                         bt_gatt_permission_t permissions,
5438                         char **desc_path);
5439
5440 /* @fn int bluetooth_gatt_set_descriptor_value(
5441                    const char *desc_path, const char *desc_value,
5442                    int value_length);
5443 *
5444 * @brief Adds value to the given descriptor handle.
5445 *
5446 * This function is a synchronous call.
5447 *
5448 * @return       BLUETOOTH_ERROR_NONE    - Success \n
5449 *        BLUETOOTH_ERROR_INTERNAL - Internal Error \n
5450 *        BLUETOOTH_ERROR_INVALID_PARAM -Invalid Parameters \n
5451 *        BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is disabled \n
5452 *
5453 * @exception     None
5454 * @param[in]   desc_value       GATT descriptor value.
5455 * @param[in]   value_length     Length of GATT descriptor value.
5456 * @param[in]   desc_path descriptor path to which the value needs to be added.
5457 *
5458 * @remark  Adapter should be enabled
5459 * @see  bluetooth_gatt_add_service()
5460 * @see  bluetooth_gatt_add_characteristics()
5461 */
5462 int bluetooth_gatt_set_descriptor_value(
5463                    const char *desc_path, const char *desc_value,
5464                    int value_length);
5465
5466 /* @fn int bluetooth_gatt_get_service(const char *svc_uuid);
5467 *
5468 * @brief Reads the Service registered on manager interface.
5469 *
5470 * This function is a synchronous call.
5471 *
5472 * @return       BLUETOOTH_ERROR_NONE    - Success \n
5473 *        BLUETOOTH_ERROR_INTERNAL - Internal Error \n
5474 *        BLUETOOTH_ERROR_INVALID_PARAM -Invalid Parameters \n
5475 *        BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is disabled \n
5476 *
5477 * @exception     None
5478 * @param[in]   svc_uuid  Gatt Service uuid.
5479 *
5480 * @remark  Adapter should be enabled and service should be registered.
5481 * @see  bluetooth_gatt_register_service()
5482 */
5483 int bluetooth_gatt_get_service(const char *svc_uuid);
5484
5485 /* @fn int bluetooth_gatt_register_service(const  char *svc_path)
5486 *
5487 * @brief Registers the given service path with the library.
5488 *
5489 * This function is a synchronous call.
5490 *
5491 * @return       BLUETOOTH_ERROR_NONE    - Success \n
5492 *        BLUETOOTH_ERROR_INTERNAL - Internal Error \n
5493 *        BLUETOOTH_ERROR_INVALID_PARAM -Invalid Parameters \n
5494 *        BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is disabled \n
5495 *
5496 * @exception     None
5497 * @param[in] svc_path   service object path of the exported service.
5498 *
5499 * @remark  Adapter should be enabled
5500 * @see  bluetooth_gatt_add_service()
5501 * @see  bluetooth_gatt_add_characteristics()
5502 * @see  bluetooth_gatt_add_descriptor()
5503 * @see  bluetooth_gatt_register_application()
5504 */
5505 int bluetooth_gatt_register_service(const char *svc_path);
5506
5507 /* @fn int bluetooth_gatt_register_application(void)
5508 *
5509 * @brief Registers the application with the bluez gatt server.
5510 *
5511 * This function is a synchronous call.
5512 *
5513 * @return       BLUETOOTH_ERROR_NONE    - Success \n
5514 *        BLUETOOTH_ERROR_INTERNAL - Internal Error \n
5515 *        BLUETOOTH_ERROR_INVALID_PARAM -Invalid Parameters \n
5516 *        BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is disabled \n
5517 *
5518 * @exception     None
5519 *
5520 * @remark  Adapter should be enabled
5521 * @see  bluetooth_gatt_init()
5522 * @see  bluetooth_gatt_add_service()
5523 * @see  bluetooth_gatt_add_characteristics()
5524 * @see  bluetooth_gatt_add_descriptor()
5525 * @see  bluetooth_gatt_register_service()
5526 */
5527 int bluetooth_gatt_register_application(void);
5528
5529 /* @fn int bluetooth_gatt_unregister_service(const  char *svc_path)
5530 *
5531 * @brief Removes(unregister) service from the bluez gatt server db.
5532 *
5533 * This function is a synchronous call.
5534 *
5535 * @return       BLUETOOTH_ERROR_NONE    - Success \n
5536 *        BLUETOOTH_ERROR_INTERNAL - Internal Error \n
5537 *        BLUETOOTH_ERROR_INVALID_PARAM -Invalid Parameters \n
5538 *        BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is disabled \n
5539 *
5540 * @exception     None
5541 * @param[in] svc_path   service object path of the exported service.
5542 *
5543 * @remark  Adapter should be enabled
5544 * @see  bluetooth_gatt_add_service()
5545 * @see  bluetooth_gatt_add_characteristics()
5546 * @see  bluetooth_gatt_add_descriptor()
5547 * @see bluetooth_gatt_register_service()
5548 */
5549 int bluetooth_gatt_unregister_service(const char *svc_path);
5550
5551 /* @fn int bluetooth_gatt_unregister_application(void)
5552 *
5553 * @brief Removes(unregister) the application with the bluez gatt server,
5554 *        and deletes all the service registered.
5555 *
5556 * This function is a synchronous call.
5557 *
5558 * @return       BLUETOOTH_ERROR_NONE    - Success \n
5559 *        BLUETOOTH_ERROR_INTERNAL - Internal Error \n
5560 *        BLUETOOTH_ERROR_INVALID_PARAM -Invalid Parameters \n
5561 *        BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is disabled \n
5562 *
5563 * @exception     None
5564 *
5565 * @remark  Adapter should be enabled
5566 * @see  bluetooth_gatt_init()
5567 * @see  bluetooth_gatt_add_service()
5568 * @see  bluetooth_gatt_add_characteristics()
5569 * @see  bluetooth_gatt_add_descriptor()
5570 * @see  bluetooth_gatt_register_service()
5571 * @see  bluetooth_gatt_unregister_service()
5572 */
5573 int bluetooth_gatt_unregister_application(void);
5574
5575 /* @fn int bluetooth_gatt_send_response(int request_id,
5576 *                               int offset, char *value, int value_length)
5577 *
5578 * @brief Updates the attribute value in local attribute list.
5579 *
5580 * This function is a synchronous call.
5581 *
5582 * @return       BLUETOOTH_ERROR_NONE    - Success \n
5583 *        BLUETOOTH_ERROR_INTERNAL - Internal Error \n
5584 *        BLUETOOTH_ERROR_INVALID_PARAM -Invalid Parameters \n
5585 *        BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is disabled \n
5586 *
5587 * @exception     None
5588 * @param[in] request_id The identification of a read request
5589 * @param[in] req_type The identification of  request type (TRUE for Read request and FALSE for write request)
5590 * @param[in] resp_state The identification of response state
5591 * @param[in] offset The offset from where a value is read
5592 * @param[in] value The value to be sent. It will be sent from @a offset.
5593 *               If it is NULL, a requested GATT handle's value will be sent from @a offset.
5594 * @param[in] value_length Value Length.
5595 *
5596 * @remark  Adapter should be enabled
5597 * @see  bluetooth_gatt_add_service()
5598 * @see  bluetooth_gatt_add_characteristics()
5599 * @see  bluetooth_gatt_add_descriptor()
5600 * @see bluetooth_gatt_register_service()
5601 */
5602 int bluetooth_gatt_send_response(int request_id, guint req_type,
5603                                 int resp_state, int offset, char *value, int value_length);
5604
5605 /* @fn bluetooth_gatt_server_set_notification(const char *char_path)
5606 *
5607 * @brief Sets the notification property for a characteristic.
5608 *
5609 * This function is a synchronous call.
5610 *
5611 * @return       BLUETOOTH_ERROR_NONE    - Success \n
5612 *        BLUETOOTH_ERROR_INTERNAL - Internal Error \n
5613 *        BLUETOOTH_ERROR_INVALID_PARAM -Invalid Parameters \n
5614 *        BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is disabled \n
5615 *
5616 * @exception     None
5617 * @param[in] char_path characteristic object path.
5618 * @param[in]   unicast_address remote device address. if set notification is sent to only one device.
5619 *
5620 * @remark  Adapter should be enabled
5621 * @see  bluetooth_gatt_update_characteristic()
5622 */
5623 int bluetooth_gatt_server_set_notification(const char *char_path,
5624                                 bluetooth_device_address_t *unicast_address);
5625
5626 /* @fn int bluetooth_gatt_delete_services(void)
5627 *
5628 * @brief deletes (unregisters) all services from the gatt server database..
5629 *
5630 * This function is a synchronous call.
5631 *
5632 * @return       BLUETOOTH_ERROR_NONE    - Success \n
5633 *        BLUETOOTH_ERROR_INTERNAL - Internal Error \n
5634 *        BLUETOOTH_ERROR_INVALID_PARAM -Invalid Parameters \n
5635 *        BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is disabled \n
5636 *
5637 * @exception     None
5638 *
5639 * @remark  Adapter should be enabled
5640 * @see  bluetooth_gatt_add_service()
5641 * @see  bluetooth_gatt_add_characteristics()
5642 * @see  bluetooth_gatt_add_descriptor()
5643 * @see bluetooth_gatt_register_service()
5644 * @see bluetooth_gatt_unregister_service()
5645 */
5646 int bluetooth_gatt_delete_services(void);
5647
5648 /* @fn int bluetooth_gatt_update_characteristic(void)
5649 *
5650 * @brief updates the given characteristic with a new value
5651 *
5652 * This function is a synchronous call.
5653 *
5654 * @return       BLUETOOTH_ERROR_NONE    - Success \n
5655 *        BLUETOOTH_ERROR_INTERNAL - Internal Error \n
5656 *        BLUETOOTH_ERROR_INVALID_PARAM -Invalid Parameters \n
5657 *        BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is disabled \n
5658 *
5659 * @exception     None
5660 *
5661 * @remark  Adapter should be enabled
5662 * @see  bluetooth_gatt_add_service()
5663 * @see  bluetooth_gatt_add_characteristics()
5664 * @see  bluetooth_gatt_add_descriptor()
5665 * @see bluetooth_gatt_register_service()
5666 * @see bluetooth_gatt_unregister_service()
5667 */
5668 int bluetooth_gatt_update_characteristic(const char *char_path,
5669                 const char* char_value, int value_length);
5670
5671 /**
5672  * @fn int bluetooth_set_advertising(int handle, gboolean enable);
5673  *
5674  * @brief Set advertising status.
5675  *
5676  * This function is used to enable or disable LE advertising.
5677  * Once advertising is enabled, Advertising data is transmitted in the advertising packets
5678  *
5679  * This function is a synchronous call.
5680  *
5681  * @return      BLUETOOTH_ERROR_NONE - Success \n
5682  *              BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is not enabled \n
5683  *              BLUETOOTH_ERROR_INTERNAL - Internal IPC error \n
5684  *
5685  * @exception   None
5686  * @param[in]   enable - The status of advertising
5687  *
5688  * @remark      None
5689  * @see         bluetooth_set_advertising_data
5690  */
5691 int bluetooth_set_advertising(int handle, gboolean enable);
5692
5693 /**
5694  * @fn int bluetooth_set_custom_advertising(int handle, gboolean enable, bluetooth_advertising_params_t *params);
5695  *
5696  * @brief Set advertising status along with interval value.
5697  *
5698  * This function is used to enable or disable LE advertising.
5699  * Interval_min and Interval_max is used to set the best advertising interval.
5700  * Once advertising is enabled, Advertising data is transmitted in the advertising packets
5701  *
5702  * This function is a synchronous call.
5703  *
5704  * @return      BLUETOOTH_ERROR_NONE - Success \n
5705  *              BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is not enabled \n
5706  *              BLUETOOTH_ERROR_INTERNAL - Internal IPC error \n
5707  *
5708  * @exception   None
5709  * @param[in]   enable - The status of advertising
5710  * @param[in]   interval_min - Minimum interval of advertising (msec)
5711  * @param[in]   interval_max - Maximum interval of advertising (msec)
5712  * @param[in]   filter_policy - Advertising filter policy
5713  *
5714  * @remark      None
5715  * @see         bluetooth_set_advertising_data
5716  */
5717 int bluetooth_set_custom_advertising(int handle, gboolean enable,
5718                                         bluetooth_advertising_params_t *params);
5719
5720 /**
5721  * @fn int bluetooth_get_advertising_data(bluetooth_advertising_data_t *value, int *length);
5722  * @brief Get the advertising data
5723  *
5724  * This function is used to get advertising data.
5725  * Before calling this API, the adapter should be enabled.
5726  *
5727  * This function is a synchronous call.
5728  *
5729  * @return      BLUETOOTH_ERROR_NONE - Success \n
5730  *              BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is not enabled \n
5731  *              BLUETOOTH_ERROR_INVALID_PARAM - Invalid parameter (NULL buffer)\n
5732  *              BLUETOOTH_ERROR_INTERNAL - Internal IPC error \n
5733  *
5734  * @param[out]  value - Advertising data structure.
5735  * @param[out]  length - The length of Advertising data.
5736  *
5737  * @remark      None
5738 @code
5739 bluetooth_advertising_data_t *value = { {0} };
5740 int length;
5741 int ret = 0;
5742 ret = bluetooth_get_advertising_data(&value, &length);
5743 @endcode
5744  */
5745 int bluetooth_get_advertising_data(bluetooth_advertising_data_t *value, int *length);
5746
5747 /**
5748  * @fn int bluetooth_set_advertising_data(int handle, const bluetooth_advertising_data_t *value, int length);
5749  *
5750  * @brief Set advertising data with value
5751  *
5752  * This function is used to set advertising data and Maximum size of advertising data
5753  *  is 28 byte (Except Flag)
5754  *
5755  * This function is a synchronous call.
5756  *
5757  * @return      BLUETOOTH_ERROR_NONE - Success \n
5758  *              BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is not enabled \n
5759  *              BLUETOOTH_ERROR_INTERNAL - Internal IPC error \n
5760  *
5761  * @exception   None
5762  * @param[in]   value - Advertising data structure.
5763  *
5764  * @remark      None
5765  */
5766 int bluetooth_set_advertising_data(int handle, const bluetooth_advertising_data_t *value, int length);
5767
5768 /**
5769  * @fn int bluetooth_check_privilege_advertising_parameter(void);
5770  *
5771  * @brief Check the privilege for advertising parameter setting
5772  *
5773  * This function is a synchronous call.
5774  *
5775  * @return      BLUETOOTH_ERROR_NONE - Success \n
5776  *              BLUETOOTH_ERROR_PERMISSION_DEINED - Permission deined \n
5777  *
5778  * @exception   None
5779  *
5780  * @remark      None
5781  */
5782 int bluetooth_check_privilege_advertising_parameter(void);
5783
5784 /**
5785  * @fn int bluetooth_get_scan_response_data(bluetooth_scan_resp_data_t *value, int *length);
5786  * @brief Get the LE scan response data
5787  *
5788  * This function is used to get scan response data.
5789  * Before calling this API, the adapter should be enabled.
5790  *
5791  * This function is a synchronous call.
5792  *
5793  * @return      BLUETOOTH_ERROR_NONE - Success \n
5794  *              BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is not enabled \n
5795  *              BLUETOOTH_ERROR_INVALID_PARAM - Invalid parameter (NULL buffer)\n
5796  *              BLUETOOTH_ERROR_INTERNAL - Internal IPC error \n
5797  *
5798  * @param[out]  value - Scan response data structure.
5799  * @param[out]  length - The length of Scan response data.
5800  *
5801  * @remark      None
5802 @code
5803 bluetooth_scan_resp_data_t *value = { {0} };
5804 int length;
5805 int ret = 0;
5806 ret = bluetooth_get_scan_response_data(&value, &length);
5807 @endcode
5808  */
5809 int bluetooth_get_scan_response_data(bluetooth_scan_resp_data_t *value, int *length);
5810
5811 /**
5812  * @fn int bluetooth_set_scan_response_data(int handle, const bluetooth_scan_resp_data_t *value, int length);
5813  *
5814  * @brief Set scan response data with value
5815  *
5816  * This function is used to set scan response data and Maximum size of scan response data is 31 byte
5817  *
5818  * This function is a synchronous call.
5819  *
5820  * @return      BLUETOOTH_ERROR_NONE - Success \n
5821  *              BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is not enabled \n
5822  *              BLUETOOTH_ERROR_INTERNAL - Internal IPC error \n
5823  *
5824  * @exception   None
5825  * @param[in]   value - LE Scan response data structure.
5826  *
5827  * @remark      None
5828  */
5829 int bluetooth_set_scan_response_data(int handle, const bluetooth_scan_resp_data_t *value, int length);
5830
5831 /**
5832  * @fn int bluetooth_set_scan_parameters(bluetooth_le_scan_params_t *params);
5833  *
5834  * @brief Set scan interval and window
5835  *
5836  * This function is used to set LE scan interval and window size
5837  *
5838  * This function is a synchronous call.
5839  *
5840  * @return      BLUETOOTH_ERROR_NONE - Success \n
5841  *              BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is not enabled \n
5842  *              BLUETOOTH_ERROR_INTERNAL - Internal IPC error \n
5843  *
5844  * @exception   None
5845  * @param[in]   interval - Interval of LE scan (msec)
5846  * @param[in]   window - Window size of LE scan (msec)
5847  *
5848  * @remark      None
5849  */
5850 int bluetooth_set_scan_parameters(bluetooth_le_scan_params_t *params);
5851
5852 /**
5853  * @fn int bluetooth_is_advertising(void)
5854  * @brief Check for the advertising is in-progress or not.
5855  *
5856  * This API is used to check the current status of the advertising procedure.
5857  * Before calling this API, make sure that the adapter is enabled. There is no callback event for
5858  * this API.
5859  *
5860  * This function checks whether the advertising is started or not.
5861  *
5862  * This function is a synchronous call.
5863  *
5864  * @param[out] is_advertising The advertising status: (@c TRUE = in progress, @c  false = not in progress)
5865  *
5866  * @return      BLUETOOTH_ERROR_NONE - Success \n
5867  *              BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is not enabled \n
5868  *
5869  * @remark      None
5870  * @see         bluetooth_set_advertising, bluetooth_set_custom_advertising
5871
5872 @code
5873 int ret;
5874 gboolean is_advertising = 0;
5875
5876 ret = bluetooth_is_advertising(&is_advertising);
5877 @endcode
5878  */
5879 int bluetooth_is_advertising(gboolean *is_advertising);
5880
5881 /**
5882  * @fn int bluetooth_add_white_list(bluetooth_device_address_t *address, bluetooth_device_address_type_t address_type)
5883  * @brief Add LE device to white list
5884  *
5885  * This API is used to add LE device to white list
5886  * Before calling this API, make sure that the adapter is enabled. There is no callback event for
5887  * this API.
5888  *
5889  *
5890  * This function is a synchronous call.
5891  *
5892  * @param[in] address The address of remote device
5893  *
5894  * @return      BLUETOOTH_ERROR_NONE - Success \n
5895  *              BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is not enabled \n
5896  *
5897  * @remark      None
5898  * @see         bluetooth_set_custom_advertising
5899  */
5900 int bluetooth_add_white_list(bluetooth_device_address_t *address, bluetooth_device_address_type_t address_type);
5901
5902 /**
5903  * @fn int bluetooth_remove_white_list(bluetooth_device_address_t *address, bluetooth_device_address_type_t address_type)
5904  * @brief Remove LE device from white list
5905  *
5906  * This API is used to remove LE device from white list
5907  * Before calling this API, make sure that the adapter is enabled. There is no callback event for
5908  * this API.
5909  *
5910  *
5911  * This function is a synchronous call.
5912  *
5913  * @param[in] address The address of remote device
5914  *
5915  * @return      BLUETOOTH_ERROR_NONE - Success \n
5916  *              BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is not enabled \n
5917  *
5918  * @remark      None
5919  * @see         bluetooth_set_custom_advertising
5920  */
5921 int bluetooth_remove_white_list(bluetooth_device_address_t *address, bluetooth_device_address_type_t address_type);
5922
5923 /**
5924  * @fn int bluetooth_clear_white_list(void)
5925  * @brief Clear white list
5926  *
5927  * This API is used to clear white list
5928  * Before calling this API, make sure that the adapter is enabled. There is no callback event for
5929  * this API.
5930  *
5931  *
5932  * This function is a synchronous call.
5933  *
5934  * @param[in] address The address of remote device
5935  *
5936  * @return      BLUETOOTH_ERROR_NONE - Success \n
5937  *              BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is not enabled \n
5938  *
5939  * @remark      None
5940  * @see         bluetooth_set_custom_advertising
5941  */
5942 int bluetooth_clear_white_list(void);
5943
5944 /**
5945  * @fn int bluetooth_le_conn_update(bluetooth_device_address_t *address,
5946  *          const bluetooth_le_connection_param_t *parameters)
5947  * @brief update connection paramter of LE connection.
5948  *
5949  * This function is a synchronous call.
5950  *
5951  * @return   BLUETOOTH_ERROR_NONE  - Success \n
5952  *           BLUETOOTH_ERROR_INTERNAL - Internal Error \n
5953  *
5954  * @exception  None
5955  * @param[in]  address - remote device address value.
5956  * @param[in]  parameters - new connection parameters.
5957  *
5958  * @remark       None
5959  * @see     bluetooth_bond_device
5960  */
5961 int bluetooth_le_conn_update(const bluetooth_device_address_t *address,
5962                 const bluetooth_le_connection_param_t *parameters);
5963
5964 /**
5965  * @fn int bluetooth_enable_le_privacy(gboolean enable_privacy);
5966  *
5967  * @brief Enable/Disable LE Privacy feature.
5968  *
5969  * This function is used to enable or disable LE Privacy feature.
5970  * Once Privacy feature is enabled, Adapter can use Random Address for more security.
5971  *
5972  * This function is a synchronous call.
5973  *
5974  * @return      BLUETOOTH_ERROR_NONE - Success \n
5975  *              BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is not enabled \n
5976  *              BLUETOOTH_ERROR_INTERNAL - Internal IPC error \n
5977  *
5978  * @exception   None
5979  * @param[in]   enable_privacy - The status of Privacy feature to be activated/deactivated[True/False].
5980  *
5981  * @remark      None
5982  */
5983 int bluetooth_enable_le_privacy(gboolean enable_privacy);
5984
5985 /**
5986  * @fn int bluetooth_set_le_static_random_address(gboolean enable);
5987  *
5988  * @brief Enable/Disable LE static random address.
5989  *
5990  * This function is used to enable or disable LE static random address.
5991  *
5992  * This function is a synchronous call.
5993  *
5994  * @return      BLUETOOTH_ERROR_NONE - Success \n
5995  *              BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is not enabled \n
5996  *              BLUETOOTH_ERROR_INTERNAL - Internal IPC error \n
5997  *
5998  * @exception   None
5999  * @param[in]   enable - The status of LE static random address to be activated/deactivated[True/False].
6000  *
6001  * @remark      None
6002  */
6003 int bluetooth_set_le_static_random_address(gboolean enable);
6004
6005 /**
6006  * @fn int bluetooth_update_le_connection_mode(bluetooth_device_address_t *address,
6007  *                                             bluetooth_le_connection_mode_t mode)
6008  * @brief update connection paramter of LE connection.
6009  *
6010  * This function is a synchronous call.
6011  *
6012  * @return   BLUETOOTH_ERROR_NONE  - Success \n
6013  *           BLUETOOTH_ERROR_INTERNAL - Internal Error \n
6014  *           BLUETOOTH_ERROR_INVALID_PARAM - Parameter is not valid \n
6015  *
6016  * @exception  None
6017  * @param[in]  address - remote device address value.
6018  * @param[in]  mode - new connection mode.
6019  *
6020  * @remark       None
6021  */
6022 int bluetooth_update_le_connection_mode(const bluetooth_device_address_t *address,
6023                 bluetooth_le_connection_mode_t mode);
6024
6025 /**
6026  * @fn int bluetooth_request_att_mtu(const bluetooth_device_address_t *device_address, guint16 mtu)
6027  * @brief Request for new ATT MTU value.
6028  *
6029  * This function is a asynchronous call.
6030  *
6031  * @return   BLUETOOTH_ERROR_NONE  - Success \n
6032  *           BLUETOOTH_ERROR_INTERNAL - Internal Error \n
6033  *           BLUETOOTH_ERROR_INVALID_PARAM - Parameter is not valid \n
6034  *
6035  * @exception  None
6036  * @param[in]  address - remote device address value.
6037  * @param[in]  mtu - MTU value to be set.
6038  *
6039  * @remark       None
6040  */
6041 int bluetooth_request_att_mtu(const bluetooth_device_address_t *device_address, unsigned int mtu);
6042
6043 /**
6044  * @fn int bluetooth_get_att_mtu(const bluetooth_device_address_t *device_address,
6045  *                              unsigned int *mtu)
6046  * @brief Gets the xisting MTU value set for a connection.
6047  *
6048  * This function is a synchronous call.
6049  *
6050  * @return       BLUETOOTH_ERROR_NONE  - Success \n
6051  *                       BLUETOOTH_ERROR_INTERNAL - Internal Error \n
6052  *                       BLUETOOTH_ERROR_INVALID_PARAM - Parameter is not valid \n
6053  *
6054  * @exception  None
6055  * @param[in]  address - remote device address value.
6056  * @param[out]  mtu - MTU value set for the connection.
6057  *
6058  * @remark               None
6059  */
6060 int bluetooth_get_att_mtu(const bluetooth_device_address_t *device_address,
6061                                 unsigned int *mtu);
6062
6063 /**
6064  * @fn int bluetooth_get_device_ida(const bluetooth_device_address_t *device_rpa,
6065  *                                      bluetooth_device_address_t *id_address)
6066  * @brief Gets the Identity address of remote device.
6067  *
6068  * This function is a synchronous call.
6069  *
6070  * @return              BLUETOOTH_ERROR_NONE  - Success \n
6071  *                      BLUETOOTH_ERROR_INTERNAL - Internal Error \n
6072  *                      BLUETOOTH_ERROR_INVALID_PARAM - Parameter is not valid \n
6073  *
6074  * @exception  None
6075  * @param[in]  device_rpa - remote Resolvable private address.
6076  * @param[out] id_address - remote Identity device address value.
6077  *
6078  * @remark               None
6079  */
6080 int bluetooth_get_device_ida(const bluetooth_device_address_t *device_rpa,
6081         bluetooth_device_address_t *id_address);
6082
6083 /**
6084  * @fn int bluetooth_le_read_maximum_data_length()
6085  * @brief reads the maximum LE data length supported in the controller.
6086  *
6087  * This function is a synchronous call.
6088  *
6089  * @return   BLUETOOTH_ERROR_NONE  - Success \n
6090  *           BLUETOOTH_ERROR_INTERNAL - Internal Error \n
6091  *
6092  * @exception  None
6093  *
6094  * @remark       None
6095  */
6096 int bluetooth_le_read_maximum_data_length(
6097                         bluetooth_le_read_maximum_data_length_t *max_le_datalength);
6098 /**
6099  * @fn int bluetooth_le_write_host_suggested_default_data_length()
6100  * @brief writes the host suggested values for the controllers max transmitted no of payload
6101  * octects to be used for new connections.
6102  *
6103  * This function is a synchronous call.
6104  *
6105  * @return   BLUETOOTH_ERROR_NONE  - Success \n
6106  *           BLUETOOTH_ERROR_INTERNAL - Internal Error \n
6107  *
6108  * @exception  None
6109  *
6110  * @remark       None
6111  */
6112 int bluetooth_le_write_host_suggested_default_data_length(
6113                 const unsigned int def_tx_Octets, const unsigned int def_tx_Time);
6114
6115 int bluetooth_le_read_suggested_default_data_length(
6116         bluetooth_le_read_host_suggested_data_length_t *le_data_length);
6117
6118 int bluetooth_le_set_data_length(bluetooth_device_address_t *address,
6119         const unsigned int max_tx_octets, const unsigned int max_tx_time);
6120
6121 int bluetooth_pbap_init(void);
6122 int bluetooth_pbap_deinit(void);
6123 int bluetooth_pbap_connect(const bluetooth_device_address_t *address);
6124 int bluetooth_pbap_disconnect(const bluetooth_device_address_t *address);
6125 int bluetooth_pbap_get_phonebook_size(const bluetooth_device_address_t *address,
6126                 bt_pbap_folder_t *folder);
6127 int bluetooth_pbap_get_phonebook(const bluetooth_device_address_t *address,
6128                 bt_pbap_folder_t *folder, bt_pbap_pull_parameters_t *app_param);
6129 int bluetooth_pbap_get_list(const bluetooth_device_address_t *address,
6130                 bt_pbap_folder_t *folder, bt_pbap_list_parameters_t *app_param);
6131 int bluetooth_pbap_pull_vcard(const bluetooth_device_address_t *address,
6132                 bt_pbap_folder_t *folder, bt_pbap_pull_vcard_parameters_t *app_param);
6133 int bluetooth_pbap_phonebook_search(const bluetooth_device_address_t *address,
6134                 bt_pbap_folder_t *folder, bt_pbap_search_parameters_t *app_param);
6135
6136 /**
6137  * @fn int bluetooth_set_manufacturer_data(const bluetooth_manufacturer_data_t *value);
6138  *
6139  * @brief Set manufacturer data with value
6140  *
6141  * This function is used to set manufacturer data.
6142  *
6143  * This function is a synchronous call.
6144  *
6145  * @return      BLUETOOTH_ERROR_NONE - Success \n
6146  *              BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Adapter is not enabled \n
6147  *              BLUETOOTH_ERROR_INTERNAL - Internal IPC error \n
6148  *
6149  * @exception   None
6150  * @param[in]   value - Manufacturer data structure.
6151  *
6152  * @remark      None
6153  */
6154 int bluetooth_set_manufacturer_data(const bluetooth_manufacturer_data_t *value);
6155
6156 int bluetooth_set_passkey_notification(gboolean enable);
6157
6158 #ifdef TIZEN_DPM_VCONF_ENABLE
6159 /**
6160  * @fn int bluetooth_dpm_is_mode_allowed(void);
6161  *
6162  * @brief Checks Restriction for BT mode(BT allowed or not)
6163  *
6164  * This function is a synchronous call.
6165  *
6166  * @return      BLUETOOTH_DPM_RESULT_SUCCESS - Success \n
6167  *              BLUETOOTH_DPM_RESULT_ACCESS_DENIED - BT restricted \n
6168  *              BLUETOOTH_DPM_RESULT_FAIL - Internal error \n
6169  *
6170  * @exception   None
6171  *  @param[in] None
6172  *
6173  * @remark      None
6174  */
6175 int bluetooth_dpm_is_mode_allowed(void);
6176 #endif
6177
6178 /**
6179  * @fn int bluetooth_dpm_set_allow_mode(bt_dpm_allow_t value);
6180  *
6181  * @brief Sets Restriction for BT mode(BT allowed or not)
6182  *
6183  * This function is a synchronous call.
6184  *
6185  * @return      BLUETOOTH_DPM_RESULT_SUCCESS - Success \n
6186  *              BLUETOOTH_DPM_RESULT_ACCESS_DENIED - BT restricted \n
6187  *              BLUETOOTH_DPM_RESULT_FAIL - Internal error \n
6188  *
6189  * @exception   None
6190  * @param[in]   value - BT Allow value.
6191  *              BLUETOOTH_DPM_ERROR  = -1,       < bluetooth allowance error
6192  *              BLUETOOTH_DPM_BT_ALLOWED,                < bluetooth allowance allowed
6193  *              BLUETOOTH_DPM_HANDSFREE_ONLY,  < bluetooth allowance handsfree only
6194  *              BLUETOOTH_DPM_BT_RESTRICTED,  < bluetooth allowance restricted
6195  *
6196  * @remark      None
6197  */
6198 int bluetooth_dpm_set_allow_mode(bt_dpm_allow_t value);
6199
6200 /**
6201  * @fn int bluetooth_dpm_get_allow_mode(bt_dpm_allow_t value);
6202  *
6203  * @brief Reads the Restriction for BT mode(BT allowed or not)
6204  *
6205  * This function is a synchronous call.
6206  *
6207  * @return      BLUETOOTH_DPM_RESULT_SUCCESS - Success \n
6208  *              BLUETOOTH_DPM_RESULT_ACCESS_DENIED - BT restricted \n
6209  *              BLUETOOTH_DPM_RESULT_FAIL - Internal error \n
6210  *
6211  * @exception   None
6212  *  @param[in] None
6213  * @param[out]  value - BT Allow value.
6214  *              BLUETOOTH_DPM_ERROR      = -1,   < bluetooth allowance error
6215  *              BLUETOOTH_DPM_BT_ALLOWED,                < bluetooth allowance allowed
6216  *              BLUETOOTH_DPM_HANDSFREE_ONLY,  < bluetooth allowance handsfree only
6217  *              BLUETOOTH_DPM_BT_RESTRICTED,  < bluetooth allowance restricted
6218  *
6219  * @remark      None
6220  */
6221 int bluetooth_dpm_get_allow_mode(bt_dpm_allow_t *value);
6222
6223 /**
6224  * @fn int bluetooth_dpm_activate_device_restriction(bt_dpm_status_t value);
6225  *
6226  * @brief Sets the Restriction for device.
6227  *
6228  * This function is a synchronous call.
6229  *
6230  * @return      BLUETOOTH_DPM_RESULT_SUCCESS - Success \n
6231  *              BLUETOOTH_DPM_RESULT_ACCESS_DENIED - BT restricted \n
6232  *              BLUETOOTH_DPM_RESULT_FAIL - Internal error \n
6233  *
6234  * @exception   None
6235  * @param[in]   value - State value.
6236  *              BLUETOOTH_DPM_ALLOWED           = 0,    < DPM Policy status allowed.
6237  *              BLUETOOTH_DPM_RESTRICTED                = 1,    < DPM Policy status restricted.
6238  *
6239  * @remark      None
6240  */
6241 int bluetooth_dpm_activate_device_restriction(bt_dpm_status_t value);
6242
6243 /**
6244  * @fn int bluetooth_dpm_is_device_restriction_active(bt_dpm_status_t *value);
6245  *
6246  * @brief Reads the Restriction for device.
6247  *
6248  * This function is a synchronous call.
6249  *
6250  * @return      BLUETOOTH_DPM_RESULT_SUCCESS - Success \n
6251  *              BLUETOOTH_DPM_RESULT_ACCESS_DENIED - BT restricted \n
6252  *              BLUETOOTH_DPM_RESULT_FAIL - Internal error \n
6253  *
6254  * @exception   None
6255  * @param[in] None
6256  * @param[out]  value - State value.
6257  *              BLUETOOTH_DPM_ALLOWED           = 0,    < DPM Policy status allowed.
6258  *              BLUETOOTH_DPM_RESTRICTED                = 1,    < DPM Policy status restricted.
6259  *
6260  * @remark      None
6261  */
6262 int bluetooth_dpm_is_device_restriction_active(bt_dpm_status_t *value);
6263
6264 /**
6265  * @fn int bluetooth_dpm_activate_bluetoooth_uuid_restriction(bt_dpm_status_t value);
6266  *
6267  * @brief Sets the Restriction for uuid.
6268  *
6269  * This function is a synchronous call.
6270  *
6271  * @return      BLUETOOTH_DPM_RESULT_SUCCESS - Success \n
6272  *              BLUETOOTH_DPM_RESULT_ACCESS_DENIED - BT restricted \n
6273  *              BLUETOOTH_DPM_RESULT_FAIL - Internal error \n
6274  *
6275  * @exception   None
6276  * @param[in]   value - State value.
6277  *              BLUETOOTH_DPM_ALLOWED           = 0,    < DPM Policy status allowed.
6278  *              BLUETOOTH_DPM_RESTRICTED                = 1,    < DPM Policy status restricted.
6279  *
6280  * @remark      None
6281  */
6282 int bluetooth_dpm_activate_uuid_restriction(bt_dpm_status_t value);
6283
6284 /**
6285  * @fn int bluetooth_dpm_is_uuid_restriction_active(bt_dpm_status_t *value);
6286  *
6287  * @brief Reads the Restriction for uuid.
6288  *
6289  * This function is a synchronous call.
6290  *
6291  * @return      BLUETOOTH_DPM_RESULT_SUCCESS - Success \n
6292  *              BLUETOOTH_DPM_RESULT_ACCESS_DENIED - BT restricted \n
6293  *              BLUETOOTH_DPM_RESULT_FAIL - Internal error \n
6294  *
6295  * @exception   None
6296  * @param[in] None
6297  * @param[out]  value - State value.
6298  *              BLUETOOTH_DPM_ALLOWED           = 0,    < DPM Policy status allowed.
6299  *              BLUETOOTH_DPM_RESTRICTED                = 1,    < DPM Policy status restricted.
6300  *
6301  * @remark      None
6302  */
6303 int bluetooth_dpm_is_uuid_restriction_active(bt_dpm_status_t *value);
6304
6305 /**
6306  * @fn int bluetooth_dpm_add_devices_to_blacklist(const bluetooth_device_address_t *device_address);
6307  *
6308  * @brief Adds the device to blacklist.
6309  *
6310  * This function is a synchronous call.
6311  *
6312  * @return      BLUETOOTH_DPM_RESULT_SUCCESS - Success \n
6313  *              BLUETOOTH_DPM_RESULT_ACCESS_DENIED - BT restricted \n
6314  *              BLUETOOTH_DPM_RESULT_FAIL - Internal error \n
6315  *
6316  * @exception   None
6317  * @param[in]   device_address - Device address
6318  *
6319  * @remark      None
6320  */
6321 int bluetooth_dpm_add_devices_to_blacklist(const bluetooth_device_address_t *device_address);
6322
6323 /**
6324  * @fn int bluetooth_dpm_add_devices_to_whitelist(const bluetooth_device_address_t *device_address);
6325  *
6326  * @brief Adds the device to whitelist.
6327  *
6328  * This function is a synchronous call.
6329  *
6330  * @return      BLUETOOTH_DPM_RESULT_SUCCESS - Success \n
6331  *              BLUETOOTH_DPM_RESULT_ACCESS_DENIED - BT restricted \n
6332  *              BLUETOOTH_DPM_RESULT_FAIL - Internal error \n
6333  *
6334  * @exception   None
6335  * @param[in]   device_address - Device address
6336  *
6337  * @remark      None
6338  */
6339 int bluetooth_dpm_add_devices_to_whitelist(const bluetooth_device_address_t *device_address);
6340
6341 /**
6342  * @fn int bluetooth_dpm_add_uuids_to_blacklist(const char *service_uuid);
6343  *
6344  * @brief Adds the Service UUIDS to blacklist.
6345  *
6346  * This function is a synchronous call.
6347  *
6348  * @return      BLUETOOTH_DPM_RESULT_SUCCESS - Success \n
6349  *              BLUETOOTH_DPM_RESULT_ACCESS_DENIED - BT restricted \n
6350  *              BLUETOOTH_DPM_RESULT_FAIL - Internal error \n
6351  *
6352  * @exception   None
6353  * @param[in]   service_uuids - profile or custom service uuids
6354  *
6355  * @remark      None
6356  */
6357 int bluetooth_dpm_add_uuids_to_blacklist(const char *service_uuid);
6358
6359 /**
6360  * @fn int bluetooth_dpm_add_uuids_to_whitelist(const char *service_uuid);
6361  *
6362  * @brief Adds the Service UUIDS to whitelist.
6363  *
6364  * This function is a synchronous call.
6365  *
6366  * @return      BLUETOOTH_DPM_RESULT_SUCCESS - Success \n
6367  *              BLUETOOTH_DPM_RESULT_ACCESS_DENIED - BT restricted \n
6368  *              BLUETOOTH_DPM_RESULT_FAIL - Internal error \n
6369  *
6370  * @exception   None
6371  * @param[in]   service_uuids - profile or custom service uuids
6372  *
6373  * @remark      None
6374  */
6375 int bluetooth_dpm_add_uuids_to_whitelist(const char *service_uuid);
6376
6377 /**
6378  * @fn int bluetooth_dpm_clear_devices_from_blacklist();
6379  *
6380  * @brief Clears the devices from blacklist.
6381  *
6382  * This function is a synchronous call.
6383  *
6384  * @return      BLUETOOTH_DPM_RESULT_SUCCESS - Success \n
6385  *              BLUETOOTH_DPM_RESULT_ACCESS_DENIED - BT restricted \n
6386  *              BLUETOOTH_DPM_RESULT_FAIL - Internal error \n
6387  *
6388  * @exception   None
6389  * @param[in]   None
6390  *
6391  * @remark      None
6392  */
6393 int bluetooth_dpm_clear_devices_from_blacklist(void);
6394
6395 /**
6396  * @fn int bluetooth_dpm_clear_devices_from_whitelist();
6397  *
6398  * @brief Clears the devices from whitelist.
6399  *
6400  * This function is a synchronous call.
6401  *
6402  * @return      BLUETOOTH_DPM_RESULT_SUCCESS - Success \n
6403  *              BLUETOOTH_DPM_RESULT_ACCESS_DENIED - BT restricted \n
6404  *              BLUETOOTH_DPM_RESULT_FAIL - Internal error \n
6405  *
6406  * @exception   None
6407  * @param[in]   None
6408  *
6409  * @remark      None
6410  */
6411 int bluetooth_dpm_clear_devices_from_whitelist(void);
6412
6413 /**
6414  * @fn int bluetooth_dpm_clear_uuids_from_blacklist();
6415  *
6416  * @brief Clears the uuids from blacklist.
6417  *
6418  * This function is a synchronous call.
6419  *
6420  * @return      BLUETOOTH_DPM_RESULT_SUCCESS - Success \n
6421  *              BLUETOOTH_DPM_RESULT_ACCESS_DENIED - BT restricted \n
6422  *              BLUETOOTH_DPM_RESULT_FAIL - Internal error \n
6423  *
6424  * @exception   None
6425  * @param[in]   None
6426  *
6427  * @remark      None
6428  */
6429 int bluetooth_dpm_clear_uuids_from_blacklist(void);
6430
6431 /**
6432  * @fn int bluetooth_dpm_clear_uuids_from_whitelist();
6433  *
6434  * @brief Clears the uuids from whitelist.
6435  *
6436  * This function is a synchronous call.
6437  *
6438  * @return      BLUETOOTH_DPM_RESULT_SUCCESS - Success \n
6439  *              BLUETOOTH_DPM_RESULT_ACCESS_DENIED - BT restricted \n
6440  *              BLUETOOTH_DPM_RESULT_FAIL - Internal error \n
6441  *
6442  * @exception   None
6443  * @param[in]   None
6444  *
6445  * @remark      None
6446  */
6447 int bluetooth_dpm_clear_uuids_from_whitelist(void);
6448
6449 /**
6450  * @fn int bluetooth_dpm_get_devices_from_blacklist(bt_dpm_device_list_t *device_list);
6451  *
6452  * @brief reads the devices from blacklist.
6453  *
6454  * This function is a synchronous call.
6455  *
6456  * @return      BLUETOOTH_DPM_RESULT_SUCCESS - Success \n
6457  *              BLUETOOTH_DPM_RESULT_ACCESS_DENIED - BT restricted \n
6458  *              BLUETOOTH_DPM_RESULT_FAIL - Internal error \n
6459  *
6460  * @exception   None
6461  * @param[out]  device_list - list of devices
6462  *
6463  * @remark      None
6464  */
6465 int bluetooth_dpm_get_devices_from_blacklist(bt_dpm_device_list_t *device_list);
6466
6467 /**
6468  * @fn int bluetooth_dpm_get_devices_from_whitelist(bt_dpm_device_list_t *device_list);
6469  *
6470  * @brief reads the devices from whitelist.
6471  *
6472  * This function is a synchronous call.
6473  *
6474  * @return      BLUETOOTH_DPM_RESULT_SUCCESS - Success \n
6475  *              BLUETOOTH_DPM_RESULT_ACCESS_DENIED - BT restricted \n
6476  *              BLUETOOTH_DPM_RESULT_FAIL - Internal error \n
6477  *
6478  * @exception   None
6479  * @param[out]  device_list - list of devices
6480  *
6481  * @remark      None
6482  */
6483 int bluetooth_dpm_get_devices_from_whitelist(bt_dpm_device_list_t *device_list);
6484
6485 /**
6486  * @fn int bluetooth_dpm_get_uuids_from_blacklist(bt_dpm_uuids_list_t *uuid_list);
6487  *
6488  * @brief reads the uuids from blacklist.
6489  *
6490  * This function is a synchronous call.
6491  *
6492  * @return      BLUETOOTH_DPM_RESULT_SUCCESS - Success \n
6493  *              BLUETOOTH_DPM_RESULT_ACCESS_DENIED - BT restricted \n
6494  *              BLUETOOTH_DPM_RESULT_FAIL - Internal error \n
6495  *
6496  * @exception   None
6497  * @param[in]   uuid_list - list of uuids
6498  *
6499  * @remark      None
6500  */
6501 int bluetooth_dpm_get_uuids_from_blacklist(bt_dpm_uuids_list_t *uuid_list);
6502
6503 /**
6504  * @fn int bluetooth_dpm_get_uuids_from_whitelist(bt_dpm_uuids_list_t *uuid_list);
6505  *
6506  * @brief reads the uuids from whitelist.
6507  *
6508  * This function is a synchronous call.
6509  *
6510  * @return      BLUETOOTH_DPM_RESULT_SUCCESS - Success \n
6511  *              BLUETOOTH_DPM_RESULT_ACCESS_DENIED - BT restricted \n
6512  *              BLUETOOTH_DPM_RESULT_FAIL - Internal error \n
6513  *
6514  * @exception   None
6515  * @param[in]   uuid_list - list of uuids
6516  *
6517  * @remark      None
6518  */
6519 int bluetooth_dpm_get_uuids_from_whitelist(bt_dpm_uuids_list_t *uuid_list);
6520
6521 /**
6522  * @fn int bluetooth_dpm_remove_device_from_whitelist(const bluetooth_device_address_t *device_address);
6523  *
6524  * @brief Removes the device from whitelist.
6525  *
6526  * This function is a synchronous call.
6527  *
6528  * @return      BLUETOOTH_DPM_RESULT_SUCCESS - Success \n
6529  *              BLUETOOTH_DPM_RESULT_ACCESS_DENIED - BT restricted \n
6530  *              BLUETOOTH_DPM_RESULT_FAIL - Internal error \n
6531  *
6532  * @exception   None
6533  * @param[in]   device_address - Device address
6534  *
6535  * @remark      None
6536  */
6537 int bluetooth_dpm_remove_device_from_whitelist(const bluetooth_device_address_t *device_address);
6538
6539 /**
6540  * @fn int bluetooth_dpm_remove_device_from_blacklist(const bluetooth_device_address_t *device_address);
6541  *
6542  * @brief Removes the device from blacklist.
6543  *
6544  * This function is a synchronous call.
6545  *
6546  * @return      BLUETOOTH_DPM_RESULT_SUCCESS - Success \n
6547  *              BLUETOOTH_DPM_RESULT_ACCESS_DENIED - BT restricted \n
6548  *              BLUETOOTH_DPM_RESULT_FAIL - Internal error \n
6549  *
6550  * @exception   None
6551  * @param[in]   device_address - Device address
6552  *
6553  * @remark      None
6554  */
6555 int bluetooth_dpm_remove_device_from_blacklist(const bluetooth_device_address_t *device_address);
6556
6557 /**
6558  * @fn int bluetooth_dpm_remove_uuid_from_whitelist(const char *service_uuid);
6559  *
6560  * @brief Removes the Service UUIDS from whitelist.
6561  *
6562  * This function is a synchronous call.
6563  *
6564  * @return      BLUETOOTH_DPM_RESULT_SUCCESS - Success \n
6565  *              BLUETOOTH_DPM_RESULT_ACCESS_DENIED - BT restricted \n
6566  *              BLUETOOTH_DPM_RESULT_FAIL - Internal error \n
6567  *
6568  * @exception   None
6569  * @param[in]   service_uuids - profile or custom service uuids
6570  *
6571  * @remark      None
6572  */
6573 int bluetooth_dpm_remove_uuid_from_whitelist(const char *service_uuid);
6574
6575 /**
6576  * @fn int bluetooth_dpm_remove_uuid_from_blacklist(const char *service_uuid);
6577  *
6578  * @brief Removes the Service UUIDS from blacklist.
6579  *
6580  * This function is a synchronous call.
6581  *
6582  * @return      BLUETOOTH_DPM_RESULT_SUCCESS - Success \n
6583  *              BLUETOOTH_DPM_RESULT_ACCESS_DENIED - BT restricted \n
6584  *              BLUETOOTH_DPM_RESULT_FAIL - Internal error \n
6585  *
6586  * @exception   None
6587  * @param[in]   service_uuids - profile or custom service uuids
6588  *
6589  * @remark      None
6590  */
6591 int bluetooth_dpm_remove_uuid_from_blacklist(const char *service_uuid);
6592
6593 /**
6594  * @fn int bluetooth_dpm_set_allow_outgoing_call(bt_dpm_status_t value);
6595  *
6596  * @brief Sets the Restriction for outgoing call.
6597  *
6598  * This function is a synchronous call.
6599  *
6600  * @return      BLUETOOTH_DPM_RESULT_SUCCESS - Success \n
6601  *              BLUETOOTH_DPM_RESULT_ACCESS_DENIED - BT restricted \n
6602  *              BLUETOOTH_DPM_RESULT_FAIL - Internal error \n
6603  *
6604  * @exception   None
6605  * @param[in]   value - State value.
6606  *              BLUETOOTH_DPM_ALLOWED           = 0,    < DPM Policy status allowed.
6607  *              BLUETOOTH_DPM_RESTRICTED                = 1,    < DPM Policy status restricted.
6608  *
6609  * @remark      None
6610  */
6611 int bluetooth_dpm_set_allow_outgoing_call(bt_dpm_status_t value);
6612
6613 /**
6614  * @fn int bluetooth_dpm_get_allow_outgoing_call(bt_dpm_status_t *value);
6615  *
6616  * @brief Reads the Restriction for  outgoing call.
6617  *
6618  * This function is a synchronous call.
6619  *
6620  * @return      BLUETOOTH_DPM_RESULT_SUCCESS - Success \n
6621  *              BLUETOOTH_DPM_RESULT_ACCESS_DENIED - BT restricted \n
6622  *              BLUETOOTH_DPM_RESULT_FAIL - Internal error \n
6623  *
6624  * @exception   None
6625  * @param[in] None
6626  * @param[out]  value - State value.
6627  *              BLUETOOTH_DPM_ALLOWED           = 0,    < DPM Policy status allowed.
6628  *              BLUETOOTH_DPM_RESTRICTED                = 1,    < DPM Policy status restricted.
6629  *
6630  * @remark      None
6631  */
6632 int bluetooth_dpm_get_allow_outgoing_call(bt_dpm_status_t *value);
6633
6634 /**
6635  * @fn int bluetooth_dpm_set_pairing_state(bt_dpm_status_t value);
6636  *
6637  * @brief Sets the Restriction for Pairing.
6638  *
6639  * This function is a synchronous call.
6640  *
6641  * @return      BLUETOOTH_DPM_RESULT_SUCCESS - Success \n
6642  *              BLUETOOTH_DPM_RESULT_ACCESS_DENIED - BT restricted \n
6643  *              BLUETOOTH_DPM_RESULT_FAIL - Internal error \n
6644  *
6645  * @exception   None
6646  * @param[in]   value - State value.
6647  *              BLUETOOTH_DPM_ALLOWED           = 0,    < DPM Policy status allowed.
6648  *              BLUETOOTH_DPM_RESTRICTED                = 1,    < DPM Policy status restricted.
6649  *
6650  * @remark      None
6651  */
6652 int bluetooth_dpm_set_pairing_state(bt_dpm_status_t value);
6653
6654 /**
6655  * @fn int bluetooth_dpm_get_pairing_state(bt_dpm_status_t *value);
6656  *
6657  * @brief Reads the Restriction for Pairing
6658  *
6659  * This function is a synchronous call.
6660  *
6661  * @return      BLUETOOTH_DPM_RESULT_SUCCESS - Success \n
6662  *              BLUETOOTH_DPM_RESULT_ACCESS_DENIED - BT restricted \n
6663  *              BLUETOOTH_DPM_RESULT_FAIL - Internal error \n
6664  *
6665  * @exception   None
6666  * @param[in] None
6667  * @param[out]  value - State value.
6668  *              BLUETOOTH_DPM_ALLOWED           = 0,    < DPM Policy status allowed.
6669  *              BLUETOOTH_DPM_RESTRICTED                = 1,    < DPM Policy status restricted.
6670  *
6671  * @remark      None
6672  */
6673 int bluetooth_dpm_get_pairing_state(bt_dpm_status_t *value);
6674
6675 /**
6676  * @fnint bluetooth_dpm_set_profile_state(bt_dpm_profile_t profile, bt_dpm_status_t value);
6677  *
6678  * @brief Sets the Restriction for using Profiles.
6679  *
6680  * This function is a synchronous call.
6681  *
6682  * @return      BLUETOOTH_DPM_RESULT_SUCCESS - Success \n
6683  *              BLUETOOTH_DPM_RESULT_ACCESS_DENIED - BT restricted \n
6684  *              BLUETOOTH_DPM_RESULT_FAIL - Internal error \n
6685  *
6686  * @exception   None
6687  * @param[in]profile - Profile.
6688  *              BLUETOOTH_DPM_POLICY_A2DP_PROFILE_STATE,
6689  *              BLUETOOTH_DPM_POLICY_AVRCP_PROFILE_STATE,
6690  *              BLUETOOTH_DPM_POLICY_BPP_PROFILE_STATE,
6691  *              BLUETOOTH_DPM_POLICY_DUN_PROFILE_STATE,
6692  *              BLUETOOTH_DPM_POLICY_FTP_PROFILE_STATE,
6693  *              BLUETOOTH_DPM_POLICY_HFP_PROFILE_STATE,
6694  *              BLUETOOTH_DPM_POLICY_HSP_PROFILE_STATE,
6695  *              BLUETOOTH_DPM_POLICY_PBAP_PROFILE_STATE,
6696  *              BLUETOOTH_DPM_POLICY_SAP_PROFILE_STATE,
6697  *              BLUETOOTH_DPM_POLICY_SPP_PROFILE_STATE,
6698  *              BLUETOOTH_DPM_PROFILE_NONE
6699  * @param[in]   value - State value.
6700  *              BLUETOOTH_DPM_ALLOWED           = 0,    < DPM Policy status allowed.
6701  *              BLUETOOTH_DPM_RESTRICTED                = 1,    < DPM Policy status restricted.
6702  *
6703  * @remark      None
6704  */
6705 int bluetooth_dpm_set_profile_state(bt_dpm_profile_t profile, bt_dpm_status_t value);
6706
6707 /**
6708  * @fn int bluetooth_dpm_get_profile_state(bt_dpm_profile_t profile, bt_dpm_status_t *value);
6709  *
6710  * @brief Reads the Restriction for using Profiles.
6711  *
6712  * This function is a synchronous call.
6713  *
6714  * @return      BLUETOOTH_DPM_RESULT_SUCCESS - Success \n
6715  *              BLUETOOTH_DPM_RESULT_ACCESS_DENIED - BT restricted \n
6716  *              BLUETOOTH_DPM_RESULT_FAIL - Internal error \n
6717  *
6718  * @exception   None
6719  * @param[in]profile - Profile.
6720  *              BLUETOOTH_DPM_POLICY_A2DP_PROFILE_STATE,
6721  *              BLUETOOTH_DPM_POLICY_AVRCP_PROFILE_STATE,
6722  *              BLUETOOTH_DPM_POLICY_BPP_PROFILE_STATE,
6723  *              BLUETOOTH_DPM_POLICY_DUN_PROFILE_STATE,
6724  *              BLUETOOTH_DPM_POLICY_FTP_PROFILE_STATE,
6725  *              BLUETOOTH_DPM_POLICY_HFP_PROFILE_STATE,
6726  *              BLUETOOTH_DPM_POLICY_HSP_PROFILE_STATE,
6727  *              BLUETOOTH_DPM_POLICY_PBAP_PROFILE_STATE,
6728  *              BLUETOOTH_DPM_POLICY_SAP_PROFILE_STATE,
6729  *              BLUETOOTH_DPM_POLICY_SPP_PROFILE_STATE,
6730  *              BLUETOOTH_DPM_PROFILE_NONE
6731  * @param[out]  value - State value.
6732  *              BLUETOOTH_DPM_ALLOWED           = 0,    < DPM Policy status allowed.
6733  *              BLUETOOTH_DPM_RESTRICTED                = 1,    < DPM Policy status restricted.
6734  *
6735  * @remark      None
6736  */
6737 int bluetooth_dpm_get_profile_state(bt_dpm_profile_t profile, bt_dpm_status_t *value);
6738
6739 /**
6740  * @fn int bluetooth_dpm_set_desktop_connectivity_state(bt_dpm_status_t value);
6741  *
6742  * @brief Sets the Restriction for Desktop Connectivity.
6743  *
6744  * This function is a synchronous call.
6745  *
6746  * @return      BLUETOOTH_DPM_RESULT_SUCCESS - Success \n
6747  *              BLUETOOTH_DPM_RESULT_ACCESS_DENIED - BT restricted \n
6748  *              BLUETOOTH_DPM_RESULT_FAIL - Internal error \n
6749  *
6750  * @exception   None
6751  * @param[in]   value - State value.
6752  *              BLUETOOTH_DPM_ALLOWED           = 0,    < DPM Policy status allowed.
6753  *              BLUETOOTH_DPM_RESTRICTED                = 1,    < DPM Policy status restricted.
6754  *
6755  * @remark      None
6756  */
6757 int bluetooth_dpm_set_desktop_connectivity_state(bt_dpm_status_t value);
6758
6759 /**
6760  * @fn int bluetooth_dpm_get_desktop_connectivity_state(bt_dpm_status_t *value);
6761  *
6762  * @brief Reads the Restriction for Desktop Connectivity.
6763  *
6764  * This function is a synchronous call.
6765  *
6766  * @return      BLUETOOTH_DPM_RESULT_SUCCESS - Success \n
6767  *              BLUETOOTH_DPM_RESULT_ACCESS_DENIED - BT restricted \n
6768  *              BLUETOOTH_DPM_RESULT_FAIL - Internal error \n
6769  *
6770  * @exception   None
6771  * @param[in] None
6772  * @param[out]  value - State value.
6773  *              BLUETOOTH_DPM_ALLOWED           = 0,    < DPM Policy status allowed.
6774  *              BLUETOOTH_DPM_RESTRICTED                = 1,    < DPM Policy status restricted.
6775  *
6776  * @remark      None
6777  */
6778 int bluetooth_dpm_get_desktop_connectivity_state(bt_dpm_status_t *value);
6779
6780 /**
6781  * @fn int bluetooth_dpm_set_discoverable_state(bt_dpm_status_t value);
6782  *
6783  * @brief Sets the Restriction for Discoverable state.
6784  *
6785  * This function is a synchronous call.
6786  *
6787  * @return      BLUETOOTH_DPM_RESULT_SUCCESS - Success \n
6788  *              BLUETOOTH_DPM_RESULT_ACCESS_DENIED - BT restricted \n
6789  *              BLUETOOTH_DPM_RESULT_FAIL - Internal error \n
6790  *
6791  * @exception   None
6792  * @param[in]   value - State value.
6793  *              BLUETOOTH_DPM_ALLOWED           = 0,    < DPM Policy status allowed.
6794  *              BLUETOOTH_DPM_RESTRICTED                = 1,    < DPM Policy status restricted.
6795  *
6796  * @remark      None
6797  */
6798 int bluetooth_dpm_set_discoverable_state(bt_dpm_status_t value);
6799
6800 /**
6801  * @fn int bluetooth_dpm_get_discoverable_state(bt_dpm_status_t *value);
6802  *
6803  * @brief Reads the Restriction for Discoverable state.
6804  *
6805  * This function is a synchronous call.
6806  *
6807  * @return      BLUETOOTH_DPM_RESULT_SUCCESS - Success \n
6808  *              BLUETOOTH_DPM_RESULT_ACCESS_DENIED - BT restricted \n
6809  *              BLUETOOTH_DPM_RESULT_FAIL - Internal error \n
6810  *
6811  * @exception   None
6812  * @param[in] None
6813  * @param[out]  value - State value.
6814  *              BLUETOOTH_DPM_ALLOWED           = 0,    < DPM Policy status allowed.
6815  *              BLUETOOTH_DPM_RESTRICTED                = 1,    < DPM Policy status restricted.
6816  *
6817  * @remark      None
6818  */
6819 int bluetooth_dpm_get_discoverable_state(bt_dpm_status_t *value);
6820
6821 /**
6822  * @fn int bluetooth_dpm_set_limited_discoverable_state(bt_dpm_status_t value);
6823  *
6824  * @brief Sets the Restriction for linited discoverable state..
6825  *
6826  * This function is a synchronous call.
6827  *
6828  * @return      BLUETOOTH_DPM_RESULT_SUCCESS - Success \n
6829  *              BLUETOOTH_DPM_RESULT_ACCESS_DENIED - BT restricted \n
6830  *              BLUETOOTH_DPM_RESULT_FAIL - Internal error \n
6831  *
6832  * @exception   None
6833  * @param[in]   value - State value.
6834  *              BLUETOOTH_DPM_ALLOWED           = 0,    < DPM Policy status allowed.
6835  *              BLUETOOTH_DPM_RESTRICTED                = 1,    < DPM Policy status restricted.
6836  *
6837  * @remark      None
6838  */
6839 int bluetooth_dpm_set_limited_discoverable_state(bt_dpm_status_t value);
6840
6841 /**
6842  * @fn int bluetooth_dpm_get_limited_discoverable_state(bt_dpm_status_t *value);
6843  *
6844  * @brief Reads the Restriction for limited discoverable state.
6845  *
6846  * This function is a synchronous call.
6847  *
6848  * @return      BLUETOOTH_DPM_RESULT_SUCCESS - Success \n
6849  *              BLUETOOTH_DPM_RESULT_ACCESS_DENIED - BT restricted \n
6850  *              BLUETOOTH_DPM_RESULT_FAIL - Internal error \n
6851  *
6852  * @exception   None
6853  * @param[in] None
6854  * @param[out]  value - State value.
6855  *              BLUETOOTH_DPM_ALLOWED           = 0,    < DPM Policy status allowed.
6856  *              BLUETOOTH_DPM_RESTRICTED                = 1,    < DPM Policy status restricted.
6857  *
6858  * @remark      None
6859  */
6860 int bluetooth_dpm_get_limited_discoverable_state(bt_dpm_status_t *value);
6861 /**
6862  * @fn int bluetooth_dpm_set_data_transfer_state(bt_dpm_status_t value);
6863  *
6864  * @brief Sets the Restriction for Data trasnfer.
6865  *
6866  * This function is a synchronous call.
6867  *
6868  * @return      BLUETOOTH_DPM_RESULT_SUCCESS - Success \n
6869  *              BLUETOOTH_DPM_RESULT_ACCESS_DENIED - BT restricted \n
6870  *              BLUETOOTH_DPM_RESULT_FAIL - Internal error \n
6871  *
6872  * @exception   None
6873  * @param[in]   value - State value.
6874  *              BLUETOOTH_DPM_ALLOWED           = 0,    < DPM Policy status allowed.
6875  *              BLUETOOTH_DPM_RESTRICTED                = 1,    < DPM Policy status restricted.
6876  *
6877  * @remark      None
6878  */
6879 int bluetooth_dpm_set_data_transfer_state(bt_dpm_status_t value);
6880
6881
6882 /**
6883  * @fn int bluetooth_dpm_get_data_transfer_state(bt_dpm_status_t *value);
6884  *
6885  * @brief Reads the Restriction for Data trasnfer.
6886  *
6887  * This function is a synchronous call.
6888  *
6889  * @return      BLUETOOTH_DPM_RESULT_SUCCESS - Success \n
6890  *              BLUETOOTH_DPM_RESULT_ACCESS_DENIED - BT restricted \n
6891  *              BLUETOOTH_DPM_RESULT_FAIL - Internal error \n
6892  *
6893  * @exception   None
6894  * @param[in] None
6895  * @param[out]  value - State value.
6896  *              BLUETOOTH_DPM_ALLOWED           = 0,    < DPM Policy status allowed.
6897  *              BLUETOOTH_DPM_RESTRICTED                = 1,    < DPM Policy status restricted.
6898  *
6899  * @remark      None
6900  */
6901 int bluetooth_dpm_get_data_transfer_state(bt_dpm_status_t *value);
6902
6903 /**
6904  * @fn int bluetooth_set_proximity_property(const bluetooth_device_address_t *device_address,
6905  *                                              bluetooth_pxp_poperty_t property, int value);
6906  *
6907  * @brief Sets the Proximity alert level/properties.
6908  *
6909  * This function is a synchronous call.
6910  *
6911  * @return   BLUETOOTH_ERROR_NONE - Success \n
6912  *               BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Device is not enabled \n
6913  *               BLUETOOTH_ERROR_NOT_FOUND - Cannot find the proxy\n
6914  *               BLUETOOTH_ERROR_INVALID_PARAM - Invalid parameter \n
6915  *
6916  * @exception   None
6917  * @param[in] device_address remote device address
6918  * @param[in] property proximity profile property
6919  * @param[in] value alert level/property value to be set
6920  * @param[out] None
6921  *
6922  * @remark      None
6923  */
6924 int bluetooth_set_proximity_property(const bluetooth_device_address_t *device_address,
6925                                                         bluetooth_pxp_poperty_t property, int value);
6926
6927 /**
6928  * @fn int bluetooth_get_proximity_property(const bluetooth_device_address_t *device_address,
6929  *                                              bluetooth_pxp_poperty_t property, int *value);
6930  *
6931  * @brief Reads the Proximity alert level/properties.
6932  *
6933  * This function is a synchronous call.
6934  *
6935  * @return   BLUETOOTH_ERROR_NONE - Success \n
6936  *               BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Device is not enabled \n
6937  *               BLUETOOTH_ERROR_NOT_FOUND - Cannot find the proxy\n
6938  *               BLUETOOTH_ERROR_INVALID_PARAM - Invalid parameter \n
6939  *
6940  * @exception   None
6941  * @param[in] device_address remote device address
6942  * @param[in] property proximity profile property
6943  * @param[out] value alert level/property value
6944  *
6945  * @remark      None
6946  */
6947 int bluetooth_get_proximity_property(const bluetooth_device_address_t *device_address,
6948                                                         bluetooth_pxp_poperty_t property, int *value);
6949
6950 /**
6951  * @fn int bluetooth_get_proximity_supported_services(const bluetooth_device_address_t *device_address,
6952  *                                              int *services_supported);
6953  *
6954  * @brief Reads the Proximity profile supported properties/services.
6955  *
6956  * This function is a synchronous call.
6957  *
6958  * @return   BLUETOOTH_ERROR_NONE - Success \n
6959  *               BLUETOOTH_ERROR_DEVICE_NOT_ENABLED - Device is not enabled \n
6960  *               BLUETOOTH_ERROR_NOT_FOUND - Cannot find the proxy\n
6961  *               BLUETOOTH_ERROR_INVALID_PARAM - Invalid parameter \n
6962  *
6963  * @exception   None
6964  * @param[in] device_address remote device address
6965  * @param[out] services_supported proximity profile property/service
6966  *
6967  * @remark      None
6968  */
6969 int bluetooth_get_proximity_supported_services(const bluetooth_device_address_t *device_address,
6970                                                         int *services_supported);
6971
6972 /**
6973  * @fn int bluetooth_register__proximity_reporter();
6974  *
6975  * @brief Register all proximity related services in BlueZ.
6976  *
6977  * This function is a synchronous call.
6978  *
6979  * @return   BLUETOOTH_ERROR_NONE - Success \n
6980  *           BLUETOOTH_ERROR_NOT_FOUND - Cannot find the proxy\n
6981  *
6982  * @exception   None
6983  *
6984  * @remark      None
6985  */
6986 int bluetooth_register_proximity_reporter();
6987
6988 /**
6989  * @fn int bluetooth_unregister__proximity_reporter();
6990  *
6991  * @brief Unregister all proximity related services in BlueZ.
6992  *
6993  * This function is a synchronous call.
6994  *
6995  * @return   BLUETOOTH_ERROR_NONE - Success \n
6996  *           BLUETOOTH_ERROR_NOT_FOUND - Cannot find the proxy\n
6997  *
6998  * @exception   None
6999  *
7000  * @remark      None
7001  */
7002 int bluetooth_unregister_proximity_reporter();
7003
7004 /**
7005  * @}
7006  */
7007
7008 #ifdef __cplusplus
7009 }
7010 #endif                          /* __cplusplus */
7011 #endif                          /* _BLUETOOTH_API_H_*/