Remove obsolete system/tools (d88a9777) · Commits · e / os / android_packages_modules_Bluetooth

system/tools/Android.mk.disabled

deleted100644 → 0

+0 −1

Original line number	Diff line number	Diff line
		include $(call all-subdir-makefiles)

system/tools/bdtool/Android.mk.disabled

deleted100644 → 0

+0 −48

Original line number	Diff line number	Diff line
		#
		# Copyright 2014 The Android Open Source Project
		#
		# Licensed under the Apache License, Version 2.0 (the "License");
		# you may not use this file except in compliance with the License.
		# You may obtain a copy of the License at
		#
		# http://www.apache.org/licenses/LICENSE-2.0
		#
		# Unless required by applicable law or agreed to in writing, software
		# distributed under the License is distributed on an "AS IS" BASIS,
		# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		# See the License for the specific language governing permissions and
		# limitations under the License.
		#

		LOCAL_PATH := $(call my-dir)

		# Bluetooth tools for target
		include $(CLEAR_VARS)

		LOCAL_MODULE_TAGS := optional
		LOCAL_MODULE := net_bdtool

		LOCAL_SRC_FILES := \
		adapter.c \
		bdtool.c \
		../../test/suite/support/callbacks.c \
		../../test/suite/support/gatt.c \
		../../test/suite/support/hal.c \
		../../test/suite/support/pan.c

		LOCAL_STATIC_LIBRARIES := \
		libbtcore \
		libosi

		LOCAL_C_INCLUDES := \
		$(LOCAL_PATH)/../../test/suite \
		$(LOCAL_PATH)/../..

		LOCAL_SHARED_LIBRARIES := \
		libhardware liblog

		LOCAL_CFLAGS += $(bluetooth_CFLAGS)
		LOCAL_CONLYFLAGS += $(bluetooth_CONLYFLAGS)
		LOCAL_CPPFLAGS += $(bluetooth_CPPFLAGS)

		include $(BUILD_EXECUTABLE)

system/tools/bdtool/adapter.c

deleted100644 → 0

+0 −276

