return list;
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
void get_uuid(uint8_t type, const void *val, bt_uuid_t *uuid)
#else
static void get_uuid(uint8_t type, const void *val, bt_uuid_t *uuid)
{
if (type == BT_UUID16)
bt_uuid16_create(uuid, get_le16(val));
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
else if (type == BT_UUID32)
bt_uuid32_create(uuid, get_le32(val));
#endif
if (uuid->type == BT_UUID16)
uuid_len = 2;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
else if (uuid->type == BT_UUID32)
uuid_len = 4;
#endif
if (len == (min_len + 2))
type = BT_UUID16;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
else if (len == (min_len + 4))
type = BT_UUID32;
#endif
uint16_t end;
};
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
void get_uuid(uint8_t type, const void *val, bt_uuid_t *uuid);
static inline bt_uuid_t att_get_uuid(const void *ptr, uint8_t len)
while (opt != GATT_OPT_INVALID) {
switch (opt) {
case GATT_OPT_CHR_UUID16:
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
case GATT_OPT_DESC_UUID16:
#endif
bt_uuid16_create(&info->uuid, va_arg(args, int));
info->num_attrs += 2;
break;
case GATT_OPT_CHR_UUID:
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
case GATT_OPT_DESC_UUID:
#endif
memcpy(&info->uuid, va_arg(args, bt_uuid_t *),
info->num_attrs += 2;
break;
case GATT_OPT_CHR_PROPS:
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
case GATT_OPT_DESC_PROPS:
#endif
info->props = va_arg(args, int);
* descriptor, but it is not supported yet. */
break;
case GATT_OPT_CHR_VALUE_CB:
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
case GATT_OPT_DESC_VALUE_CB:
#endif
cb = g_new0(struct attrib_cb, 1);
}
opt = va_arg(args, gatt_option);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (opt == GATT_OPT_CHR_UUID16 || opt == GATT_OPT_CHR_UUID ||
opt == GATT_OPT_DESC_UUID16 || opt == GATT_OPT_DESC_UUID) {
#else
if (info->value_handle != NULL)
*info->value_handle = a->handle;
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
/* Since old attrib service implementation add descriptor by default
* if notification and indication properties are set, As per new gatt server implemenation
* CCCD are added by the application*/
/* a uint16 value */
GATT_OPT_CHR_UUID16,
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
/* bt_uuid_t* value */
GATT_OPT_DESC_UUID,
GATT_OPT_CHR_PROPS,
GATT_OPT_CHR_VALUE_CB,
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
GATT_OPT_DESC_PROPS,
GATT_OPT_DESC_VALUE_CB,
#endif
{
if (uuid->type == BT_UUID16)
put_le16(uuid->value.u16, dst);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
else if (uuid->type == BT_UUID32)
put_le32(uuid->value.u32, dst);
#endif
bt_uuid16_create(&uuid16, get_le16(val));
bt_uuid_to_uuid128(&uuid16, uuid);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
} else if (type == BT_UUID32) {
bt_uuid_t uuid32;
long_read->func(status, rpdu, rlen, long_read->user_data);
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
guint gatt_read_char_by_offset(GAttrib *attrib, uint16_t handle, uint16_t offset,
GAttribResultFunc func, gpointer user_data)
{
uuid_t *prim_uuid, uint16_t *psm,
uint16_t *start, uint16_t *end);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
guint gatt_read_char_by_offset(GAttrib *attrib, uint16_t handle, uint16_t offset,
GAttribResultFunc func, gpointer user_data);
#endif
static void cmd_read_hnd(int argcp, char **argvp)
{
int handle;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
int offset = 0;
#endif
if (conn_state != STATE_CONNECTED) {
error("Invalid handle: %s\n", argvp[1]);
return;
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (argcp > 2) {
offset = strtohandle(argvp[2]);
if (offset < 0) {
"Characteristics Discovery" },
{ "char-desc", cmd_char_desc, "[start hnd] [end hnd]",
"Characteristics Descriptor Discovery" },
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
{ "char-read-hnd", cmd_read_hnd, "<handle> [offset]",
"Characteristics Value/Descriptor Read by handle" },
#else
print_uuids(proxy);
print_property(proxy, "Modalias");
print_property(proxy, "Discovering");
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
print_property(proxy, "Advertising");
#endif
}
print_property(proxy, "LegacyPairing");
print_uuids(proxy);
print_property(proxy, "Modalias");
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
print_property(proxy, "ManufacturerDataLen");
#endif
print_property(proxy, "ManufacturerData");
org.bluez.Error.NotSupported
org.bluez.Error.Failed
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
void StartCustomDiscovery(string pattern)
This method starts the device discovery session with
Local Device ID information in modalias format
used by the kernel and udev.
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
boolean LEDiscovering [readonly]
Indicates that a device LE discovery procedure is active.
org.bluez.Error.InvalidArguments
org.bluez.Error.NotSupported
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
void Pair(uint8 conn_type)
#else
void Pair()
In case there is no application agent and also
no default agent present, this method will fail.
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
conn_type represents the type of the connection to be
used for pairing.
0xFF -> BR/EDR and LE
Possible errors: org.bluez.Error.DoesNotExist
org.bluez.Error.Failed
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
void ConnectLe()
This is a generic method to connect GATT of
Indicates if the remote device is paired.
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
byte Connected [readonly]
#else
boolean Connected [readonly]
updated once all remote GATT services of this device
have been discovered and exported over D-Bus.
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
boolean GattConnected [readonly]
Indicates if the remote LE device is currently connected.
descriptor objects will become available via
ObjectManager as soon as they get discovered.
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
string Unicast [read-only]
12:34:56:78:9A:BC remote device address, if address is set then
Possible errors: org.bluez.Error.InvalidArguments
org.bluez.Error.DoesNotExist
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
GetService(string uuid)
This Reads the service, characterstics and descriptors
Possible errors: Invalid Parameters
Invalid Index
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
Generate Identity Resolving Key Command
=======================================
All servers will be automatically unregistered when
the calling application terminates.
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
void Disconnect(string address)
Disconnect the device from the network device.
Possible errors: org.bluez.Error.InvalidArguments
org.bluez.Error.AlreadyExists
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
void RegisterProfile2(object profile, string uuid, string destination,
string path,dict options)
0 = disable timer, i.e. stay
discoverable forever
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
LocalIrk String Identity resolving key for local
adapter. This key value is used to
generate the RPA to suport privacy feature.
Discoverable=false
Pairable=true
DiscoverableTimeout=0
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
LocalIrk=""
#endif
Authenticated Boolean True if the key is authenticated
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
[IdentityResolvingKey] group contains:
Key String Identity Resolving key in hexadecimal format
#include "gdbus.h"
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
#if 0
#include <syslog.h>
static void gdbus_dbg(const char *format, ...)
static struct generic_data *root;
static GSList *pending = NULL;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
#define ADAPTER_INTERFACE "org.bluez.Adapter1"
static char *adapter_path = NULL;
data->interfaces = g_slist_remove(data->interfaces, iface);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (g_strcmp0(iface->name, ADAPTER_INTERFACE) == 0) {
g_free(adapter_path);
adapter_path = NULL;
if (check_privilege(connection, message, method,
iface->user_data) == TRUE)
return DBUS_HANDLER_RESULT_HANDLED;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
#if 0
gdbus_dbg("%s: %s.%s()", dbus_message_get_path(message),
iface->name, method->name);
return reply;
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static DBusMessage *default_adapter(DBusConnection *conn,
DBusMessage *msg, void *data)
{
static const GDBusMethodTable manager_methods[] = {
{ GDBUS_METHOD("GetManagedObjects", NULL,
GDBUS_ARGS({ "objects", "a{oa{sa{sv}}}" }), get_objects) },
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
{ GDBUS_METHOD("DefaultAdapter",
NULL, GDBUS_ARGS({ "adapter", "o" }),
default_adapter) },
return FALSE;
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (g_strcmp0(name, ADAPTER_INTERFACE) == 0)
adapter_path = g_strdup(path);
#endif
GHashTable *tags;
gsize count = 0;
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
if (size < 2)
return NULL;
-#endif /* __TIZEN_PATCH__ */
+#endif /* TIZEN_FEATURE_BLUEZ_MODIFY */
apparam = g_obex_apparam_new();
return count;
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
void g_obex_apparam_remove_all(GObexApparam *apparam)
{
g_hash_table_remove_all(apparam->tags);
GObexApparam *g_obex_apparam_decode(const void *data, gsize size);
gssize g_obex_apparam_encode(GObexApparam *apparam, void *buf, gsize size);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
void g_obex_apparam_remove_all(GObexApparam *apparam);
#endif
GObexHeader *header;
gsize len;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
gunichar2 *utf16;
glong utf16_len;
#endif
len = g_utf8_strlen(str, -1);
header->vlen = len;
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
header->hlen = len == 0 ? 3 : 3 + ((len + 1) * 2);
header->v.string = g_strdup(str);
#else
return result;
g_checksum_update(md5, nonce, NONCE_LEN);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
g_checksum_update(md5, (guint8 *) ":0000", 5);
#else
g_checksum_update(md5, (guint8 *) ":BlueZ", 6);
-#endif /* __TIZEN_PATCH__ */
+#endif /* TIZEN_FEATURE_BLUEZ_MODIFY */
size = NONCE_LEN;
#define BT_SNDMTU 12
#define BT_RCVMTU 13
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
#define BT_LE_CONN_PARAM 14
struct le_conn_param {
uint16_t min;
return "PCI";
case HCI_SDIO:
return "SDIO";
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
case HCI_SMD:
return "QC_SMD";
#endif
{ "LE Receiver Test", 228 },
{ "LE Transmitter Test", 229 },
{ "LE Test End", 230 },
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
{ "LE Read Maximum Data Length", 231 },
{ "Reserved", 232 },
#else
/* HCI functions that require open device
* dd - Device descriptor returned by hci_open_dev. */
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
int hci_send_data(int dd, uint16_t handle, uint8_t len, void *data)
{
uint8_t type = HCI_ACLDATA_PKT;
struct hci_request rq;
memset(&cp, 0, sizeof(cp));
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
strncpy((char *) cp.name, name, sizeof(cp.name) - 1);
#else
strncpy((char *) cp.name, name, sizeof(cp.name));
return 0;
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
int hci_le_read_maximum_data_length(
int dd, uint8_t *status, uint16_t *tx_octets,
uint16_t *tx_time, uint16_t *rx_octets,
#define HCI_PCI 5
#define HCI_SDIO 6
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
#define HCI_SMD 7
#endif
} __attribute__ ((packed)) le_test_end_rp;
#define LE_TEST_END_RP_SIZE 3
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
#define OCF_LE_READ_MAXIMUM_DATA_LENGTH 0x002F
typedef struct {
uint8_t status;
/* Vendor specific commands */
#define OGF_VENDOR_CMD 0x3f
-#ifdef __TIZEN_PATCH__
-#ifdef __BROADCOM_QOS_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
+#ifdef TIZEN_FEATURE_BLUEZ_BRCM_QOS
#define BRCM_QOS_PRIORITY_NORMAL 0x00
#define BRCM_QOS_PRIORITY_HIGH 0xFF
#define BROADCOM_QOS_CMD 0xFC57 /* Only for bcm4329/bcm4330/bcm4334 chipsets */
uint8_t priority;
} __attribute__ ((__packed__)) broadcom_qos_cp;
#define BROADCOM_QOS_CP_SIZE 3
-#endif /* __BROADCOM_QOS_PATCH__ */
-#endif /* __TIZEN_PATCH__ */
+#endif /* TIZEN_FEATURE_BLUEZ_BRCM_QOS */
+#endif /* TIZEN_FEATURE_BLUEZ_MODIFY */
/* ---- HCI Events ---- */
int hci_open_dev(int dev_id);
int hci_close_dev(int dd);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
int hci_send_data(int dd, uint16_t handle, uint8_t len, void *data);
#endif
int hci_send_cmd(int dd, uint16_t ogf, uint16_t ocf, uint8_t plen, void *param);
int hci_le_read_resolving_list_size(int dd, uint8_t *size, int to);
int hci_le_set_address_resolution_enable(int dev_id, uint8_t enable, int to);
int hci_le_read_remote_features(int dd, uint16_t handle, uint8_t *features, int to);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
int hci_le_read_maximum_data_length(
int dd, uint8_t *status, uint16_t *tx_octets,
uint16_t *tx_time, uint16_t *rx_octets,
} __attribute__ ((packed)) l2cap_conf_opt;
#define L2CAP_CONF_OPT_SIZE 2
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
typedef struct {
uint8_t mode;
uint8_t txwin_size;
"Permission Denied",
};
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
#define TIZEN_OP_CODE_BASE 0xff00
#define TIZEN_EV_BASE 0xff00
"LE Set Scan Parameters",
"Set Voice Setting",
"Get Adv Tx Power",
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
"Enable BT 6LOWPAN",
"Connect BT 6LOWPAN",
"Disconnect BT 6LOWPAN"
"LE Device Found",
"Multi Adv State Change",
};
-#endif /* End of __TIZEN_PATCH__ */
+#endif /* End of TIZEN_FEATURE_BLUEZ_MODIFY */
#ifndef NELEM
#define NELEM(x) (sizeof(x) / sizeof((x)[0]))
static inline const char *mgmt_opstr(uint16_t op)
{
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (op >= NELEM(mgmt_op)) {
uint16_t tizen_op = op - TIZEN_OP_CODE_BASE;
static inline const char *mgmt_evstr(uint16_t ev)
{
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (ev >= NELEM(mgmt_ev)) {
uint16_t tizen_ev = ev - TIZEN_EV_BASE;
#endif
#include <stdint.h>
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
#include <bluetooth/bluetooth.h>
#endif
#define OBEX_MNS_UUID "00001133-0000-1000-8000-00805f9b34fb"
#define OBEX_MAP_UUID "00001134-0000-1000-8000-00805f9b34fb"
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
/* Samsung Accessary Protocol UUIDs */
#define WEARABLE_OLD_SAP_UUID "a49eb41e-cb06-495c-9f4f-aa80a90cdf4a"
#define WEARABLE_NEW_SAP_UUID "a49eb41e-cb06-495c-9f4f-bb80a90cdf00"
#define GATT_CHARAC_SOFTWARE_REVISION_STRING 0x2A28
#define GATT_CHARAC_MANUFACTURER_NAME_STRING 0x2A29
#define GATT_CHARAC_PNP_ID 0x2A50
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
#define GATT_CHARAC_CENTRAL_RPA_RESOLUTION 0x2AA6
#endif
#define GATT_EXTERNAL_REPORT_REFERENCE 0x2907
#define GATT_REPORT_REFERENCE 0x2908
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
/* GATT Service UUIDs : Defined by SIG */
#define GATT_IPSP_UUID 0x1820
#endif
#include "ll.h"
#include "vendor.h"
#include "broadcom.h"
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
#include "uuid.h"
#endif
print_field("Address: 0x%8.8x", addr);
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static void set_advt_param_multi_subcmd(const void *data, uint8_t size)
{
uint8_t adv_instance = get_u8(data + size - 2);
print_field("Build number: %u (0x%4.4x)", build_num, build_num);
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static void get_vendor_capabilities_rsp(const void *data, uint8_t size)
{
uint8_t status = get_u8(data);
{ 0x079, "Read Verbose Config Version Info",
null_cmd, 0, true,
read_verbose_version_info_rsp, 7, true },
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
{ 0x0153, "LE Get Vendor Capabilities",
null_cmd, 0, true,
get_vendor_capabilities_rsp, 10, false },
}
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
struct hci_vse_sec_brcm_link_loss_dbg_info{
unsigned char linklost_status;
unsigned char conn_handle;
#endif
static const struct vendor_evt vendor_evt_table[] = {
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
{ 0x76, "SEC Link Loss", linkloss_evt, 18, true },
#endif
{ }
server_fd = fd;
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
bool control_writer(const char *path, int16_t rotate_count, ssize_t file_size)
#else
bool control_writer(const char *path)
#endif
{
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
btsnoop_file = btsnoop_create(path, BTSNOOP_FORMAT_MONITOR,
rotate_count, file_size);
#else
break;
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
setenv("PAGER", "cat", 0);
#endif
open_pager();
#include <stdint.h>
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
bool control_writer(const char *path, int16_t rotate_count, ssize_t file_size);
#else
bool control_writer(const char *path);
#define COLOR_INFO COLOR_OFF
#define COLOR_DEBUG COLOR_WHITE
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
#define FALLBACK_TERMINAL_WIDTH 130
#else
#define FALLBACK_TERMINAL_WIDTH 80
"\t-T, --date Show time and date information\n"
"\t-S, --sco Dump SCO traffic\n"
"\t-E, --ellisys [ip] Send Ellisys HCI Injection\n"
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
"\t-C, --count <num> Save traces by <num> rotation\n"
"\t-W, --size <num> Save traces at most <num> size\n"
#endif
{ "date", no_argument, NULL, 'T' },
{ "sco", no_argument, NULL, 'S' },
{ "ellisys", required_argument, NULL, 'E' },
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
{ "count", required_argument, NULL, 'C' },
{ "size", required_argument, NULL, 'W' },
#endif
const char *analyze_path = NULL;
const char *ellisys_server = NULL;
unsigned short ellisys_port = 0;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
int16_t rotate_count = -1;
ssize_t file_size = -1;
#endif
for (;;) {
int opt;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
opt = getopt_long(argc, argv, "r:w:a:s:p:i:tTSE:C:W:vh",
main_options, NULL);
#else
ellisys_server = optarg;
ellisys_port = 24352;
break;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
case 'C':
rotate_count = atoi(optarg);
break;
return EXIT_SUCCESS;
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (writer_path && !control_writer(writer_path,
rotate_count, file_size)) {
printf("Failed to open '%s'\n", writer_path);
return "Intel";
case 15:
return "Broadcom";
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
default:
return "Unknown";
#endif
return intel_vendor_ocf(ocf);
case 15:
return broadcom_vendor_ocf(ocf);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
default:
return broadcom_vendor_ocf(ocf);
#endif
return intel_vendor_evt(evt);
case 15:
return broadcom_vendor_evt(evt);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
default:
return broadcom_vendor_evt(evt);
#endif
}
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
void print_le_set_adv_parameters_cmd(const void *data, uint8_t size)
{
le_set_adv_parameters_cmd(data, size);
void packet_todo(void);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
void print_le_set_adv_parameters_cmd(const void *data, uint8_t size);
void print_le_set_random_address_cmd(const void *data, uint8_t size);
void print_le_set_adv_data_cmd(const void *data, uint8_t size);
protos = NULL;
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
/* Use obex over l2cap only if obex over rfcomm is not there */
if (ch == -1) {
data = sdp_data_get(rec, 0x0200);
#include "sync.h"
#include "map.h"
#include "manager.h"
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
#include "mns-tizen.h"
#endif
#define CLIENT_INTERFACE "org.bluez.obex.Client1"
obc_session_unref(session);
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
void release_session(struct obc_session *session)
{
DBG("+");
static struct obc_session *find_session(const char *path)
{
GSList *l;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if(!path)
return NULL;
#endif
ERROR_INTERFACE ".NotAuthorized",
"Not Authorized");
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
obc_session_update(session, message, connection);
#endif
release_session(session);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
return NULL;
#else
return dbus_message_new_method_return(message);
{ "pbap", pbap_init, pbap_exit },
{ "sync", sync_init, sync_exit },
{ "map", map_init, map_exit },
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
{ "mns", mns_init, mns_exit },
#endif
{ }
char *filename;
char *basename;
GError *err = NULL;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
char *mimetype = NULL;
#endif
if (dbus_message_get_args(message, NULL,
DBUS_TYPE_STRING, &filename,
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
DBUS_TYPE_STRING, &mimetype,
#endif
DBUS_TYPE_INVALID) == FALSE)
basename = g_path_get_basename(filename);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
transfer = obc_transfer_put(mimetype, basename, filename, NULL, 0, &err);
#else
transfer = obc_transfer_put(NULL, basename, filename, NULL, 0, &err);
static const GDBusMethodTable opp_methods[] = {
{ GDBUS_METHOD("SendFile",
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
GDBUS_ARGS({ "sourcefile", "s" }, { "mimetype", "s" }),
#else
GDBUS_ARGS({ "sourcefile", "s" }),
internal = TRUE;
} else if (!g_ascii_strncasecmp(location, "sim", 3)) {
if (strlen(location) == 3)
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
tmp = g_strdup("SIM1");
#else
tmp = g_strdup("sim1");
} else
return NULL;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (!g_ascii_strcasecmp(item, "nil"))
return path;
#endif
g_obex_apparam_get_uint16(apparam, PHONEBOOKSIZE_TAG,
phone_book_size);
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
g_obex_apparam_get_uint16(apparam, NEWMISSEDCALLS_TAG,
#else
g_obex_apparam_get_uint8(apparam, NEWMISSEDCALLS_TAG,
{
guint16 num;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_UINT16 &&
dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_UINT32)
return NULL;
{
guint16 num;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_UINT16 &&
dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_UINT32)
return NULL;
}
request = pending_request_new(pbap, message);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (pbap->path == NULL || strlen(pbap->path) == 0)
obc_session_setpath(pbap->session, path + 1, pbap_setpath_cb, request,
&err);
struct pbap_data *pbap = user_data;
GObexApparam *apparam;
DBusMessageIter args;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
const char *pb_folder;
#endif
dbus_message_iter_init(message, &args);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (dbus_message_iter_get_arg_type(&args) != DBUS_TYPE_STRING)
return g_dbus_create_error(message,
ERROR_INTERFACE ".InvalidArguments", NULL);
ERROR_INTERFACE ".InvalidArguments", NULL);
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
return pull_vcard_listing(pbap, message, pb_folder, apparam);
#else
return pull_vcard_listing(pbap, message, "", apparam);
{ "properties", "a{sv}" }),
pbap_pull_vcard) },
{ GDBUS_ASYNC_METHOD("List",
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
GDBUS_ARGS({ "folder", "s" }, {"filters", "a{sv}" }),
#else
GDBUS_ARGS({"filters", "a{sv}" }),
#include "dbus.h"
#include "transfer.h"
#include "session.h"
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
#include "manager.h"
#endif
#include "driver.h"
guint process_id;
char *folder;
struct callback_data *callback;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
DBusMessage *message;
DBusConnection *connection;
#endif
return session;
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
void obc_session_update(struct obc_session *session, DBusMessage *message,
DBusConnection *connection)
{
if (err)
error("%s", err->message);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (session->message) {
/* Dbus reply need to be done */
DBG("Dbus reply for remove_session");
if (err)
error("%s", err->message);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
release_session(session);
#else
obc_session_shutdown(session);
if (!data->remaining || !data->remaining[0]) {
error("obc_session_setpath: invalid path %s", path);
g_set_error(err, OBEX_IO_ERROR, -EINVAL, "Invalid argument");
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
setpath_data_free(data);
#endif
return 0;
GError **err);
void obc_session_cancel(struct obc_session *session, guint id,
gboolean remove);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
void release_session(struct obc_session *session);
void obc_session_update(struct obc_session *session, DBusMessage *message,
DBusConnection *connection);
if (transfer->transferred == transfer->progress)
return TRUE;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (transfer->transferred == transfer->size) {
transfer->progress_id = 0;
if(transfer->progress == 0) {
if (transfer->path == NULL)
return TRUE;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
transfer->progress_id = g_timeout_add(10, report_progress,
transfer);
#else
GObexApparam *inparams;
GObexApparam *outparams;
gboolean ap_sent;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
gboolean headers_sent;
int notification_status;
char *remote_addr;
mas->nth_call = FALSE;
mas->finished = FALSE;
mas->ap_sent = FALSE;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
mas->headers_sent = FALSE;
g_free(mas->response_handle);
mas->response_handle = NULL;
static void mas_clean(struct mas_session *mas)
{
reset_request(mas);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
g_free(mas->remote_addr);
#endif
g_free(mas);
static void *mas_connect(struct obex_session *os, int *err)
{
struct mas_session *mas;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
char *address;
#endif
manager_register_session(os);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (obex_getpeername(os, &address) == 0) {
mas->remote_addr = address;
DBG("mas->remote_addr = %s\n", mas->remote_addr);
obex_object_set_io_flags(mas, G_IO_IN, 0);
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static void put_message_cb(void *session, int err, guint64 handle,
void *user_data)
{
mas->finished = TRUE;
goto proceed;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
} else {
mas->ap_sent = TRUE;
#endif
DBG("");
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (oflag != O_RDONLY) {
DBG("Message pushing invoked \n");
return mas;
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static ssize_t message_write(void *object, const void *buf, size_t count)
{
DBG("");
return mas;
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static int notification_registration_close(void *obj)
{
struct mas_session *mas = obj;
.open = message_open,
.close = any_close,
.read = any_read,
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
.write = message_write,
.get_next_header = put_next_header
#else
.target_size = TARGET_SIZE,
.mimetype = "x-bt/MAP-NotificationRegistration",
.open = notification_registration_open,
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
.close = notification_registration_close,
#else
.close = any_close,
return 1;
}
-#ifndef SUPPORT_SMS_ONLY
+#ifndef TIZEN_FEATURE_BLUEZ_SMS_ONLY
static void message_update_msg(DBusPendingCall *call, void *user_data)
{
DBusMessage *reply = dbus_pending_call_steal_reply(call);
messages_status_cb callback,
void *user_data)
{
-#ifdef SUPPORT_SMS_ONLY
+#ifdef TIZEN_FEATURE_BLUEZ_SMS_ONLY
/* MAP.TS.1.0.3 : TP/MMB/BV-16-I
Currently support is only for SMS, Since SMS service does not
allow the polling of its mailbox, it must return Not implemented */
* value is used to set the error code in OBEX response.
******************************************************************************/
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
/* Registers Message Client for receiving message event reports.
*
messages_get_messages_listing_cb callback,
void *user_data);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
/* Retrieves bMessage object (see MAP specification, ch. 3.1.3) of a given
* message.
*
int messages_set_delete(void *session, const char *handle, uint8_t value,
messages_status_cb callback, void *user_data);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
/* Informs Message Server to modify status of the message.
*
#define PHONEBOOKSIZE_TAG 0X08
#define NEWMISSEDCALLS_TAG 0X09
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
#define PBAP_MAXLISTCOUNT_MAX_VALUE 65535
-#endif /* __TIZEN_PATCH__ */
+#endif /* TIZEN_FEATURE_BLUEZ_MODIFY */
struct cache {
gboolean valid;
uint32_t find_handle;
struct cache cache;
struct pbap_object *obj;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
void *backend_data;
#endif
};
phonebooksize);
pbap->obj->firstpacket = TRUE;
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
if (missed > 0) {
#else
if (pbap->params->required_missedcall_call_header == TRUE) {
-#endif /* __TIZEN_PATCH__ */
+#endif /* TIZEN_FEATURE_BLUEZ_MODIFY */
DBG("missed %d", missed);
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
pbap->obj->apparam = g_obex_apparam_set_uint16(
#else
pbap->obj->apparam = g_obex_apparam_set_uint8(
else
pbap->obj->buffer = g_string_append_len(pbap->obj->buffer,
buffer, bufsize);
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
if (missed > 0) {
#else
if (pbap->params->required_missedcall_call_header == TRUE) {
pbap->obj->firstpacket = TRUE;
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
pbap->obj->apparam = g_obex_apparam_set_uint16(
#else
pbap->obj->apparam = g_obex_apparam_set_uint8(
pbap->obj->apparam,
PHONEBOOKSIZE_TAG,
size);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (pbap->params->required_missedcall_call_header == TRUE) {
//DBG("missed %d", missed);
pbap->obj->apparam = g_obex_apparam_set_uint8(
NEWMISSEDCALLS_TAG,
pbap->params->new_missed_calls);
}
-#endif /* __TIZEN_PATCH__ */
+#endif /* TIZEN_FEATURE_BLUEZ_MODIFY */
return 0;
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (pbap->params->required_missedcall_call_header == TRUE) {
pbap->obj->firstpacket = TRUE;
pbap->obj->apparam = g_obex_apparam_set_uint8(
NEWMISSEDCALLS_TAG,
pbap->params->new_missed_calls);
}
-#endif /* __TIZEN_PATCH__ */
+#endif /* TIZEN_FEATURE_BLUEZ_MODIFY */
/*
* Don't free the sorted list content: this list contains
return 0;
}
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
static void cache_ready_notify(void *user_data)
#else
static void cache_ready_notify(void *user_data, unsigned int new_missed_call)
-#endif /* __TIZEN_PATCH__ */
+#endif /* TIZEN_FEATURE_BLUEZ_MODIFY */
{
struct pbap_session *pbap = user_data;
DBG("");
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
pbap->params->new_missed_calls = new_missed_call;
-#endif /* __TIZEN_PATCH__ */
+#endif /* TIZEN_FEATURE_BLUEZ_MODIFY */
phonebook_req_finalize(pbap->obj->request);
pbap->obj->request = NULL;
obex_object_set_io_flags(pbap->obj, G_IO_ERR, ret);
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static void cache_clear_notify(void *user_data)
{
struct pbap_session *pbap = user_data;
{
GObexApparam *apparam;
struct apparam_field *param;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
gboolean bmaxlistCount = FALSE;
-#endif /* __TIZEN_PATCH__ */
+#endif /* TIZEN_FEATURE_BLUEZ_MODIFY */
apparam = g_obex_apparam_decode(buffer, hlen);
if (apparam == NULL)
g_obex_apparam_get_uint8(apparam, SEARCHATTRIB_TAG,
¶m->searchattrib);
g_obex_apparam_get_uint8(apparam, FORMAT_TAG, ¶m->format);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
bmaxlistCount = g_obex_apparam_get_uint16(apparam, MAXLISTCOUNT_TAG,
¶m->maxlistcount);
#else
g_obex_apparam_get_uint16(apparam, MAXLISTCOUNT_TAG,
¶m->maxlistcount);
-#endif /* __TIZEN_PATCH__ */
+#endif /* TIZEN_FEATURE_BLUEZ_MODIFY */
g_obex_apparam_get_uint16(apparam, LISTSTARTOFFSET_TAG,
¶m->liststartoffset);
g_obex_apparam_get_uint64(apparam, FILTER_TAG, ¶m->filter);
param->searchval = g_obex_apparam_get_string(apparam, SEARCHVALUE_TAG);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if(bmaxlistCount == FALSE) {
param->maxlistcount = PBAP_MAXLISTCOUNT_MAX_VALUE;
}
else {
/* Keep the MaxlistCount value as send in request from client */
}
-#endif /* __TIZEN_PATCH__ */
+#endif /* TIZEN_FEATURE_BLUEZ_MODIFY */
DBG("o %x sa %x sv %s fil %" G_GINT64_MODIFIER "x for %x max %x off %x",
param->order, param->searchattrib, param->searchval,
pbap->folder = g_strdup("/");
pbap->find_handle = PHONEBOOK_INVALID_HANDLE;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
int error;
error = phonebook_connect(&pbap->backend_data);
return pbap;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
failed:
g_free(pbap);
manager_unregister_session(os);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (!pbap)
return;
ret = -EBADR;
goto fail;
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (strcmp(name, "/telecom/mch.vcf") == 0)
pbap->params->required_missedcall_call_header = TRUE;
DBG("[%s] - required_missedcall_call_header [%d] ",
name,pbap->params->required_missedcall_call_header);
-#endif /* __TIZEN_PATCH__ */
+#endif /* TIZEN_FEATURE_BLUEZ_MODIFY */
if (pbap->params->maxlistcount == 0)
cb = phonebook_size_result;
ret = -EPERM;
goto fail;
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (strcmp(name, "/telecom/mch") == 0)
pbap->params->required_missedcall_call_header = TRUE;
DBG("[%s] - required_missedcall_call_header [%d] ",
name,pbap->params->required_missedcall_call_header);
-#endif /* __TIZEN_PATCH__ */
+#endif /* TIZEN_FEATURE_BLUEZ_MODIFY */
/* PullvCardListing always get the contacts from the cache */
cache_ready_notify, pbap, &ret);
if (ret == 0)
obj = vobject_create(pbap, request);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
phonebook_set_cache_notification(pbap->backend_data,
cache_clear_notify, pbap);
#endif
struct pbap_session *pbap = context;
const char *id;
uint32_t handle;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
int ret = 0;
#else
int ret;
if (pbap->cache.valid == FALSE) {
pbap->find_handle = handle;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
request = phonebook_create_cache(pbap->folder,
(phonebook_entry_cb)cache_entry_notify,
(phonebook_cache_ready_cb)cache_entry_done, pbap, &ret);
request = phonebook_create_cache(pbap->folder,
cache_entry_notify, cache_entry_done, pbap, &ret);
#endif
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
phonebook_set_cache_notification(pbap->backend_data,
cache_clear_notify, pbap);
#endif
if (obj->firstpacket) {
obj->firstpacket = FALSE;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
gsize count = 0;
count = g_obex_apparam_encode(obj->apparam, buf, mtu);
DBG("APPARAM Processed remove tags");
return -EAGAIN;
*hi = G_OBEX_HDR_APPARAM;
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
if (pbap->params->maxlistcount == 0)
return g_obex_apparam_encode(obj->apparam, buf, mtu);
}
else
return 0;
-#endif /* __TIZEN_PATCH__ */
+#endif /* TIZEN_FEATURE_BLUEZ_MODIFY */
}
static ssize_t vobject_list_read(void *object, void *buf, size_t count)
fd = open(filename, O_RDONLY);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
g_free(filename);
#endif
DBG("new_missed_call %d\n", new_missed_call);
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
data->ready_cb(data->user_data, new_missed_call);
#else
data->ready_cb(data->user_data);
-#endif /* __TIZEN_PATCH__ */
+#endif /* TIZEN_FEATURE_BLUEZ_MODIFY */
dbus_message_unref(reply);
}
uint8_t order;
uint8_t searchattrib;
char *searchval;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
gboolean required_missedcall_call_header;
uint16_t new_missed_calls;
-#endif /* __TIZEN_PATCH__ */
+#endif /* TIZEN_FEATURE_BLUEZ_MODIFY */
};
/*
const char *name, const char *sound,
const char *tel, void *user_data);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
typedef void (*phonebook_cache_clear_cb) (void *user_data);
#endif
* After notify all entries to PBAP core, the backend
* needs to notify that the operation has finished.
*/
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
typedef void (*phonebook_cache_ready_cb) (void *user_data);
#else
typedef void (*phonebook_cache_ready_cb) (void *user_data, unsigned int new_missed_calls);
-#endif /* __TIZEN_PATCH__ */
+#endif /* TIZEN_FEATURE_BLUEZ_MODIFY */
int phonebook_init(void);
void phonebook_exit(void);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
int phonebook_connect(void **user_data);
void phonebook_disconnect(void *user_data);
#endif
*/
void phonebook_req_finalize(void *request);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
void phonebook_set_cache_notification(void *session,
phonebook_cache_clear_cb cache_cb,
void *user_data);
{ NULL },
};
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
void obex_option_set_root_folder(const char *root)
{
g_free(option_root);
return dbus_message_new_method_return(msg);
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static DBusMessage *set_root(DBusConnection *conn, DBusMessage *msg,
const char *root, void *data)
{
return TRUE;
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static gboolean transfer_operation_exists(const GDBusPropertyTable *property,
void *data)
{
GDBUS_ARGS({ "agent", "o" }), NULL, register_agent) },
{ GDBUS_METHOD("UnregisterAgent",
GDBUS_ARGS({ "agent", "o" }), NULL, unregister_agent) },
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
{ GDBUS_METHOD("SetProperty",
GDBUS_ARGS({ "property", "sv" }), NULL, set_property) },
#endif
{ "Time", "t", transfer_get_time, NULL, transfer_time_exists },
{ "Filename", "s", transfer_get_filename, NULL,
transfer_filename_exists },
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
{ "Operation", "s", transfer_get_operation, NULL,
transfer_operation_exists },
{ "Address", "s", transfer_get_address, NULL,
if (!g_obex_header_get_unicode(hdr, &name))
return;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
DBG("Obex Session For: %s", os->service->name);
if (name && g_strcmp0(os->service->name, "Object Push server") == 0) {
char *new_name;
int err;
os->object = os->driver->open(filename, O_WRONLY | O_CREAT | O_TRUNC,
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
0644, os->service_data,
#else
0600, os->service_data,
const char *obex_option_root_folder(void);
gboolean obex_option_symlinks(void);
const char *obex_option_capability(void);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
void obex_option_set_root_folder(const char *root);
#endif
Name: bluez
Summary: Bluetooth Stack for Linux
Version: 5.37
-Release: 1
+Release: 2
Group: Network & Connectivity/Bluetooth
License: GPL-2.0+ and LGPL-2.1+ and Apache-2.0
URL: http://www.bluez.org/
autoreconf -fiv
%if "%{?tizen_target_name}" == "TM1" || "%{?profile}" == "ivi"
-export CFLAGS="${CFLAGS} -D__TIZEN_PATCH__ -DBLUEZ5_27_GATT_CLIENT"
+%if "%{?tizen_target_name}" == "TM1"
+export CFLAGS="${CFLAGS} -DTIZEN_FEATURE_BLUEZ_SPRD_QOS -DTIZEN_FEATURE_BLUEZ_SPRD_PAGE_SCAN"
+%endif
%else
-export CFLAGS="${CFLAGS} -D__TIZEN_PATCH__ -D__BROADCOM_PATCH__ -DBLUEZ5_27_GATT_CLIENT"
+export CFLAGS="${CFLAGS} -DTIZEN_FEATURE_BLUEZ_BRCM_CHIP"
%endif
%if "%{?profile}" == "wearable"
-export CFLAGS="${CFLAGS} -D__BT_SCMST_FEATURE__ -DSUPPORT_SMS_ONLY -D__BROADCOM_QOS_PATCH__ -DTIZEN_WEARABLE"
+export CFLAGS="${CFLAGS} -DTIZEN_FEATURE_BLUEZ_SMS_ONLY -DTIZEN_FEATURE_BLUEZ_BRCM_QOS -DTIZEN_FEATURE_BLUEZ_ROLE_CHANGE -DTIZEN_FEATURE_BLUEZ_CONFIRM_ONLY"
%endif
export LDFLAGS=" -lncurses -Wl,--as-needed "
-export CFLAGS+=" -DPBAP_SIM_ENABLE -DSUPPORT_AVRCP_TARGET"
+export CFLAGS+=" -DTIZEN_FEATURE_BLUEZ_MODIFY -DTIZEN_FEATURE_BLUEZ_PBAP_SIM -DTIZEN_FEATURE_BLUEZ_AVRCP_TARGET"
%reconfigure --disable-static \
--sysconfdir=%{_sysconfdir} \
--localstatedir=%{_localstatedir} \
--enable-experimental \
--enable-autopair=no \
%if "%{?profile}" == "wearable"
- --enable-wearable \
+ --enable-wearable \
%else
--enable-network \
%endif
*
*/
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
#ifdef HAVE_CONFIG_H
#include <config.h>
#endif
return reply;
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static void read_local_complete(struct btd_adapter *adapter,
const uint8_t *hash, const uint8_t *randomizer,
const uint8_t *hash256, const uint8_t *randomizer256,
#include "src/profile.h"
#include "src/hcid.h"
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
#define CONTROL_CONNECT_TIMEOUT 4
#define TARGET_CONNECT_TIMEOUT 1
#else
#define SINK_RETRY_TIMEOUT SOURCE_RETRY_TIMEOUT
#define CT_RETRY_TIMEOUT 1
#define TG_RETRY_TIMEOUT CT_RETRY_TIMEOUT
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
#define SOURCE_RETRIES 0
#else
#define SOURCE_RETRIES 1
* immediatelly otherwise set timer
*/
if (old_state == BTD_SERVICE_STATE_CONNECTING)
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
/* Set timer as most of the devices initiate
* avrcp connection immediately; irrespective of local
* or remote initiated a2dp connection
g_source_remove(data->tg_timer);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
data->tg_timer = g_timeout_add_seconds(TARGET_CONNECT_TIMEOUT,
policy_connect_tg,
data);
if (data->tg_timer > 0) {
g_source_remove(data->tg_timer);
data->tg_timer = 0;
-#if defined __TIZEN_PATCH__ && defined BT_QUALIFICATION
+#if defined TIZEN_FEATURE_BLUEZ_MODIFY && defined BT_QUALIFICATION
}
#else
} else if (btd_service_get_state(target) !=
struct avdtp *session;
struct avdtp_stream *stream;
guint suspend_timer;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
gboolean remote_suspended;
#endif
gboolean delay_reporting;
{
GSourceFunc finalize;
va_list args;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
struct avdtp_error *avdtp_err;
#else
struct avdtp_error avdtp_err;
#endif
if (err < 0) {
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
avdtp_err = g_new(struct avdtp_error, 1);
avdtp_error_init(avdtp_err, AVDTP_ERRNO, -err);
s->err = avdtp_err;
return;
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (new_state == AVDTP_STATE_STREAMING && sep->suspend_timer) {
g_source_remove(sep->suspend_timer);
sep->suspend_timer = 0;
else
DBG("Source %p: Start_Ind", sep);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (!a2dp_sep->locked) {
a2dp_sep->session = avdtp_ref(session);
if(a2dp_sep->remote_suspended == FALSE)
else
DBG("Source %p: Suspend_Ind", sep);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
a2dp_sep->remote_suspended = TRUE;
#endif
sdp_record_t *record;
sdp_data_t *psm, *version, *features;
uint16_t lp = AVDTP_UUID;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
#ifdef SUPPORT_LOCAL_DEVICE_A2DP_SINK
uint16_t a2dp_ver = 0x0102, avdtp_ver = 0x0103, feat = 0x0002;
#else
return NULL;
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (chan->auth_id) {
DBG("auth is already going...");
return NULL;
if (!device)
goto drop;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
{
gboolean restricted = FALSE;
btd_adapter_get_address(server->adapter),
BT_IO_OPT_PSM, AVDTP_PSM,
BT_IO_OPT_SEC_LEVEL, BT_IO_SEC_MEDIUM,
-#if defined(__TIZEN_PATCH__) && defined(SUPPORT_LOCAL_DEVICE_A2DP_SINK)
+#if defined(TIZEN_FEATURE_BLUEZ_MODIFY) && defined(SUPPORT_LOCAL_DEVICE_A2DP_SINK)
BT_IO_OPT_IMTU, 895,
#endif
BT_IO_OPT_MASTER, true,
static struct a2dp_sep *a2dp_find_sep(struct avdtp *session, GSList *list,
const char *sender)
{
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
struct a2dp_sep *selected_sep = NULL;
#endif
for (; list; list = list->next) {
struct a2dp_sep *sep = list->data;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
struct avdtp_remote_sep *rsep;
struct avdtp_media_codec_capability *cap;
struct avdtp_service_capability *service;
continue;
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
rsep = avdtp_find_remote_sep(session, sep->lsep);
if (rsep == NULL)
continue;
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (selected_sep)
return selected_sep;
else
static int a2dp_init(void)
{
btd_register_adapter_driver(&media_driver);
-#if defined(__TIZEN_PATCH__) && defined(SUPPORT_LOCAL_DEVICE_A2DP_SINK)
+#if defined(TIZEN_FEATURE_BLUEZ_MODIFY) && defined(SUPPORT_LOCAL_DEVICE_A2DP_SINK)
btd_profile_register(&a2dp_source_profile);
#endif
btd_profile_register(&a2dp_sink_profile);
static gboolean auto_release(gpointer user_data)
{
struct avctp *session = user_data;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
uint16_t op = session->key.op;
#endif
DBG("AV/C: key press timeout");
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (op != KEY_FASTFORWARD && op != KEY_REWIND) {
session->key.timer = 0;
send_key(session->uinput, op, 0);
return FALSE;
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
extern void avrcp_stop_position_timer(void);
#endif
/* Only auto release if keys are different */
if (session->key.op == op)
goto done;
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
send_key(session->uinput, session->key.op, 0);
#endif
}
send_key(session->uinput, op, 0);
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
extern void avrcp_stop_position_timer(void);
#endif
if (pressed) {
handle_press(session, key_map[i].uinput);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (key_map[i].avc == AVC_REWIND)
avrcp_stop_position_timer();
#endif
return FALSE;
chan->p = p;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
p->timeout = g_timeout_add_seconds(5, req_timeout, chan);
#else
p->timeout = g_timeout_add_seconds(2, req_timeout, chan);
src = btd_adapter_get_address(device_get_adapter(dev));
dst = device_get_address(dev);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
session->auth_id = btd_request_authorization(src, dst,
AVRCP_TARGET_UUID,
auth_cb, session);
if (!device)
return;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
char name[10];
device_get_name(device, name, sizeof(name));
DBG("name : %s", name);
struct avctp *session = user_data;
avctp_passthrough_release(session, session->key.op);
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
avctp_passthrough_press(session, session->key.op);
return TRUE;
static void release_pressed(struct avctp *session)
{
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (session->key.op != AVC_FAST_FORWARD && session->key.op != AVC_REWIND)
#endif
avctp_passthrough_release(session, session->key.op);
return avctp_passthrough_press(session, op);
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
int avctp_send_release_passthrough(struct avctp *session, uint8_t op)
{
DBG("+");
gboolean avctp_unregister_browsing_pdu_handler(unsigned int id);
int avctp_send_passthrough(struct avctp *session, uint8_t op);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
int avctp_send_release_passthrough(struct avctp *session, uint8_t op);
#endif
int avctp_send_vendordep(struct avctp *session, uint8_t transaction,
#include "lib/sdp_lib.h"
#include "lib/uuid.h"
-#ifdef __TIZEN_PATCH__
-#if defined(__BROADCOM_QOS_PATCH__) || defined(__SPRD_QOS_PATCH__)
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
+#if defined(TIZEN_FEATURE_BLUEZ_BRCM_QOS) || defined(TIZEN_FEATURE_BLUEZ_SPRD_QOS)
#include <sys/ioctl.h>
#include <bluetooth/hci.h>
-#endif /* __BROADCOM_QOS_PATCH__ */
-#endif /* __TIZEN_PATCH__ */
+#endif /* TIZEN_FEATURE_BLUEZ_BRCM_QOS */
+#endif /* TIZEN_FEATURE_BLUEZ_MODIFY */
#include "btio/btio.h"
#include "src/log.h"
#include "src/adapter.h"
#include "src/device.h"
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
#include "src/service.h"
#endif
#define AVDTP_MSG_TYPE_ACCEPT 0x02
#define AVDTP_MSG_TYPE_REJECT 0x03
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
#define REQ_TIMEOUT 10
#else
#define REQ_TIMEOUT 6
goto proceed;
DBG("sk %d, omtu %d, send buffer size %d", sk, omtu, buf_size);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
min_buf_size = omtu * 10;
#else
min_buf_size = omtu * 2;
min_buf_size);
set_send_buffer_size(sk, min_buf_size);
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
else {
DBG("send buffer size to be decreassed to %d",
min_buf_size);
pending_req_free(req);
}
-#ifdef __TIZEN_PATCH__
-#ifdef __BROADCOM_QOS_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
+#ifdef TIZEN_FEATURE_BLUEZ_BRCM_QOS
static gboolean send_broadcom_a2dp_qos(const bdaddr_t *dst, gboolean qos_high)
{
int dd;
return TRUE;
}
-#endif /* __BROADCOM_QOS_PATCH__ */
+#endif /* TIZEN_FEATURE_BLUEZ_BRCM_QOS */
-#ifdef __SPRD_QOS_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_SPRD_QOS
static gboolean send_sprd_a2dp_qos(bdaddr_t *dst, gboolean qos_high)
{
int dd;
return TRUE;
}
-#endif /* __SPRD_QOS_PATCH__ */
+#endif /* TIZEN_FEATURE_BLUEZ_SPRD_QOS */
-#ifdef TIZEN_WEARABLE
+#ifdef TIZEN_FEATURE_BLUEZ_ROLE_CHANGE
static gboolean fix_role_to_master(const bdaddr_t *dst, gboolean fix_to_master)
{
int dd;
return TRUE;
}
-#endif /* TIZEN_WEARABLE */
-#endif /* __TIZEN_PATCH__ */
+#endif /* TIZEN_FEATURE_BLUEZ_ROLE_CHANGE */
+#endif /* TIZEN_FEATURE_BLUEZ_MODIFY */
static void avdtp_sep_set_state(struct avdtp *session,
struct avdtp_local_sep *sep,
avdtp_state_t state)
{
struct avdtp_stream *stream = sep->stream;
-#ifdef __TIZEN_PATCH__
-#if (defined(__BROADCOM_QOS_PATCH__) || defined(TIZEN_WEARABLE)) || \
- defined(__SPRD_QOS_PATCH__)
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
+#if (defined(TIZEN_FEATURE_BLUEZ_BRCM_QOS) || defined(TIZEN_FEATURE_BLUEZ_ROLE_CHANGE)) || \
+ defined(TIZEN_FEATURE_BLUEZ_SPRD_QOS)
const bdaddr_t *dst;
dst = device_get_address(session->device);
#endif
break;
case AVDTP_STATE_OPEN:
stream->starting = FALSE;
-#ifdef __TIZEN_PATCH__
-#ifdef __BROADCOM_QOS_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
+#ifdef TIZEN_FEATURE_BLUEZ_BRCM_QOS
send_broadcom_a2dp_qos(dst, FALSE);
-#elif defined(__SPRD_QOS_PATCH__)
+#elif defined(TIZEN_FEATURE_BLUEZ_SPRD_QOS)
if (old_state == AVDTP_STATE_STREAMING)
send_sprd_a2dp_qos(dst, FALSE);
#endif
-#ifdef TIZEN_WEARABLE
+#ifdef TIZEN_FEATURE_BLUEZ_ROLE_CHANGE
fix_role_to_master(dst, FALSE);
-#endif /* TIZEN_WEARABLE */
-#endif /* __TIZEN_PATCH__ */
+#endif /* TIZEN_FEATURE_BLUEZ_ROLE_CHANGE */
+#endif /* TIZEN_FEATURE_BLUEZ_MODIFY */
break;
case AVDTP_STATE_STREAMING:
stream->start_timer = 0;
}
-#ifdef __TIZEN_PATCH__
-#ifdef __BROADCOM_QOS_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
+#ifdef TIZEN_FEATURE_BLUEZ_BRCM_QOS
send_broadcom_a2dp_qos(dst, TRUE);
-#elif defined(__SPRD_QOS_PATCH__)
+#elif defined(TIZEN_FEATURE_BLUEZ_SPRD_QOS)
if (old_state == AVDTP_STATE_OPEN)
send_sprd_a2dp_qos(dst, TRUE);
#endif
-#ifdef TIZEN_WEARABLE
+#ifdef TIZEN_FEATURE_BLUEZ_ROLE_CHANGE
fix_role_to_master(dst, TRUE);
-#endif /* TIZEN_WEARABLE */
-#endif /* __TIZEN_PATCH__ */
+#endif /* TIZEN_FEATURE_BLUEZ_ROLE_CHANGE */
+#endif /* TIZEN_FEATURE_BLUEZ_MODIFY */
stream->open_acp = FALSE;
break;
case AVDTP_STATE_CLOSING:
}
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
void finalize_discovery(struct avdtp *session, int err)
#else
static void finalize_discovery(struct avdtp *session, int err)
static void connection_lost(struct avdtp *session, int err)
{
char address[18];
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
struct btd_service *service;
#endif
ba2str(device_get_address(session->device), address);
DBG("Disconnected from %s", address);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
service = btd_device_get_service(session->device, A2DP_SINK_UUID);
if (service)
btd_service_connecting_complete(service, -err);
avdtp_set_state(session, AVDTP_SESSION_STATE_DISCONNECTED);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
DBG("%p: ref=%d", session, session->ref);
if (err != EIO && session->ref > 0) /* link loss*/
return;
avdtp_free(session);
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static gboolean disconnect_acl_timeout(gpointer user_data)
{
struct btd_device *device = user_data;
struct avdtp *session = user_data;
struct btd_service *service;
gboolean stream_setup;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
struct btd_device *device = NULL;
struct btd_adapter *adapter = NULL;
const bdaddr_t *bdaddr = NULL;
#endif
/* Fix : REVERSE_INULL */
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (session->device == NULL) {
error("session device NOT found");
return FALSE;
return FALSE;
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (session->device) {
adapter = device_get_adapter(session->device);
bdaddr = device_get_address(session->device);
connection_lost(session, ETIMEDOUT);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (device)
g_timeout_add(100,
disconnect_acl_timeout,
return FALSE;
}
-#if defined __TIZEN_PATCH__ && defined SUPPORT_LOCAL_DEVICE_A2DP_SINK
+#if defined TIZEN_FEATURE_BLUEZ_MODIFY && defined SUPPORT_LOCAL_DEVICE_A2DP_SINK
static void set_disconnect_timer(struct avdtp *session, gboolean disconn)
#else
static void set_disconnect_timer(struct avdtp *session)
#endif
{
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
char name[6];
#endif
if (session->dc_timer)
remove_disconnect_timer(session);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
device_get_name(session->device, name, sizeof(name));
DBG("name : [%s]", name);
if (g_str_equal(name, "VW BT") || g_str_equal(name, "VW MI") ||
session);
} else {
#endif
-#if defined __TIZEN_PATCH__ && defined SUPPORT_LOCAL_DEVICE_A2DP_SINK
+#if defined TIZEN_FEATURE_BLUEZ_MODIFY && defined SUPPORT_LOCAL_DEVICE_A2DP_SINK
if (disconn == TRUE)
session->dc_timer = g_timeout_add(100,
disconnect_timeout,
if (session->ref > 0)
return;
-#if defined __TIZEN_PATCH__ && defined SUPPORT_LOCAL_DEVICE_A2DP_SINK
+#if defined TIZEN_FEATURE_BLUEZ_MODIFY && defined SUPPORT_LOCAL_DEVICE_A2DP_SINK
set_disconnect_timer(session, TRUE);
#else
set_disconnect_timer(session);
}
if (session->in.message_type == AVDTP_MSG_TYPE_COMMAND) {
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
struct btd_service *service;
service = btd_device_get_service(session->device, A2DP_SINK_UUID);
NULL);
if (session->stream_setup)
-#if defined __TIZEN_PATCH__ && defined SUPPORT_LOCAL_DEVICE_A2DP_SINK
+#if defined TIZEN_FEATURE_BLUEZ_MODIFY && defined SUPPORT_LOCAL_DEVICE_A2DP_SINK
set_disconnect_timer(session, FALSE);
#else
set_disconnect_timer(session);
device_get_address(session->device),
BT_IO_OPT_PSM, AVDTP_PSM,
BT_IO_OPT_SEC_LEVEL, BT_IO_SEC_MEDIUM,
-#if defined __TIZEN_PATCH__ && defined SUPPORT_LOCAL_DEVICE_A2DP_SINK
+#if defined TIZEN_FEATURE_BLUEZ_MODIFY && defined SUPPORT_LOCAL_DEVICE_A2DP_SINK
BT_IO_OPT_IMTU, 895,
#endif
BT_IO_OPT_INVALID);
struct seid_rej *resp, int size)
{
struct avdtp_local_sep *sep = stream->lsep;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (!sep) {
error("Error in getting sep");
return FALSE;
/* If timer already active wait it */
if (stream->start_timer)
return 0;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
else {
char address[18];
uint32_t timeout_sec = START_TIMEOUT;
gboolean avdtp_has_stream(struct avdtp *session, struct avdtp_stream *stream);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
void finalize_discovery(struct avdtp *session, int err);
#endif
#define AVRCP_CHARSET_UTF8 106
#define AVRCP_BROWSING_TIMEOUT 1
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
#define AVRCP_CT_VERSION 0x0103
#define AVRCP_TG_VERSION 0x0103
#else
uint8_t transaction;
uint8_t transaction_events[AVRCP_EVENT_LAST + 1];
struct pending_pdu *pending_pdu;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
uint32_t playback_status_id;
#endif
};
static GSList *servers = NULL;
static unsigned int avctp_id = 0;
-#ifdef __TIZEN_PATCH__
-#ifdef SUPPORT_AVRCP_TARGET
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
+#ifdef TIZEN_FEATURE_BLUEZ_AVRCP_TARGET
static uint16_t adapter_avrcp_tg_ver = 0;
#endif
-#ifdef SUPPORT_AVRCP_CONTROL
+#ifdef TIZEN_FEATURE_BLUEZ_AVRCP_CONTROL
static uint16_t adapter_avrcp_ct_ver = 0;
#endif
#endif
static void avrcp_register_notification(struct avrcp *session, uint8_t event);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static GList *player_list_settings(struct avrcp_player *player);
void avrcp_stop_position_timer(void);
unsigned int pos_timer_id = 0;
#endif
-#ifdef SUPPORT_AVRCP_CONTROL
+#ifdef TIZEN_FEATURE_BLUEZ_AVRCP_CONTROL
static sdp_record_t *avrcp_ct_record(void)
{
sdp_list_t *svclass_id, *pfseq, *apseq, *apseq1, *root;
sdp_record_t *record;
sdp_data_t *psm[2], *version, *features;
uint16_t lp = AVCTP_CONTROL_PSM, ap = AVCTP_BROWSING_PSM;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
uint16_t avctp_ver = 0x0104;
uint16_t feat = 0;
#ifdef ENABLE_AVRCP_CATEGORY1
/* Bluetooth Profile Descriptor List */
sdp_uuid16_create(&profile[0].uuid, AV_REMOTE_PROFILE_ID);
profile[0].version = AVRCP_CT_VERSION;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
adapter_avrcp_ct_ver = AVRCP_CT_VERSION;
#endif
pfseq = sdp_list_append(NULL, &profile[0]);
}
#endif
-#ifdef SUPPORT_AVRCP_TARGET
+#ifdef TIZEN_FEATURE_BLUEZ_AVRCP_TARGET
static sdp_record_t *avrcp_tg_record(void)
{
sdp_list_t *svclass_id, *pfseq, *apseq, *root, *apseq_browsing;
sdp_list_t *aproto_control, *proto_control[2];
sdp_record_t *record;
sdp_data_t *psm_control, *version, *features, *psm_browsing;
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
sdp_list_t *aproto_browsing;
#endif
sdp_list_t *proto_browsing[2] = {0};
uint16_t lp = AVCTP_CONTROL_PSM;
uint16_t lp_browsing = AVCTP_BROWSING_PSM;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
uint16_t avctp_ver = 0x0104;
uint16_t feat = 0;
#ifdef ENABLE_AVRCP_CATEGORY1
proto_browsing[1] = sdp_list_append(proto_browsing[1], version);
apseq_browsing = sdp_list_append(apseq_browsing, proto_browsing[1]);
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
aproto_browsing = sdp_list_append(NULL, apseq_browsing);
sdp_set_add_access_protos(record, aproto_browsing);
#endif
/* Bluetooth Profile Descriptor List */
sdp_uuid16_create(&profile[0].uuid, AV_REMOTE_PROFILE_ID);
profile[0].version = AVRCP_TG_VERSION;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
adapter_avrcp_tg_ver = AVRCP_TG_VERSION;
#endif
pfseq = sdp_list_append(NULL, &profile[0]);
sdp_list_free(proto_browsing[0], NULL);
sdp_list_free(proto_browsing[1], NULL);
sdp_list_free(apseq_browsing, NULL);
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
sdp_list_free(aproto_browsing, NULL);
#endif
case AVRCP_ATTRIBUTE_EQUALIZER:
return AVRCP_EQUALIZER_ON;
case AVRCP_ATTRIBUTE_REPEAT_MODE:
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
return AVRCP_REPEAT_MODE_ALL;
#else
return AVRCP_REPEAT_MODE_GROUP;
#endif
case AVRCP_ATTRIBUTE_SHUFFLE:
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
return AVRCP_SHUFFLE_ALL;
#else
return AVRCP_SHUFFLE_GROUP;
GSList *l;
int attr;
int val;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
uint32_t *position_val = NULL;
GList *settings;
#endif
break;
case AVRCP_EVENT_SETTINGS_CHANGED:
size = 2;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
settings = player_list_settings(player);
pdu->params[1] = g_list_length(settings);
for (; settings; settings = settings->next) {
pdu->params[size++] = val;
#endif /* __TIZEN__PATCH__ */
break;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
case AVRCP_EVENT_PLAYBACK_POS_CHANGED:
size = 5;
position_val = (uint32_t *) data;
done:
pdu->params_len = htons(size);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (id == AVRCP_EVENT_PLAYBACK_POS_CHANGED &&
pos_timer_id > 0) {
/* Remove the timer function which was added for register notification.
return "singletrack";
case AVRCP_REPEAT_MODE_ALL:
return "alltracks";
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
case AVRCP_REPEAT_MODE_GROUP:
return "group";
#endif
return "off";
case AVRCP_SCAN_ALL:
return "alltracks";
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
case AVRCP_SCAN_GROUP:
return "group";
#endif
return player->cb->list_settings(player->user_data);
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static uint32_t player_get_playback_position(struct avrcp_player *player)
{
if (player == NULL)
return handler->func(session);
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
void avrcp_stop_position_timer(void)
{
if (pos_timer_id > 0) {
struct btd_device *dev = session->dev;
uint16_t len = ntohs(pdu->params_len);
uint64_t uid;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
uint32_t playback_interval;
uint32_t playback_position;
uint8_t play_status;
len = 2;
break;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
case AVRCP_EVENT_PLAYBACK_POS_CHANGED:
len = 5;
return 0;
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static int ct_release(struct avrcp_player *player, uint8_t op)
{
DBG("+");
return ct_press(player, AVC_BACKWARD);
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static int ct_press_fast_forward(struct media_player *mp, void *user_data)
{
DBG("+");
.stop = ct_stop,
.next = ct_next,
.previous = ct_previous,
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
.press_fast_forward = ct_press_fast_forward,
.release_fast_forward = ct_release_fast_forward,
.press_rewind = ct_press_rewind,
if (player->destroy)
player->destroy(player->user_data);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
avrcp_stop_position_timer();
#endif
avrcp_handle_event, session);
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static char *avrcp_event_to_string(uint8_t event)
{
uint8_t event = pdu->params[1 + count];
events |= (1 << event);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
DBG("Supported Event %s", avrcp_event_to_string(event));
#endif
switch (event) {
case AVRCP_EVENT_TRACK_CHANGED:
case AVRCP_EVENT_PLAYBACK_POS_CHANGED:
case AVRCP_EVENT_SETTINGS_CHANGED:
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
case AVRCP_EVENT_ADDRESSED_PLAYER_CHANGED:
case AVRCP_EVENT_UIDS_CHANGED:
case AVRCP_EVENT_AVAILABLE_PLAYERS_CHANGED:
if (!(events & (1 << AVRCP_EVENT_STATUS_CHANGED)))
avrcp_get_element_attributes(session);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if ((events & (1 << AVRCP_EVENT_STATUS_CHANGED)) == 0) {
session->playback_status_id = g_timeout_add_seconds(1,
avrcp_get_playback_status, session);
session);
}
-#ifdef SUPPORT_AVRCP_TARGET
+#ifdef TIZEN_FEATURE_BLUEZ_AVRCP_TARGET
static void target_init(struct avrcp *session)
{
struct avrcp_server *server = session->server;
session->supported_events |= (1 << AVRCP_EVENT_STATUS_CHANGED) |
(1 << AVRCP_EVENT_TRACK_CHANGED) |
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
(1 << AVRCP_EVENT_TRACK_REACHED_START) |
(1 << AVRCP_EVENT_TRACK_REACHED_END) |
#endif
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
(1 << AVRCP_EVENT_PLAYBACK_POS_CHANGED) |
#endif
(1 << AVRCP_EVENT_SETTINGS_CHANGED);
if (target->version < 0x0104)
return;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (adapter_avrcp_tg_ver < 0x0104)
return;
#endif
}
#endif
-#ifdef SUPPORT_AVRCP_CONTROL
+#ifdef TIZEN_FEATURE_BLUEZ_AVRCP_CONTROL
static void controller_init(struct avrcp *session)
{
struct avrcp_player *player;
DBG("%p version 0x%04x", controller, controller->version);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if ((controller->version >= 0x0104) && (adapter_avrcp_ct_ver >= 0x0104))
session->supported_events |= (1 << AVRCP_EVENT_VOLUME_CHANGED);
#endif
if (controller->version < 0x0104)
return;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (adapter_avrcp_ct_ver < 0x0104)
return;
#endif
handle_vendordep_pdu,
session);
session->control_handlers = control_handlers;
-#ifdef SUPPORT_AVRCP_CONTROL
+#ifdef TIZEN_FEATURE_BLUEZ_AVRCP_CONTROL
if (btd_device_get_service(session->dev, AVRCP_TARGET_UUID) != NULL)
controller_init(session);
#endif
-#ifdef SUPPORT_AVRCP_TARGET
+#ifdef TIZEN_FEATURE_BLUEZ_AVRCP_TARGET
if (btd_device_get_service(session->dev, AVRCP_REMOTE_UUID) != NULL)
target_init(session);
#endif
server->sessions = g_slist_remove(server->sessions, session);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (session->playback_status_id > 0) {
DBG("Removing the timer for playback status polling");
g_source_remove(session->playback_status_id);
{
struct btd_device *dev = btd_service_get_device(service);
const char *path = device_get_path(dev);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
char name[10];
#endif
DBG("path %s", path);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
device_get_name(dev, name, sizeof(name));
DBG("name : %s", name);
if (g_str_equal(name, "PLT_M50")) {
control_unregister(service);
}
-#ifdef SUPPORT_AVRCP_TARGET
+#ifdef TIZEN_FEATURE_BLUEZ_AVRCP_TARGET
static void avrcp_target_server_remove(struct btd_profile *p,
struct btd_adapter *adapter)
{
}
#endif
-#ifdef SUPPORT_AVRCP_TARGET
+#ifdef TIZEN_FEATURE_BLUEZ_AVRCP_TARGET
static int avrcp_target_server_probe(struct btd_profile *p,
struct btd_adapter *adapter)
{
.connect = avrcp_connect,
.disconnect = avrcp_disconnect,
-#ifdef SUPPORT_AVRCP_TARGET
+#ifdef TIZEN_FEATURE_BLUEZ_AVRCP_TARGET
.adapter_probe = avrcp_target_server_probe,
.adapter_remove = avrcp_target_server_remove,
#endif
control_unregister(service);
}
-#ifdef SUPPORT_AVRCP_CONTROL
+#ifdef TIZEN_FEATURE_BLUEZ_AVRCP_CONTROL
static void avrcp_controller_server_remove(struct btd_profile *p,
struct btd_adapter *adapter)
{
}
#endif
-#ifdef SUPPORT_AVRCP_CONTROL
+#ifdef TIZEN_FEATURE_BLUEZ_AVRCP_CONTROL
static int avrcp_controller_server_probe(struct btd_profile *p,
struct btd_adapter *adapter)
{
.connect = avrcp_connect,
.disconnect = avrcp_disconnect,
-#ifdef SUPPORT_AVRCP_CONTROL
+#ifdef TIZEN_FEATURE_BLUEZ_AVRCP_CONTROL
.adapter_probe = avrcp_controller_server_probe,
.adapter_remove = avrcp_controller_server_remove,
#endif
#include "src/dbus-common.h"
#include "src/profile.h"
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
#include "src/service.h"
#endif
#include "transport.h"
#include "a2dp.h"
#include "avrcp.h"
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
#include "sink.h"
#endif
#define REQUEST_TIMEOUT (3 * 1000) /* 3 seconds */
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
#define SINK_SUSPEND_TIMEOUT 4 /* 4 seconds */
unsigned int suspend_timer_id = 0;
guint watch;
guint properties_watch;
guint seek_watch;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
guint sink_watch;
#endif
char *status;
static GSList *adapters = NULL;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static gboolean set_avrcp_status = FALSE;
static gboolean send_track_changed_event = FALSE;
{
DBusMessage *msg;
const char *path;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
struct media_player *mp;
#endif
g_dbus_send_message(btd_get_dbus_connection(), msg);
done:
endpoint->transports = g_slist_remove(endpoint->transports, transport);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if ((mp = media_adapter_get_player(endpoint->adapter)))
if (mp->sink_watch) {
sink_remove_state_cb(mp->sink_watch);
return match->data;
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
struct media_player * media_adapter_get_player(struct media_adapter * adapter)
{
GSList *l;
if ((old_state == SINK_STATE_PLAYING) &&
(new_state == SINK_STATE_CONNECTED)) {
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
struct btd_device *device = btd_service_get_device(service);
char name[20] = {0,};
#endif
media_stop_suspend_timer();
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
device_get_name(device, name, sizeof(name));
DBG("Name : %s", name);
suspend_timer_id = g_timeout_add_seconds(SINK_SUSPEND_TIMEOUT,
media_reset_mp_status, mp);
DBG("SINK SUSPEND TIMEOUT started");
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
}
#endif
}
(new_state == SINK_STATE_PLAYING)) {
struct btd_device *device = btd_service_get_device(service);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
char name[20] = {0,};
#else
char name[20];
const char *path;
DBusMessageIter iter;
struct media_transport *transport;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
struct media_adapter *adapter;
struct media_player *mp;
#endif
return FALSE;
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
set_avrcp_status = FALSE;
adapter = find_adapter(device);
if ((mp = media_adapter_get_player(adapter)))
if (parse_properties(&props, &uuid, &delay_reporting, &codec,
&capabilities, &size) < 0)
return btd_error_invalid_args(msg);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if(!a2dp_sink_support && !g_strcmp0(uuid, A2DP_SINK_UUID)) {
error("A2DP sink role is not supported.");
return btd_error_not_supported(msg);
if (mp->settings)
g_hash_table_unref(mp->settings);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
media_stop_suspend_timer();
if (mp->sink_watch)
if (mp->track == NULL)
return UINT64_MAX;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (!g_hash_table_lookup(mp->track, "Title"))
return UINT64_MAX;
#endif
static gboolean set_status(struct media_player *mp, DBusMessageIter *iter)
{
const char *value;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
uint32_t playback_position;
#endif
mp->status = g_strdup(value);
avrcp_player_event(mp->player, AVRCP_EVENT_STATUS_CHANGED, mp->status);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (strcasecmp(mp->status, "reverse-seek") != 0 &&
strcasecmp(mp->status, "playing") != 0) {
playback_position = get_position(mp);
static gboolean set_position(struct media_player *mp, DBusMessageIter *iter)
{
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
uint32_t value;
#else
uint64_t value;
const char *status;
#endif
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
uint32_t playback_position;
#endif
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_INT64)
return FALSE;
#else
#endif
dbus_message_iter_get_basic(iter, &value);
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
value /= 1000;
#endif
DBG("Value %d", value);
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
if (value > get_position(mp))
status = "forward-seek";
else
if (!mp->position) {
avrcp_player_event(mp->player,
AVRCP_EVENT_TRACK_REACHED_START, NULL);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
playback_position = get_position(mp);
avrcp_player_event(mp->player, AVRCP_EVENT_PLAYBACK_POS_CHANGED,
&playback_position);
if (mp->position == UINT32_MAX || mp->position >= mp->duration) {
avrcp_player_event(mp->player, AVRCP_EVENT_TRACK_REACHED_END,
NULL);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
playback_position = get_position(mp);
avrcp_player_event(mp->player, AVRCP_EVENT_PLAYBACK_POS_CHANGED,
&playback_position);
return TRUE;
}
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
/* Send a status change to force resync the position */
avrcp_player_event(mp->player, AVRCP_EVENT_STATUS_CHANGED, status);
#endif
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
playback_position = get_position(mp);
avrcp_player_event(mp->player, AVRCP_EVENT_PLAYBACK_POS_CHANGED,
&playback_position);
static void set_metadata(struct media_player *mp, const char *key,
const char *value)
{
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
const char *current_value = NULL;
current_value = g_hash_table_lookup(mp->track, key);
dbus_message_iter_get_basic(iter, &value);
if (strcasecmp(key, "Duration") == 0) {
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
value /= 1000;
#endif
mp->duration = value;
int ctype;
gboolean title = FALSE;
uint64_t uid;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
uint32_t playback_position;
#endif
dbus_message_iter_recurse(iter, &dict);
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
if (mp->track != NULL)
g_hash_table_unref(mp->track);
} else if (strcasecmp(key, "mpris:length") == 0) {
if (!parse_int64_metadata(mp, "Duration", &var))
return FALSE;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
} else if (strcasecmp(key, "xesam:totalTracks") == 0) {
if (!parse_int32_metadata(mp, "NumberOfTracks", &var))
return FALSE;
g_hash_table_insert(mp->track, g_strdup("Title"),
g_strdup(""));
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (send_track_changed_event) {
uid = get_uid(mp);
avrcp_player_event(mp->player,
mp->settings = g_hash_table_new_full(g_str_hash, g_str_equal, g_free,
g_free);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
mp->track = g_hash_table_new_full(g_str_hash, g_str_equal, g_free,
g_free);
#endif
return g_dbus_create_reply(msg, DBUS_TYPE_INVALID);
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static DBusMessage *media_player_press_fast_forward(DBusConnection *conn,
DBusMessage *msg, void *data)
{
{ GDBUS_METHOD("Stop", NULL, NULL, media_player_stop) },
{ GDBUS_METHOD("Next", NULL, NULL, media_player_next) },
{ GDBUS_METHOD("Previous", NULL, NULL, media_player_previous) },
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
{ GDBUS_METHOD("PressFastForward", NULL, NULL, media_player_press_fast_forward) },
{ GDBUS_METHOD("ReleaseFastForward", NULL, NULL, media_player_release_fast_forward) },
{ GDBUS_METHOD("PressRewind", NULL, NULL, media_player_press_rewind) },
struct media_item *item, const char *key,
void *data, size_t len)
{
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
char *value;
char *end, *temp;
#else
value = g_strndup(data, len);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
temp = value;
while (g_utf8_validate(temp, -1, (const gchar **)&end) == FALSE) {
temp = g_utf8_find_next_char(end, NULL);
DBG("%s: %s", key, value);
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
curval = g_hash_table_lookup(mp->track, key);
if (g_strcmp0(curval, value) == 0) {
g_free(value);
int (*stop) (struct media_player *mp, void *user_data);
int (*next) (struct media_player *mp, void *user_data);
int (*previous) (struct media_player *mp, void *user_data);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
int (*press_fast_forward) (struct media_player *mp, void *user_data);
int (*release_fast_forward) (struct media_player *mp, void *user_data);
int (*press_rewind) (struct media_player *mp, void *user_data);
if (new_state != SINK_STATE_DISCONNECTED)
return;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
btd_service_disconnecting_complete(service, 0);
#endif
if (sink->session) {
avdtp_unref(sink->session);
sink->session = NULL;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
sink->connect_id = 0;
sink->disconnect_id = 0;
#endif
switch (new_state) {
case AVDTP_STATE_IDLE:
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
btd_service_disconnecting_complete(sink->service, 0);
#endif
avdtp_unref(sink->session);
sink->session = NULL;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (err && avdtp_error_category(err) == AVDTP_ERRNO
&& avdtp_error_posix_errno(err) != EHOSTDOWN)
#else
{
struct sink *sink = btd_service_get_user_data(service);
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
if (!sink->session)
sink->session = a2dp_avdtp_get(btd_service_get_device(service));
if (sink->stream_state >= AVDTP_STATE_OPEN)
return -EALREADY;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (!sink->session)
sink->session = a2dp_avdtp_get(btd_service_get_device(service));
avdtp_stream_remove_cb(sink->session, sink->stream,
sink->cb_id);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (sink->session) {
/* We need to clear the avdtp discovery procedure */
finalize_discovery(sink->session, ECANCELED);
DBG("Failed to send request to read appearance");
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static void read_rpa_res_characteristic_value_cb(bool success, uint8_t att_ecode,
const uint8_t *value, uint16_t length,
void *user_data)
handle_device_name(gas, value_handle);
else if (uuid_cmp(GATT_CHARAC_APPEARANCE, &uuid))
handle_appearance(gas, value_handle);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
else if (uuid_cmp(GATT_CHARAC_CENTRAL_RPA_RESOLUTION, &uuid))
handle_rpa_res_characteristic_value(gas, value_handle);
#endif
static int ctl;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
/* Compatibility with old ioctls */
#define OLD_BNEPCONADD 1
#define OLD_BNEPCONDEL 2
return err;
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
/* Temporary ioctl compatibility hack */
{
struct bnep_connlist_req req;
sk = socket(AF_INET, SOCK_DGRAM, 0);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (sk < 0)
return -1;
#endif
if (!session)
return;
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
if (session->watch > 0) {
g_source_remove(session->watch);
session->watch = 0;
bnep_conndel(&session->dst_addr);
}
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
static int bnep_add_to_bridge(const char *devname, const char *bridge)
{
int ifindex;
sk = socket(AF_INET, SOCK_STREAM, 0);
if (sk < 0)
return -1;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
err = ioctl(sk, SIOCBRADDBR, bridge);
if (err < 0)
{
return BNEP_CONN_INVALID_DST;
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
int bnep_if_down_wrapper(const char *devname)
{
bnep_if_down(devname);
goto reply;
}
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
err = bnep_add_to_bridge(iface, bridge);
if (err < 0) {
bnep_conndel(addr);
goto failed;
}
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
err = bnep_add_to_bridge(iface, bridge);
if (err < 0)
goto failed_conn;
failed_bridge:
bnep_del_from_bridge(iface, bridge);
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
failed_conn:
#endif
bnep_conndel(addr);
int bnep_server_add(int sk, char *bridge, char *iface, const bdaddr_t *addr,
uint8_t *setup_data, int len);
void bnep_server_delete(char *bridge, char *iface, const bdaddr_t *addr);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
int bnep_if_down_wrapper(const char *devname);
int bnep_conndel_wrapper(const bdaddr_t *dst);
#endif
DBusConnection *conn = btd_get_dbus_connection();
const char *path = device_get_path(nc->peer->device);
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
g_dbus_emit_property_changed(conn, path,
NETWORK_PEER_INTERFACE, "Connected");
g_dbus_emit_property_changed(conn, path,
info("%s disconnected", nc->dev);
nc->state = DISCONNECTED;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
g_dbus_emit_property_changed(conn, path,
NETWORK_PEER_INTERFACE, "Connected");
g_dbus_emit_property_changed(conn, path,
if (nc->state == CONNECTED)
bnep_disconnect(nc->session);
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
bnep_free(nc->session);
nc->session = NULL;
#endif
conn = btd_get_dbus_connection();
path = device_get_path(nc->peer->device);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
nc->state = CONNECTED;
#endif
g_dbus_emit_property_changed(conn, path,
g_dbus_emit_property_changed(conn, path,
NETWORK_PEER_INTERFACE, "UUID");
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
nc->state = CONNECTED;
#endif
nc->dc_id = device_add_disconnect_watch(nc->peer->device, disconnect_cb,
static GSList *adapters = NULL;
static gboolean security = TRUE;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static gboolean server_disconnected_cb(GIOChannel *chan,
GIOCondition cond, gpointer user_data);
#endif
return NULL;
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static struct network_session *find_session(GSList *list, GIOChannel *io)
{
GSList *l;
sdp_data_t *v, *p;
uint16_t psm = BNEP_PSM, version = 0x0100;
uint16_t security_desc = (security ? 0x0001 : 0x0000);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
uint16_t net_access_type = 0x000a;
uint32_t max_net_access_rate = 0x001312d0;
#else
session_free(setup);
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static gboolean server_disconnected_cb(GIOChannel *chan,
GIOCondition cond, gpointer user_data)
{
packet, n) < 0)
error("BNEP server cannot be added");
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (ns) {
/* Emit connected signal to BT application */
const gchar *adapter_path = adapter_get_path(na->adapter);
bnep_server_delete(ns->bridge, session->dev, &session->dst);
}
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
g_slist_free_full(ns->sessions, session_free);
ns->sessions = NULL;
if (!ns)
return btd_error_failed(msg, "Invalid UUID");
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (!ns->record_id)
return btd_error_not_available(msg);
#endif
adapter_free(na);
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static DBusMessage *disconnect_device(DBusConnection *conn, DBusMessage *msg,
void *data)
{
}
#endif
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static GDBusSignalTable server_signals[] = {
{ GDBUS_SIGNAL("PeerConnected",
GDBUS_ARGS({ "device", "s" }, { "address", "s" })) },
{ GDBUS_METHOD("Unregister",
GDBUS_ARGS({ "uuid", "s" }), NULL,
unregister_server) },
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
{ GDBUS_METHOD("Disconnect",
GDBUS_ARGS({ "address", "s" }), NULL,
disconnect_device) },
if (g_slist_length(na->servers) > 0)
goto done;
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
if (!g_dbus_register_interface(btd_get_dbus_connection(), path,
NETWORK_SERVER_INTERFACE,
server_methods, NULL, NULL, na,
#include "src/attio.h"
#include "src/dbus-common.h"
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
#include "src/shared/queue.h"
#include "src/shared/gatt-db.h"
#include "src/shared/att.h"
struct imm_alert_adapter {
struct btd_adapter *adapter;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
struct gatt_db_attribute *imservice;
#endif
GSList *connected_devices;
static GSList *imm_alert_adapters;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static bool get_dest_info(struct bt_att *att, bdaddr_t *dst, uint8_t *dst_type)
{
GIOChannel *io = NULL;
imm_alert_remove_condev(condev);
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static void imm_alert_alert_lvl_write(struct gatt_db_attribute *attrib,
unsigned int id, uint16_t offset,
const uint8_t *value, size_t len,
void imm_alert_unregister(struct btd_adapter *adapter)
{
struct imm_alert_adapter *imadapter;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
struct gatt_db *db;
#endif
g_slist_foreach(imadapter->connected_devices, remove_condev_list_item,
NULL);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
/* Remove registered service */
if (imadapter->imservice) {
db = (struct gatt_db *) btd_gatt_database_get_db(btd_adapter_get_database(adapter));
#include "src/attio.h"
#include "src/dbus-common.h"
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
#include "src/shared/queue.h"
#include "src/shared/gatt-db.h"
#include "src/shared/att.h"
struct link_loss_adapter {
struct btd_adapter *adapter;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
struct gatt_db_attribute *llservice;
#else
uint16_t alert_lvl_value_handle;
static GSList *link_loss_adapters;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static bool get_dest_info(struct bt_att *att, bdaddr_t *dst, uint8_t *dst_type)
{
GIOChannel *io = NULL;
g_dbus_emit_property_changed(btd_get_dbus_connection(), path,
PROXIMITY_REPORTER_INTERFACE, "LinkLossAlertLevel");
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static void link_loss_alert_lvl_read(struct gatt_db_attribute *attrib,
unsigned int id, uint16_t offset,
uint8_t opcode, struct bt_att *att,
DBG("alert level zeroed for locally disconnecting dev %p", device);
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static void link_loss_alert_lvl_write(struct gatt_db_attribute *attrib,
unsigned int id, uint16_t offset,
const uint8_t *value, size_t len,
void link_loss_register(struct btd_adapter *adapter)
{
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
struct gatt_db_attribute *service, *charc;
struct gatt_db *db;
#else
lladapter->adapter = adapter;
link_loss_adapters = g_slist_append(link_loss_adapters, lladapter);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
db = (struct gatt_db *) btd_gatt_database_get_db(btd_adapter_get_database(adapter));
/*
void link_loss_unregister(struct btd_adapter *adapter)
{
struct link_loss_adapter *lladapter;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
struct gatt_db *db;
#endif
g_slist_foreach(lladapter->connected_devices, remove_condev_list_item,
NULL);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
/* Remove registered service */
if (lladapter->llservice) {
db = (struct gatt_db *) btd_gatt_database_get_db(btd_adapter_get_database(adapter));
#include "attrib/att-database.h"
#include "src/attrib-server.h"
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
#include "src/error.h"
#endif
return "unknown";
}
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
static void register_tx_power(struct btd_adapter *adapter)
{
uint16_t start_handle, h;
return 0;
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static DBusMessage *register_proximity(DBusConnection *conn, DBusMessage *msg,
void *user_data)
{
radapter = g_new0(struct reporter_adapter, 1);
radapter->adapter = adapter;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
const char *path = adapter_get_path(adapter);
g_dbus_register_interface(btd_get_dbus_connection(), path,
#include "advertising.h"
#include "eir.h"
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
#include "adapter_le_vsc_features.h"
#endif
#define ADAPTER_INTERFACE "org.bluez.Adapter1"
-#ifdef __TIZEN_PATCH__
-#ifdef TIZEN_WEARABLE
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
+#ifdef TIZEN_FEATURE_BLUEZ_BATTERY_WATCH
#define DEVICED_DEST "org.tizen.system.deviced"
#define DEVICED_BATT_INTERFACE "org.tizen.system.deviced.Battery"
#define DEVICED_BATT_OBJECT_PATH "/Org/Tizen/System/DeviceD/Battery"
-#endif /* TIZEN_WEARABLE */
+#endif /* TIZEN_FEATURE_BLUEZ_BATTERY_WATCH */
#endif
#define MODE_OFF 0x00
#define DISTANCE_VAL_INVALID 0x7FFF
#define PATHLOSS_MAX 137
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
#define check_address(address) bachk(address)
#define ADV_DATA_MAX_LENGTH 31
#define SCAN_RESPONSE_DATA_LENGTH_MAX 31
#define LE_BEARER_POSTFIX " LE"
#define LE_BEARER_POSTFIX_LEN 3
-#endif /* __TIZEN_PATCH__ */
+#endif /* TIZEN_FEATURE_BLUEZ_MODIFY */
static DBusConnection *dbus_conn = NULL;
/* When the iterator reaches the end, it is NULL and attempt is 0 */
};
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
struct adv_info {
int slot_id; /* Reservied slot id is 0 (Single adv) */
bool status; /* Advertising status */
struct mgmt *mgmt;
bdaddr_t bdaddr; /* controller Bluetooth address */
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
bdaddr_t le_static_addr;
bdaddr_t rpaddr; /* controller RPA */
#endif
char *current_alias; /* current adapter name alias */
char *stored_alias; /* stored adapter name alias */
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
bool le_privacy_enabled; /* whether LE Privacy feature enabled */
uint8_t *local_irk; /* adapter local IRK */
uint8_t disc_type;
bool ipsp_intialized; /* Ipsp Initialization state */
struct le_data_length_read_handler *read_handler;
struct le_data_length_read_default_data_length_handler *def_read_handler;
-#ifdef TIZEN_WEARABLE
+#ifdef TIZEN_FEATURE_BLUEZ_BATTERY_WATCH
guint charging_watch;
guint charging_timeout;
charging_state_e charging;
-#endif /* TIZEN_WEARABLE */
+#endif /* TIZEN_FEATURE_BLUEZ_BATTERY_WATCH */
#endif
bool discovering; /* discovering property state */
struct btd_advertising *adv_manager;
gboolean initialized;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
GSList *adv_list; /* List of advertising instance */
bool advertising; /* Advertising active */
gchar *version; /* Bluetooth Version */
guint pair_device_timeout;
unsigned int db_id; /* Service event handler for GATT db */
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
guint private_addr_timeout;
uint8_t central_rpa_res_support;
#ifdef TIZEN_FEATURE_PLATFROM_SCAN_FILTER
bool is_default; /* true if adapter is default one */
};
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
enum {
DEINIT_6LOWPAN,
INIT_6LOWPAN
if (adapter->stored_alias)
g_key_file_set_string(key_file, "General", "Alias",
adapter->stored_alias);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (adapter->local_irk) {
int i;
char key_str[35];
static void trigger_passive_scanning(struct btd_adapter *adapter);
static bool set_mode(struct btd_adapter *adapter, uint16_t opcode,
uint8_t mode);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static bool set_privacy(struct btd_adapter *adapter, bool privacy);
#endif
-#ifdef __TIZEN_PATCH__
-#ifdef TIZEN_WEARABLE
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
+#ifdef TIZEN_FEATURE_BLUEZ_BATTERY_WATCH
static gboolean charging_state_timeout_cb(gpointer user_data)
{
struct btd_adapter *adapter = user_data;
DBG("charging_state: %d", adapter->charging);
return adapter->charging;
}
-#endif /* TIZEN_WEARABLE */
+#endif /* TIZEN_FEATURE_BLUEZ_BATTERY_WATCH */
static int compare_slot(gconstpointer a, gconstpointer b)
{
}
#endif
-#if defined __TIZEN_PATCH__ && defined __SPRD_PAGE_SCAN_PATCH__
+#if defined TIZEN_FEATURE_BLUEZ_MODIFY && defined TIZEN_FEATURE_BLUEZ_SPRD_PAGE_SCAN
#define OCF_PAGE_SCAN_TIMEOUT 0x0018
#define OGF_PAGE_SCAN_TIMEOUT 0x03
if (adapter->current_settings & MGMT_SETTING_POWERED) {
adapter_start(adapter);
-#if defined __TIZEN_PATCH__ && defined __SPRD_PAGE_SCAN_PATCH__
+#if defined TIZEN_FEATURE_BLUEZ_MODIFY && defined TIZEN_FEATURE_BLUEZ_SPRD_PAGE_SCAN
/* Approx 6.4 Seconds of timeout */
/* This Added because Z3 device was not able to connect with
* some device as it was getting Page Timeout
* from 5.12 Sec (which is default) to ~6.4sec*/
DBG("Setting value");
send_sprd_page_scan_timeout(10240);
-#endif /* __SPRD_QOS_PATCH__ */
+#endif /* TIZEN_FEATURE_BLUEZ_SPRD_PAGE_SCAN */
} else {
adapter_stop(adapter);
trigger_pairable_timeout(adapter);
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (changed_mask & MGMT_SETTING_ADVERTISING) {
if ((adapter->current_settings & MGMT_SETTING_ADVERTISING) &&
(adapter->advertising)) {
struct device_addr_type addr;
struct btd_device *device;
GSList *list;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
bool exact_match = false;
#endif
char addr_str[18];
ba2str(dst, addr_str);
DBG("find device %s %d", addr_str, bdaddr_type);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
list = g_slist_find_custom(adapter->devices, &addr,
device_addr_type_strict_cmp);
if (list) {
device = list->data;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (exact_match)
return device;
#endif
DBG("%s", adapter->path);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (rec == NULL) {
DBG("record is NULL return");
return;
remove_record_from_server(rec->handle);
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static void adapter_print_devices(struct btd_adapter *adapter)
{
GSList *dev;
adapter->devices = g_slist_append(adapter->devices, device);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
adapter_print_devices(adapter);
#endif
g_free(auth);
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
void btd_adapter_unpair_device(struct btd_adapter *adapter,
struct btd_device *dev)
{
if (!adapter)
return NULL;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (!bacmp(addr, BDADDR_ANY))
return NULL;
#endif
adapter->passive_scan_timeout = 0;
cp.type = SCAN_TYPE_LE;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
mgmt_send(adapter->mgmt, MGMT_OP_START_LE_DISCOVERY,
adapter->dev_id, sizeof(cp), &cp,
passive_scanning_complete, adapter, NULL);
* The discovery procedure is using interleaved scanning and
* thus will discover Low Energy devices as well.
*/
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (adapter->discovery_list || adapter->le_discovery_list)
return;
#else
static void stop_passive_scanning(struct btd_adapter *adapter)
{
struct mgmt_cp_stop_discovery cp;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
struct mgmt_cp_stop_discovery le_cp;
#endif
/* If there are any normal discovery clients passive scanning
* wont be running */
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (adapter->discovery_list || adapter->le_discovery_list)
return;
#else
if (adapter->discovery_enable == 0x00)
return;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if ((adapter->discovery_type & 0x01) > 0)
cp.type = 0x01;
mgmt_send(adapter->mgmt, MGMT_OP_STOP_DISCOVERY,
const struct mgmt_cp_start_discovery *rp = param;
DBG("status 0x%02x", status);
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
DBG("Discovery Type 0x%02x", rp->type);
#endif
}
if (status == MGMT_STATUS_SUCCESS) {
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
DBG("Return param discovery type 0x%02x", rp->type);
adapter->discovery_type |= rp->type;
#else
ADAPTER_INTERFACE, "Discovering");
return;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
} else {
adapter->discovering = false;
g_dbus_emit_property_changed(dbus_conn, adapter->path,
* In case the restart of the discovery failed, then just trigger
* it for the next idle timeout again.
*/
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
trigger_start_discovery(adapter, IDLE_DISCOV_TIMEOUT * 2);
#endif
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static void start_le_discovery_complete(uint8_t status, uint16_t length,
const void *param, void *user_data)
{
static gboolean start_discovery_timeout(gpointer user_data)
{
struct btd_adapter *adapter = user_data;
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
struct mgmt_cp_start_service_discovery *sd_cp;
#endif
uint8_t new_type;
adapter->discovery_idle_timeout = 0;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (adapter->disc_type == BT_DISC_TYPE_BREDR_ONLY)
new_type = SCAN_TYPE_BREDR;
else if (adapter->disc_type == BT_DISC_TYPE_LE_ONLY)
start_discovery_timeout, adapter);
}
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
static void suspend_discovery_complete(uint8_t status, uint16_t length,
const void *param, void *user_data)
{
DBG("hci%u type %u discovering %u method %d", adapter->dev_id, ev->type,
ev->discovering, adapter->filtered_discovery);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
DBG("info discov_type %d", adapter->discovery_type);
if (ev->type == DISCOV_TYPE_BREDR) {
if (ev->discovering == FALSE) {
* If there are no clients, then it is good idea to trigger a
* passive scanning attempt.
*/
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (adapter->discovery_list == NULL && adapter->le_discovery_list == NULL) {
if (!adapter->connect_le)
trigger_passive_scanning(adapter);
}
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static void stop_discovery_complete(uint8_t status, uint16_t length,
const void *param, void *user_data)
{
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static void le_discovery_destroy(void *user_data)
{
struct watch_client *client = user_data;
return dbus_message_new_method_return(msg);
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
void btd_adapter_set_read_le_data_length_handler(
struct btd_adapter *adapter,
struct le_data_length_read_handler *handler)
return btd_error_failed(msg, "Set manufacturer data failed");
}
-#endif /* __TIZEN_PATCH__ */
+#endif /* TIZEN_FEATURE_BLUEZ_MODIFY */
static DBusMessage *start_discovery(DBusConnection *conn,
adapter->discovery_list = g_slist_prepend(adapter->discovery_list,
client);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
adapter->disc_type = BT_DISC_TYPE_BREDR_ONLY;
#endif
client = list->data;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
adapter->disc_type = BT_DISC_TYPE_BREDR_ONLY;
#endif
cp.type = adapter->discovery_type;
return dbus_message_new_method_return(msg);
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
cp.type = 0x01;
#endif
mgmt_send(adapter->mgmt, MGMT_OP_STOP_DISCOVERY,
return TRUE;
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static gboolean property_get_le_address(const GDBusPropertyTable *property,
DBusMessageIter *iter, void *user_data)
{
len = sizeof(mode);
break;
case MGMT_SETTING_DISCOVERABLE:
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
if (kernel_conn_control) {
if (mode) {
set_mode(adapter, MGMT_OP_SET_CONNECTABLE,
param = &mode;
len = sizeof(mode);
break;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
case MGMT_SETTING_CONNECTABLE:
opcode = MGMT_OP_SET_CONNECTABLE;
param = &mode;
data->adapter = adapter;
data->id = id;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
/*
* Use mgmt_send_nowait to avoid dbus timeout in a state of bonding.
*/
dbus_message_iter_append_basic(iter, DBUS_TYPE_STRING, &uuid);
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static gboolean property_get_le_discovering(const GDBusPropertyTable *property,
DBusMessageIter *iter, void *user_data)
{
return strcasecmp(dev_path, path);
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static DBusMessage *adapter_unpair_device(DBusConnection *conn,
DBusMessage *msg, void *user_data)
{
GDBUS_ARGS({ "properties", "a{sv}" }), NULL,
set_discovery_filter) },
{ GDBUS_METHOD("StopDiscovery", NULL, NULL, stop_discovery) },
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
{ GDBUS_METHOD("StartCustomDiscovery",
GDBUS_ARGS({ "type", "s" }), NULL,
adapter_start_custom_discovery) },
#endif
{ GDBUS_ASYNC_METHOD("RemoveDevice",
GDBUS_ARGS({ "device", "o" }), NULL, remove_device) },
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
{ GDBUS_ASYNC_METHOD("LEReadMaximumDataLength", NULL,
GDBUS_ARGS({"maxTxOctets", "q" }, { "maxTxTime", "q" },
{"maxRxOctets", "q" }, { "maxRxTime", "q" }),
{ }
};
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static const GDBusSignalTable adapter_signals[] = {
{ GDBUS_SIGNAL("AdvertisingEnabled",
GDBUS_ARGS({ "slot_id", "i" },
{ "PairableTimeout", "u", property_get_pairable_timeout,
property_set_pairable_timeout },
{ "Discovering", "b", property_get_discovering },
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
{ "LEDiscovering", "b", property_get_le_discovering },
#endif
{ "UUIDs", "as", property_get_uuids },
{ "Modalias", "s", property_get_modalias, NULL,
property_exists_modalias },
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
{ "Connectable", "b", property_get_connectable,
property_set_connectable },
{ "Version", "s", property_get_version },
char *str;
str = g_key_file_get_string(key_file, "IdentityResolvingKey", "Key", NULL);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (!str)
return NULL;
if (strlen(str) < 32) {
return addr_type;
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static uint8_t get_addr_type(GKeyFile *keyfile)
{
char **techno, **t;
struct btd_device *device;
char filename[PATH_MAX];
GKeyFile *key_file;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
struct link_key_info *key_info = NULL;
GSList *list, *ltk_info = NULL;
struct device_addr_type addr;
if (entry->d_type != DT_DIR || bachk(entry->d_name) < 0)
continue;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
{
bdaddr_t bdaddr;
if (param)
params = g_slist_append(params, param);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
str2ba(entry->d_name, &addr.bdaddr);
addr.bdaddr_type = get_addr_type(key_file);
device_address_cmp);
#endif
if (list) {
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
DBG("Skip already loaded device [%s] [%d]",
entry->d_name, addr.bdaddr_type);
#endif
if (!device)
goto free;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
{
char idaddr[18];
static void adapter_start(struct btd_adapter *adapter)
{
-#if defined(__TIZEN_PATCH__) && !defined(__SPRD_PATCH__)
+#if defined(TIZEN_FEATURE_BLUEZ_MODIFY) && !defined(__SPRD_PATCH__)
if (adapter_le_read_ble_feature_info())
g_dbus_emit_property_changed(dbus_conn, adapter->path,
ADAPTER_INTERFACE, "SupportedLEFeatures");
adapter_le_enable_offloading(TRUE);
#endif
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
g_dbus_emit_property_changed(dbus_conn, adapter->path,
ADAPTER_INTERFACE, "Powered");
#else
char address[18];
struct stat st;
GError *gerr = NULL;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
char *str;
#endif
gerr = NULL;
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
/* Get Le Privacy feature support */
adapter->le_privacy_enabled = main_opts.le_privacy;
if (adapter->le_privacy_enabled) {
static struct btd_adapter *btd_adapter_new(uint16_t index)
{
struct btd_adapter *adapter;
-#ifdef __TIZEN_PATCH__
-#ifdef TIZEN_WEARABLE
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
+#ifdef TIZEN_FEATURE_BLUEZ_BATTERY_WATCH
DBusConnection *conn = btd_get_dbus_connection();
DBusMessage *msg = NULL;
DBusMessage *reply = NULL;
int charging_state = 0;
-#endif /* TIZEN_WEARABLE */
+#endif /* TIZEN_FEATURE_BLUEZ_BATTERY_WATCH */
#endif
adapter = g_try_new0(struct btd_adapter, 1);
main_opts.did_version);
adapter->discoverable_timeout = main_opts.discovto;
adapter->pairable_timeout = main_opts.pairto;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
adapter->advertising = FALSE;
#endif
DBG("Modalias: %s", adapter->modalias);
DBG("Discoverable timeout: %u seconds", adapter->discoverable_timeout);
DBG("Pairable timeout: %u seconds", adapter->pairable_timeout);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (main_opts.le_privacy)
DBG("LE Privacy is enabled.");
else
#endif
adapter->auths = g_queue_new();
-#ifdef __TIZEN_PATCH__
-#ifdef TIZEN_WEARABLE
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
+#ifdef TIZEN_FEATURE_BLUEZ_BATTERY_WATCH
adapter->charging_watch = g_dbus_add_signal_watch(conn, DEVICED_DEST,
DEVICED_BATT_OBJECT_PATH,
DEVICED_BATT_INTERFACE, "ChargerType",
} else {
error("Unable to create dbus message for charging state");
}
-#endif /* TIZEN_WEARABLE */
+#endif /* TIZEN_FEATURE_BLUEZ_BATTERY_WATCH */
#endif
return btd_adapter_ref(adapter);
static void adapter_remove(struct btd_adapter *adapter)
{
GSList *l;
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
struct gatt_db *db;
#endif
DBG("Removing adapter %s", adapter->path);
-#ifdef __TIZEN_PATCH__
-#ifdef TIZEN_WEARABLE
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
+#ifdef TIZEN_FEATURE_BLUEZ_BATTERY_WATCH
if (adapter->charging_watch > 0) {
g_dbus_remove_watch(btd_get_dbus_connection(),
adapter->charging_watch);
g_source_remove(adapter->charging_timeout);
adapter->charging_timeout = 0;
}
-#endif /* TIZEN_WEARABLE */
+#endif /* TIZEN_FEATURE_BLUEZ_BATTERY_WATCH */
#endif
if (adapter->discovery_idle_timeout > 0) {
unload_drivers(adapter);
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
db = btd_gatt_database_get_db(adapter->database);
gatt_db_unregister(db, adapter->db_id);
adapter->db_id = 0;
return &adapter->bdaddr;
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
const bdaddr_t *btd_adapter_get_le_address(struct btd_adapter *adapter)
{
if (adapter->le_static_addr.b[5] != 0)
return got_match;
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static void update_found_devices(struct btd_adapter *adapter,
const bdaddr_t *bdaddr,
uint8_t bdaddr_type, int8_t rssi,
* not marked as discoverable, then do not create new
* device objects.
*/
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
/*DBG("List BREDR:%p LE:%p Discoverable:%d", adapter->discovery_list,
adapter->le_discovery_list, discoverable);*/
if ((adapter->discovery_list == NULL &&
return;
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if(device_get_rpa_exist(dev) == true)
bdaddr_type = BDADDR_LE_RANDOM;
#endif
* If no client has requested discovery, then only update
* already paired devices (skip temporary ones).
*/
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (device_is_temporary(dev) && adapter->discovery_list == NULL &&
adapter->le_discovery_list == NULL) {
DBG("discovery list is NULL");
}
#endif
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (bdaddr_type == BDADDR_BREDR) {
#endif
if (adapter->filtered_discovery &&
if (eir_data.tx_power != 127)
device_set_tx_power(dev, eir_data.tx_power);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
}
#endif
/* Report an unknown name to the kernel even if there is a short name
* known, but still update the name with the known short name. */
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (eir_data.name_complete)
name_known = device_name_known(dev);
else
device_add_eir_uuids(dev, eir_data.services);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (eir_data.flags != 0)
device_set_remote_feature_flag(dev, eir_data.flags);
* Otherwise, this is an event from passive discovery and we
* should check if the device needs connecting to.
*/
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (!adapter->discovery_list && !adapter->le_discovery_list)
#else
if (!adapter->discovery_list)
return;
connect_le:
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
/* Ignore non-connectable events */
if (not_connectable)
return;
confirm_name = (flags & MGMT_DEV_FOUND_CONFIRM_NAME);
legacy = (flags & MGMT_DEV_FOUND_LEGACY_PAIRING);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
update_found_devices(adapter, &ev->addr.bdaddr, ev->addr.type,
ev->rssi, confirm_name, legacy, 0,
eir, eir_len);
#endif
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static void le_device_found_callback(uint16_t index, uint16_t length,
const void *param, void *user_data)
{
device_remove_connection(device, bdaddr_type);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (device_is_authenticating(device, bdaddr_type))
#else
if (device_is_authenticating(device))
return;
adapter->connections = g_slist_remove(adapter->connections, device);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
DBG("isPaired %d, isBonded %d", device_is_paired(device, bdaddr_type),
device_is_bonded(device, bdaddr_type));
if ((device_is_temporary(device) && !device_is_retrying(device)) ||
const char *path = device_get_path(device);
DBG("Removing temporary device %s", path);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
/* device_is_paired is added incase of tempoary bonded
* oop file transfer in that device is not bonded it's paired.
*/
g_dbus_emit_property_changed(dbus_conn, adapter->path,
ADAPTER_INTERFACE, "Discovering");
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
g_dbus_emit_property_changed(dbus_conn, adapter->path,
ADAPTER_INTERFACE, "LEDiscovering");
#endif
ADAPTER_INTERFACE, "Class");
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
advertiser_cleanup(adapter);
#endif
g_dbus_emit_property_changed(dbus_conn, adapter->path,
/* Wait services to be resolved before asking authorization */
if (auth->svc_id > 0) {
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
DBG("Wait services to be resolved before asking authorization");
#endif
return FALSE;
}
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
if (device_is_trusted(device) == TRUE) {
#else
if (device_is_trusted(device) == TRUE ||
goto next;
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
/* If Profile is Blocked, Simply reject Authorization*/
if (device_is_profile_blocked(device, auth->uuid) == TRUE) {
auth->cb(&err, auth->user_data);
return;
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
device_set_auth_addr_type(device, ev->addr.type);
#endif
return;
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
device_set_auth_addr_type(device, ev->addr.type);
#endif
"device_notify_passkey: %s", strerror(-err));
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static void rssi_alert_callback(uint16_t index, uint16_t length,
const void *param, void *user_data)
{
/* Flag the request of a pincode to allow a bonding retry. */
adapter->pincode_requested = true;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
btd_device_set_legacy_pairing(device, true);
#endif
if (device != NULL)
device_bonding_complete(device, addr_type, status);
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
resume_discovery(adapter);
#endif
check_oob_bonding_complete(adapter, bdaddr, status);
return -EBUSY;
}
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
suspend_discovery(adapter);
#endif
return adapter_bonding_attempt(adapter, bdaddr, addr_type, io_cap);
{
struct btd_device *device;
char dst[18];
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
struct device_addr_type t_addr;
#endif
device = btd_adapter_find_device(adapter, &addr->bdaddr, addr->type);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (device) {
device_get_tizen_addr(device, addr->type, &t_addr);
return;
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
/* Use HCI error code instead of MGMT disconnection reason */
dev_disconnected(adapter, &rp->addr, 0x16);
#else
key->pin_len);
device_set_bonded(device, BDADDR_BREDR);
-#if defined(__TIZEN_PATCH__) && defined(SUPPORT_LOCAL_DEVICE_A2DP_SINK)
+#if defined(TIZEN_FEATURE_BLUEZ_MODIFY) && defined(SUPPORT_LOCAL_DEVICE_A2DP_SINK)
} else {
DBG("store_hint %d", ev->store_hint);
btd_device_set_temporary(device, false);
struct btd_device *device;
bool persistent;
char dst[18];
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
struct device_addr_type t_addr;
#endif
ediv = le16_to_cpu(key->ediv);
rand = le64_to_cpu(key->rand);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
device_get_tizen_addr(device, addr->type, &t_addr);
store_longtermkey(bdaddr, &t_addr.bdaddr, t_addr.bdaddr_type,
key->val, key->master, key->type,
const bdaddr_t *bdaddr = btd_adapter_get_address(adapter);
struct btd_device *device;
char dst[18];
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
struct device_addr_type t_addr;
#endif
if (!ev->store_hint)
return;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
device_get_tizen_addr(device, addr->type, &t_addr);
store_csrk(bdaddr, &t_addr.bdaddr, t_addr.bdaddr_type, key->val, 0,
key->type);
struct btd_device *device, *duplicate;
bool persistent;
char dst[18], rpa[18];
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
struct device_addr_type t_addr;
#endif
if (bacmp(&ev->rpa, BDADDR_ANY)) {
device = btd_adapter_get_device(adapter, &ev->rpa,
BDADDR_LE_RANDOM);
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
duplicate = btd_adapter_find_device(adapter, &addr->bdaddr,
addr->type);
if (duplicate == device)
if (duplicate)
device_merge_duplicate(device, duplicate);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
device_set_irk_value(device, irk->val);
#endif
if (!persistent)
return;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
device_get_tizen_addr(device, addr->type, &t_addr);
store_irk(adapter, &t_addr.bdaddr, t_addr.bdaddr_type, irk->val);
#else
uint16_t min, max, latency, timeout;
struct btd_device *dev;
char dst[18];
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
struct device_addr_type t_addr;
#endif
if (!ev->store_hint)
return;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
device_get_tizen_addr(dev, ev->addr.type, &t_addr);
store_conn_param(adapter, &t_addr.bdaddr, t_addr.bdaddr_type,
ev->min_interval, ev->max_interval,
return -EIO;
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
int btd_adapter_add_remote_oob_ext_data(struct btd_adapter *adapter,
const bdaddr_t *bdaddr, uint8_t bdaddr_type,
uint8_t *hash192, uint8_t *randomizer192,
const struct mgmt_rp_read_local_oob_data *rp = param;
struct btd_adapter *adapter = user_data;
const uint8_t *hash, *randomizer;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
const uint8_t *hash256 = NULL;
const uint8_t *randomizer256 = NULL;
#endif
mgmt_errstr(status), status);
hash = NULL;
randomizer = NULL;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
} else if (length < 32) {
#else
} else if (length < sizeof(*rp)) {
} else {
hash = rp->hash192;
randomizer = rp->rand192;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (length > 32) {
hash256 = rp->hash256;
randomizer256 = rp->rand256;
if (!adapter->oob_handler || !adapter->oob_handler->read_local_cb)
return;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
adapter->oob_handler->read_local_cb(adapter, hash, randomizer,
hash256, randomizer256,
adapter->oob_handler->user_data);
if (!g_dbus_register_interface(dbus_conn,
adapter->path, ADAPTER_INTERFACE,
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
adapter_methods, adapter_signals,
#else
adapter_methods, NULL,
clear_blocked(adapter);
load_devices(adapter);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
adapter_print_devices(adapter);
if (adapter->le_privacy_enabled &&
device_bonding_failed(device, ev->status);
}
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
/* In the case the bonding was canceled or did exists, remove the device
* when it is temporary. */
if (device && !device_is_bonding(device, NULL)
ba2str(btd_adapter_get_address(adapter), adapter_addr);
ba2str(device_get_address(device), device_addr);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (device_get_rpa_exist(device) == true)
ba2str(device_get_rpa(device), device_addr);
#endif
device_set_unpaired(device, ev->addr.type);
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static void set_privacy_complete(uint8_t status, uint16_t length,
const void *param, void *user_data)
{
adapter->supported_settings = btohl(rp->supported_settings);
adapter->current_settings = btohl(rp->current_settings);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
adapter_check_version(adapter, rp->version);
#endif
(missing_settings & MGMT_SETTING_FAST_CONNECTABLE))
set_mode(adapter, MGMT_OP_SET_FAST_CONNECTABLE, 0x01);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
/* Set the RPA resolution value to '1' if privacy is supported */
if (adapter->le_privacy_enabled &&
adapter->supported_settings & MGMT_SETTING_PRIVACY)
device_found_callback,
adapter, NULL);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
mgmt_register(adapter->mgmt, MGMT_EV_LE_DEVICE_FOUND,
adapter->dev_id,
le_device_found_callback,
user_passkey_notify_callback,
adapter, NULL);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
mgmt_register(adapter->mgmt, MGMT_EV_RSSI_ALERT,
adapter->dev_id,
rssi_alert_callback,
if (adapter->current_settings & MGMT_SETTING_POWERED)
adapter_start(adapter);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
else
set_mode(adapter, MGMT_OP_SET_POWERED, 0x01);
#endif
#include <stdbool.h>
#include <dbus/dbus.h>
#include <glib.h>
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
#include <bluetooth/bluetooth.h>
#include <bluetooth/sdp.h>
#include <bluetooth/hci.h>
/* Invalid SSP passkey value used to indicate negative replies */
#define INVALID_PASSKEY 0xffffffff
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
#define BT_DISC_TYPE_DEFAULT 0
#define BT_DISC_TYPE_BREDR_ONLY 1
#define BT_DISC_TYPE_LE_ONLY 2
typedef void (*adapter_cb) (struct btd_adapter *adapter, gpointer user_data);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
typedef void (*oob_ext_read_local_cb_t) (struct btd_adapter *adapter,
const uint8_t *hash192,
const uint8_t *randomizer192,
void *user_data);
struct oob_handler {
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
oob_ext_read_local_cb_t read_local_cb;
#else
oob_read_local_cb_t read_local_cb;
void *user_data;
};
-#ifdef __TIZEN_PATCH__
-#ifdef TIZEN_WEARABLE
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
+#ifdef TIZEN_FEATURE_BLUEZ_BATTERY_WATCH
typedef enum {
NONE_CHARGING,
WIRE_CHARGING,
WIRELESS_CHARGING,
} charging_state_e;
-#endif /* TIZEN_WEARABLE */
+#endif /* TIZEN_FEATURE_BLUEZ_BATTERY_WATCH */
#endif
int adapter_init(void);
const char *adapter_get_path(struct btd_adapter *adapter);
const bdaddr_t *btd_adapter_get_address(struct btd_adapter *adapter);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
const bdaddr_t *btd_adapter_get_le_address(struct btd_adapter *adapter);
uint8_t btd_adapter_get_le_address_type(struct btd_adapter * adapter);
#endif
int btd_adapter_remove_remote_oob_data(struct btd_adapter *adapter,
const bdaddr_t *bdaddr);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
int btd_adapter_add_remote_oob_ext_data(struct btd_adapter *adapter,
const bdaddr_t *bdaddr, uint8_t bdaddr_type,
uint8_t *hash192, uint8_t *randomizer192,
bool btd_le_connect_before_pairing(void);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
int btd_adapter_connect_ipsp(struct btd_adapter *adapter,
const bdaddr_t *bdaddr,
uint8_t bdaddr_type);
int btd_adapter_le_set_data_length(struct btd_adapter *adapter, bdaddr_t *bdaddr,
uint16_t max_tx_octets, uint16_t max_tx_time);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
void adapter_check_version(struct btd_adapter *adapter, uint8_t hci_ver);
-#ifdef TIZEN_WEARABLE
+#ifdef TIZEN_FEATURE_BLUEZ_BATTERY_WATCH
charging_state_e get_charging_state(struct btd_adapter *adapter);
-#endif /* TIZEN_WEARABLE */
+#endif /* TIZEN_FEATURE_BLUEZ_BATTERY_WATCH */
#endif
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
#include <errno.h>
}
-#endif /* __TIZEN_PATCH__ */
+#endif /* TIZEN_FEATURE_BLUEZ_MODIFY */
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
typedef enum {
BLE_ADV_TX_POWER_MIN = 0x00,
gboolean adapter_le_remove_irk_to_list(const bdaddr_t *bdaddr, uint8_t bdaddr_type);
-#endif /* __TIZEN_PATCH__ */
+#endif /* TIZEN_FEATURE_BLUEZ_MODIFY */
return attrib1->handle - attrib2->handle;
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static int attribute_uuid_cmp(gconstpointer a, gconstpointer b)
{
const struct attribute *attrib1 = a;
if (a->len == 2)
sdp_uuid16_create(&svc, get_le16(a->data));
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
else if (a->len == 4)
sdp_uuid32_create(&svc, get_le32(a->data));
#endif
return 0;
if (name != NULL)
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
sdp_set_info_attr(record, name, "Samsung", NULL);
#else
sdp_set_info_attr(record, name, "BlueZ", NULL);
#endif
sdp_uuid16_create(&gap_uuid, GENERIC_ACCESS_PROFILE_ID);
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
if (sdp_uuid_cmp(&svc, &gap_uuid) == 0) {
sdp_set_url_attr(record, "http://www.bluez.org/",
"http://www.bluez.org/",
if (dl == NULL)
cur->end = a->handle;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
else if (a->handle == end && end == 0xffff)
cur->end = a->handle;
#endif
g_file_set_contents(filename, data, length, NULL);
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
g_free(filename);
filename = btd_device_get_storage_path(channel->device, "ccc_sc");
if (!filename) {
}
length = find_info(channel, start, end, opdu, channel->mtu);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (length == 0 && start == end) {
status = ATT_ECODE_ATTR_NOT_FOUND;
goto done;
uint8_t atval[256];
bt_uuid_t uuid;
uint16_t appearance = 0x0000;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
uint16_t service_changed_handle;
#endif
attrib_db_add_new(server, 0x0010, &uuid, ATT_NONE, ATT_NOT_PERMITTED,
atval, 2);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
/* GATT service: service changed characteristic */
service_changed_handle = 0x0012;
bt_uuid16_create(&uuid, GATT_CHARAC_UUID);
return 0;
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
uint16_t send_sc_indication(uint16_t start_handle, uint16_t end_handle, size_t vlen,
uint8_t *pdu, size_t len)
{
GAttrib *attrib_from_device(struct btd_device *device);
guint attrib_channel_attach(GAttrib *attrib);
gboolean attrib_channel_detach(GAttrib *attrib, guint id);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
struct attribute *attribute_find(struct btd_adapter *adapter, const bt_uuid_t *uuid);
void attrib_send_noty_ind(struct btd_device *device, GAttrib *attrib,
uint16_t handle, uint16_t desc_handle,
#include "attrib-server.h"
#include "eir.h"
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
#include "sdp-xml.h"
-#ifdef TIZEN_WEARABLE
+#ifdef TIZEN_FEATURE_BLUEZ_BATTERY_WATCH
#include <sys/ioctl.h>
-#endif /* TIZEN_WEARABLE */
+#endif /* TIZEN_FEATURE_BLUEZ_BATTERY_WATCH */
#endif
#define IO_CAPABILITY_NOINPUTNOOUTPUT 0x03
#define GATT_INCLUDE_UUID_STR "2802"
#define GATT_CHARAC_UUID_STR "2803"
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
#define DEV_SIMUL_CONTROLLER 0x08 /* Simultaneous LE and BR/EDR to Same
Device Capable (Controller) */
#define DEV_SIMUL_HOST 0x10 /* Simultaneous LE and BR/EDR to Same
void *user_data;
};
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
struct le_adv_report_info {
uint8_t flags;
char manufacturer_data[DEV_MAX_MANUFACTURER_DATA_LEN];
uint32_t counter;
};
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
typedef enum {
DEV_PAIRED_NONE = 0,
DEV_PAIRED_BREDR = 1,
time_t le_seen;
gboolean trusted;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
struct trusted_profile_t trusted_profiles;
struct restricted_profile_t restricted_profiles;
#endif
GIOChannel *att_io;
guint store_id;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
bool legacy_pairing;
char *manufacturer_data;
int manufacturer_data_len;
0
};
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
typedef enum {
SHOW_AUTHORIZATION = 0x0, /* 0b00 */
SUPPORTED_BLOCKED = 0x1, /* 0b01 */
g_key_file_set_integer(key_file, group, "Counter", csrk->counter);
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static char *manufacturer_data2str(char *data, int size)
{
char str[DEV_MAX_MANUFACTURER_DATA_LEN * 3 + 1];
char class[9];
char **uuids = NULL;
gsize length = 0;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
gboolean svc_change_regd = false;
#endif
ba2str(btd_adapter_get_address(device->adapter), adapter_addr);
ba2str(&device->bdaddr, device_addr);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (device->rpa)
ba2str(device->rpa, device_addr);
#endif
g_key_file_remove_key(key_file, "General", "Appearance", NULL);
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (device->rpa_res_support) {
g_key_file_set_integer(key_file, "General", "RPAResSupport",
device->rpa_res_support);
g_key_file_set_boolean(key_file, "General", "Trusted",
device->trusted);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
struct trusted_profile_t trust_profile = device->trusted_profiles;
int trusted_profiles = (trust_profile.pbap << PBAP_SHIFT_OFFSET) |
(trust_profile.map << MAP_SHIFT_OFFSET) |
g_key_file_remove_key(key_file, "General", "Services", NULL);
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (device->le_adv_data.flags) {
g_key_file_set_integer(key_file, "General", "Flags",
device->le_adv_data.flags);
g_key_file_remove_group(key_file, "DeviceID", NULL);
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
svc_change_regd = bt_att_get_svc_changed_indication_registered(device->att);
g_key_file_set_boolean(key_file, "Att", "SvcChangeRegd",
svc_change_regd);
ba2str(btd_adapter_get_address(dev->adapter), s_addr);
ba2str(&dev->bdaddr, d_addr);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (dev->rpa)
ba2str(dev->rpa, d_addr);
#endif
static void browse_request_free(struct browse_req *req)
{
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
DBG("");
#endif
if (req->listener_id)
if (device->eir_uuids)
g_slist_free_full(device->eir_uuids, g_free);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
g_free(device->rpa);
#endif
g_free(device->local_csrk);
g_free(device);
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
void device_set_remote_feature_flag(struct btd_device *device, int flags)
{
device->remote_feature_flags = flags;
return device->trusted;
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
gboolean device_is_profile_trusted(struct btd_device *device,
const char *uuid)
{
char dstaddr[18];
const char *ptr = dstaddr;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (device->rpa)
ba2str(device->rpa, dstaddr);
else
ptr = device->name;
} else {
ba2str(&device->bdaddr, dstaddr);
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
g_strdelimit(dstaddr, ":", '-');
#endif
ptr = dstaddr;
return TRUE;
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static gboolean dev_property_get_alias_set(const GDBusPropertyTable *property,
DBusMessageIter *iter, void *data)
{
set_trust(id, b, data);
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static gboolean dev_property_get_trusted_profiles(const GDBusPropertyTable *property,
DBusMessageIter *iter, void *data)
{
set_blocked(id, b, data);
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static uint8_t device_get_connected_state(struct btd_device *device)
{
if (device->bredr_state.connected && device->le_state.connected)
{
struct btd_device *dev = data;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
uint8_t connected = device_get_connected_state(dev);
dbus_message_iter_append_basic(iter, DBUS_TYPE_BYTE, &connected);
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static gboolean property_get_manufacturer_data_len(const GDBusPropertyTable *property,
DBusMessageIter *iter, void *user_data)
{
if (!err)
btd_device_set_temporary(dev, false);
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
if (dev->pending == NULL)
goto done;
#endif
}
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (dev->pending == NULL)
return;
#endif
g_dbus_send_message(dbus_conn,
btd_error_failed(dev->connect, strerror(-err)));
else {
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
/* SDP is not required for Samsung TV Power on */
if (g_strcmp0(profile->name, "hid-device") == 0) {
DBG("Skip SDP discovery.");
/* Start passive SDP discovery to update known services */
if (dev->bredr && !dev->svc_refreshed)
device_browse_sdp(dev, NULL);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
}
#endif
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (err)
g_dbus_send_message(dbus_conn,
btd_error_failed(dev->connect, strerror(-err)));
const char *uuid)
{
GSList *l;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
struct btd_service *s = NULL;
#endif
for (l = dev->services; l != NULL; l = g_slist_next(l)) {
if (!p->connect || !p->remote_uuid)
continue;
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
if (strcasecmp(uuid, p->remote_uuid) == 0)
return service;
#else
}
#endif
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (s)
return s;
#endif
struct btd_service *service;
struct btd_profile *p;
GSList *l;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
bool hs_hf_verify = FALSE;
#endif
service = find_connectable_service(dev, uuid);
if (service)
return g_slist_prepend(dev->pending, service);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
else if ((service == NULL) &&
(g_strcmp0(uuid, HFP_HS_UUID) == 0)) {
DBG("HFP service not found check for HSP service");
service = l->data;
p = btd_service_get_profile(service);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
DBG("profile uuid %s", p->remote_uuid);
if (g_strcmp0(p->remote_uuid, HSP_HS_UUID) == 0) {
DBG("HSP service is found check for HFP service");
DBG("%s %s, client %s", dev->path, uuid ? uuid : "(all)",
dbus_message_get_sender(msg));
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (dev->pending || dev->connect)
return btd_error_in_progress(msg);
#else
dev->pending = create_pending_list(dev, uuid);
if (!dev->pending) {
if (dev->svc_refreshed) {
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (!uuid && find_service_with_state(dev->services,
BTD_SERVICE_STATE_CONNECTED))
#else
return btd_error_invalid_args(msg);
service = find_connectable_service(dev, uuid);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if ((service == NULL) && (g_strcmp0(uuid, HFP_HS_UUID) == 0)) {
DBG("HFP service is not found check for HSP service");
service = find_connectable_service(dev, HSP_HS_UUID);
ba2str(btd_adapter_get_address(adapter), src_addr);
ba2str(&device->bdaddr, dst_addr);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (device->rpa)
ba2str(device->rpa, dst_addr);
#endif
struct bearer_state *state = get_state(dev, bdaddr_type);
struct browse_req *req = dev->browse;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
DBG("%s bdaddr_type %d err %d", dev->path, bdaddr_type, err);
#else
DBG("%s err %d", dev->path, err);
#endif
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
state->svc_resolved = true;
#else
if (err == 0)
if (!req)
return;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
/* If bdaddr_type is LE but req is for SDP, don't complete browse req. */
if (bdaddr_type != BDADDR_BREDR && req->search_uuid) {
DBG("Discover comp. is for LE but browse req. is for SDP.");
{
struct btd_device *device = data;
struct btd_adapter *adapter = device->adapter;
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
struct bearer_state *state;
#endif
uint8_t bdaddr_type;
struct agent *agent;
struct bonding_req *bonding;
uint8_t io_cap;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
uint8_t conn_type;
bool connect_le = FALSE;
#endif
btd_device_set_temporary(device, false);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (dbus_message_get_args(msg, NULL, DBUS_TYPE_BYTE, &conn_type,
DBUS_TYPE_INVALID) == FALSE)
#else
if (device->bonding)
return btd_error_in_progress(msg);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (conn_type == DEV_CONN_DEFAULT) {
if (device_is_bonded(device, DEV_CONN_BREDR))
return btd_error_already_exists(msg);
return btd_error_already_exists(msg);
#endif
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (conn_type == DEV_CONN_LE &&
(device_is_bredrle(device) || bdaddr_type != BDADDR_BREDR)) {
DBG("LE Connect request");
else
io_cap = IO_CAPABILITY_NOINPUTNOOUTPUT;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if ((conn_type == DEV_CONN_LE && bdaddr_type != BDADDR_BREDR) ||
connect_le)
bonding = bonding_request_new(msg, device, bdaddr_type, agent);
* channel first and only then start pairing (there's code for
* this in the ATT connect callback)
*/
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (((conn_type == DEV_CONN_LE && bdaddr_type != BDADDR_BREDR) ||
(connect_le)) && !device->le_state.connected)
err = device_connect_le(device);
"Authentication Rejected");
case MGMT_STATUS_CANCELLED:
case MGMT_STATUS_NO_RESOURCES:
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
case MGMT_STATUS_DISCONNECTED:
#endif
return dbus_message_new_error(msg,
return dbus_message_new_method_return(msg);
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static DBusMessage *discover_services(DBusConnection *conn,
DBusMessage *msg, void *user_data)
{
NULL, connect_profile) },
{ GDBUS_ASYNC_METHOD("DisconnectProfile", GDBUS_ARGS({ "UUID", "s" }),
NULL, disconnect_profile) },
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
{ GDBUS_ASYNC_METHOD("Pair", GDBUS_ARGS({ "conn_type", "y" }), NULL,
pair_device) },
#else
{ GDBUS_ASYNC_METHOD("Pair", NULL, NULL, pair_device) },
#endif
{ GDBUS_METHOD("CancelPairing", NULL, NULL, cancel_pairing) },
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
{ GDBUS_ASYNC_METHOD("ConnectLE", GDBUS_ARGS({ "auto_connect", "b"}),
NULL, connect_le) },
{ GDBUS_ASYNC_METHOD("DisconnectLE", NULL, NULL, disconnect_le) },
{ "Blocked", "b", dev_property_get_blocked, dev_property_set_blocked },
{ "LegacyPairing", "b", dev_property_get_legacy },
{ "RSSI", "n", dev_property_get_rssi, NULL, dev_property_exists_rssi },
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
{"IsAliasSet", "b", dev_property_get_alias_set },
{ "Connected", "y", dev_property_get_connected },
#else
{ "Modalias", "s", dev_property_get_modalias, NULL,
dev_property_exists_modalias },
{ "Adapter", "o", dev_property_get_adapter },
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
/* To handle Failed Legacy Pairing when initiated from Remote device*/
{ "LegacyPaired", "b", dev_property_get_paired },
{ "ManufacturerDataLen", "q", property_get_manufacturer_data_len },
{ }
};
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static const GDBusSignalTable device_signals[] = {
{ GDBUS_SIGNAL("Disconnected",
GDBUS_ARGS({ "bdaddr_type", "y" }, { "reason", "y" },
state->connected = true;
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
if (dev->le_state.connected && dev->bredr_state.connected)
return;
g_dbus_emit_property_changed(dbus_conn, dev->path, DEVICE_INTERFACE,
"Connected");
#else
-#ifdef TIZEN_WEARABLE
+#ifdef TIZEN_FEATURE_BLUEZ_BATTERY_WATCH
if (bdaddr_type == BDADDR_BREDR &&
get_charging_state(dev->adapter) == WIRELESS_CHARGING) {
int br_pkt_type = ACL_PTYPE_MASK |
DBG("During wireless charging... Change packet type");
device_change_pkt_type(dev, (gpointer)br_pkt_type);
}
-#endif /* TIZEN_WEARABLE */
+#endif /* TIZEN_FEATURE_BLUEZ_BATTERY_WATCH */
g_dbus_emit_signal(dbus_conn, dev->path,
DEVICE_INTERFACE, "DeviceConnected",
void device_remove_connection(struct btd_device *device, uint8_t bdaddr_type)
{
struct bearer_state *state = get_state(device, bdaddr_type);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
char *dev_name = device->name;
#endif
device->disconn_timer = 0;
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (device->browse) {
struct browse_req *req = device->browse;
btd_adapter_remove_bonding(device->adapter, &device->bdaddr,
bdaddr_type);
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
if (device->bredr_state.connected || device->le_state.connected)
return;
char **uuids;
int source, vendor, product, version;
char **techno, **t;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
gboolean svc_change_regd;
char buf[DEV_MAX_MANUFACTURER_DATA_LEN] = { 0, };
#endif
g_free(str);
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
/* Load RPA Resolution Support value */
device->rpa_res_support = g_key_file_get_integer(key_file,
"General", "RPAResSupport", NULL);
device->trusted = g_key_file_get_boolean(key_file, "General",
"Trusted", NULL);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
/* Load Trusted Profiles*/
int trusted_profiles = g_key_file_get_integer(key_file, "General",
"TrustedProfiles", NULL);
btd_device_set_pnpid(device, source, vendor, product, version);
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
/* Load Service changed Registered flag */
svc_change_regd = g_key_file_get_boolean(key_file, "Att",
"SvcChangeRegd", NULL);
gatt_db_foreach_service(device->db, NULL, add_gatt_service, device);
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static void accept_gatt_service(struct gatt_db_attribute *attr, void *user_data)
{
struct btd_device *device = user_data;
static void device_accept_gatt_profiles(struct btd_device *device)
{
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
GSList *l;
for (l = device->services; l != NULL; l = g_slist_next(l))
if (g_dbus_register_interface(dbus_conn,
device->path, DEVICE_INTERFACE,
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
device_methods, device_signals,
#else
device_methods, NULL,
return btd_device_ref(device);
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
void device_print_addr(struct btd_device *dev)
{
char ida[18];
ba2str(btd_adapter_get_address(device->adapter), srcaddr);
ba2str(&device->bdaddr, dstaddr);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (device->rpa)
ba2str(device->rpa, dstaddr);
#endif
void device_set_bredr_support(struct btd_device *device)
{
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
char addr_str[18];
if (device->rpa) {
store_device_info(device);
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
void device_set_rpa(struct btd_device *device, const bdaddr_t *rpa)
{
if (device->rpa == NULL) {
ba2str(src, adapter_addr);
ba2str(&device->bdaddr, device_addr);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (device->rpa)
ba2str(device->rpa, device_addr);
#endif
g_key_file_free(key_file);
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
void device_unpair(struct btd_device *device, gboolean remove_stored)
{
DBG("+");
btd_device_unref(device);
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
int device_rpa_cmp(gconstpointer a, gconstpointer b)
{
const struct btd_device *device = a;
return false;
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
int device_addr_type_strict_cmp(gconstpointer a, gconstpointer b)
{
const struct btd_device *dev = a;
*/
if (!cmp && addr_is_public(addr->bdaddr_type) &&
addr_is_public(dev->bdaddr_type))
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
{
if (dev->rpa && addr->bdaddr_type == BDADDR_BREDR) {
char addr_str[18];
return cmp;
}
-#ifdef TIZEN_WEARABLE
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
+#ifdef TIZEN_FEATURE_BLUEZ_BATTERY_WATCH
void device_change_pkt_type(gpointer data, gpointer user_data)
{
int pkt_type = (int)user_data;
hci_close_dev(hdev);
return;
}
-#endif /* TIZEN_WEARABLE */
+#endif /* TIZEN_FEATURE_BLUEZ_BATTERY_WATCH */
+#endif
static gboolean record_has_uuid(const sdp_record_t *rec,
const char *profile_uuid)
* Profile based auto connection is not used in Tizen.
* Instead, the applications request auto connection with address.
*/
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
if (profile->auto_connect)
device_set_auto_connect(device, TRUE);
#endif
DEVICE_INTERFACE, "UUIDs");
send_reply:
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (!req->msg)
goto done;
adapter_connect_list_add(device->adapter, device);
done:
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
device_set_gatt_connected(device, FALSE);
#endif
attio_cleanup(device);
btd_device_set_temporary(device, false);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (req) {
if (req->search_uuid)
DBG("browse req. is for SDP. Ignore it.");
if (!device->gatt_cache_used)
g_idle_add(gatt_services_changed, device);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (device->name[0] == '\0') {
char *name = NULL;
name = bt_gatt_client_get_gap_device_name(device->client);
return true;
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static bool load_svc_change_indication_status(struct btd_device *device, const char *local,
const char *peer)
{
struct btd_gatt_database *database;
const bdaddr_t *src, *dst;
char srcaddr[18], dstaddr[18];
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
uint8_t dst_type = BDADDR_BREDR;
#endif
bt_io_get(io, &gerr, BT_IO_OPT_SEC_LEVEL, &sec_level,
BT_IO_OPT_IMTU, &mtu,
BT_IO_OPT_CID, &cid,
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
BT_IO_OPT_DEST_TYPE, &dst_type,
#endif
BT_IO_OPT_INVALID);
return false;
}
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
if (sec_level == BT_IO_SEC_LOW && dev->le_state.paired) {
DBG("Elevating security level since LTK is available");
bt_att_set_remote_key(dev->att, dev->remote_csrk->key,
remote_counter, dev);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (dst_type != BDADDR_BREDR && device_get_rpa_exist(dev) == true) {
bt_att_set_remote_addr(dev->att,
device_get_rpa(dev), BDADDR_LE_RANDOM);
*/
adapter_connect_list_remove(dev->adapter, dev);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
/* load the service changed indication status on connection */
load_svc_change_indication_status(dev, srcaddr, dstaddr);
#endif
struct att_callbacks *attcb;
struct browse_req *req;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
DBG("");
#endif
req = browse_request_new(device, msg);
uuid_t uuid;
int err;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
DBG("");
#endif
req = browse_request_new(device, msg);
&device->bdaddr, &uuid, browse_cb, req, NULL,
req->sdp_flags);
if (err < 0) {
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
device->browse = NULL;
#endif
browse_request_free(req);
return err;
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
void device_set_last_addr_type(struct btd_device *device, uint8_t type)
{
if (!device)
DEVICE_INTERFACE, "Trusted");
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
void btd_device_set_trusted_profiles(struct btd_device *device,
uint32_t pbap, uint32_t map, uint32_t sap)
{
if (!device)
return;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (rssi == 0 || device->rssi == 0) {
if (device->rssi == rssi)
return;
if (status) {
device_cancel_authentication(device, TRUE);
device_bonding_failed(device, status);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
device->legacy_pairing = false;
#endif
return;
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
device->legacy_pairing = false;
#endif
device_auth_req_free(device);
/* If we're already paired nothing more is needed */
if (state->paired) {
-#ifdef __TIZEN_PATCH__
-#ifdef TIZEN_WEARABLE
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (bdaddr_type == BDADDR_BREDR && state->svc_resolved) {
DBG("Link key has been changed. Report it");
if (!device->rpa)
g_dbus_emit_property_changed(dbus_conn, device->path,
DEVICE_INTERFACE, "Paired");
}
-#endif /* TIZEN_WEARABLE */
-#endif /* __TIZEN_PATCH__ */
+#endif /* TIZEN_FEATURE_BLUEZ_MODIFY */
return;
}
g_source_remove(dev->discov_timer);
dev->discov_timer = g_idle_add(start_discovery, dev);
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
else if (!dev->browse) {
DBG("Service is not going on. Start discovery");
dev->discov_timer = g_idle_add(start_discovery, dev);
DBG("status %u", status);
if (!bonding) {
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (device->legacy_pairing) {
DBG("Emit LegacyPaired");
g_dbus_emit_property_changed(dbus_conn, device->path,
#endif
return;
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
btd_device_set_temporary(device, TRUE);
#endif
if (auth->agent == NULL)
return;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
btd_adapter_confirm_reply(device->adapter, &device->bdaddr,
device->auth_bdaddr_type,
err ? FALSE : TRUE);
if (err)
passkey = INVALID_PASSKEY;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
btd_adapter_passkey_reply(device->adapter, &device->bdaddr,
device->auth_bdaddr_type, passkey);
device_set_auth_addr_type(device, BDADDR_BREDR);
auth->passkey = passkey;
-#ifndef TIZEN_WEARABLE
+#ifndef TIZEN_FEATURE_BLUEZ_CONFIRM_ONLY
if (confirm_hint)
err = agent_request_authorization(auth->agent, device,
confirm_cb, auth, NULL);
device_auth_req_free(device);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
device_set_auth_addr_type(device, BDADDR_BREDR);
#endif
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
gboolean device_is_authenticating(struct btd_device *dev, uint8_t bdaddr_type)
{
return (dev->auth_bdaddr_type == bdaddr_type && dev->authr != NULL);
ba2str(btd_adapter_get_address(device->adapter), local);
ba2str(&device->bdaddr, peer);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (device->rpa)
ba2str(device->rpa, peer);
#endif
store_device_info(device);
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
int device_get_rpa_res_char_value(struct btd_device *device)
{
return device->rpa_res_support;
attio->dcfunc = dcfunc;
attio->user_data = user_data;
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
device_set_auto_connect(device, TRUE);
#endif
struct btd_device *device = btd_service_get_device(service);
int err = btd_service_get_error(service);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (!err) {
if (old_state == BTD_SERVICE_STATE_UNAVAILABLE ||
new_state == BTD_SERVICE_STATE_UNAVAILABLE)
btd_service_remove_state_cb(service_state_cb_id);
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
void btd_device_set_legacy_pairing(struct btd_device *dev, bool legacy_pairing)
{
dev->legacy_pairing = legacy_pairing;
struct btd_device;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
/* Device Physical channel connection Type */
#define DEV_CONN_DEFAULT 0xFF /* Represents support for BREDR and LE */
#define DEV_CONN_BREDR 0x00 /* Only BREDR */
uint8_t bdaddr_type;
};
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
int device_addr_type_strict_cmp(gconstpointer a, gconstpointer b);
#endif
int device_addr_type_cmp(gconstpointer a, gconstpointer b);
struct btd_adapter *device_get_adapter(struct btd_device *device);
const bdaddr_t *device_get_address(struct btd_device *device);
const char *device_get_path(const struct btd_device *device);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
void device_set_remote_feature_flag(struct btd_device *device, int flags);
gboolean device_is_bredrle(struct btd_device *device);
void device_set_disconnect_reason(struct btd_device *device, uint8_t reason);
int device_notify_pincode(struct btd_device *device, gboolean secure,
const char *pincode);
void device_cancel_authentication(struct btd_device *device, gboolean aborted);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
gboolean device_is_authenticating(struct btd_device *dev, uint8_t bdaddr_type);
#else
gboolean device_is_authenticating(struct btd_device *device);
int device_get_appearance(struct btd_device *device, uint16_t *value);
void device_set_appearance(struct btd_device *device, uint16_t value);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
struct eir_data;
void device_set_manufacturer_info(struct btd_device *dev, struct eir_data *eir);
void device_set_adv_report_info(struct btd_device *device, void *data,
struct btd_service *btd_device_get_service(struct btd_device *dev,
const char *remote_uuid);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
void device_print_addr(struct btd_device *dev);
gboolean device_is_profile_trusted(struct btd_device *device,
const char *uuid);
void btd_device_set_legacy_pairing(struct btd_device *dev, bool legacy_pairing);
void btd_device_set_svc_changed_indication(struct btd_device *dev, bool value);
bool btd_device_get_svc_changed_indication(struct btd_device *dev);
-#ifdef TIZEN_WEARABLE
+#ifdef TIZEN_FEATURE_BLUEZ_BATTERY_WATCH
void device_change_pkt_type(gpointer data, gpointer user_data);
-#endif /* TIZEN_WEARABLE */
+#endif /* TIZEN_FEATURE_BLUEZ_BATTERY_WATCH */
#endif
int device_discover_services(struct btd_device *device);
eir->msd_list = NULL;
g_slist_free_full(eir->sd_list, sd_free);
eir->sd_list = NULL;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
g_free(eir->manufacturer_data);
eir->manufacturer_data = NULL;
#endif
static char *name2utf8(const uint8_t *name, uint8_t len)
{
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
char *utf8_name;
char *in_name;
char *ptr;
break;
case EIR_MANUFACTURER_DATA:
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (data_len < 1)
break;
uint16_t did_source;
GSList *msd_list;
GSList *sd_list;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
char *manufacturer_data;
uint8_t manufacturer_data_len;
#endif
struct queue *services;
struct queue *all_notify_clients;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
guint wait_charcs_id;
#endif
};
bool chrcs_ready;
struct queue *pending_ext_props;
guint idle_id;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
guint idle_id2;
#endif
};
return true;
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static bool parse_type_value_arg(DBusMessage *msg, uint8_t *type, uint8_t **value,
size_t *value_len)
{
reply = btd_error_failed(op->msg,
"Reliable write failed");
else {
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
reply = dbus_message_new_method_return(op->msg);
if (!reply) {
error("Failed to allocate D-Bus message reply");
error("Failed to allocate D-Bus message reply");
return;
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
dbus_message_append_args(reply,
DBUS_TYPE_BYTE, &att_ecode,
DBUS_TYPE_INVALID);
return id;
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static unsigned int start_write_cmd(DBusMessage *msg, uint16_t handle,
struct bt_gatt_client *gatt, bool signed_write,
const uint8_t *value, size_t value_len,
}
static const GDBusPropertyTable descriptor_properties[] = {
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
{ "UUID", "s", descriptor_get_uuid },
{ "Characteristic", "o", descriptor_get_characteristic },
{ "Value", "ay", descriptor_get_value, NULL,
};
static const GDBusMethodTable descriptor_methods[] = {
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
{ GDBUS_ASYNC_METHOD("ReadValue", NULL, GDBUS_ARGS({ "value", "ay" }),
descriptor_read_value) },
{ GDBUS_ASYNC_METHOD("WriteValue",
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static void notify_characteristic_cb(struct gatt_db_attribute *attr, int err,
void *user_data)
{
* - If value is larger than MTU - 3: long-write
* * "write-without-response" property set -> write command.
*/
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
if ((chrc->ext_props & BT_GATT_CHRC_EXT_PROP_RELIABLE_WRITE)) {
supported = true;
chrc->write_id = start_long_write(msg, chrc->value_handle, gatt,
return btd_error_not_supported(msg);
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static DBusMessage *characteristic_write_value_by_type(DBusConnection *conn,
DBusMessage *msg, void *user_data)
{
return strcmp(client->owner, sender) == 0;
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
void gatt_characteristic_value_changed(struct notify_client *client, const uint8_t *data, uint16_t data_len, void *user_data)
{
struct characteristic *chrc = user_data;
* applications.
*/
gatt_db_attribute_reset(chrc->attr);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
gatt_db_attribute_write(chrc->attr, 0, value, length, 0, NULL,
notify_characteristic_cb, chrc);
}
static const GDBusPropertyTable characteristic_properties[] = {
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
{ "UUID", "s", characteristic_get_uuid },
{ "Service", "o", characteristic_get_service },
{ "Value", "ay", characteristic_get_value, NULL,
};
static const GDBusMethodTable characteristic_methods[] = {
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
{ GDBUS_ASYNC_METHOD("ReadValue", NULL, GDBUS_ARGS({ "value", "ay" }),
characteristic_read_value) },
{ GDBUS_ASYNC_METHOD("WriteValue", GDBUS_ARGS({ "value", "ay" }),
#endif
};
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static const GDBusSignalTable service_signals[] = {
{ GDBUS_SIGNAL("GattServiceAdded",
GDBUS_ARGS({ "Service Path","s"})) },
chrc->notify_clients = queue_new();
chrc->service = service;
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
gatt_db_attribute_get_char_data(attr, &chrc->handle,
&chrc->value_handle,
&chrc->props, &uuid);
if (!g_dbus_register_interface(btd_get_dbus_connection(), chrc->path,
GATT_CHARACTERISTIC_IFACE,
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
characteristic_methods, characteristic_signals,
#else
characteristic_methods, NULL,
}
static const GDBusPropertyTable service_properties[] = {
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
{ "UUID", "s", service_get_uuid },
{ "Device", "o", service_get_device },
{ "Primary", "b", service_get_primary },
if (!g_dbus_register_interface(btd_get_dbus_connection(), service->path,
GATT_SERVICE_IFACE,
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
NULL, service_signals,
#else
NULL, NULL,
if (service->idle_id)
g_source_remove(service->idle_id);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (service->idle_id2)
g_source_remove(service->idle_id2);
#endif
struct characteristic *chrc = user_data;
struct service *service = chrc->service;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
chrc->read_id = 0;
#endif
{
struct characteristic *chrc = data;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
chrc->read_id = bt_gatt_client_read_value(chrc->service->client->gatt,
chrc->ext_props_handle,
read_ext_props_cb,
return FALSE;
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static gboolean notify_service_added_complete(gpointer user_data)
{
struct service *service = user_data;
if (!service->chrcs_ready && queue_isempty(service->pending_ext_props))
service->idle_id = g_idle_add(set_chrcs_ready, service);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (service->primary == true)
service->idle_id2 = g_idle_add(notify_service_added_complete, service);
#endif
if (!client)
return;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (client->wait_charcs_id)
g_source_remove(client->wait_charcs_id);
#endif
notify_client_free(notify_client);
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static void check_chrcs_ready(void *data, void *user_data)
{
gboolean *chrcs_ready = user_data;
DBG("GATT client ready");
create_services(client);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
/*
* In case of more number of services and services having
* characteristics extended properties; GattConnected signal
DBG("Device disconnected. Cleaning up.");
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (client->wait_charcs_id) {
g_source_remove(client->wait_charcs_id);
client->wait_charcs_id = 0;
struct gatt_db_attribute *attrib;
struct queue *owner_queue;
struct iovec data;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
bdaddr_t bdaddr;
uint8_t bdaddr_type;
#endif
uint8_t bdaddr_type;
};
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static void conf_cb(void *user_data);
#endif
return queue_find(database->device_states, dev_state_match, &dev_info);
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static void send_service_changed_indication_on_reconnect(
struct btd_device *device,
struct bt_gatt_server *server)
uint8_t bdaddr_type)
{
struct device_state *dev_state;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
char addr[18] = { 0 };
ba2str(bdaddr, addr);
{
struct device_state *dev_state;
struct ccc_state *ccc;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
char addr[18] = { 0 };
#endif
if (ccc)
return ccc;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
ba2str(bdaddr, addr);
DBG("create ccc_state of handle: 0x%04x for %s [%d]",
handle, addr, bdaddr_type);
device_attach_att(device, io);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (btd_device_get_svc_changed_indication(device)) {
send_service_changed_indication_on_reconnect(device,
btd_device_get_gatt_server(device));
#endif
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
#define LE_BEARER_POSTFIX " LE"
#define LE_BEARER_POSTFIX_LEN 3
size_t len = 0;
const uint8_t *value = NULL;
const char *device_name;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
bdaddr_t dst = { { 0 } };
uint8_t dst_type = 0;
char le_name[MAX_NAME_LENGTH + 1];
DBG("GAP Device Name read request\n");
device_name = btd_adapter_get_name(database->adapter);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (get_dst_info(att, &dst, &dst_type) && dst_type != BDADDR_BREDR &&
bacmp(btd_adapter_get_address(database->adapter),
btd_adapter_get_le_address(database->adapter))) {
gatt_db_attribute_read_result(attrib, id, error, value, len);
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static void gap_rpa_res_support_read_cb(struct gatt_db_attribute *attrib,
unsigned int id, uint16_t offset,
uint8_t opcode, struct bt_att *att,
return 0;
if (name != NULL)
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
sdp_set_info_attr(record, name, "Samsung", NULL);
#else
sdp_set_info_attr(record, name, "BlueZ", NULL);
#endif
sdp_uuid16_create(&gap_uuid, UUID_GAP);
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
if (sdp_uuid_cmp(&svc, &gap_uuid) == 0) {
sdp_set_url_attr(record, "http://www.bluez.org/",
"http://www.bluez.org/",
gap_appearance_read_cb,
NULL, database);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
/* Central address resolution characteristic */
bt_uuid16_create(&uuid, GATT_CHARAC_CENTRAL_RPA_RESOLUTION);
gatt_db_service_add_characteristic(service, &uuid, BT_ATT_PERM_READ,
static bool get_dst_info(struct bt_att *att, bdaddr_t *dst, uint8_t *dst_type)
{
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
return bt_att_get_remote_addr(att, dst, dst_type);
#else
GIOChannel *io = NULL;
done:
gatt_db_attribute_write_result(attrib, id, ecode);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (!ecode) {
uint16_t svc_chngd_handle = gatt_db_attribute_get_handle(database->svc_chngd_ccc);
if (handle == svc_chngd_handle) {
bool indicate;
};
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
struct notify_indicate {
struct btd_gatt_database *database;
GDBusProxy *proxy;
static void conf_cb(void *user_data)
{
DBG("GATT server received confirmation");
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
struct notify_indicate_cb *confirm = user_data;
if (confirm) {
#endif
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static void send_notification_indication_to_device(void *data, void *user_data)
{
struct device_state *device_state = data;
free(op);
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static struct pending_op *pending_read_new(struct queue *owner_queue,
struct gatt_db_attribute *attrib,
struct bt_att *att,
#endif
{
struct pending_op *op;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
bdaddr_t bdaddr;
uint8_t bdaddr_type;
#endif
op = new0(struct pending_op, 1);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (!get_dst_info(att, &bdaddr, &bdaddr_type)) {
return NULL;
}
#endif
op->owner_queue = owner_queue;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
memcpy(&op->bdaddr, &bdaddr, sizeof(bdaddr_t));
op->bdaddr_type = bdaddr_type;
#endif
return op;
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static void read_setup_cb(DBusMessageIter *iter, void *user_data)
{
struct pending_op *op = user_data;
}
#endif
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static void send_read(struct gatt_db_attribute *attrib, struct bt_att *att,
GDBusProxy *proxy, struct queue *owner_queue,
unsigned int id)
struct pending_op *op;
uint8_t ecode = BT_ATT_ERROR_UNLIKELY;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
op = pending_read_new(owner_queue, attrib, att, id);
#else
op = pending_read_new(owner_queue, attrib, id);
#endif
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (g_dbus_proxy_method_call(proxy, "ReadValue", read_setup_cb, read_reply_cb,
op, pending_op_free) == TRUE)
#else
{
struct pending_op *op = user_data;
DBusMessageIter array;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
char dstaddr[18] = { 0 };
char *addr_value = NULL;
uint16_t offset = 0;
#endif
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
ba2str(&op->bdaddr, dstaddr);
addr_value = g_strdup(dstaddr);
gatt_db_attribute_write_result(op->attrib, op->id, ecode);
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static struct pending_op *pending_write_new(struct queue *owner_queue,
struct gatt_db_attribute *attrib, struct bt_att *att,
unsigned int id,
#endif
{
struct pending_op *op;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
bdaddr_t bdaddr;
uint8_t bdaddr_type;
#endif
op = new0(struct pending_op, 1);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (!get_dst_info(att, &bdaddr, &bdaddr_type)) {
return NULL;
}
op->data.iov_base = (uint8_t *) value;
op->data.iov_len = len;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
memcpy(&op->bdaddr, &bdaddr, sizeof(bdaddr_t));
op->bdaddr_type = bdaddr_type;
#endif
return op;
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static void send_write(struct gatt_db_attribute *attrib, struct bt_att *att,
GDBusProxy *proxy, struct queue *owner_queue,
unsigned int id, const uint8_t *value, size_t len)
struct pending_op *op;
uint8_t ecode = BT_ATT_ERROR_UNLIKELY;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
op = pending_write_new(owner_queue, attrib, att, id, value, len);
#else
op = pending_write_new(owner_queue, attrib, id, value, len);
DBusMessageIter array;
uint8_t *value = NULL;
int len = 0;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
bool enable = FALSE;
const bdaddr_t *unicast_addr = NULL;
#endif
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (strcmp(name, "Value") == 0) {
if (dbus_message_iter_get_arg_type(iter) != DBUS_TYPE_ARRAY) {
DBG("Malformed \"Value\" property received");
error("Read callback called with incorrect attribute");
return;
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
send_read(attrib, att, desc->proxy, desc->pending_reads, id);
#else
send_read(attrib, desc->proxy, desc->pending_reads, id);
return;
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
send_write(attrib, att, desc->proxy, desc->pending_writes, id, value, len);
#else
send_write(attrib, desc->proxy, desc->pending_writes, id, value, len);
return;
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
send_read(attrib, att, chrc->proxy, chrc->pending_reads, id);
#else
send_read(attrib, chrc->proxy, chrc->pending_reads, id);
#endif
}
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
static void write_without_response_setup_cb(DBusMessageIter *iter,
void *user_data)
{
return;
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if ((!(chrc->props & BT_GATT_CHRC_PROP_WRITE_WITHOUT_RESP) &&
opcode == BT_ATT_OP_WRITE_CMD) ||
(!(chrc->props & BT_GATT_CHRC_PROP_WRITE) &&
#endif
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static bool database_check_ccc_desc(struct external_desc *desc)
{
bt_uuid_t uuid, uuid_ccc;
return false;
}
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
/* Existing implementation adds CCC descriptor by default
* if notification and indication properties are set. But as per the requirment
* CCCD shall be added by the application */
if (desc->handled || g_strcmp0(desc->chrc_path, chrc->path))
continue;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
/* Check if Application wants to add CCC and use existing
* implemenation to add CCC descriptors */
if (database_check_ccc_desc(desc)) {
}
static const GDBusMethodTable manager_methods[] = {
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
{ GDBUS_ASYNC_METHOD("RegisterApplication",
GDBUS_ARGS({ "application", "o" },
{ "options", "a{sv}" }), NULL,
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
/*
*
* BlueZ - Bluetooth protocol stack for Linux
esvc->proxies = g_slist_remove(esvc->proxies, proxy);
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static void proxy_prop_changed(GDBusProxy *proxy, const char *name,
DBusMessageIter *iter, void *user_data)
{
return reply;
}
#endif
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static uint8_t proxy_read_cb(struct btd_attribute *attr, bdaddr_t *bdaddr,
btd_attr_read_result_t result, void *user_data)
#else
GDBusProxy *proxy;
uint8_t *value = NULL;
int len = 0;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
char dstaddr[18] = { 0 };
char *addr_value = NULL;
DBusMessage *reply;
*/
proxy = g_hash_table_lookup(proxy_hash, attr);
if (!proxy) {
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
return result(-ENOENT, NULL, 0, user_data);
#else
result(-ENOENT, NULL, 0, user_data);
return;
#endif
}
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
if (!g_dbus_proxy_get_property(proxy, "Value", &iter)) {
/* Unusual situation, read property will checked earlier */
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
return result(-EPERM, NULL, 0, user_data);
#else
result(-EPERM, NULL, 0, user_data);
if (dbus_message_iter_get_arg_type(&iter) != DBUS_TYPE_ARRAY) {
DBG("External service inconsistent!");
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
return result(-EPERM, NULL, 0, user_data);
#else
result(-EPERM, NULL, 0, user_data);
#endif
DBG("attribute: %p read %d bytes", attr, len);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
return result(0, value, len, user_data);
#else
result(0, value, len, user_data);
wdata->result_cb(err, wdata->user_data);
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static uint8_t proxy_write_cb(struct btd_attribute *attr,
const uint8_t *value, size_t len,
btd_attr_write_result_t result,
proxy = g_hash_table_lookup(proxy_hash, attr);
if (!proxy) {
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
return result(-ENOENT, user_data);
#else
result(-ENOENT, user_data);
wdata->result_cb = result;
wdata->user_data = user_data;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
btd_gatt_set_notify_indicate_flag(attr, FALSE);
#endif
proxy_write_reply,
wdata, g_free)) {
g_free(wdata);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
return result(-ENOENT, user_data);
#else
result(-ENOENT, user_data);
* This flow implements the ATT Write Command scenario, where
* the remote doesn't receive ATT response.
*/
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
btd_gatt_set_notify_indicate_flag(attr, FALSE);
#endif
g_dbus_proxy_set_property_array(proxy, "Value", DBUS_TYPE_BYTE,
DBG("Server: Write attribute callback %s",
g_dbus_proxy_get_path(proxy));
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
return 0;
#endif
if (bt_string_to_uuid(&uuid, str) < 0)
return -EINVAL;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
esvc->service = btd_gatt_add_service(&uuid, path);
#else
esvc->service = btd_gatt_add_service(&uuid);
btd_attr_write_t write_cb;
btd_attr_read_t read_cb;
uint8_t propmask = 0;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
const char *path;
#endif
else
write_cb = NULL;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
path = g_dbus_proxy_get_path(proxy);
attr = btd_gatt_add_char(uuid, propmask, path, read_cb, write_cb);
#else
static int add_char_desc(GDBusProxy *proxy, const bt_uuid_t *uuid)
{
struct btd_attribute *attr;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
const char *path;
#endif
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
path = g_dbus_proxy_get_path(proxy);
attr = btd_gatt_add_char_desc(uuid, path, proxy_read_cb, proxy_write_cb);
#else
dbus_message_unref(esvc->reg);
esvc->reg = NULL;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
btd_gatt_update_attr_db();
#endif
g_dbus_client_set_disconnect_watch(client, remove_service, esvc);
g_dbus_client_set_proxy_handlers(client, proxy_added, proxy_removed,
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
proxy_prop_changed, esvc);
#else
NULL, esvc);
return esvc;
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static DBusMessage *get_service(DBusConnection *conn,
DBusMessage *msg, void *user_data)
{
esvc = list->data;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (strcmp(dbus_message_get_sender(msg), esvc->owner))
#else
if (!strcmp(dbus_message_get_sender(msg), esvc->owner))
}
static const GDBusMethodTable methods[] = {
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
{ GDBUS_ASYNC_METHOD("RegisterService",
#else
{ GDBUS_EXPERIMENTAL_ASYNC_METHOD("RegisterService",
GDBUS_ARGS({ "service", "o"},
{ "options", "a{sv}"}),
NULL, register_service) },
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
{ GDBUS_METHOD("UnregisterService",
#else
{ GDBUS_EXPERIMENTAL_METHOD("UnregisterService",
#endif
GDBUS_ARGS({"service", "o"}),
NULL, unregister_service) },
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
{ GDBUS_METHOD("GetService",
#else
{ GDBUS_EXPERIMENTAL_METHOD("GetService",
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
/*
*
* BlueZ - Bluetooth protocol stack for Linux
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
/*
*
* BlueZ - Bluetooth protocol stack for Linux
#include <glib.h>
#include <stdbool.h>
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
#include <errno.h>
#include <dbus/dbus.h>
#include <gdbus/gdbus.h>
#include "gatt-dbus.h"
#include "gatt.h"
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
#include "adapter.h"
#include "attrib/gatt-service.h"
#include "attrib/att-database.h"
static const bt_uuid_t chr_uuid = { .type = BT_UUID16,
.value.u16 = GATT_CHARAC_UUID };
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
#define ATT_CHAR_READ_VALUE 0x01
#define ATT_CHAR_RD_WRT_CB 0x02
struct btd_attribute {
uint16_t handle;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
uint16_t attr_start_handle;
uint16_t attr_end_handle;
bool notify_indicate;
uint8_t value[0];
};
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
struct pending_hndl {
uint16_t handle;
uint16_t type;
attr->type = *type;
attr->read_cb = read_cb;
attr->write_cb = write_cb;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
attr->notify_indicate = TRUE;
#endif
return 0;
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static int attr_uuid_cmp(gconstpointer a, gconstpointer b)
{
const struct btd_attribute *attrib1 = a;
#endif
#endif
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
struct btd_attribute *btd_gatt_add_service(const bt_uuid_t *uuid,
const char *path)
#else
if (!attr)
return NULL;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
attr->path = g_strdup(path);
/* Store the primary handle in linkedlist,
* later this list shall be used to add the attributes to DB */
{
GList *list = g_list_find(local_attribute_db, service);
bool first_node;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
struct btd_attribute *attrib_rmv = NULL;
#endif
if (!list)
return;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
attrib_rmv = list->data;
/* Remove the service from Attrib database */
/* Remove all characteristics until next service declaration */
while (list && !is_service(list->data)) {
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
free(list->data);
#endif
list = g_list_delete_link(list, list);
local_attribute_db = list;
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
bool btd_gatt_update_char(const bt_uuid_t *uuid, uint8_t *value, size_t len)
{
GList *l;
}
#endif
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
struct btd_attribute *btd_gatt_add_char(const bt_uuid_t *uuid,
uint8_t properties,
const char *path,
if (!char_decl)
goto fail;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
char_decl->path = g_strdup(path);
#endif
if (!char_value)
goto fail;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
char_value->path = g_strdup(path);
#endif
if (local_database_add(next_handle, char_decl) < 0)
goto fail;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
/* Store the char decl handle in linkedlist,
* later this list shall be used to add the attributes to DB */
if (hndl_list && hndl_list->next == NULL) {
/* TODO: remove declaration */
goto fail;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
/* Store the char value handle in linkedlist,
* later this list shall be used to add the attributes to DB */
if (hndl_list && hndl_list->next == NULL) {
return char_value;
fail:
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
/* Fix : RESOURCE_LEAK */
if (char_decl != NULL && char_decl->path != NULL)
g_free(char_decl->path);
return NULL;
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
struct btd_attribute *btd_gatt_add_char_desc(const bt_uuid_t *uuid,
const char *path,
btd_attr_read_t read_cb,
return NULL;
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
attr->path = g_strdup(path);
/* Store the store handle in linkedlist,
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
/*
*
* BlueZ - Bluetooth protocol stack for Linux
* @len: length of value.
* @user_data: user_data passed in btd_attr_read_t callback.
*/
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
typedef uint8_t (*btd_attr_read_result_t) (int err, uint8_t *value, size_t len,
void *user_data);
#else
* value of attribute read.
* @user_data: user_data passed in btd_attr_read_result_t callback.
*/
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
typedef uint8_t (*btd_attr_read_t) (struct btd_attribute *attr, bdaddr_t *bdaddr,
btd_attr_read_result_t result,
void *user_data);
* @err: error in -errno format.
* @user_data: user_data passed in btd_attr_write_t callback.
*/
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
typedef uint8_t (*btd_attr_write_result_t) (int err, void *user_data);
#else
typedef void (*btd_attr_write_result_t) (int err, void *user_data);
* result of the write operation.
* @user_data: user_data passed in btd_attr_write_result_t callback.
*/
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
typedef uint8_t (*btd_attr_write_t) (struct btd_attribute *attr,
const uint8_t *value, size_t len,
btd_attr_write_result_t result,
* Returns a reference to service declaration attribute. In case of error,
* NULL is returned.
*/
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
struct btd_attribute *btd_gatt_add_service(const bt_uuid_t *uuid, const char *path);
#else
struct btd_attribute *btd_gatt_add_service(const bt_uuid_t *uuid);
#endif
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
/*
* btd_gatt_update_attr_db - updates the attribute data base.
*/
* Returns a reference to characteristic value attribute. In case of error,
* NULL is returned.
*/
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
struct btd_attribute *btd_gatt_add_char(const bt_uuid_t *uuid,
uint8_t properties,
const char *path,
* Returns a reference to characteristic descriptor attribute. In case of
* error, NULL is returned.
*/
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
struct btd_attribute *btd_gatt_add_char_desc(const bt_uuid_t *uuid,
const char *path,
btd_attr_read_t read_cb,
btd_attr_write_t write_cb);
#endif
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
/*
* btd_gatt_update_char - update characteristic value to the local
* attribute database.
gboolean name_resolv;
gboolean debug_keys;
gboolean fast_conn;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
gboolean le_privacy;
#endif
desc->flags |= BTD_DEBUG_FLAG_PRINT;
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
void __hci_attach_log_init(void)
{
int option = LOG_NDELAY | LOG_PID;
void btd_debug(uint16_t index, const char *format, ...)
__attribute__((format(printf, 2, 3)));
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
void __hci_attach_log_init(void );
#endif
void __btd_log_init(const char *debug, int detach);
"DebugKeys",
"ControllerMode",
"MultiProfile",
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
"EnableLEPrivacy",
#endif
};
g_clear_error(&err);
else
main_opts.fast_conn = boolean;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
boolean = g_key_file_get_boolean(config, "General",
"EnableLEPrivacy", &err);
if (err)
main_opts.reverse_sdp = TRUE;
main_opts.name_resolv = TRUE;
main_opts.debug_keys = FALSE;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
main_opts.le_privacy = FALSE;
#endif
if (sscanf(VERSION, "%hhu.%hhu", &major, &minor) != 2)
return;
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
main_opts.did_source = 0x0002; /* USB */
main_opts.did_vendor = 0x1d6b; /* Linux Foundation */
main_opts.did_product = 0x0246; /* BlueZ */
local_oob_read_cb = cb;
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
void oob_read_local_data_complete(struct btd_adapter *adapter, uint8_t *hash,
uint8_t *randomizer, void *user_data)
#else
uint8_t *randomizer);
void oob_register_cb(oob_read_cb_t cb);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
void oob_read_local_data_complete(struct btd_adapter *adapter, uint8_t *hash,
uint8_t *randomizer, void *user_data);
#else
</attribute> \
</record>"
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
#define SPP_RECORD \
"<?xml version=\"1.0\" encoding=\"UTF-8\" ?> \
<record> \
</attribute> \
</record>"
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
#define OPP_RECORD \
"<?xml version=\"1.0\" encoding=\"UTF-8\" ?> \
<record> \
</attribute> \
</record>"
-#ifdef PBAP_SIM_ENABLE
+#ifdef TIZEN_FEATURE_BLUEZ_PBAP_SIM
#define PBAP_ACCESS "0x03" /* Phone and SIM access support*/
#else
#define PBAP_ACCESS "0x01" /* Phone access support only*/
#endif
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
#define PSE_RECORD \
"<?xml version=\"1.0\" encoding=\"UTF-8\" ?> \
<record> \
</record>"
#endif
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
#define SUPPORTED_MESSAGE_TYPES "0x03" /* EMAIL and SMS_GSM */
#else
#define SUPPORTED_MESSAGE_TYPES "0x0F" /* EMAIL, SMS_GSM, SMS_CDMA and MMS */
GSList *conns;
GSList *connects;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
char *destination;
char *app_path;
#endif
DBG("incoming connect from %s", addr);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
{
struct btd_device *device;
gboolean restricted = FALSE;
return l->data;
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
gboolean ext_profile_is_registered_as_client_role(struct btd_profile *p)
{
struct ext_profile *ext = find_ext(p);
sdp_record_t *rec = r->data;
sdp_list_t *protos;
int port;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
char *profile_uuid;
sdp_list_t *svcclass = NULL;
struct ext_io *rfcomm)
{
char *svc, *rec;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
char *lan_seq;
uint16_t code_ISO639 = (0x65 << 8) | 0x6e;
uint16_t encoding = 106;
else
svc = g_strdup("");
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
lan_seq = g_strdup_printf(LANG_SEQ, code_ISO639, encoding,
base_offset);
rec = g_strdup_printf(SPP_RECORD, svc, rfcomm->chan, lan_seq, ext->version,
static char *get_pse_record(struct ext_profile *ext, struct ext_io *l2cap,
struct ext_io *rfcomm)
{
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
uint8_t chan = 0;
if (rfcomm)
static char *get_opp_record(struct ext_profile *ext, struct ext_io *l2cap,
struct ext_io *rfcomm)
{
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
uint16_t psm = 0;
#endif
uint8_t chan = 0;
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
if (l2cap)
psm = l2cap->psm;
#endif
if (rfcomm)
chan = rfcomm->chan;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
return g_strdup_printf(OPP_RECORD, chan, ext->version, ext->name);
#else
return g_strdup_printf(OPP_RECORD, chan, ext->version, psm, ext->name);
.sec_level = BT_IO_SEC_LOW,
.authorize = false,
.get_record = get_opp_record,
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
.version = 0x0100,
#else
.version = 0x0102,
return -EINVAL;
dbus_message_iter_get_basic(value, &b);
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
if (b)
ext->sec_level = BT_IO_SEC_MEDIUM;
else
}
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static struct ext_profile *create_ext2(const char *owner, const char *path,
const char *uuid, const char *destination, const char *app_path,
DBusMessageIter *opts)
return dbus_message_new_method_return(msg);
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static DBusMessage *register_profile2(DBusConnection *conn,
DBusMessage *msg, void *user_data)
{
GDBUS_ARGS({ "profile", "o"}, { "UUID", "s" },
{ "options", "a{sv}" }),
NULL, register_profile) },
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
/* For Dbus Smack devides dbus API, the functionality is same */
{ GDBUS_METHOD("RegisterProfile1",
GDBUS_ARGS({ "profile", "o"}, { "UUID", "s" },
g_slist_free_full(ext->conns, ext_io_destroy);
ext->conns = NULL;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (ext->destination == NULL) {
msg = dbus_message_new_method_call(ext->owner,
ext->path,
void *user_data);
bool btd_profile_remove_custom_prop(const char *uuid, const char *name);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
gboolean ext_profile_is_registered_as_client_role(struct btd_profile *p);
#endif
struct context_data *ctx_data = user_data;
struct sdp_xml_data *elem;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (element_name == NULL)
return;
#endif
void service_remove(struct btd_service *service)
{
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (service->profile == NULL)
return;
#endif
struct btd_profile *profile = service->profile;
char addr[18];
int err;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (profile != NULL && !profile->connect)
#else
if (!profile->connect)
void btd_service_connecting_complete(struct btd_service *service, int err)
{
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (service->state != BTD_SERVICE_STATE_DISCONNECTED &&
service->state != BTD_SERVICE_STATE_CONNECTING)
return;
bool in_req; /* There's a pending incoming request */
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
bdaddr_t bdaddr;
uint8_t bdaddr_type;
bool service_change_indication; /* Service changed indication status */
static void cancel_att_send_op(struct att_send_op *op)
{
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (op->callback)
op->callback(BT_ATT_OP_ERROR_RSP, NULL, 0, op->user_data);
#endif
* response from the remote end, then no callback should have been
* provided, since it will never be called.
*/
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (callback && type != ATT_OP_TYPE_REQ && type != ATT_OP_TYPE_IND
&& type != ATT_OP_TYPE_CMD)
return NULL;
case ATT_OP_TYPE_IND:
att->pending_ind = op;
break;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
case ATT_OP_TYPE_CMD:
if (op->callback)
op->callback(0, NULL, 0, op->user_data);
att->in_req = false;
/* Fall through to the next case */
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
case ATT_OP_TYPE_CMD:
#endif
case ATT_OP_TYPE_NOT:
if (ecode == BT_ATT_ERROR_INSUFFICIENT_ENCRYPTION &&
security < BT_ATT_SECURITY_MEDIUM)
security = BT_ATT_SECURITY_MEDIUM;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
else if (ecode == BT_ATT_ERROR_AUTHENTICATION &&
security < BT_ATT_SECURITY_MEDIUM)
security = BT_ATT_SECURITY_MEDIUM;
att->pending_req = NULL;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (op->timeout_id) {
timeout_remove(op->timeout_id);
op->timeout_id = 0;
return att->crypto ? true : false;
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
bool bt_att_set_remote_addr(struct bt_att *att,
const bdaddr_t *bdaddr, uint8_t bdaddr_type)
{
#include <stdint.h>
#include "src/shared/att-types.h"
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
#include "lib/bluetooth.h"
#endif
bool bt_att_set_remote_key(struct bt_att *att, uint8_t sign_key[16],
bt_att_counter_func_t func, void *user_data);
bool bt_att_has_crypto(struct bt_att *att);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
bool bt_att_set_remote_addr(struct bt_att *att,
const bdaddr_t *bdaddr, uint8_t bdaddr_type);
bool bt_att_get_remote_addr(struct bt_att *att,
#include <config.h>
#endif
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
#include <stdio.h>
#endif
#include <endian.h>
bool aborted;
bool pklg_format;
bool pklg_v2;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
char *path;
int16_t rotate_count;
ssize_t file_size;
return NULL;
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
struct btsnoop *btsnoop_create(const char *path, uint32_t format,
int16_t rotate_count, ssize_t file_size)
#else
return NULL;
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (rotate_count > 0 && file_size > 0) {
btsnoop->path = strdup(path);
btsnoop->rotate_count = rotate_count;
return btsnoop_ref(btsnoop);
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static int btsnoop_create_2(struct btsnoop *btsnoop)
{
struct btsnoop_hdr hdr;
if (__sync_sub_and_fetch(&btsnoop->ref_count, 1))
return;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (btsnoop->path)
free(btsnoop->path);
#endif
pkt.drops = htobe32(0);
pkt.ts = htobe64(ts + 0x00E03AB44A676000ll);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if ((btsnoop->rotate_count > 0 && btsnoop->file_size > 0) &&
lseek(btsnoop->fd, 0x00, SEEK_CUR) +
BTSNOOP_PKT_SIZE + size > btsnoop->file_size) {
struct btsnoop;
struct btsnoop *btsnoop_open(const char *path, unsigned long flags);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
struct btsnoop *btsnoop_create(const char *path, uint32_t format,
int16_t rotate_count, ssize_t file_size);
#else
return -1;
/* FIXME: This should use accept4() with SOCK_CLOEXEC */
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
return accept(fd, NULL, NULL);
#else
return accept(fd, NULL, 0);
#include "src/shared/queue.h"
#include "src/shared/gatt-db.h"
#include "src/shared/gatt-client.h"
-#if defined __TIZEN_PATCH__ && defined BLUEZ5_27_GATT_CLIENT
+#if defined TIZEN_FEATURE_BLUEZ_MODIFY
#include "../log.h"
#endif
struct bt_gatt_request *discovery_req;
unsigned int mtu_req_id;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
char *device_name;
struct queue *pending_noti;
bool svc_changed_failed;
void (*destroy)(void *);
};
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
struct noti {
uint8_t opcode;
void *pdu;
{
/* Reset remaining range */
if (success) {
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
util_debug(op->client->debug_callback, op->client->debug_data,
"op->start : %u, op->end : %u, op->last : %u",
op->start, op->end, op->last);
UINT16_MAX);
#endif
} else {
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
util_debug(op->client->debug_callback, op->client->debug_data,
"Fail to discover service. Clear DB [%d]", err);
#endif
op->failure_func = failure_func;
op->start = start;
op->end = end;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
op->last = start;
#endif
discovery_op_complete(op, success, att_ecode);
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static void read_name_cb(bool success, uint8_t att_ecode, const uint8_t *value,
uint16_t length, void *user_data)
{
chrc_data->properties = properties;
chrc_data->uuid = uuid;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (!strcmp(uuid_str, "00002a00-0000-1000-8000-00805f9b34fb")) {
if (!bt_gatt_client_read_value(client, chrc_data->value_handle,
read_name_cb, client, NULL)) {
start, end, uuid_str);
/* Store the service */
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (client->in_svc_chngd) {
util_debug(client->debug_callback, client->debug_data,
"In service changed, delete service first.");
"Primary service discovery failed."
" ATT ECODE: 0x%02x", att_ecode);
/* Reset error in case of not found */
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (att_ecode == BT_ATT_ERROR_ATTRIBUTE_NOT_FOUND) {
#else
if (BT_ATT_ERROR_ATTRIBUTE_NOT_FOUND) {
"start: 0x%04x, end: 0x%04x, uuid: %s",
start, end, uuid_str);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (client->in_svc_chngd) {
util_debug(client->debug_callback, client->debug_data,
"In service changed, delete service first.");
bt_att_get_mtu(client->att));
discover:
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
op->success = false;
#endif
client->discovery_req = bt_gatt_discover_all_primary_services(
uint16_t end_handle;
};
-#if defined __TIZEN_PATCH__ && defined BLUEZ5_27_GATT_CLIENT
+#if defined TIZEN_FEATURE_BLUEZ_MODIFY
bool bt_gatt_discover_services(struct bt_gatt_client *client)
{
struct discovery_op *op;
done:
notify_client_ready(client, success, att_ecode);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (success) {
struct noti *noti;
"Failed to discover services within changed range - "
"error: 0x%02x", att_ecode);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
client->svc_changed_failed = true;
#endif
gatt_db_clear_range(client->db, start_handle, end_handle);
{
struct bt_gatt_client *client = op->client;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
util_debug(client->debug_callback, client->debug_data,
"Failed to discover services");
#endif
uint16_t start, end;
if (length != 4) {
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
util_debug(client->debug_callback, client->debug_data,
"Service changed is received with invalid length : %d",
length);
done:
notify_client_ready(client, success, att_ecode);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (success) {
struct noti *noti;
{
struct bt_gatt_client *client = op->client;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
util_debug(client->debug_callback, client->debug_data,
"GATT client init is failed");
#endif
if (notify_data->att_id) {
bt_att_cancel(notify_data->client->att, notify_data->att_id);
notify_data->att_id = 0;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
notify_data->chrc->ccc_write_id = 0;
__sync_sub_and_fetch(¬ify_data->chrc->notify_count, 1);
#endif
struct bt_gatt_client *client = user_data;
struct pdu_data pdu_data;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (client->ready == false) {
struct noti *noti;
bt_att_unref(client->att);
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (client->in_svc_chngd || client->svc_changed_failed) {
util_debug(client->debug_callback, client->debug_data,
"Service changed is going. Clear DB");
queue_destroy(client->notify_chrcs, notify_chrc_free);
queue_destroy(client->pending_requests, request_unref);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (client->device_name) {
free(client->device_name);
client->device_name = NULL;
client->notify_list = queue_new();
client->notify_chrcs = queue_new();
client->pending_requests = queue_new();
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
client->pending_noti = queue_new();
#endif
return req->id;
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
struct write_cmd_op {
struct bt_gatt_client *client;
bt_gatt_client_callback_t callback;
if (!client || !client->db || !chrc_value_handle || !callback)
return 0;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (client->in_svc_chngd)
util_debug(client->debug_callback, client->debug_data,
"register_notify in service changed handling");
return bt_att_get_security(client->att);
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
char *bt_gatt_client_get_gap_device_name(struct bt_gatt_client *client)
{
if (!client)
void *user_data,
bt_gatt_client_destroy_func_t destroy);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
unsigned int bt_gatt_client_write_without_response_async(
struct bt_gatt_client *client,
uint16_t value_handle,
bool bt_gatt_client_set_security(struct bt_gatt_client *client, int level);
int bt_gatt_client_get_security(struct bt_gatt_client *client);
-#if defined __TIZEN_PATCH__ && defined BLUEZ5_27_GATT_CLIENT
+#if defined TIZEN_FEATURE_BLUEZ_MODIFY
bool bt_gatt_discover_services(struct bt_gatt_client *client);
#endif
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
char *bt_gatt_client_get_gap_device_name(struct bt_gatt_client *client);
bool bt_gatt_request_att_mtu(struct bt_gatt_client *client, uint16_t mtu,
void *callback, void *user_data);
uint32_t permissions;
uint16_t value_len;
uint8_t *value;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
bool notify_indicate;
bdaddr_t unicast_addr;
#endif
service->attributes[i] = new_attribute(service, handle, uuid, NULL, 0);
if (!service->attributes[i]) {
free(service->attributes[i - 1]);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
service->attributes[i - 1] = NULL;
#endif
return NULL;
return true;
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
void set_ccc_notify_indicate(struct gatt_db_attribute *ccc,
bool enable)
{
bool gatt_db_attribute_reset(struct gatt_db_attribute *attrib);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
void set_ccc_notify_indicate(struct gatt_db_attribute *ccc,
bool enable);
int iter = 0;
uint16_t start_handle, end_handle;
struct iovec value;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
uint8_t data_val_len = 0;
#else
uint8_t data_val_len;
uint16_t handle;
struct gatt_db_attribute *attr;
const bt_uuid_t *type;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
int uuid_len = 0, cur_uuid_len;
#else
int uuid_len, cur_uuid_len;
goto error;
if (server->pending_write_op) {
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (opcode != BT_ATT_OP_WRITE_CMD) {
#endif
ecode = BT_ATT_ERROR_UNLIKELY;
goto error;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
}
#endif
}
op->server = server;
op->opcode = opcode;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
if (opcode != BT_ATT_OP_WRITE_CMD)
server->pending_write_op = op;
#else
ecode = BT_ATT_ERROR_UNLIKELY;
error:
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
util_debug(server->debug_callback, server->debug_data,
"Handling \"Write %s\" is failed : %d",
(opcode == BT_ATT_OP_WRITE_REQ) ? "Req" : "Cmd",
ecode = BT_ATT_ERROR_UNLIKELY;
error:
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
util_debug(server->debug_callback, server->debug_data,
"Handling \"Read %sReq\" is failed : %d",
(opcode == BT_ATT_OP_READ_BLOB_REQ) ? "Blob" : "",
return 0;
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
int write_device_characteristics(const bdaddr_t *sba, const bdaddr_t *dba,
uint8_t bdaddr_type, uint16_t handle,
const char *chars)
int read_pairable_timeout(const char *src, int *timeout);
int read_on_mode(const char *src, char *mode, int length);
int read_local_name(const bdaddr_t *bdaddr, char *name);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
int write_device_characteristics(const bdaddr_t *sba, const bdaddr_t *dba,
uint8_t bdaddr_type, uint16_t handle,
const char *chars);
sk = g_io_channel_unix_get_fd(chan);
/* Reading BNEP_SETUP_CONNECTION_REQUEST_MSG */
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
n = recv(sk, packet, sizeof(packet), MSG_PEEK);
#else
n = read(sk, packet, sizeof(packet));
struct client *cli = user_data;
if (!success) {
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
PRLOG("GATT discovery procedures failed - error code: 0x%02x\n",
att_ecode);
#else
int i;
if (!success) {
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
PRLOG("\nRead multiple request failed: 0x%02x\n", att_ecode);
#else
PRLOG("\nRead multiple request failed: %s (0x%02x)\n",
static void register_notify_cb(uint16_t att_ecode, void *user_data)
{
if (att_ecode) {
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
PRLOG("Failed to register notify handler "
"- error code: 0x%02x\n", att_ecode);
#else
#include <stdint.h>
#include <stdbool.h>
#include <string.h>
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
#include <time.h>
#include <sys/time.h>
#endif
for (i = 0; i < num_input; i++)
close(input_fd[i]);
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
#define BT_SNOOP_TYPE_HCI_PREFIX "btsnoop_type_hci"
static void command_split(const char *input)
printf("commands:\n"
"\t-m, --merge <output> Merge multiple btsnoop files\n"
"\t-e, --extract <input> Extract data from btsnoop file\n"
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
"\t-s, --split <input> Split btmon file into legacy btsnoop file(s)\n"
#endif
"\t-h, --help Show help options\n");
{ "merge", required_argument, NULL, 'm' },
{ "extract", required_argument, NULL, 'e' },
{ "type", required_argument, NULL, 't' },
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
{ "split", required_argument, NULL, 's' },
#endif
{ "version", no_argument, NULL, 'v' },
{ }
};
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
enum { INVALID, MERGE, EXTRACT, SPLIT };
#else
enum { INVALID, MERGE, EXTRACT };
for (;;) {
int opt;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
opt = getopt_long(argc, argv, "m:e:s:t:vh", main_options, NULL);
#else
opt = getopt_long(argc, argv, "m:e:t:vh", main_options, NULL);
command = EXTRACT;
input_path = optarg;
break;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
case 's':
command = SPLIT;
input_path = optarg;
fprintf(stderr, "extract type not supported\n");
break;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
case SPLIT:
if (argc - optind > 0) {
fprintf(stderr, "extra arguments not allowed\n");
#include <config.h>
#endif
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
#define _GNU_SOURCE
#endif
#include <stdio.h>
int (*init) (int fd, struct uart_t *u, struct termios *ti);
int (*post) (int fd, struct uart_t *u, struct termios *ti);
-/* __TIZEN_PATCH__ */
-#if defined __TIZEN_PATCH__ && defined __TI_PATCH__
+/* TIZEN_FEATURE_BLUEZ_MODIFY */
+#if defined TIZEN_FEATURE_BLUEZ_MODIFY && defined __TI_PATCH__
uint16_t device_param;
#endif
};
-#if defined __TIZEN_PATCH__ && defined __TI_PATCH__
+#if defined TIZEN_FEATURE_BLUEZ_MODIFY && defined __TI_PATCH__
int firmware_path = 0;
#endif
-#ifdef __TIZEN_PATCH__
-#if defined(__TI_PATCH__) || defined(__BROADCOM_PATCH__)
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
+#if defined(__TI_PATCH__) || defined(TIZEN_FEATURE_BLUEZ_BRCM_CHIP)
#define TIOSETBRFPOWER 0x6000
#define BRF_DEEP_SLEEP_OPCODE_BYTE_1 0x0c
#define BRF_DEEP_SLEEP_OPCODE_BYTE_2 0xfd
memset(cmd, 0, sizeof(cmd));
memset(resp, 0, sizeof(resp));
-/* __TIZEN_PATCH__ */
-#if defined(__TIZEN_PATCH__) && !defined(__BROADCOM_PATCH__)
+/* TIZEN_FEATURE_BLUEZ_MODIFY */
+#if defined(TIZEN_FEATURE_BLUEZ_MODIFY) && !defined(TIZEN_FEATURE_BLUEZ_BRCM_CHIP)
cmd[0] = HCI_COMMAND_PKT;
cmd[1] = 0x18;
cmd[2] = 0xfc;
return 0;
}
-#ifdef __TIZEN_PATCH__ /*SPRD add Start*/
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY /*SPRD add Start*/
static int init_sprd_config(int fd, struct uart_t *u, struct termios *ti)
{
struct uart_t uart[] = {
{ "any", 0x0000, 0x0000, HCI_UART_H4, 115200, 115200,
FLOW_CTL, DISABLE_PM, NULL, NULL },
-#ifdef __TIZEN_PATCH__ /*SPRD*/
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY /*SPRD*/
{ "sprd", 0x0000, 0x0000, HCI_UART_H4, 3000000, 3000000,
FLOW_CTL, DISABLE_PM, NULL, init_sprd_config },
#endif
{ "swave", 0x0000, 0x0000, HCI_UART_H4, 115200, 115200,
FLOW_CTL, DISABLE_PM, NULL, swave },
-/* __TIZEN_PATCH__ */
-#if defined __TIZEN_PATCH__ && defined __TI_PATCH__
+/* TIZEN_FEATURE_BLUEZ_MODIFY */
+#if defined TIZEN_FEATURE_BLUEZ_MODIFY && defined __TI_PATCH__
/* Texas Instruments BRF63xx modules */
{ "texas", 0x0000, 0x0000, HCI_UART_LL, 115200,3000000, FLOW_CTL, NULL, texas, NULL/*texas_continue_script*/, BRF_DEEP_SLEEP_OPCODE},
#else
return NULL;
}
-#if defined __TIZEN_PATCH__ && defined __BROADCOM_PATCH__
+#if defined TIZEN_FEATURE_BLUEZ_MODIFY && defined TIZEN_FEATURE_BLUEZ_BRCM_CHIP
static int enable_hci(char *dev, struct uart_t *u)
{
int fd, i;
return fd;
}
-#else /* __BROADCOM_PATCH__ */
+#else /* TIZEN_FEATURE_BLUEZ_BRCM_CHIP */
/* Initialize UART driver */
static int init_uart(char *dev, struct uart_t *u, int send_break, int raw)
int fd, i;
unsigned long flags = 0;
-/* __TIZEN_PATCH__ */
-#ifdef __TIZEN_PATCH__
-#if defined(__TI_PATCH__) || defined(__BROADCOM_PATCH__)
+/* TIZEN_FEATURE_BLUEZ_MODIFY */
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
+#if defined(__TI_PATCH__) || defined(TIZEN_FEATURE_BLUEZ_BRCM_CHIP)
int power;
#endif
#endif
cfmakeraw(&ti);
-/* __TIZEN_PATCH__ */
-#if defined(__TIZEN_PATCH__) && !defined(__BROADCOM_PATCH__)
+/* TIZEN_FEATURE_BLUEZ_MODIFY */
+#if defined(TIZEN_FEATURE_BLUEZ_MODIFY) && !defined(TIZEN_FEATURE_BLUEZ_BRCM_CHIP)
ti.c_cflag |= CLOCAL;
if (u->flags & FLOW_CTL)
ti.c_cflag |= CRTSCTS;
usleep(500000);
}
-/* __TIZEN_PATCH__ */
-#ifdef __TIZEN_PATCH__
-#if defined(__TI_PATCH__) || defined(__BROADCOM_PATCH__)
+/* TIZEN_FEATURE_BLUEZ_MODIFY */
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
+#if defined(__TI_PATCH__) || defined(TIZEN_FEATURE_BLUEZ_BRCM_CHIP)
/* Power up the BRF chip */
power = 1;
ioctl(fd, TIOSETBRFPOWER, &power);
goto fail;
}
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
if (u->post && u->post(fd, u, &ti) < 0)
goto fail;
#endif
return -1;
}
-#endif /* __BROADCOM_PATCH__ */
+#endif /* TIZEN_FEATURE_BLUEZ_BRCM_CHIP */
static void usage(void)
{
printf("hciattach - HCI UART driver initialization utility\n");
printf("Usage:\n");
-/* __TIZEN_PATCH__ */
-#if defined(__TIZEN_PATCH__) && !defined(__TI_PATCH__)\r
+/* TIZEN_FEATURE_BLUEZ_MODIFY */
+#if defined(TIZEN_FEATURE_BLUEZ_MODIFY) && !defined(__TI_PATCH__)
/* This commented code was present before bluez 5.25 upgrade
* printf("\thciattach [-n] [-p] [-b] [-g device_param] [-r] [-f] [-t timeout] [-s initial_speed] <tty> <type | id> [speed] [flow|noflow] [bdaddr]\n");*/
printf("\thciattach [-n] [-p] [-b] [-g device_param] [-r] [-f]"
int main(int argc, char *argv[])
{
struct uart_t *u = NULL;
-#if defined(__TIZEN_PATCH__) && !defined(__BROADCOM_PATCH__)
+#if defined(TIZEN_FEATURE_BLUEZ_MODIFY) && !defined(TIZEN_FEATURE_BLUEZ_BRCM_CHIP)
int detach, printpid, raw, opt, i, n, ld, err;
#else
int detach, printpid, opt, i, n, ld, err;
#endif
int to = 10;
int init_speed = 0;
-#if defined(__TIZEN_PATCH__) && !defined(__BROADCOM_PATCH__)
+#if defined(TIZEN_FEATURE_BLUEZ_MODIFY) && !defined(TIZEN_FEATURE_BLUEZ_BRCM_CHIP)
int send_break = 0;
#endif
pid_t pid;
sigset_t sigs;
char dev[PATH_MAX];
-#ifdef __TIZEN_PATCH__
-/* __TIZEN_PATCH__ */
-#if defined(__TI_PATCH__) || defined(__BROADCOM_PATCH__)
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
+/* TIZEN_FEATURE_BLUEZ_MODIFY */
+#if defined(__TI_PATCH__) || defined(TIZEN_FEATURE_BLUEZ_BRCM_CHIP)
int power;
#endif
#endif
#endif
detach = 1;
printpid = 0;
-#if defined(__TIZEN_PATCH__) && !defined(__BROADCOM_PATCH__)
+#if defined(TIZEN_FEATURE_BLUEZ_MODIFY) && !defined(TIZEN_FEATURE_BLUEZ_BRCM_CHIP)
raw = 0;
#endif
-#if defined(__TIZEN_PATCH__) && !defined(__TI_PATCH__)
+#if defined(TIZEN_FEATURE_BLUEZ_MODIFY) && !defined(__TI_PATCH__)
while ((opt=getopt(argc, argv, "bnprft:g:s:l")) != EOF) {
#else
while ((opt=getopt(argc, argv, "bnpt:s:lr")) != EOF) {
#endif
switch(opt) {
case 'b':
-#if defined(__TIZEN_PATCH__) && !defined(__BROADCOM_PATCH__)
+#if defined(TIZEN_FEATURE_BLUEZ_MODIFY) && !defined(TIZEN_FEATURE_BLUEZ_BRCM_CHIP)
send_break = 1;
#endif
break;
to = atoi(optarg);
break;
-/* __TIZEN_PATCH__ */
-#if defined(__TIZEN_PATCH__) && defined(__TI_PATCH__)
+/* TIZEN_FEATURE_BLUEZ_MODIFY */
+#if defined(TIZEN_FEATURE_BLUEZ_MODIFY) && defined(__TI_PATCH__)
case 'g':
device_param = (uint16_t)strtol(optarg, NULL, 16);
break;
exit(0);
case 'r':
-#if defined(__TIZEN_PATCH__) && !defined(__BROADCOM_PATCH__)
+#if defined(TIZEN_FEATURE_BLUEZ_MODIFY) && !defined(TIZEN_FEATURE_BLUEZ_BRCM_CHIP)
raw = 1;
#endif
break;
}
n = argc - optind;
-/* __TIZEN_PATCH__ */
-#if defined(__TIZEN_PATCH__) && defined(__TI_PATCH__)
+/* TIZEN_FEATURE_BLUEZ_MODIFY */
+#if defined(TIZEN_FEATURE_BLUEZ_MODIFY) && defined(__TI_PATCH__)
if (!reset_device || (reset_device && n < 1))
#endif
if (n < 2) {
break;
}
}
-/* __TIZEN_PATCH__ */
-#if defined(__TIZEN_PATCH__) && defined(__TI_PATCH__)
+/* TIZEN_FEATURE_BLUEZ_MODIFY */
+#if defined(TIZEN_FEATURE_BLUEZ_MODIFY) && defined(__TI_PATCH__)
if (reset_device)
{
// Reset row device
exit(1);
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
// __hci_attach_log_init();
#endif
the hardware's default */
if (init_speed)
u->init_speed = init_speed;
-#if defined(__TIZEN_PATCH__) && defined(__TI_PATCH__)
+#if defined(TIZEN_FEATURE_BLUEZ_MODIFY) && defined(__TI_PATCH__)
/* If user specified a device parameter, use that instead of
the hardware's default */
if (device_param)
/* 10 seconds should be enough for initialization */
alarm(to);
bcsp_max_retries = to;
-#if defined __TIZEN_PATCH__ && defined __BROADCOM_PATCH__
+#if defined TIZEN_FEATURE_BLUEZ_MODIFY && defined TIZEN_FEATURE_BLUEZ_BRCM_CHIP
n = enable_hci(dev, u);
#else
n = init_uart(dev, u, send_break, raw);
exit(1);
}
-/* __TIZEN_PATCH__ */
-#ifdef __TIZEN_PATCH__
-#if defined(__TI_PATCH__) || defined(__BROADCOM_PATCH__)
+/* TIZEN_FEATURE_BLUEZ_MODIFY */
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
+#if defined(__TI_PATCH__) || defined(TIZEN_FEATURE_BLUEZ_BRCM_CHIP)
/* Power down the BRF or BCMchip */
power = 0;
ioctl(n, TIOSETBRFPOWER, &power);
int bgb2xx_init(int dd, bdaddr_t *bdaddr);
int ath3k_init(int fd, int speed, int init_speed, char *bdaddr,
struct termios *ti);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
int sprd_config_init(int fd, char *bdaddr, struct termios *ti);
#endif
int ath3k_post(int fd, int pm);
#include "hciattach.h"
#ifndef FIRMWARE_DIR
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
#define FIRMWARE_DIR "/usr/etc/bluetooth"
#else
#define FIRMWARE_DIR "/etc/firmware"
#define TI_MANUFACTURER_ID 13
-/* __TIZEN_PATCH__ */
+/* TIZEN_FEATURE_BLUEZ_MODIFY */
#ifdef __TI_PATCH__
#define FIRMWARE_DIRECTORY1 "/mnt/mmc/"
#define FIRMWARE_DIRECTORY2 "/usr/etc/bluetooth/"
if (version & 0x8000)
maj_ver |= 0x0008;
-/* __TIZEN_PATCH__ */
+/* TIZEN_FEATURE_BLUEZ_MODIFY */
#ifdef __TI_PATCH__
FILE *fp;
sprintf(firmware_file_name, FIRMWARE_DIRECTORY1 "TIInit_%d.%d.%d.bts", chip, maj_ver, min_ver);
static void print_link_policy(struct hci_dev_info *di)
{
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
char *str;
str = hci_lptostr(di->link_policy);
printf("\tLink policy: %s\n", str);
hci_close_dev(dd);
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
/* Send arbitrary ACL data */
static struct option data_options[] = {
{ "help", 0, 0, 'h' },
{ "spinq", cmd_spinq, "Start periodic inquiry" },
{ "epinq", cmd_epinq, "Exit periodic inquiry" },
{ "cmd", cmd_cmd, "Submit arbitrary HCI commands" },
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
{ "acl", cmd_data, "Submit arbitrary ACL data" },
#endif
{ "con", cmd_con, "Display active connections" },
LSENDRECV,
CSENDRECV,
INFOREQ,
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
CONFIGREQ,
#endif
PAIRING,
};
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
#define L2CAP_DEFAULT_RETRANS_TO 2000 /* 2 seconds */
#define L2CAP_DEFAULT_MONITOR_TO 12000 /* 12 seconds */
#endif
static bdaddr_t bdaddr;
static unsigned short psm = 0;
static unsigned short cid = 0;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static uint16_t dcid = 0x0000;
#endif
}
}
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
static void l2cap_add_conf_opt(void **ptr, uint8_t type, uint8_t len, unsigned long val)
{
l2cap_conf_opt *opt = *ptr;
unsigned char buf[48];
l2cap_cmd_hdr *cmd = (l2cap_cmd_hdr *) buf;
uint8_t *req_buf = (uint8_t *) (buf + L2CAP_CMD_HDR_SIZE);
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
uint16_t mtu;
uint32_t channels, mask = 0x0000;
#endif
struct sockaddr_l2 addr;
-#ifndef __TIZEN_PATCH__
+#ifndef TIZEN_FEATURE_BLUEZ_MODIFY
int sk, err;
#else
int sk;
"\t-c connect, disconnect, connect, ...\n"
"\t-m multiple connects\n"
"\t-p trigger dedicated bonding\n"
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
"\t-o configuration request\n"
#endif
"\t-z information request\n");
"\t[-M] become master\n"
"\t[-T] enable timestamps\n"
"\t[-V type] address type (help for list, default = bredr)\n"
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
"\t[-f DCID] destination CID\n"
#endif
"\t[-e seq] initial sequence value (default = 0)\n");
bacpy(&bdaddr, BDADDR_ANY);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
while ((opt = getopt(argc, argv, "a:b:cde:f:g:i:mnopqrstuwxyz"
"AB:C:D:EF:GH:I:J:K:L:MN:O:P:Q:RSTUV:W:X:Y:Z:")) != EOF) {
#else
need_addr = 1;
break;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
case 'o':
mode = CONFIGREQ;
need_addr = 1;
break;
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
case 'f':
dcid = atoi(optarg);
printf("dcid %d", dcid);
info_request(argv[optind]);
exit(0);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
case CONFIGREQ:
config_request(argv[optind]);
exit(0);
} __attribute__ ((packed)) l2cap_conf_opt;
#define L2CAP_CONF_OPT_SIZE 2
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
typedef struct {
uint8_t mode;
uint8_t txwin_size;
sdp_set_service_classes(&record, svclass_id);
sdp_uuid16_create(&profile.uuid, SERIAL_PORT_PROFILE_ID);
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
profile.version = 0x0102;
#else
profile.version = 0x0100;
static void run_command(char *cmdname, char *home)
{
-#ifdef __TIZEN_PATCH__
+#ifdef TIZEN_FEATURE_BLUEZ_MODIFY
char *argv[10], *envp[3];
#else
char *argv[9], *envp[3];
projects / platform / upstream / bluez.git / commitdiff