Original line number	Diff line number	Diff line
		/******************************************************************************
		*
		* Copyright 2014 Google, Inc.
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at:
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*
		******************************************************************************/

		#include "support/adapter.h"

		#include "base.h"
		#include "btcore/include/property.h"
		#include "support/callbacks.h"
		#include "types/bluetooth/uuid.h"
		#include "types/raw_address.h"

		static bt_state_t state;
		static int property_count = 0;
		static bt_property_t* properties = NULL;
		static bt_discovery_state_t discovery_state;
		static bt_acl_state_t acl_state;
		static bt_bond_state_t bond_state;

		static void parse_properties(int num_properties, bt_property_t* property);

		// Returns the current adapter state.
		bt_state_t adapter_get_state() { return state; }

		// Returns the number of adapter properties.
		int adapter_get_property_count() { return property_count; }

		// Returns the specified property.
		bt_property_t* adapter_get_property(bt_property_type_t type) {
		for (int i = 0; i < property_count; ++i) {
		if (properties[i].type == type) {
		return &properties[i];
		}
		}

		return NULL;
		}

		// Returns the device discovery state.
		bt_discovery_state_t adapter_get_discovery_state() { return discovery_state; }

		// Returns the device acl state.
		bt_acl_state_t adapter_get_acl_state() { return acl_state; }

		// Returns the device bond state.
		bt_bond_state_t adapter_get_bond_state() { return bond_state; }

		// callback
		void acl_state_changed(bt_status_t status, RawAddress* remote_bd_addr,
		bt_acl_state_t state) {
		acl_state = state;
		CALLBACK_RET();
		}

		// callback
		void adapter_properties(bt_status_t status, int num_properties,
		bt_property_t* new_properties) {
		property_free_array(properties, property_count);
		properties = property_copy_array(new_properties, num_properties);
		property_count = num_properties;

		CALLBACK_RET();
		}

		// callback
		void adapter_state_changed(bt_state_t new_state) {
		state = new_state;
		CALLBACK_RET();
		}

		// callback
		void bond_state_changed(bt_status_t status, RawAddress* bdaddr,
		bt_bond_state_t state) {
		char buf[18];
		bond_state = state;

		const char* state_name = "Bond state unknown";
		switch (bond_state) {
		case BT_BOND_STATE_NONE:
		state_name = "Bond state none";
		break;

		case BT_BOND_STATE_BONDING:
		state_name = "Bond state bonding";
		break;

		case BT_BOND_STATE_BONDED:
		state_name = "Bond state bonded";
		break;

		// default none
		}
		fprintf(stdout, "Bond state changed callback addr:%s state:%s\n",
		bdaddr_to_string(bdaddr, buf, sizeof(buf)), state_name);

		CALLBACK_RET();
		}

		// callback
		void device_found(int num_properties, bt_property_t* property) {
		fprintf(stdout, "Device found num_properties:%d\n", num_properties);
		parse_properties(num_properties, property);

		CALLBACK_RET();
		}

		// callback
		void discovery_state_changed(bt_discovery_state_t state) {
		const char* state_name = "Unknown";
		discovery_state = state;

		switch (discovery_state) {
		case BT_DISCOVERY_STOPPED:
		state_name = "Discovery stopped";
		break;

		case BT_DISCOVERY_STARTED:
		state_name = "Discovery started";
		break;

		// default omitted
		}
		fprintf(stdout, "Discover state %s\n", state_name);

		CALLBACK_RET();
		}

		// callback
		void remote_device_properties(bt_status_t status, RawAddress* bdaddr,
		int num_properties, bt_property_t* properties) {
		char buf[18];
		fprintf(stdout, "Device found bdaddr:%s num_properties:%d\n",
		bdaddr_to_string(bdaddr, buf, sizeof(buf)), num_properties);

		parse_properties(num_properties, properties);

		CALLBACK_RET();
		}

		// callback
		void ssp_request(RawAddress* remote_bd_addr, bt_bdname_t* bd_name, uint32_t cod,
		bt_ssp_variant_t pairing_variant, uint32_t pass_key) {
		char* pairing_variant_name = "Unknown";

		switch (pairing_variant) {
		case BT_SSP_VARIANT_PASSKEY_CONFIRMATION:
		pairing_variant_name = "Passkey confirmation";
		break;
		case BT_SSP_VARIANT_PASSKEY_ENTRY:
		pairing_variant_name = "Passkey entry";
		break;

		case BT_SSP_VARIANT_CONSENT:
		pairing_variant_name = "Passkey consent";
		break;

		case BT_SSP_VARIANT_PASSKEY_NOTIFICATION:
		pairing_variant_name = "Passkey notification";
		break;
		}

		fprintf(stdout,
		"Got ssp request device_class:%u passkey:%x pairing_variant:%s\n",
		cod, pass_key, pairing_variant_name);
		char buf[18];
		fprintf(stdout, "Device found:%s %s\n",
		bdaddr_to_string(remote_bd_addr, buf, sizeof(buf)), bd_name->name);

		fprintf(stdout, "auto-accepting bond\n");
		bool accept = true;
		int rc = bt_interface->ssp_reply(remote_bd_addr, pairing_variant,
		(uint8_t)accept, pass_key);
		CALLBACK_RET();
		}

		// callback
		void thread_evt(bt_cb_thread_evt evt) { CALLBACK_RET(); }

		static void parse_properties(int num_properties, bt_property_t* property) {
		while (num_properties-- > 0) {
		switch (property->type) {
		case BT_PROPERTY_BDNAME: {
		const bt_bdname_t* name = property_as_name(property);
		if (name) fprintf(stdout, " name:%s\n", name->name);
		} break;

		case BT_PROPERTY_BDADDR: {
		char buf[18];
		const RawAddress* addr = property_as_addr(property);
		if (addr)
		fprintf(stdout, " addr:%s\n",
		bdaddr_to_string(addr, buf, sizeof(buf)));
		} break;

		case BT_PROPERTY_UUIDS: {
		size_t num_uuid;
		const Uuid* uuid = property_as_uuids(property, &num_uuid);
		if (uuid) {
		for (size_t i = 0; i < num_uuid; i++) {
		fprintf(stdout, " uuid:%zd: ", i);
		for (size_t j = 0; j < sizeof(uuid); j++) {
		fprintf(stdout, "%02x", uuid->uu[j]);
		}
		fprintf(stdout, "\n");
		}
		}
		} break;

		case BT_PROPERTY_TYPE_OF_DEVICE: {
		bt_device_type_t device_type = property_as_device_type(property);
		if (device_type) {
		const struct {
		const char* device_type;
		} device_type_lookup[] = {
		{"Unknown"},
		{"Classic Only"},
		{"BLE Only"},
		{"Both Classic and BLE"},
		};
		int idx = (int)device_type;
		if (idx > BT_DEVICE_DEVTYPE_DUAL) idx = 0;
		fprintf(stdout, " device_type:%s\n",
		device_type_lookup[idx].device_type);
		}
		} break;

		case BT_PROPERTY_CLASS_OF_DEVICE: {
		const bt_device_class_t* dc = property_as_device_class(property);
		int dc_int = device_class_to_int(dc);
		fprintf(stdout, " device_class:0x%x\n", dc_int);
		} break;

		case BT_PROPERTY_REMOTE_RSSI: {
		int8_t rssi = property_as_rssi(property);
		fprintf(stdout, " rssi:%d\n", rssi);
		} break;

		case BT_PROPERTY_REMOTE_FRIENDLY_NAME: {
		const bt_bdname_t* name = property_as_name(property);
		if (name) fprintf(stdout, " remote_name:%s\n", name->name);
		} break;

		case BT_PROPERTY_SERVICE_RECORD:
		case BT_PROPERTY_ADAPTER_SCAN_MODE:
		case BT_PROPERTY_ADAPTER_BONDED_DEVICES:
		case BT_PROPERTY_ADAPTER_DISCOVERABLE_TIMEOUT:
		case BT_PROPERTY_REMOTE_VERSION_INFO:
		case BT_PROPERTY_LOCAL_LE_FEATURES:
		case BT_PROPERTY_REMOTE_DEVICE_TIMESTAMP:
		default: {
		fprintf(stderr, "Unhandled property type:%d len:%d\n", property->type,
		property->len);
		uint8_t* p = (uint8_t*)property->val;
		for (int i = 0; i < property->len; ++i, p++) {
		fprintf(stderr, " %02x", *p);
		}
		if (property->len != 0) fprintf(stderr, "\n");
		}
		}
		property++;
		}
		}

system/tools/bdtool/bdtool.c

deleted100644 → 0

+0 −362

Original line number	Diff line number	Diff line
		/******************************************************************************
		*
		* Copyright 2014 Google, Inc.
		*
		* Licensed under the Apache License, Version 2.0 (the "License");
		* you may not use this file except in compliance with the License.
		* You may obtain a copy of the License at:
		*
		* http://www.apache.org/licenses/LICENSE-2.0
		*
		* Unless required by applicable law or agreed to in writing, software
		* distributed under the License is distributed on an "AS IS" BASIS,
		* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		* See the License for the specific language governing permissions and
		* limitations under the License.
		*
		******************************************************************************/

		#include <getopt.h>
		#include <signal.h>
		#include <stdlib.h>
		#include <unistd.h>

		#include "btcore/include/property.h"
		#include "osi/include/osi.h"
		#include "test/suite/support/callbacks.h"
		#include "test/suite/support/hal.h"
		#include "types/bluetooth/uuid.h"
		#include "types/raw_address.h"

		static const Uuid HFP_UUID =
		Uuid::From128BitBE({{0x00, 0x00, 0x11, 0x1E, 0x00, 0x00, 0x10, 0x00, 0x80,
		0x00, 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB}});
		static const Uuid HFP_AG_UUID =
		Uuid::From128BitBE({{0x00, 0x00, 0x11, 0x1F, 0x00, 0x00, 0x10, 0x00, 0x80,
		0x00, 0x00, 0x80, 0x5F, 0x9B, 0x34, 0xFB}});

		const bt_interface_t* bt_interface;

		RawAddress bt_remote_bdaddr;

		static int f_verbose;
		static bool discover = false;
		static bool discoverable = false;
		static bool bond = false;
		static bool up = false;
		static bool get_name = false;
		static bool set_name = false;
		static bool sco_listen = false;
		static bool sco_connect = false;

		static int timeout_in_sec = 30;
		static char* bd_name;

		static struct option long_options[] = {
		{"bdaddr", required_argument, 0, 0}, {"discover", no_argument, 0, 0},
		{"discoverable", no_argument, 0, 0}, {"time", required_argument, 0, 0},
		{"bond", no_argument, 0, 0}, {"up", no_argument, 0, 0},
		{"verbose", no_argument, 0, 0}, {"get_name", no_argument, 0, 0},
		{"set_name", required_argument, 0, 0}, {"sco_listen", no_argument, 0, 0},
		{"sco_connect", no_argument, 0, 0}, {0, 0, 0, 0}};

		static void usage(const char* name);
		static bool parse_args(int argc, char** argv);
		static void sig_handler(int signo);

		bt_property_t* adapter_get_property(bt_property_type_t type);

		int main(int argc, char** argv) {
		if (!parse_args(argc, argv)) {
		usage(argv[0]);
		}

		if (bond && discoverable) {
		fprintf(stderr, "Can only select either bond or discoverable, not both\n");
		usage(argv[0]);
		}

		if (sco_listen && sco_connect) {
		fprintf(stderr,
		"Can only select either sco_listen or sco_connect, not both\n");
		usage(argv[0]);
		}

		if (!bond && !discover && !discoverable && !up && !get_name && !set_name &&
		!sco_listen && !sco_connect) {
		fprintf(stderr, "Must specify one command\n");
		usage(argv[0]);
		}

		if (signal(SIGINT, sig_handler) == SIG_ERR) {
		fprintf(stderr, "Will be unable to catch signals\n");
		}

		fprintf(stdout, "Bringing up bluetooth adapter\n");
		if (!hal_open(callbacks_get_adapter_struct())) {
		fprintf(stderr, "Unable to open Bluetooth HAL.\n");
		return 1;
		}

		if (discover) {
		CALL_AND_WAIT(bt_interface->enable(), adapter_state_changed);
		fprintf(stdout, "BT adapter is up\n");

		fprintf(stdout, "Starting to start discovery\n");
		CALL_AND_WAIT(bt_interface->start_discovery(), discovery_state_changed);
		fprintf(stdout, "Started discovery for %d seconds\n", timeout_in_sec);

		sleep(timeout_in_sec);

		fprintf(stdout, "Starting to cancel discovery\n");
		CALL_AND_WAIT(bt_interface->cancel_discovery(), discovery_state_changed);
		fprintf(stdout, "Cancelled discovery after %d seconds\n", timeout_in_sec);
		}

		if (discoverable) {
		CALL_AND_WAIT(bt_interface->enable(), adapter_state_changed);
		fprintf(stdout, "BT adapter is up\n");

		bt_property_t* property =
		property_new_scan_mode(BT_SCAN_MODE_CONNECTABLE_DISCOVERABLE);

		int rc = bt_interface->set_adapter_property(property);
		fprintf(stdout, "Set rc:%d device as discoverable for %d seconds\n", rc,
		timeout_in_sec);

		sleep(timeout_in_sec);

		property_free(property);
		}

		if (bond) {
		if (bdaddr_is_empty(&bt_remote_bdaddr)) {
		fprintf(stderr,
		"Must specify a remote device address [ "
		"--bdaddr=xx:yy:zz:aa:bb:cc ]\n");
		exit(1);
		}

		CALL_AND_WAIT(bt_interface->enable(), adapter_state_changed);
		fprintf(stdout, "BT adapter is up\n");

		int rc = bt_interface->create_bond(
		&bt_remote_bdaddr, 0 /* UNKNOWN; Currently not documented :( */);
		fprintf(stdout, "Started bonding:%d for %d seconds\n", rc, timeout_in_sec);

		sleep(timeout_in_sec);
		}

		if (up) {
		CALL_AND_WAIT(bt_interface->enable(), adapter_state_changed);
		fprintf(stdout, "BT adapter is up\n");

		fprintf(stdout, "Waiting for %d seconds\n", timeout_in_sec);
		sleep(timeout_in_sec);
		}

		if (get_name) {
		CALL_AND_WAIT(bt_interface->enable(), adapter_state_changed);
		fprintf(stdout, "BT adapter is up\n");
		int error;
		CALL_AND_WAIT(
		error = bt_interface->get_adapter_property(BT_PROPERTY_BDNAME),
		adapter_properties);
		if (error != BT_STATUS_SUCCESS) {
		fprintf(stderr, "Unable to get adapter property\n");
		exit(1);
		}
		bt_property_t* property = adapter_get_property(BT_PROPERTY_BDNAME);
		const bt_bdname_t* name = property_as_name(property);
		if (name)
		printf("Queried bluetooth device name:%s\n", name->name);
		else
		printf("No name\n");
		}

		if (set_name) {
		CALL_AND_WAIT(bt_interface->enable(), adapter_state_changed);
		fprintf(stdout, "BT adapter is up\n");

		bt_property_t* property = property_new_name(bd_name);
		printf("Setting bluetooth device name to:%s\n", bd_name);
		int error;
		CALL_AND_WAIT(error = bt_interface->set_adapter_property(property),
		adapter_properties);
		if (error != BT_STATUS_SUCCESS) {
		fprintf(stderr, "Unable to set adapter property\n");
		exit(1);
		}
		CALL_AND_WAIT(
		error = bt_interface->get_adapter_property(BT_PROPERTY_BDNAME),
		adapter_properties);
		if (error != BT_STATUS_SUCCESS) {
		fprintf(stderr, "Unable to get adapter property\n");
		exit(1);
		}
		property_free(property);
		sleep(timeout_in_sec);
		}

		const int app_uid = 0;

		if (sco_listen) {
		CALL_AND_WAIT(bt_interface->enable(), adapter_state_changed);
		fprintf(stdout, "BT adapter is up\n");

		bt_property_t* property =
		property_new_scan_mode(BT_SCAN_MODE_CONNECTABLE_DISCOVERABLE);
		CALL_AND_WAIT(bt_interface->set_adapter_property(property),
		adapter_properties);
		property_free(property);

		const btsock_interface_t* sock =
		bt_interface->get_profile_interface(BT_PROFILE_SOCKETS_ID);

		int rfcomm_fd = INVALID_FD;
		int error =
		sock->listen(BTSOCK_RFCOMM, "meow", (const uint8_t*)&HFP_AG_UUID, 0,
		&rfcomm_fd, 0, app_uid);
		if (error != BT_STATUS_SUCCESS) {
		fprintf(stderr, "Unable to listen for incoming RFCOMM socket: %d\n",
		error);
		exit(1);
		}

		int sock_fd = INVALID_FD;
		error = sock->listen(BTSOCK_SCO, NULL, NULL, 5, &sock_fd, 0, app_uid);
		if (error != BT_STATUS_SUCCESS) {
		fprintf(stderr, "Unable to listen for incoming SCO sockets: %d\n", error);
		exit(1);
		}
		fprintf(stdout, "Waiting for incoming SCO connections...\n");
		sleep(timeout_in_sec);
		}

		if (sco_connect) {
		if (bdaddr_is_empty(&bt_remote_bdaddr)) {
		fprintf(stderr,
		"Must specify a remote device address [ "
		"--bdaddr=xx:yy:zz:aa:bb:cc ]\n");
		exit(1);
		}

		CALL_AND_WAIT(bt_interface->enable(), adapter_state_changed);
		fprintf(stdout, "BT adapter is up\n");

		const btsock_interface_t* sock =
		bt_interface->get_profile_interface(BT_PROFILE_SOCKETS_ID);

		int rfcomm_fd = INVALID_FD;
		int error =
		sock->connect(&bt_remote_bdaddr, BTSOCK_RFCOMM,
		(const uint8_t*)&HFP_AG_UUID, 0, &rfcomm_fd, 0, app_uid);
		if (error != BT_STATUS_SUCCESS) {
		fprintf(stderr, "Unable to connect to RFCOMM socket: %d.\n", error);
		exit(1);
		}

		WAIT(acl_state_changed);

		fprintf(stdout, "Establishing SCO connection...\n");

		int sock_fd = INVALID_FD;
		error = sock->connect(&bt_remote_bdaddr, BTSOCK_SCO, NULL, 5, &sock_fd, 0,
		app_uid);
		if (error != BT_STATUS_SUCCESS) {
		fprintf(stderr, "Unable to connect to SCO socket: %d.\n", error);
		exit(1);
		}
		sleep(timeout_in_sec);
		}

		CALL_AND_WAIT(bt_interface->disable(), adapter_state_changed);
		fprintf(stdout, "BT adapter is down\n");
		}

		static void sig_handler(int signo) {
		if (signo == SIGINT) {
		fprintf(stderr, "Received SIGINT\n");
		CALL_AND_WAIT(bt_interface->disable(), adapter_state_changed);
		fprintf(stderr, "BT adapter is down\n");
		exit(1);
		}
		}

		static void usage(const char* name) {
		fprintf(stderr,
		"Usage: %s "
		"[--bond\|--discover\|--discoverable\|--up\|--sco_listen\|--sco_connect] "
		"[--bdaddr=<bdaddr>] [--time=<time_in_sec>] --verbose\n",
		name);
		fprintf(stderr, " bond: Discover actively advertising devices\n");
		fprintf(stderr, " discover: Discover actively advertising devices\n");
		fprintf(stderr,
		" discoverable: Set into a connectable and discoverable mode\n");
		fprintf(stderr, " up: Only bring up stack\n");
		fprintf(stderr, " sco_listen: Listen for incoming SCO connections\n");
		fprintf(stderr,
		" sco_connect: Establish a SCO connection with another device\n");
		fprintf(stderr, " time: Time to hold in the specified mode\n");
		exit(1);
		}

		static bool parse_args(int argc, char** argv) {
		while (1) {
		int option_index = 0;
		int c = getopt_long_only(argc, argv, "", long_options, &option_index);
		if (c != 0) break;

		switch (c) {
		case 0:
		if (option_index == 0) {
		if (!string_to_bdaddr(optarg, &bt_remote_bdaddr)) {
		return false;
		}
		}
		if (option_index == 1) {
		discover = true;
		}
		if (option_index == 2) {
		discoverable = true;
		}
		if (option_index == 3) {
		timeout_in_sec = atoi(optarg);
		}
		if (option_index == 4) {
		bond = true;
		}
		if (option_index == 5) {
		up = true;
		}
		if (option_index == 6) {
		f_verbose++;
		}
		if (option_index == 7) {
		get_name = true;
		}
		if (option_index == 8) {
		bd_name = (char*)optarg;
		set_name = true;
		}
		if (option_index == 9) {
		sco_listen = true;
		}
		if (option_index == 10) {
		sco_connect = true;
		}
		break;

		default:
		fprintf(stderr, "?? getopt returned character code 0%o ??\n", c);
		}
		}

		if (optind < argc) {
		fprintf(stderr, "non-option ARGV-elements: ");
		while (optind < argc) fprintf(stderr, "%s ", argv[optind++]);
		fprintf(stderr, "\n");
		return false;
		}
		return true;
		}

system/tools/hci/Android.mk.disabled

deleted100644 → 0

+0 −33

Original line number	Diff line number	Diff line
		#
		# Copyright 2014 The Android Open Source Project
		#
		# Licensed under the Apache License, Version 2.0 (the "License");
		# you may not use this file except in compliance with the License.
		# You may obtain a copy of the License at
		#
		# http://www.apache.org/licenses/LICENSE-2.0
		#
		# Unless required by applicable law or agreed to in writing, software
		# distributed under the License is distributed on an "AS IS" BASIS,
		# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
		# See the License for the specific language governing permissions and
		# limitations under the License.
		#

		LOCAL_PATH := $(call my-dir)

		# Bluetooth HCI tools for target
		include $(CLEAR_VARS)

		LOCAL_MODULE_TAGS := optional
		LOCAL_MODULE := net_hci

		LOCAL_SRC_FILES := main.c
		LOCAL_STATIC_LIBRARIES := libosi
		LOCAL_C_INCLUDES := $(LOCAL_PATH)/../../

		LOCAL_CFLAGS += $(bluetooth_CFLAGS)
		LOCAL_CONLYFLAGS += $(bluetooth_CONLYFLAGS)
		LOCAL_CPPFLAGS += $(bluetooth_CPPFLAGS)

		include $(BUILD_EXECUTABLE)