[Verification] Code compiles without errors.
Change-Id: I17708a174180de7ad846f2042bccf3d0eb15c4c4
Signed-off-by: Tomasz Marciniak <t.marciniak@samsung.com>
}
static bool IsValidAddress(const std::string& address) {
- static pcrecpp::RE re("(([0-9a-zA-Z]+):)+([0-9a-zA-Z]+)");
- static std::string compare_address = "00:12:47:08:9A:A6";
+ static pcrecpp::RE re("(([0-9a-zA-Z]+):)+([0-9a-zA-Z]+)");
+ static std::string compare_address = "00:12:47:08:9A:A6";
- if (!re.FullMatch(address)) {
- LoggerE("Invalid address");
- return false;
- }
- if (address.size() != compare_address.size()) {
- LoggerE("Invalid size");
- return false;
- }
- return true;
+ if (!re.FullMatch(address)) {
+ LoggerE("Invalid address");
+ return false;
+ }
+ if (address.size() != compare_address.size()) {
+ LoggerE("Invalid size");
+ return false;
+ }
+ return true;
}
static bool IsValidUUID(const std::string& uuid) {
- static pcrecpp::RE re("(([0-9a-zA-Z]+)-)+([0-9a-zA-Z]+)");
- static std::string compare_uuid = "00001101-0000-1000-8000-00805F9B34FB";
+ static pcrecpp::RE re("(([0-9a-zA-Z]+)-)+([0-9a-zA-Z]+)");
+ static std::string compare_uuid = "00001101-0000-1000-8000-00805F9B34FB";
- if (!re.FullMatch(uuid)) {
- LoggerE("Invalid UUID: %s", uuid.c_str());
- return false;
- }
+ if (!re.FullMatch(uuid)) {
+ LoggerE("Invalid UUID: %s", uuid.c_str());
+ return false;
+ }
- if (uuid.size() != compare_uuid.size()) {
- LoggerE("Invalid size: %s", uuid.c_str());
- return false;
- }
+ if (uuid.size() != compare_uuid.size()) {
+ LoggerE("Invalid size: %s", uuid.c_str());
+ return false;
+ }
- return true;
+ return true;
}
void BluetoothAdapter::StateChangedCB(int result, bt_adapter_state_e state, void *user_data) {
- LoggerD("Entered");
-
- BluetoothAdapter* adapter = static_cast<BluetoothAdapter*>(user_data);
- if (!adapter) {
- LoggerD("User data is NULL");
- return;
- }
+ LoggerD("Entered");
- const bool powered = BT_ADAPTER_ENABLED == state;
- bool previous_powered = adapter->is_powered_;
- adapter->is_powered_ = powered;
+ BluetoothAdapter* adapter = static_cast<BluetoothAdapter*>(user_data);
+ if (!adapter) {
+ LoggerD("User data is NULL");
+ return;
+ }
- if (powered) {
- //update visible state if bluetooth device has been turned on
- adapter->is_visible_ = adapter->get_visible();
- }
+ const bool powered = BT_ADAPTER_ENABLED == state;
+ bool previous_powered = adapter->is_powered_;
+ adapter->is_powered_ = powered;
- if (previous_powered != powered && BT_ERROR_NONE == result) {
- picojson::value value = picojson::value(picojson::object());
- picojson::object* data_obj = &value.get<picojson::object>();
+ if (powered) {
+ //update visible state if bluetooth device has been turned on
+ adapter->is_visible_ = adapter->get_visible();
+ }
- data_obj->insert(std::make_pair(kAction, picojson::value(kOnStateChanged)));
- data_obj->insert(std::make_pair(kAdapterPowered, picojson::value(powered)));
+ if (previous_powered != powered && BT_ERROR_NONE == result) {
+ picojson::value value = picojson::value(picojson::object());
+ picojson::object* data_obj = &value.get<picojson::object>();
- util::FireEvent(kAdapterChangeCallbackEvent, value);
- }
+ data_obj->insert(std::make_pair(kAction, picojson::value(kOnStateChanged)));
+ data_obj->insert(std::make_pair(kAdapterPowered, picojson::value(powered)));
- if (adapter->user_request_list_[SET_POWERED]) {
- if (adapter->requested_powered_ != powered) {
- return;
- }
+ util::FireEvent(kAdapterChangeCallbackEvent, value);
+ }
- PlatformResult ret = PlatformResult(ErrorCode::NO_ERROR);
- switch(result) {
- case BT_ERROR_NONE:
- case BT_ERROR_ALREADY_DONE:
- case BT_ERROR_NOT_ENABLED:
- //do nothing
- break;
- case BT_ERROR_NOW_IN_PROGRESS:
- ret = PlatformResult(ErrorCode::SERVICE_NOT_AVAILABLE_ERR, "Bluetooth device is busy");
- break;
- default:
- ret = PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown exception");
- }
+ if (adapter->user_request_list_[SET_POWERED]) {
+ if (adapter->requested_powered_ != powered) {
+ return;
+ }
- util::AsyncResponse(adapter->user_request_callback_[SET_POWERED], ret);
- adapter->user_request_list_[SET_POWERED] = false;
+ PlatformResult ret = PlatformResult(ErrorCode::NO_ERROR);
+ switch(result) {
+ case BT_ERROR_NONE:
+ case BT_ERROR_ALREADY_DONE:
+ case BT_ERROR_NOT_ENABLED:
+ //do nothing
+ break;
+ case BT_ERROR_NOW_IN_PROGRESS:
+ ret = PlatformResult(ErrorCode::SERVICE_NOT_AVAILABLE_ERR, "Bluetooth device is busy");
+ break;
+ default:
+ ret = PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown exception");
+ }
+
+ util::AsyncResponse(adapter->user_request_callback_[SET_POWERED], ret);
+ adapter->user_request_list_[SET_POWERED] = false;
}
}
void BluetoothAdapter::NameChangedCB(char *name, void *user_data) {
- LoggerD("Entered");
+ LoggerD("Entered");
- BluetoothAdapter* adapter = static_cast<BluetoothAdapter*>(user_data);
- if (!adapter) {
- LoggerD("User data is NULL");
- return;
- }
+ BluetoothAdapter* adapter = static_cast<BluetoothAdapter*>(user_data);
+ if (!adapter) {
+ LoggerD("User data is NULL");
+ return;
+ }
- picojson::value value = picojson::value(picojson::object());
-
picojson::object* data_obj = &value.get<picojson::object>();
+ picojson::value value = picojson::value(picojson::object());
+ picojson::object* data_obj = &value.get<picojson::object>();
- data_obj->insert(std::make_pair(kAction, picojson::value(kOnNameChanged)));
- data_obj->insert(std::make_pair(kName, picojson::value(name)));
+ data_obj->insert(std::make_pair(kAction, picojson::value(kOnNameChanged)));
+ data_obj->insert(std::make_pair(kName, picojson::value(name)));
- util::FireEvent(kAdapterChangeCallbackEvent, value);
+ util::FireEvent(kAdapterChangeCallbackEvent, value);
- if (adapter->user_request_list_[SET_NAME] && name == adapter->requested_name_) {
-
std::shared_ptr<picojson::value> response =
-
std::shared_ptr<picojson::value>(new picojson::value(picojson::object()));
- util::AsyncResponse(adapter->user_request_callback_[SET_NAME], response);
- adapter->user_request_list_[SET_NAME] = false;
- }
+ if (adapter->user_request_list_[SET_NAME] && name == adapter->requested_name_) {
+ std::shared_ptr<picojson::value> response =
+ std::shared_ptr<picojson::value>(new picojson::value(picojson::object()));
+ util::AsyncResponse(adapter->user_request_callback_[SET_NAME], response);
+ adapter->user_request_list_[SET_NAME] = false;
+ }
}
void BluetoothAdapter::VisibilityChangedCB(int result, bt_adapter_visibility_mode_e mode, void *user_data) {
- LoggerD("Entered");
+ LoggerD("Entered");
- BluetoothAdapter* adapter = static_cast<BluetoothAdapter*>(user_data);
- if (!adapter) {
- LoggerD("User data is NULL");
- return;
- }
-
- bool visible = BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE != mode;
- bool previous_visible = adapter->is_visible_;
- adapter->is_visible_ = visible;
+ BluetoothAdapter* adapter = static_cast<BluetoothAdapter*>(user_data);
+ if (!adapter) {
+ LoggerD("User data is NULL");
+ return;
+ }
- if (previous_visible != visible) {
- picojson::value value = picojson::value(picojson::object());
- picojson::object* data_obj = &value.get<picojson::object>();
+ bool visible = BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE != mode;
+ bool previous_visible = adapter->is_visible_;
+ adapter->is_visible_ = visible;
- data_obj->insert(std::make_pair(kAction, picojson::value(kOnVisibilityChanged)));
- data_obj->insert(std::make_pair(kAdapterVisible, picojson::value(visible)));
+ if (previous_visible != visible) {
+ picojson::value value = picojson::value(picojson::object());
+ picojson::object* data_obj = &value.get<picojson::object>();
- util::FireEvent(kAdapterChangeCallbackEvent, value);
- }
+ data_obj->insert(std::make_pair(kAction, picojson::value(kOnVisibilityChanged)));
+ data_obj->insert(std::make_pair(kAdapterVisible, picojson::value(visible)));
- if (adapter->user_request_list_[SET_VISIBLE] && adapter->requested_visibility_ == mode) {
- PlatformResult ret = PlatformResult(ErrorCode::NO_ERROR);
+ util::FireEvent(kAdapterChangeCallbackEvent, value);
+ }
- if (BT_ERROR_NONE != result) {
- ret = PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown exception");
- }
+ if (adapter->user_request_list_[SET_VISIBLE] && adapter->requested_visibility_ == mode) {
+ PlatformResult ret = PlatformResult(ErrorCode::NO_ERROR);
- util::AsyncResponse(adapter->user_request_callback_[SET_VISIBLE], ret);
- adapter->user_request_list_[SET_VISIBLE] = false;
+ if (BT_ERROR_NONE != result) {
+ ret = PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown exception");
}
+
+ util::AsyncResponse(adapter->user_request_callback_[SET_VISIBLE], ret);
+ adapter->user_request_list_[SET_VISIBLE] = false;
+ }
}
static bool ForeachBondedDevicesCB(bt_device_info_s *device_info, void *user_data)
{
- LoggerD("Entered");
- if (nullptr == user_data) {
- LoggerD("user data is NULL.");
- return false;
- }
+ LoggerD("Entered");
+ if (nullptr == user_data) {
+ LoggerD("user data is NULL.");
+ return false;
+ }
- if (nullptr == device_info) {
- LoggerD("Device info is not valid.");
- return false;
- }
+ if (nullptr == device_info) {
+ LoggerD("Device info is not valid.");
+ return false;
+ }
- picojson::array* array = static_cast<picojson::array*>(user_data);
- for (auto iter = array->begin(); iter != array->end(); iter++) {
- if (!strcmp(device_info->remote_address, ((*iter).get<picojson::object>())
- .find(kDeviceAddress)->second.get<std::string>().c_str())) {
- BluetoothDevice::ToJson(device_info, &iter->get<picojson::object>());
- return true;
- }
+ picojson::array* array = static_cast<picojson::array*>(user_data);
+ for (auto iter = array->begin(); iter != array->end(); iter++) {
+ if (!strcmp(device_info->remote_address, ((*iter).get<picojson::object>())
+ .find(kDeviceAddress)->second.get<std::string>().c_str())) {
+ BluetoothDevice::ToJson(device_info, &iter->get<picojson::object>());
+ return true;
}
+ }
- array->push_back(picojson::value(picojson::object()));
+ array->push_back(picojson::value(picojson::object()));
-
BluetoothDevice::ToJson(device_info, &array->back().get<picojson::object>());
- return true;
+ BluetoothDevice::ToJson(device_info, &array->back().get<picojson::object>());
+ return true;
}
void BluetoothAdapter::DiscoveryStateChangedCB(
- int result,
- bt_adapter_device_discovery_state_e discovery_state,
- bt_adapter_device_discovery_info_s *discovery_info,
- void *user_data)
+ int result,
+ bt_adapter_device_discovery_state_e discovery_state,
+ bt_adapter_device_discovery_info_s *discovery_info,
+ void *user_data)
{
- LoggerD("Entered");
+ LoggerD("Entered");
- BluetoothAdapter* adapter = static_cast<BluetoothAdapter*>(user_data);
- if (!adapter) {
- LoggerD("User data is NULL");
- return;
- }
+ BluetoothAdapter* adapter = static_cast<BluetoothAdapter*>(user_data);
+ if (!adapter) {
+ LoggerD("User data is NULL");
+ return;
+ }
- picojson::value value = picojson::value(picojson::object());
-
picojson::object* data_obj = &value.get<picojson::object>();
+ picojson::value value = picojson::value(picojson::object());
+ picojson::object* data_obj = &value.get<picojson::object>();
- switch(discovery_state) {
- case BT_ADAPTER_DEVICE_DISCOVERY_STARTED: {
- if (adapter->user_request_list_[DISCOVER_DEVICES]) {
- if (BT_ERROR_NONE == result) {
- //store addresses of previously found devices into disappeared_addresses
- adapter->disappeared_addresses_ = adapter->discovered_addresses_;
- adapter->discovered_addresses_.clear();
- adapter->discovered_devices_.clear();
-
- data_obj->insert(std::make_pair(kAction, picojson::value(kOnDiscoverStarted)));
- util::FireEvent(kAdapterDiscoverSuccessEvent, value);
- } else {
- ReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error"), data_obj);
- util::FireEvent(kAdapterDiscoverErrorEvent, value);
- adapter->user_request_list_[DISCOVER_DEVICES] = false;
- }
- }
- break;
+ switch(discovery_state) {
+ case BT_ADAPTER_DEVICE_DISCOVERY_STARTED: {
+ if (adapter->user_request_list_[DISCOVER_DEVICES]) {
+ if (BT_ERROR_NONE == result) {
+ //store addresses of previously found devices into disappeared_addresses
+ adapter->disappeared_addresses_ = adapter->discovered_addresses_;
+ adapter->discovered_addresses_.clear();
+ adapter->discovered_devices_.clear();
+
+ data_obj->insert(std::make_pair(kAction, picojson::value(kOnDiscoverStarted)));
+ util::FireEvent(kAdapterDiscoverSuccessEvent, value);
+ } else {
+ ReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error"), data_obj);
+ util::FireEvent(kAdapterDiscoverErrorEvent, value);
+ adapter->user_request_list_[DISCOVER_DEVICES] = false;
}
- case BT_ADAPTER_DEVICE_DISCOVERY_FINISHED: {
- if (BT_ERROR_NONE == result || BT_ERROR_CANCELLED == result) {
- if (adapter->user_request_list_[DISCOVER_DEVICES]) {
- data_obj->insert(std::make_pair(kAction, picojson::value(kOnDiscoverFinished)));
+ }
+ break;
+ }
+ case BT_ADAPTER_DEVICE_DISCOVERY_FINISHED: {
+ if (BT_ERROR_NONE == result || BT_ERROR_CANCELLED == result) {
+ if (adapter->user_request_list_[DISCOVER_DEVICES]) {
+ data_obj->insert(std::make_pair(kAction, picojson::value(kOnDiscoverFinished)));
- for (auto it : adapter->disappeared_addresses_) {
- picojson::value disapeared_val = picojson::value(picojson::object());
-
picojson::object* disapeared_obj = &disapeared_val.get<picojson::object>();
+ for (auto it : adapter->disappeared_addresses_) {
+ picojson::value disapeared_val = picojson::value(picojson::object());
+ picojson::object* disapeared_obj = &disapeared_val.get<picojson::object>();
- disapeared_obj->insert(std::make_pair(kAction,
- picojson::value(kOnDiscoverDisappeared)));
- disapeared_obj->insert(std::make_pair(kData, picojson::value(it)));
+ disapeared_obj->insert(std::make_pair(kAction,
+ picojson::value(kOnDiscoverDisappeared)));
+ disapeared_obj->insert(std::make_pair(kData, picojson::value(it)));
- util::FireEvent(kAdapterDiscoverSuccessEvent, disapeared_val);
- }
+ util::FireEvent(kAdapterDiscoverSuccessEvent, disapeared_val);
+ }
- data_obj->insert(std::make_pair(kData,
- picojson::value(adapter->discovered_devices_)));
- util::FireEvent(kAdapterDiscoverSuccessEvent, value);
+ data_obj->insert(std::make_pair(kData, picojson::value(adapter->discovered_devices_)));
+ util::FireEvent(kAdapterDiscoverSuccessEvent, value);
- adapter->user_request_list_[DISCOVER_DEVICES] = false;
- }
+ adapter->user_request_list_[DISCOVER_DEVICES] = false;
+ }
- if (adapter->user_request_list_[STOP_DISCOVERY]) {
-
std::shared_ptr<picojson::value> response =
-
std::shared_ptr<picojson::value>(new picojson::value(picojson::object()));
+ if (adapter->user_request_list_[STOP_DISCOVERY]) {
+ std::shared_ptr<picojson::value> response =
+ std::shared_ptr<picojson::value>(new picojson::value(picojson::object()));
- ReportSuccess(response->get<picojson::object>());
- util::AsyncResponse(
- adapter->user_request_callback_[STOP_DISCOVERY], response);
+ ReportSuccess(response->get<picojson::object>());
+ util::AsyncResponse(adapter->user_request_callback_[STOP_DISCOVERY], response);
- adapter->user_request_list_[STOP_DISCOVERY] = false;
- }
- }
- break;
+ adapter->user_request_list_[STOP_DISCOVERY] = false;
}
- case BT_ADAPTER_DEVICE_DISCOVERY_FOUND: {
- if (adapter->user_request_list_[DISCOVER_DEVICES]) {
- if (BT_ERROR_NONE == result &&
- adapter->discovered_addresses_.insert(
- discovery_info->remote_address).second) {
- adapter->disappeared_addresses_.erase(discovery_info->remote_address);
-
- data_obj->insert(std::make_pair(kAction, picojson::value(kOnDiscoverFound)));
- picojson::value& data = data_obj->insert(std::make_pair(kData,
- picojson::value(picojson::object()))).first->second;
-
- BluetoothDevice::ToJson(discovery_info, &data.get<picojson::object>());
- adapter->discovered_devices_.push_back(data);
-
- util::FireEvent(kAdapterDiscoverSuccessEvent, value);
- }
- }
- break;
+ }
+ break;
+ }
+ case BT_ADAPTER_DEVICE_DISCOVERY_FOUND: {
+ if (adapter->user_request_list_[DISCOVER_DEVICES]) {
+ if (BT_ERROR_NONE == result &&
+ adapter->discovered_addresses_.insert(
+ discovery_info->remote_address).second) {
+ adapter->disappeared_addresses_.erase(discovery_info->remote_address);
+
+ data_obj->insert(std::make_pair(kAction, picojson::value(kOnDiscoverFound)));
+ picojson::value& data = data_obj->insert(std::make_pair(kData,
+ picojson::value(picojson::object()))).first->second;
+
+ BluetoothDevice::ToJson(discovery_info, &data.get<picojson::object>());
+ adapter->discovered_devices_.push_back(data);
+
+ util::FireEvent(kAdapterDiscoverSuccessEvent, value);
}
- default:
- LoggerD("Unknown state");
- break;
+ }
+ break;
}
+ default:
+ LoggerD("Unknown state");
+ break;
+ }
}
BluetoothAdapter::BluetoothAdapter() :
is_powered_(false),
is_initialized_(false)
{
- LoggerD("Entered");
- if (BT_ERROR_NONE == bt_initialize()) {
- LoggerD("Bluetooth service is initialized.");
- is_initialized_ = true;
-
- int ret = BT_ERROR_NONE;
- ret |= bt_adapter_set_device_discovery_state_changed_cb(DiscoveryStateChangedCB, this);
- ret |= bt_adapter_set_state_changed_cb(StateChangedCB, this);
- ret |= bt_adapter_set_name_changed_cb(NameChangedCB, this);
- ret |= bt_adapter_set_visibility_mode_changed_cb(VisibilityChangedCB, this);
-
- if (BT_ERROR_NONE != ret) {
- LoggerE("Setting listeners function failed.");
- }
- } else {
- LoggerE("Bluetooth service initialization failed.");
- }
+ LoggerD("Entered");
+ if (BT_ERROR_NONE == bt_initialize()) {
+ LoggerD("Bluetooth service is initialized.");
+ is_initialized_ = true;
+
+ int ret = BT_ERROR_NONE;
+ ret |= bt_adapter_set_device_discovery_state_changed_cb(DiscoveryStateChangedCB, this);
+ ret |= bt_adapter_set_state_changed_cb(StateChangedCB, this);
+ ret |= bt_adapter_set_name_changed_cb(NameChangedCB, this);
+ ret |= bt_adapter_set_visibility_mode_changed_cb(VisibilityChangedCB, this);
+
+ if (BT_ERROR_NONE != ret) {
+ LoggerE("Setting listeners function failed.");
+ }
+ } else {
+ LoggerE("Bluetooth service initialization failed.");
+ }
- bt_adapter_state_e state;
- if (BT_ERROR_NONE == bt_adapter_get_state(&state)) {
- is_powered_ = BT_ADAPTER_ENABLED == state;
- }
+ bt_adapter_state_e state;
+ if (BT_ERROR_NONE == bt_adapter_get_state(&state)) {
+ is_powered_ = BT_ADAPTER_ENABLED == state;
+ }
- bt_adapter_visibility_mode_e mode;
- if (BT_ERROR_NONE == bt_adapter_get_visibility(&mode, nullptr)) {
- is_visible_ = BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE != mode;
- }
+ bt_adapter_visibility_mode_e mode;
+ if (BT_ERROR_NONE == bt_adapter_get_visibility(&mode, nullptr)) {
+ is_visible_ = BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE != mode;
+ }
}
BluetoothAdapter::~BluetoothAdapter() {
- bt_socket_unset_data_received_cb();
- bt_socket_unset_connection_state_changed_cb();
+ bt_socket_unset_data_received_cb();
+ bt_socket_unset_connection_state_changed_cb();
- for (auto it : connected_sockets_) {
- bt_socket_disconnect_rfcomm(it);
- }
+ for (auto it : connected_sockets_) {
+ bt_socket_disconnect_rfcomm(it);
+ }
- for (auto it : registered_uuids_) {
- bt_socket_destroy_rfcomm(it.second.first);
- }
+ for (auto it : registered_uuids_) {
+ bt_socket_destroy_rfcomm(it.second.first);
+ }
- bt_adapter_unset_state_changed_cb();
- bt_adapter_unset_name_changed_cb();
- bt_adapter_unset_visibility_mode_changed_cb();
- bt_adapter_unset_device_discovery_state_changed_cb();
+ bt_adapter_unset_state_changed_cb();
+ bt_adapter_unset_name_changed_cb();
+ bt_adapter_unset_visibility_mode_changed_cb();
+ bt_adapter_unset_device_discovery_state_changed_cb();
- if (is_initialized_) {
- if (BT_ERROR_NONE == bt_deinitialize()) {
- LoggerD("Bluetooth service is deinitialized.");
- } else {
- LoggerE("Bluetooth service deinitialization failed.");
- }
+ if (is_initialized_) {
+ if (BT_ERROR_NONE == bt_deinitialize()) {
+ LoggerD("Bluetooth service is deinitialized.");
+ } else {
+ LoggerE("Bluetooth service deinitialization failed.");
}
+ }
}
BluetoothAdapter& BluetoothAdapter::GetInstance() {
- static BluetoothAdapter instance;
- return instance;
+ static BluetoothAdapter instance;
+ return instance;
}
std::string BluetoothAdapter::get_name() const {
- char* name = nullptr;
- std::string str_name = "";
- if (BT_ERROR_NONE == bt_adapter_get_name(&name)) {
- if (name) {
- str_name = name;
- free(name);
- }
+ char* name = nullptr;
+ std::string str_name = "";
+ if (BT_ERROR_NONE == bt_adapter_get_name(&name)) {
+ if (name) {
+ str_name = name;
+ free(name);
}
+ }
- return str_name;
+ return str_name;
}
bool BluetoothAdapter::get_visible() const {
- bt_adapter_visibility_mode_e mode;
+ bt_adapter_visibility_mode_e mode;
- if (BT_ERROR_NONE == bt_adapter_get_visibility(&mode, NULL)) {
- return mode != BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE;
- }
+ if (BT_ERROR_NONE == bt_adapter_get_visibility(&mode, NULL)) {
+ return mode != BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE;
+ }
- return false;
+ return false;
}
void BluetoothAdapter::set_visible(bool visible) {
- is_visible_ = visible;
+ is_visible_ = visible;
}
bool BluetoothAdapter::get_powered() {
- return is_powered_;
+ return is_powered_;
}
void BluetoothAdapter::set_powered(bool powered) {
- is_powered_ = powered;
+ is_powered_ = powered;
}
bool BluetoothAdapter::is_initialized() const {
- return is_initialized_;
+ return is_initialized_;
}
void BluetoothAdapter::SetName(const picojson::value& data, picojson::object& out) {
- LoggerD("Entered");
-
- util::CheckAccess(Privilege::kBluetoothAdmin);
-
- const auto callback_handle = util::GetAsyncCallbackHandle(data);
- const auto& args = util::GetArguments(data);
- const auto name = FromJson<std::string>(args, "name");
-
- PlatformResult result = PlatformResult(ErrorCode::NO_ERROR);
- if (!this->is_initialized()) {
- result = PlatformResult(ErrorCode::UNKNOWN_ERR, "Bluetooth service is not initialized.");
- util::AsyncResponse(callback_handle, result);
- return;
- }
+ LoggerD("Entered");
- if (this->get_powered()) {
- if (get_name() == name) {
- util::AsyncResponse(callback_handle, result);
- return;
- }
+ util::CheckAccess(Privilege::kBluetoothAdmin);
- if (this->user_request_list_[SET_NAME]) {
- result = PlatformResult(ErrorCode::SERVICE_NOT_AVAILABLE_ERR, "Already requested");
- util::AsyncResponse(callback_handle, result);
- return;
- }
+ const auto callback_handle = util::GetAsyncCallbackHandle(data);
+ const auto& args = util::GetArguments(data);
+ const auto name = FromJson<std::string>(args, "name");
- this->user_request_list_[SET_NAME] = true;
- this->user_request_callback_[SET_NAME] = callback_handle;
+ PlatformResult result = PlatformResult(ErrorCode::NO_ERROR);
+ if (!this->is_initialized()) {
+ result = PlatformResult(ErrorCode::UNKNOWN_ERR, "Bluetooth service is not initialized.");
+ util::AsyncResponse(callback_handle, result);
+ return;
+ }
- int ret = bt_adapter_set_name(name.c_str());
- switch(ret) {
- case BT_ERROR_NONE:
- //bt_adapter_name_changed_cb() will be invoked
- //if this function returns #BT_ERROR_NONE
- this->requested_name_ = name;
- break;
- case BT_ERROR_INVALID_PARAMETER:
- result = PlatformResult(ErrorCode::INVALID_VALUES_ERR, "Invalid value");
- break;
- default:
- result = PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown exception");
- }
- } else {
- result = PlatformResult(
- ErrorCode::SERVICE_NOT_AVAILABLE_ERR, "Bluetooth device is turned off");
+ if (this->get_powered()) {
+ if (get_name() == name) {
+ util::AsyncResponse(callback_handle, result);
+ return;
}
- if (result.IsError()) {
- this->user_request_list_[SET_NAME] = false;
+ if (this->user_request_list_[SET_NAME]) {
+ result = PlatformResult(ErrorCode::SERVICE_NOT_AVAILABLE_ERR, "Already requested");
+ util::AsyncResponse(callback_handle, result);
+ return;
}
- util::AsyncResponse(callback_handle, result);
+ this->user_request_list_[SET_NAME] = true;
+ this->user_request_callback_[SET_NAME] = callback_handle;
+
+ int ret = bt_adapter_set_name(name.c_str());
+ switch(ret) {
+ case BT_ERROR_NONE:
+ //bt_adapter_name_changed_cb() will be invoked
+ //if this function returns #BT_ERROR_NONE
+ this->requested_name_ = name;
+ break;
+ case BT_ERROR_INVALID_PARAMETER:
+ result = PlatformResult(ErrorCode::INVALID_VALUES_ERR, "Invalid value");
+ break;
+ default:
+ result = PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown exception");
+ }
+ } else {
+ result = PlatformResult(ErrorCode::SERVICE_NOT_AVAILABLE_ERR, "Bluetooth device is turned off");
+ }
+
+ if (result.IsError()) {
+ this->user_request_list_[SET_NAME] = false;
+ }
+
+ util::AsyncResponse(callback_handle, result);
}
void BluetoothAdapter::SetPowered(const picojson::value& data, picojson::object& out) {
- LoggerD("Entered");
+ LoggerD("Entered");
- util::CheckAccess(Privilege::kBluetoothAdmin);
+ util::CheckAccess(Privilege::kBluetoothAdmin);
- const auto callback_handle = util::GetAsyncCallbackHandle(data);
- const auto& args = util::GetArguments(data);
- const auto new_powered = FromJson<bool>(args, "powered");
+ const auto callback_handle = util::GetAsyncCallbackHandle(data);
+ const auto& args = util::GetArguments(data);
+ const auto new_powered = FromJson<bool>(args, "powered");
- PlatformResult ret = PlatformResult(ErrorCode::NO_ERROR);
+ PlatformResult ret = PlatformResult(ErrorCode::NO_ERROR);
- if (!this->is_initialized()) {
- ret = PlatformResult(ErrorCode::UNKNOWN_ERR, "Bluetooth service is not initialized.");
- }
+ if (!this->is_initialized()) {
+ ret = PlatformResult(ErrorCode::UNKNOWN_ERR, "Bluetooth service is not initialized.");
+ }
- if (ret.IsSuccess() && this->user_request_list_[SET_POWERED]) {
- ret = PlatformResult(ErrorCode::SERVICE_NOT_AVAILABLE_ERR, "Already requested");
- }
+ if (ret.IsSuccess() && this->user_request_list_[SET_POWERED]) {
+ ret = PlatformResult(ErrorCode::SERVICE_NOT_AVAILABLE_ERR, "Already requested");
+ }
- bool cur_powered = this->get_powered();
+ bool cur_powered = this->get_powered();
- if (ret.IsSuccess() && new_powered != cur_powered) {
- this->requested_powered_ = new_powered;
- this->user_request_list_[SET_POWERED] = true;
- this->user_request_callback_[SET_POWERED] = callback_handle;
+ if (ret.IsSuccess() && new_powered != cur_powered) {
+ this->requested_powered_ = new_powered;
+ this->user_request_list_[SET_POWERED] = true;
+ this->user_request_callback_[SET_POWERED] = callback_handle;
- if (new_powered) {
- bt_adapter_enable();
- } else {
- bt_adapter_disable();
- }
- return;
+ if (new_powered) {
+ bt_adapter_enable();
+ } else {
+ bt_adapter_disable();
}
+ return;
+ }
- util::AsyncResponse(callback_handle, ret);
+ util::AsyncResponse(callback_handle, ret);
}
-void BluetoothAdapter::SetVisible(const picojson::value& data, picojson::object& out)
-{
- LoggerD("Entered");
-
- util::CheckAccess(Privilege::kBluetoothManager);
+void BluetoothAdapter::SetVisible(const picojson::value& data, picojson::object& out) {
+ LoggerD("Entered");
- const auto callback_handle = util::GetAsyncCallbackHandle(data);
- const auto& args = util::GetArguments(data);
- const auto visible = FromJson<bool>(args, "visible");
+ util::CheckAccess(Privilege::kBluetoothManager);
- unsigned short timeout = kTimeout;
- if (visible) {
- timeout = static_cast<unsigned short>(FromJson<double>(args, "timeout"));
- }
-
- PlatformResult result = PlatformResult(ErrorCode::NO_ERROR);
+ const auto callback_handle = util::GetAsyncCallbackHandle(data);
+ const auto& args = util::GetArguments(data);
+ const auto visible = FromJson<bool>(args, "visible");
- if (!this->is_initialized()) {
- result = PlatformResult(ErrorCode::UNKNOWN_ERR, "Bluetooth service is not initialized.");
- }
+ unsigned short timeout = kTimeout;
+ if (visible) {
+ timeout = static_cast<unsigned short>(FromJson<double>(args, "timeout"));
+ }
- if (result.IsSuccess() && this->user_request_list_[SET_VISIBLE]) {
- result = PlatformResult(ErrorCode::SERVICE_NOT_AVAILABLE_ERR, "Already requested");
- }
+ PlatformResult result = PlatformResult(ErrorCode::NO_ERROR);
- if (result.IsSuccess() && this->get_powered()) {
- bt_adapter_visibility_mode_e mode = BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE;
- if (visible) {
- if (0 == timeout) {
- mode = BT_ADAPTER_VISIBILITY_MODE_GENERAL_DISCOVERABLE;
- } else {
- mode = BT_ADAPTER_VISIBILITY_MODE_LIMITED_DISCOVERABLE;
- }
- }
+ if (!this->is_initialized()) {
+ result = PlatformResult(ErrorCode::UNKNOWN_ERR, "Bluetooth service is not initialized.");
+ }
- bt_adapter_visibility_mode_e current = BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE;
- int time = 0;
- if (BT_ERROR_NONE != bt_adapter_get_visibility(¤t , &time)) {
- result = PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown exception");
- util::AsyncResponse(callback_handle, result);
- return;
- }
+ if (result.IsSuccess() && this->user_request_list_[SET_VISIBLE]) {
+ result = PlatformResult(ErrorCode::SERVICE_NOT_AVAILABLE_ERR, "Already requested");
+ }
- if (mode == current) {
- if (BT_ADAPTER_VISIBILITY_MODE_LIMITED_DISCOVERABLE != mode ||
- (unsigned int)time != timeout) {
- util::AsyncResponse(callback_handle, result);
- return;
- }
- }
+ if (result.IsSuccess() && this->get_powered()) {
+ bt_adapter_visibility_mode_e mode = BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE;
+ if (visible) {
+ if (0 == timeout) {
+ mode = BT_ADAPTER_VISIBILITY_MODE_GENERAL_DISCOVERABLE;
+ } else {
+ mode = BT_ADAPTER_VISIBILITY_MODE_LIMITED_DISCOVERABLE;
+ }
+ }
- this->requested_visibility_ = mode;
- this->user_request_list_[SET_VISIBLE] = true;
- this->user_request_callback_[SET_VISIBLE] = callback_handle;
- int ret = bt_adapter_set_visibility(mode, timeout);
+ bt_adapter_visibility_mode_e current = BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE;
+ int time = 0;
+ if (BT_ERROR_NONE != bt_adapter_get_visibility(¤t , &time)) {
+ result = PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown exception");
+ util::AsyncResponse(callback_handle, result);
+ return;
+ }
- switch(ret) {
- case BT_ERROR_NONE:
- //bt_adapter_visibility_mode_changed_cb() will be invoked
- //if this function returns #BT_ERROR_NONE
- break;
- case BT_ERROR_INVALID_PARAMETER:
- result = PlatformResult(ErrorCode::INVALID_VALUES_ERR, "Invalid value");
- break;
- default:
- result = PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown exception");
- }
- } else if (result.IsSuccess()){
- result = PlatformResult(
- ErrorCode::SERVICE_NOT_AVAILABLE_ERR, "Bluetooth device is turned off");
+ if (mode == current) {
+ if (BT_ADAPTER_VISIBILITY_MODE_LIMITED_DISCOVERABLE != mode ||
+ (unsigned int)time != timeout) {
+ util::AsyncResponse(callback_handle, result);
+ return;
+ }
}
- util::AsyncResponse(callback_handle, result);
+ this->requested_visibility_ = mode;
+ this->user_request_list_[SET_VISIBLE] = true;
+ this->user_request_callback_[SET_VISIBLE] = callback_handle;
+ int ret = bt_adapter_set_visibility(mode, timeout);
+
+ switch(ret) {
+ case BT_ERROR_NONE:
+ //bt_adapter_visibility_mode_changed_cb() will be invoked
+ //if this function returns #BT_ERROR_NONE
+ break;
+ case BT_ERROR_INVALID_PARAMETER:
+ result = PlatformResult(ErrorCode::INVALID_VALUES_ERR, "Invalid value");
+ break;
+ default:
+ result = PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown exception");
+ }
+ } else if (result.IsSuccess()){
+ result = PlatformResult(ErrorCode::SERVICE_NOT_AVAILABLE_ERR, "Bluetooth device is turned off");
+ }
+
+ util::AsyncResponse(callback_handle, result);
}
void BluetoothAdapter::DiscoverDevices(const picojson::value& /* data */, picojson::object& out) {
- LoggerD("Entered");
-
- util::CheckAccess(Privilege::kBluetoothGap);
+ LoggerD("Entered");
- PlatformResult result = PlatformResult(ErrorCode::NO_ERROR);
+ util::CheckAccess(Privilege::kBluetoothGap);
- if (!is_initialized_) {
- result = PlatformResult(ErrorCode::UNKNOWN_ERR, "Bluetooth service is not initialized.");
- }
+ PlatformResult result = PlatformResult(ErrorCode::NO_ERROR);
- if (result.IsSuccess() && this->user_request_list_[DISCOVER_DEVICES]) {
- result = PlatformResult(ErrorCode::SERVICE_NOT_AVAILABLE_ERR, "Already requested");
- }
+ if (!is_initialized_) {
+ result = PlatformResult(ErrorCode::UNKNOWN_ERR, "Bluetooth service is not initialized.");
+ }
- if (result.IsSuccess() && !get_powered()) {
- result = PlatformResult(
- ErrorCode::SERVICE_NOT_AVAILABLE_ERR, "Bluetooth device is turned off");
- }
+ if (result.IsSuccess() && this->user_request_list_[DISCOVER_DEVICES]) {
+ result = PlatformResult(ErrorCode::SERVICE_NOT_AVAILABLE_ERR, "Already requested");
+ }
- if (result.IsSuccess()) {
- this->user_request_list_[DISCOVER_DEVICES] = true;
- bt_adapter_start_device_discovery();
- } else {
- std::shared_ptr<picojson::value> response =
- std::shared_ptr<picojson::value>(new picojson::value(picojson::object()));
+ if (result.IsSuccess() && !get_powered()) {
+ result = PlatformResult(
+ ErrorCode::SERVICE_NOT_AVAILABLE_ERR, "Bluetooth device is turned off");
+ }
- ReportError(result, &response->get<picojson::object>());
- TaskQueue::GetInstance().Async<picojson::value>([](const std::shared_ptr<picojson::value>& result) {
- util::FireEvent(kAdapterDiscoverErrorEvent, result);
- }, response);
- }
+ if (result.IsSuccess()) {
+ this->user_request_list_[DISCOVER_DEVICES] = true;
+ bt_adapter_start_device_discovery();
+ } else {
+ std::shared_ptr<picojson::value> response =
+ std::shared_ptr<picojson::value>(new picojson::value(picojson::object()));
+
+ ReportError(result, &response->get<picojson::object>());
+ TaskQueue::GetInstance().Async<picojson::value>([](const std::shared_ptr<picojson::value>& result) {
+ util::FireEvent(kAdapterDiscoverErrorEvent, result);
+ }, response);
+ }
}
void BluetoothAdapter::StopDiscovery(const picojson::value& data, picojson::object& out) {
- LoggerD("Entered");
+ LoggerD("Entered");
- util::CheckAccess(Privilege::kBluetoothGap);
+ util::CheckAccess(Privilege::kBluetoothGap);
- const auto callback_handle = util::GetAsyncCallbackHandle(data);
+ const auto callback_handle = util::GetAsyncCallbackHandle(data);
- PlatformResult result = PlatformResult(ErrorCode::NO_ERROR);
-
- if (!this->is_initialized()) {
- result = PlatformResult(ErrorCode::UNKNOWN_ERR, "Bluetooth service is not initialized.");
- }
+ PlatformResult result = PlatformResult(ErrorCode::NO_ERROR);
- if (result.IsSuccess() && this->user_request_list_[STOP_DISCOVERY]) {
- result = PlatformResult(ErrorCode::SERVICE_NOT_AVAILABLE_ERR, "Already requested");
- }
+ if (!this->is_initialized()) {
+ result = PlatformResult(ErrorCode::UNKNOWN_ERR, "Bluetooth service is not initialized.");
+ }
- if (result.IsSuccess() && this->get_powered()) {
- bool is_discovering = false;
- bt_adapter_is_discovering(&is_discovering);
+ if (result.IsSuccess() && this->user_request_list_[STOP_DISCOVERY]) {
+ result = PlatformResult(ErrorCode::SERVICE_NOT_AVAILABLE_ERR, "Already requested");
+ }
- if (!is_discovering) {
- util::AsyncResponse(callback_handle, result);
- return;
- }
+ if (result.IsSuccess() && this->get_powered()) {
+ bool is_discovering = false;
+ bt_adapter_is_discovering(&is_discovering);
- this->user_request_list_[STOP_DISCOVERY] = true;
- this->user_request_callback_[STOP_DISCOVERY] = callback_handle;
- int ret = bt_adapter_stop_device_discovery();
- switch(ret) {
- case BT_ERROR_NONE: {
- //This function invokes bt_adapter_device_discovery_state_changed_cb().
- break;
- }
- default: {
- this->user_request_list_[STOP_DISCOVERY] = false;
- result = PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown exception");
- }
- }
- } else if (result.IsSuccess()) {
- result = PlatformResult(
- ErrorCode::SERVICE_NOT_AVAILABLE_ERR, "Bluetooth device is turned off");
+ if (!is_discovering) {
+ util::AsyncResponse(callback_handle, result);
+ return;
}
- if (result.IsError()) {
- util::AsyncResponse(callback_handle, result);
+ this->user_request_list_[STOP_DISCOVERY] = true;
+ this->user_request_callback_[STOP_DISCOVERY] = callback_handle;
+ int ret = bt_adapter_stop_device_discovery();
+ switch(ret) {
+ case BT_ERROR_NONE: {
+ //This function invokes bt_adapter_device_discovery_state_changed_cb().
+ break;
+ }
+ default: {
+ this->user_request_list_[STOP_DISCOVERY] = false;
+ result = PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown exception");
+ }
}
+ } else if (result.IsSuccess()) {
+ result = PlatformResult(ErrorCode::SERVICE_NOT_AVAILABLE_ERR, "Bluetooth device is turned off");
+ }
+
+ if (result.IsError()) {
+ util::AsyncResponse(callback_handle, result);
+ }
}
void BluetoothAdapter::GetKnownDevices(const picojson::value& data, picojson::object& out) {
- LoggerD("Entered");
+ LoggerD("Entered");
- util::CheckAccess(Privilege::kBluetoothGap);
+ util::CheckAccess(Privilege::kBluetoothGap);
- const auto callback_handle = util::GetAsyncCallbackHandle(data);
+ const auto callback_handle = util::GetAsyncCallbackHandle(data);
-
auto get_known_devices = [this](const std::shared_ptr<picojson::value>& response) -> void {
- PlatformResult ret = PlatformResult(ErrorCode::NO_ERROR);
+ auto get_known_devices = [this](const std::shared_ptr<picojson::value>& response) -> void {
+ PlatformResult ret = PlatformResult(ErrorCode::NO_ERROR);
- if (!this->is_initialized()) {
- ret = PlatformResult(ErrorCode::UNKNOWN_ERR, "Bluetooth service is not initialized.");
- }
+ if (!this->is_initialized()) {
+ ret = PlatformResult(ErrorCode::UNKNOWN_ERR, "Bluetooth service is not initialized.");
+ }
- if (ret.IsSuccess() && this->get_powered()) {
-
picojson::object& response_obj = response->get<picojson::object>();
- picojson::value result = picojson::value(picojson::object());
-
picojson::object& result_obj = result.get<picojson::object>();
- picojson::array& array = result_obj.insert(std::make_pair("devices", picojson::value(
-
picojson::array()))).first->second.get<picojson::array>();
+ if (ret.IsSuccess() && this->get_powered()) {
+ picojson::object& response_obj = response->get<picojson::object>();
+ picojson::value result = picojson::value(picojson::object());
+ picojson::object& result_obj = result.get<picojson::object>();
+ picojson::array& array = result_obj.insert(std::make_pair("devices", picojson::value(
+ picojson::array()))).first->second.get<picojson::array>();
- array = discovered_devices_;
+ array = discovered_devices_;
- if (BT_ERROR_NONE == bt_adapter_foreach_bonded_device(ForeachBondedDevicesCB, &array)) {
- ReportSuccess(result, response_obj);
- } else {
- ret = PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown exception");
- }
- } else if (ret.IsSuccess()) {
- ret = PlatformResult(
- ErrorCode::SERVICE_NOT_AVAILABLE_ERR, "Bluetooth device is turned off");
- }
+ if (BT_ERROR_NONE == bt_adapter_foreach_bonded_device(ForeachBondedDevicesCB, &array)) {
+ ReportSuccess(result, response_obj);
+ } else {
+ ret = PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown exception");
+ }
+ } else if (ret.IsSuccess()) {
+ ret = PlatformResult(ErrorCode::SERVICE_NOT_AVAILABLE_ERR, "Bluetooth device is turned off");
+ }
- if (ret.IsError()) {
-
ReportError(ret, &response->get<picojson::object>());
- }
- };
- auto get_known_devices_response = [callback_handle](
-
const std::shared_ptr<picojson::value>& response) -> void {
- util::SyncResponse(callback_handle, response);
- };
+ if (ret.IsError()) {
+ ReportError(ret, &response->get<picojson::object>());
+ }
+ };
+ auto get_known_devices_response = [callback_handle](
+ const std::shared_ptr<picojson::value>& response) -> void {
+ util::SyncResponse(callback_handle, response);
+ };
-
TaskQueue::GetInstance().Queue<picojson::value>(
- get_known_devices,
- get_known_devices_response,
-
std::shared_ptr<picojson::value>(new picojson::value(picojson::object())));
+ TaskQueue::GetInstance().Queue<picojson::value>(
+ get_known_devices,
+ get_known_devices_response,
+ std::shared_ptr<picojson::value>(new picojson::value(picojson::object())));
- ReportSuccess(out);
+ ReportSuccess(out);
}
void BluetoothAdapter::GetDevice(const picojson::value& data, picojson::object& out) {
- LoggerD("Entered");
+ LoggerD("Entered");
- util::CheckAccess(Privilege::kBluetoothGap);
+ util::CheckAccess(Privilege::kBluetoothGap);
- const auto callback_handle = util::GetAsyncCallbackHandle(data);
- const auto& args = util::GetArguments(data);
+ const auto callback_handle = util::GetAsyncCallbackHandle(data);
+ const auto& args = util::GetArguments(data);
- const auto& address = FromJson<std::string>(args, "address");
+ const auto& address = FromJson<std::string>(args, "address");
-
auto get_device = [this, address](const std::shared_ptr<picojson::value>& response) -> void {
- PlatformResult ret = PlatformResult(ErrorCode::NO_ERROR);
- if (!IsValidAddress(address)) {
- ret = PlatformResult(ErrorCode::NOT_FOUND_ERR, "Wrong address");
- }
+ auto get_device = [this, address](const std::shared_ptr<picojson::value>& response) -> void {
+ PlatformResult ret = PlatformResult(ErrorCode::NO_ERROR);
+ if (!IsValidAddress(address)) {
+ ret = PlatformResult(ErrorCode::NOT_FOUND_ERR, "Wrong address");
+ }
- if (ret.IsSuccess() && !this->is_initialized()) {
- ret = PlatformResult(ErrorCode::UNKNOWN_ERR, "Bluetooth service is not initialized.");
- }
- if (ret.IsSuccess() && this->get_powered()) {
-
picojson::object& response_obj = response->get<picojson::object>();
- bt_device_info_s *info = nullptr;
+ if (ret.IsSuccess() && !this->is_initialized()) {
+ ret = PlatformResult(ErrorCode::UNKNOWN_ERR, "Bluetooth service is not initialized.");
+ }
+ if (ret.IsSuccess() && this->get_powered()) {
+ picojson::object& response_obj = response->get<picojson::object>();
+ bt_device_info_s *info = nullptr;
- if (bt_adapter_get_bonded_device_info(address.c_str(), &info) == BT_ERROR_NONE &&
- info != nullptr) {
- picojson::value result = picojson::value(picojson::object());
-
picojson::object& result_obj = result.get<picojson::object>();
+ if (bt_adapter_get_bonded_device_info(address.c_str(), &info) == BT_ERROR_NONE &&
+ info != nullptr) {
+ picojson::value result = picojson::value(picojson::object());
+ picojson::object& result_obj = result.get<picojson::object>();
- BluetoothDevice::ToJson(info, &result_obj);
- ReportSuccess(result, response_obj);
- bt_adapter_free_device_info(info);
- return;
- }
+ BluetoothDevice::ToJson(info, &result_obj);
+ ReportSuccess(result, response_obj);
+ bt_adapter_free_device_info(info);
+ return;
+ }
- auto is_address = discovered_addresses_.find(address);
- if (is_address != discovered_addresses_.end()) {
- for (auto iter = discovered_devices_.begin();
- iter != discovered_devices_.end(); iter++) {
- if (!strcmp(address.c_str(), ((*iter).get<picojson::object>())
- .find(kDeviceAddress)->second.get<std::string>().c_str())) {
- ReportSuccess(*iter, response_obj);
- return;
- }
- }
- } else {
- ret = PlatformResult(
- ErrorCode::NOT_FOUND_ERR, "There is no device with the given address");
- }
- } else if (ret.IsSuccess()) {
- ret = PlatformResult(
- ErrorCode::SERVICE_NOT_AVAILABLE_ERR, "Bluetooth device is turned off");
+ auto is_address = discovered_addresses_.find(address);
+ if (is_address != discovered_addresses_.end()) {
+ for (auto iter = discovered_devices_.begin();
+ iter != discovered_devices_.end(); iter++) {
+ if (!strcmp(address.c_str(), ((*iter).get<picojson::object>())
+ .find(kDeviceAddress)->second.get<std::string>().c_str())) {
+ ReportSuccess(*iter, response_obj);
+ return;
+ }
}
+ } else {
+ ret = PlatformResult(ErrorCode::NOT_FOUND_ERR, "There is no device with the given address");
+ }
+ } else if (ret.IsSuccess()) {
+ ret = PlatformResult(ErrorCode::SERVICE_NOT_AVAILABLE_ERR, "Bluetooth device is turned off");
+ }
- if (ret.IsError()) {
-
ReportError(ret, &response->get<picojson::object>());
- }
- };
+ if (ret.IsError()) {
+ ReportError(ret, &response->get<picojson::object>());
+ }
+ };
- auto get_device_response = [callback_handle](
-
const std::shared_ptr<picojson::value>& response) -> void {
- util::SyncResponse(callback_handle, response);
- };
+ auto get_device_response = [callback_handle](
+ const std::shared_ptr<picojson::value>& response) -> void {
+ util::SyncResponse(callback_handle, response);
+ };
-
TaskQueue::GetInstance().Queue<picojson::value>(
- get_device,
- get_device_response,
-
std::shared_ptr<picojson::value>(new picojson::value(picojson::object())));
+ TaskQueue::GetInstance().Queue<picojson::value>(
+ get_device,
+ get_device_response,
+ std::shared_ptr<picojson::value>(new picojson::value(picojson::object())));
- ReportSuccess(out);
+ ReportSuccess(out);
}
class BondingHandler {
-public:
- BondingHandler(double callback_handle, const std::string& address) :
- callback_handle_(callback_handle), address_(address) {}
-
- void set_address(const std::string& address) {
- address_ = address;
- }
+ public:
+ BondingHandler(double callback_handle, const std::string& address) :
+ callback_handle_(callback_handle), address_(address) {}
- const std::string& address() const {
- return address_;
- }
+ void set_address(const std::string& address) {
+ address_ = address;
+ }
- void Invoke(const PlatformResult& result, const std::shared_ptr<picojson::value>& response) {
- LoggerD("Entered");
+ const std::string& address() const {
+ return address_;
+ }
- if (result.IsError()) {
- ReportError(result, &response->get<picojson::object>());
- } else {
- ReportSuccess(response->get<picojson::object>());
- }
+ void Invoke(const PlatformResult& result, const std::shared_ptr<picojson::value>& response) {
+ LoggerD("Entered");
- util::AsyncResponse(callback_handle_, response);
+ if (result.IsError()) {
+ ReportError(result, &response->get<picojson::object>());
+ } else {
+ ReportSuccess(response->get<picojson::object>());
}
-private:
- double callback_handle_;
- std::string address_;
+ util::AsyncResponse(callback_handle_, response);
+ }
+
+ private:
+ double callback_handle_;
+ std::string address_;
};
-void BluetoothAdapter::CreateBonding(const picojson::value& data, picojson::object& out)
-{
- LoggerD("Entered");
+void BluetoothAdapter::CreateBonding(const picojson::value& data, picojson::object& out) {
+ LoggerD("Entered");
- util::CheckAccess(Privilege::kBluetoothGap);
+ util::CheckAccess(Privilege::kBluetoothGap);
- const auto callback_handle = util::GetAsyncCallbackHandle(data);
- const auto& args = util::GetArguments(data);
+ const auto callback_handle = util::GetAsyncCallbackHandle(data);
+ const auto& args = util::GetArguments(data);
- const auto& address = FromJson<std::string>(args, "address");
+ const auto& address = FromJson<std::string>(args, "address");
- auto create_bonding = [address, callback_handle, this]() -> void {
- PlatformResult result = PlatformResult(ErrorCode::NO_ERROR);
- if(!IsValidAddress(address)) {
- result = PlatformResult(ErrorCode::NOT_FOUND_ERR, "Wrong address");
- }
+ auto create_bonding = [address, callback_handle, this]() -> void {
+ PlatformResult result = PlatformResult(ErrorCode::NO_ERROR);
+ if(!IsValidAddress(address)) {
+ result = PlatformResult(ErrorCode::NOT_FOUND_ERR, "Wrong address");
+ }
+
+ if (result.IsSuccess() && !this->is_initialized()) {
+ result = PlatformResult(ErrorCode::UNKNOWN_ERR, "Bluetooth service is not initialized.");
+ }
- if (result.IsSuccess() && !this->is_initialized()) {
- result = PlatformResult(
- ErrorCode::UNKNOWN_ERR, "Bluetooth service is not initialized.");
+ if (result.IsSuccess() && this->get_powered()) {
+
+ auto bond_create_callback = [](int callback_result,
+ bt_device_info_s *device_info,
+ void *user_data) {
+ LoggerD("bond_create_callback");
+
+ BondingHandler* handler = static_cast<BondingHandler*>(user_data);
+ if (!handler) {
+ LoggerW("user_data is nullptr");
+ return;
+ }
+ if (!device_info) {
+ LoggerW("device_info is nullptr");
+ return;
}
- if (result.IsSuccess() && this->get_powered()) {
-
- auto bond_create_callback = [](int callback_result,
- bt_device_info_s *device_info,
- void *user_data) {
- LoggerD("bond_create_callback");
-
- BondingHandler* handler = static_cast<BondingHandler*>(user_data);
- if (!handler) {
- LoggerW("user_data is nullptr");
- return;
- }
- if (!device_info) {
- LoggerW("device_info is nullptr");
- return;
- }
-
- PlatformResult ret = PlatformResult(ErrorCode::NO_ERROR);
- std::shared_ptr<picojson::value> response =
- std::shared_ptr<picojson::value>(new picojson::value(picojson::object()));
- if (!strcmp(handler->address().c_str(), device_info->remote_address)) { // requested event
- if (BT_ERROR_NONE == callback_result && nullptr != device_info ) {
- picojson::object& response_obj = response->get<picojson::object>();
- picojson::value result = picojson::value(picojson::object());
- picojson::object& result_obj = result.get<picojson::object>();
-
- BluetoothDevice::ToJson(device_info, &result_obj);
- ReportSuccess(result, response_obj);
- } else if (BT_ERROR_REMOTE_DEVICE_NOT_FOUND == callback_result) {
- LoggerE("Not found");
- ret = PlatformResult(ErrorCode::SERVICE_NOT_AVAILABLE_ERR, "Not found");
-
- } else {
- LoggerE("Unknown exception");
- ret = PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown exception");
- }
-
- handler->Invoke(ret, response);
- delete handler;
- bt_device_unset_bond_created_cb();
- } else { // unexpected event
- LoggerD("An unexpected bonding detected");
- }
- };
-
- BondingHandler* handler = new BondingHandler(callback_handle, address);
- bt_device_set_bond_created_cb(bond_create_callback, handler);
- int ret = bt_device_create_bond(address.c_str());
-
- switch(ret) {
- case BT_ERROR_NONE:
- {
- LoggerD("bt_device_create_bond() succeeded");
- break;
- }
- case BT_ERROR_INVALID_PARAMETER:
- {
- LoggerE("Not found");
- bt_device_unset_bond_created_cb();
- delete handler;
- result = PlatformResult(ErrorCode::INVALID_VALUES_ERR, "Invalid value");
- break;
- }
- default:
- {
- LoggerE("Unknown exception");
- bt_device_unset_bond_created_cb();
- delete handler;
- result = PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown exception");
- }
- }
- } else if (result.IsSuccess()) {
- LoggerE("Bluetooth device is turned off");
- result = PlatformResult(
- ErrorCode::SERVICE_NOT_AVAILABLE_ERR, "Bluetooth device is turned off");
+ PlatformResult ret = PlatformResult(ErrorCode::NO_ERROR);
+ std::shared_ptr<picojson::value> response =
+ std::shared_ptr<picojson::value>(new picojson::value(picojson::object()));
+ if (!strcmp(handler->address().c_str(), device_info->remote_address)) { // requested event
+ if (BT_ERROR_NONE == callback_result && nullptr != device_info ) {
+ picojson::object& response_obj = response->get<picojson::object>();
+ picojson::value result = picojson::value(picojson::object());
+ picojson::object& result_obj = result.get<picojson::object>();
+
+ BluetoothDevice::ToJson(device_info, &result_obj);
+ ReportSuccess(result, response_obj);
+ } else if (BT_ERROR_REMOTE_DEVICE_NOT_FOUND == callback_result) {
+ LoggerE("Not found");
+ ret = PlatformResult(ErrorCode::SERVICE_NOT_AVAILABLE_ERR, "Not found");
+
+ } else {
+ LoggerE("Unknown exception");
+ ret = PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown exception");
+ }
+
+ handler->Invoke(ret, response);
+ delete handler;
+ bt_device_unset_bond_created_cb();
+ } else { // unexpected event
+ LoggerD("An unexpected bonding detected");
}
+ };
+
+ BondingHandler* handler = new BondingHandler(callback_handle, address);
+ bt_device_set_bond_created_cb(bond_create_callback, handler);
+ int ret = bt_device_create_bond(address.c_str());
- if (result.IsError()) {
- util::AsyncResponse(callback_handle, result);
+ switch(ret) {
+ case BT_ERROR_NONE:
+ {
+ LoggerD("bt_device_create_bond() succeeded");
+ break;
}
- };
- TaskQueue::GetInstance().Queue(create_bonding);
- ReportSuccess(out);
+ case BT_ERROR_INVALID_PARAMETER:
+ {
+ LoggerE("Not found");
+ bt_device_unset_bond_created_cb();
+ delete handler;
+ result = PlatformResult(ErrorCode::INVALID_VALUES_ERR, "Invalid value");
+ break;
+ }
+ default:
+ {
+ LoggerE("Unknown exception");
+ bt_device_unset_bond_created_cb();
+ delete handler;
+ result = PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown exception");
+ }
+ }
+ } else if (result.IsSuccess()) {
+ LoggerE("Bluetooth device is turned off");
+ result = PlatformResult(
+ ErrorCode::SERVICE_NOT_AVAILABLE_ERR, "Bluetooth device is turned off");
+ }
+
+ if (result.IsError()) {
+ util::AsyncResponse(callback_handle, result);
+ }
+ };
+ TaskQueue::GetInstance().Queue(create_bonding);
+ ReportSuccess(out);
}
void BluetoothAdapter::DestroyBonding(const picojson::value& data, picojson::object& out)
{
- LoggerD("Entered");
+ LoggerD("Entered");
- util::CheckAccess(Privilege::kBluetoothGap);
+ util::CheckAccess(Privilege::kBluetoothGap);
- const auto callback_handle = util::GetAsyncCallbackHandle(data);
- const auto& args = util::GetArguments(data);
+ const auto callback_handle = util::GetAsyncCallbackHandle(data);
+ const auto& args = util::GetArguments(data);
- const auto& address = FromJson<std::string>(args, "address");
+ const auto& address = FromJson<std::string>(args, "address");
- auto destroy_bonding = [address, callback_handle, this]() -> void {
- PlatformResult result = PlatformResult(ErrorCode::NO_ERROR);
- if(!IsValidAddress(address)) {
- result = PlatformResult(ErrorCode::NOT_FOUND_ERR, "Wrong address");
- }
- if (result.IsSuccess() && !this->is_initialized()) {
- result = PlatformResult(
- ErrorCode::UNKNOWN_ERR, "Bluetooth service is not initialized.");
- }
+ auto destroy_bonding = [address, callback_handle, this]() -> void {
+ PlatformResult result = PlatformResult(ErrorCode::NO_ERROR);
+ if(!IsValidAddress(address)) {
+ result = PlatformResult(ErrorCode::NOT_FOUND_ERR, "Wrong address");
+ }
+ if (result.IsSuccess() && !this->is_initialized()) {
+ result = PlatformResult(ErrorCode::UNKNOWN_ERR, "Bluetooth service is not initialized.");
+ }
+
+ if (result.IsSuccess() && this->get_powered()) {
+ bt_device_info_s *device_info = nullptr;
+ int ret = bt_adapter_get_bonded_device_info(address.c_str(), &device_info);
+
+ if (BT_ERROR_NONE != ret || nullptr == device_info) {
+ LoggerD("There is no bonding");
+ result = PlatformResult(ErrorCode::NOT_FOUND_ERR, "Not found");
+ } else {
+ bt_adapter_free_device_info(device_info);
+
+ auto bond_destroy_callback = [](int callback_result,
+ char *remote_address,
+ void *user_data) {
+ LoggerD("bond_destroy_callback");
+
+ BondingHandler* handler = static_cast<BondingHandler*>(user_data);
+ if (!handler) {
+ LoggerW("user_data is nullptr");
+ return;
+ }
+
+ PlatformResult ret = PlatformResult(ErrorCode::NO_ERROR);
+ std::shared_ptr<picojson::value> response =
+ std::shared_ptr<picojson::value>(new picojson::value(picojson::object()));
- if (result.IsSuccess() && this->get_powered()) {
- bt_device_info_s *device_info = nullptr;
- int ret = bt_adapter_get_bonded_device_info(address.c_str(), &device_info);
-
- if (BT_ERROR_NONE != ret || nullptr == device_info) {
- LoggerD("There is no bonding");
- result = PlatformResult(ErrorCode::NOT_FOUND_ERR, "Not found");
- } else {
- bt_adapter_free_device_info(device_info);
-
- auto bond_destroy_callback = [](int callback_result,
- char *remote_address,
- void *user_data) {
- LoggerD("bond_destroy_callback");
-
- BondingHandler* handler = static_cast<BondingHandler*>(user_data);
- if (!handler) {
- LoggerW("user_data is nullptr");
- return;
- }
-
- PlatformResult ret = PlatformResult(ErrorCode::NO_ERROR);
- std::shared_ptr<picojson::value> response =
- std::shared_ptr<picojson::value>(new picojson::value(picojson::object()));
-
- if (!strcmp(handler->address().c_str(), remote_address)) { // requested event
- if (BT_ERROR_NONE != callback_result) {
- LoggerE("Unknown exception");
- ret = PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown exception");
- }
-
- handler->Invoke(ret, response);
- delete handler;
- bt_device_unset_bond_destroyed_cb();
- } else { // unexpected event
- LoggerD("An unexpected bonding detected");
- }
- };
-
- BondingHandler* handler = new BondingHandler(callback_handle, address);
- bt_device_set_bond_destroyed_cb(bond_destroy_callback, handler);
-
- int ret = bt_device_destroy_bond(address.c_str());
-
- switch(ret) {
- case BT_ERROR_NONE:
- {
- LoggerD("bt_device_destroy_bond() succeeded");
- break;
- }
- case BT_ERROR_INVALID_PARAMETER:
- {
- LoggerE("Not found");
- bt_device_unset_bond_destroyed_cb();
- delete handler;
- result = PlatformResult(ErrorCode::INVALID_VALUES_ERR, "Invalid value");
- break;
- }
- default:
- {
- LoggerE("Unknown exception");
- bt_device_unset_bond_destroyed_cb();
- delete handler;
- result = PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown exception");
- }
- }
+ if (!strcmp(handler->address().c_str(), remote_address)) { // requested event
+ if (BT_ERROR_NONE != callback_result) {
+ LoggerE("Unknown exception");
+ ret = PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown exception");
}
- } else if (result.IsSuccess()) {
- LoggerE("Bluetooth device is turned off");
- result = PlatformResult(
- ErrorCode::SERVICE_NOT_AVAILABLE_ERR, "Bluetooth device is turned off");
- }
- if (result.IsError()) {
- util::AsyncResponse(callback_handle, result);
+ handler->Invoke(ret, response);
+ delete handler;
+ bt_device_unset_bond_destroyed_cb();
+ } else { // unexpected event
+ LoggerD("An unexpected bonding detected");
+ }
+ };
+
+ BondingHandler* handler = new BondingHandler(callback_handle, address);
+ bt_device_set_bond_destroyed_cb(bond_destroy_callback, handler);
+
+ int ret = bt_device_destroy_bond(address.c_str());
+
+ switch(ret) {
+ case BT_ERROR_NONE:
+ {
+ LoggerD("bt_device_destroy_bond() succeeded");
+ break;
+ }
+ case BT_ERROR_INVALID_PARAMETER:
+ {
+ LoggerE("Not found");
+ bt_device_unset_bond_destroyed_cb();
+ delete handler;
+ result = PlatformResult(ErrorCode::INVALID_VALUES_ERR, "Invalid value");
+ break;
+ }
+ default:
+ {
+ LoggerE("Unknown exception");
+ bt_device_unset_bond_destroyed_cb();
+ delete handler;
+ result = PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown exception");
+ }
}
- };
- TaskQueue::GetInstance().Queue(destroy_bonding);
- ReportSuccess(out);
+ }
+ } else if (result.IsSuccess()) {
+ LoggerE("Bluetooth device is turned off");
+ result = PlatformResult(
+ ErrorCode::SERVICE_NOT_AVAILABLE_ERR, "Bluetooth device is turned off");
+ }
+
+ if (result.IsError()) {
+ util::AsyncResponse(callback_handle, result);
+ }
+ };
+ TaskQueue::GetInstance().Queue(destroy_bonding);
+ ReportSuccess(out);
}
void BluetoothAdapter::RegisterRFCOMMServiceByUUID(const picojson::value& data, picojson::object& out) {
- LoggerD("Entered");
+ LoggerD("Entered");
- util::CheckAccess(Privilege::kBluetoothSpp);
+ util::CheckAccess(Privilege::kBluetoothSpp);
- const auto callback_handle = util::GetAsyncCallbackHandle(data);
- const auto& args = util::GetArguments(data);
+ const auto callback_handle = util::GetAsyncCallbackHandle(data);
+ const auto& args = util::GetArguments(data);
- const auto& uuid = FromJson<std::string>(args, "uuid");
- const auto& name = FromJson<std::string>(args, "name");
+ const auto& uuid = FromJson<std::string>(args, "uuid");
+ const auto& name = FromJson<std::string>(args, "name");
- auto rfcomm = [this, uuid, name](const std::shared_ptr<picojson::value>& response) -> void {
- PlatformResult result = PlatformResult(ErrorCode::NO_ERROR);
- if (!this->is_initialized()) {
- result = PlatformResult(
- ErrorCode::UNKNOWN_ERR, "Bluetooth service is not initialized.");
- }
+ auto rfcomm = [this, uuid, name](const std::shared_ptr<picojson::value>& response) -> void {
+ PlatformResult result = PlatformResult(ErrorCode::NO_ERROR);
+ if (!this->is_initialized()) {
+ result = PlatformResult(ErrorCode::UNKNOWN_ERR, "Bluetooth service is not initialized.");
+ }
- if (result.IsSuccess() && !IsValidUUID(uuid)) {
- result = PlatformResult(ErrorCode::INVALID_VALUES_ERR, "Wrong UUID");
- }
+ if (result.IsSuccess() && !IsValidUUID(uuid)) {
+ result = PlatformResult(ErrorCode::INVALID_VALUES_ERR, "Wrong UUID");
+ }
+
+ if (result.IsSuccess() && this->get_powered()) {
+ bool is_registered = false;
+ int ret = bt_adapter_is_service_used(uuid.c_str(), &is_registered);
+
+ if (BT_ERROR_NONE == ret && is_registered) {
+ result = PlatformResult(ErrorCode::SERVICE_NOT_AVAILABLE_ERR, "Already requested");
+ } else {
+ int socket = -1;
+ ret = bt_socket_create_rfcomm(uuid.c_str(), &socket);
+
+ switch (ret) {
+ case BT_ERROR_NONE: {
+ int ret_in = bt_socket_listen_and_accept_rfcomm(socket, 0);
+ switch(ret_in) {
+ case BT_ERROR_NONE: {
+ LoggerD("bt_socket_listen() succeeded");
+ bt_socket_set_connection_state_changed_cb(OnSocketConnected, this);
- if (result.IsSuccess() && this->get_powered()) {
- bool is_registered = false;
- int ret = bt_adapter_is_service_used(uuid.c_str(), &is_registered);
-
- if (BT_ERROR_NONE == ret && is_registered) {
- result = PlatformResult(ErrorCode::SERVICE_NOT_AVAILABLE_ERR, "Already requested");
- } else {
- int socket = -1;
- ret = bt_socket_create_rfcomm(uuid.c_str(), &socket);
-
- switch (ret) {
- case BT_ERROR_NONE: {
- int ret_in = bt_socket_listen_and_accept_rfcomm(socket, 0);
- switch(ret_in) {
- case BT_ERROR_NONE: {
- LoggerD("bt_socket_listen() succeeded");
- bt_socket_set_connection_state_changed_cb(OnSocketConnected, this);
-
- registered_uuids_.insert(std::make_pair(uuid,
- std::make_pair(socket, false)));
-
- ReportSuccess(response->get<picojson::object>());
- break;
- }
-
- case BT_ERROR_INVALID_PARAMETER: {
- result = PlatformResult(
- ErrorCode::INVALID_VALUES_ERR, "Invalid value");
- break;
- }
-
- default: {
- result = PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error");
- break;
- }
- }
- break;
- }
- case BT_ERROR_INVALID_PARAMETER:
- result = PlatformResult(ErrorCode::INVALID_VALUES_ERR, "Invalid value");
- break;
- default:
- result = PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error");
- break;
- }
+ registered_uuids_.insert(std::make_pair(uuid,
+ std::make_pair(socket, false)));
+
+ ReportSuccess(response->get<picojson::object>());
+ break;
+ }
+
+ case BT_ERROR_INVALID_PARAMETER: {
+ result = PlatformResult(ErrorCode::INVALID_VALUES_ERR, "Invalid value");
+ break;
+ }
+
+ default: {
+ result = PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error");
+ break;
+ }
}
- } else if (result.IsSuccess()) {
- result = PlatformResult(
- ErrorCode::SERVICE_NOT_AVAILABLE_ERR, "Bluetooth device is turned off");
+ break;
+ }
+ case BT_ERROR_INVALID_PARAMETER:
+ result = PlatformResult(ErrorCode::INVALID_VALUES_ERR, "Invalid value");
+ break;
+ default:
+ result = PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error");
+ break;
}
+ }
+ } else if (result.IsSuccess()) {
+ result = PlatformResult(
+ ErrorCode::SERVICE_NOT_AVAILABLE_ERR, "Bluetooth device is turned off");
+ }
- if (result.IsError()) {
-
ReportError(result, &response->get<picojson::object>());
- }
- };
+ if (result.IsError()) {
+ ReportError(result, &response->get<picojson::object>());
+ }
+ };
-
auto rfcomm_response = [callback_handle](const std::shared_ptr<picojson::value>& response) -> void {
- util::SyncResponse(callback_handle, response);
- };
+ auto rfcomm_response = [callback_handle](const std::shared_ptr<picojson::value>& response) -> void {
+ util::SyncResponse(callback_handle, response);
+ };
- TaskQueue::GetInstance().Queue<picojson::value>(rfcomm, rfcomm_response,
- std::shared_ptr<picojson::value>(new picojson::value(picojson::object())));
+ TaskQueue::GetInstance().Queue<picojson::value>(
+ rfcomm,
+ rfcomm_response,
+ std::shared_ptr<picojson::value>(new picojson::value(picojson::object())));
- ReportSuccess(out);
+ ReportSuccess(out);
}
void BluetoothAdapter::UnregisterUUID(const std::string& uuid, int callback_handle) {
- LoggerD("Entered");
+ LoggerD("Entered");
- PlatformResult result = PlatformResult(ErrorCode::NO_ERROR);
- if (!IsValidUUID(uuid)) {
- result = PlatformResult(ErrorCode::INVALID_VALUES_ERR, "Wrong UUID");
- }
+ PlatformResult result = PlatformResult(ErrorCode::NO_ERROR);
+ if (!IsValidUUID(uuid)) {
+ result = PlatformResult(ErrorCode::INVALID_VALUES_ERR, "Wrong UUID");
+ }
- if (result.IsSuccess() && is_powered_) {
- auto iter = registered_uuids_.find(uuid);
- if (iter != registered_uuids_.end()) {
- if (BT_ERROR_NONE == bt_socket_destroy_rfcomm(iter->second.first)) {
- registered_uuids_.erase(iter);
- } else {
- result = PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown exception");
- }
- }
+ if (result.IsSuccess() && is_powered_) {
+ auto iter = registered_uuids_.find(uuid);
+ if (iter != registered_uuids_.end()) {
+ if (BT_ERROR_NONE == bt_socket_destroy_rfcomm(iter->second.first)) {
+ registered_uuids_.erase(iter);
+ } else {
+ result = PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown exception");
+ }
+ }
- if (registered_uuids_.size() == 0 &&
- connection_requests_.size() == 0 &&
- connected_sockets_.size() == 0) {
- bt_socket_unset_connection_state_changed_cb();
- }
- } else if (result.IsSuccess()){
- result = PlatformResult(
- ErrorCode::SERVICE_NOT_AVAILABLE_ERR, "Bluetooth device is turned off");
+ if (registered_uuids_.size() == 0 &&
+ connection_requests_.size() == 0 &&
+ connected_sockets_.size() == 0) {
+ bt_socket_unset_connection_state_changed_cb();
}
+ } else if (result.IsSuccess()){
+ result = PlatformResult(ErrorCode::SERVICE_NOT_AVAILABLE_ERR, "Bluetooth device is turned off");
+ }
- util::AsyncResponse(callback_handle, result);
+ util::AsyncResponse(callback_handle, result);
}
void BluetoothAdapter::GetBluetoothProfileHandler(const picojson::value& data,
picojson::object& out) {
- LoggerD("Entered");
-
- const auto& args = util::GetArguments(data);
- auto profile = FromJson<std::string>(args, "profileType");
+ LoggerD("Entered");
- PlatformResult result = PlatformResult(ErrorCode::NO_ERROR);
+ const auto& args = util::GetArguments(data);
+ auto profile = FromJson<std::string>(args, "profileType");
- if (kBluetoothProfileHealth == profile) {
- bool supported = false;
- if (SYSTEM_INFO_ERROR_NONE != system_info_get_platform_bool(kFeatureBluetoothHealth.c_str(),
- &supported)) {
- LoggerW("Can't check if BT health profile is supported or not");
- }
+ PlatformResult result = PlatformResult(ErrorCode::NO_ERROR);
- if (!supported) {
- result = PlatformResult(
- ErrorCode::NOT_SUPPORTED_ERR, "Bluetooth health profile is not supported");
- } else {
- LoggerD("BT health profile is supported");
- }
- } else {
- result = PlatformResult(ErrorCode::TYPE_MISMATCH_ERR, "Wrong profile type.");
+ if (kBluetoothProfileHealth == profile) {
+ bool supported = false;
+ if (SYSTEM_INFO_ERROR_NONE !=
+ system_info_get_platform_bool(kFeatureBluetoothHealth.c_str(), &supported)) {
+ LoggerW("Can't check if BT health profile is supported or not");
}
- if (result.IsSuccess()) {
- ReportSuccess(out);
+ if (!supported) {
+ result = PlatformResult(
+ ErrorCode::NOT_SUPPORTED_ERR, "Bluetooth health profile is not supported");
} else {
- ReportError(result, &out);
+ LoggerD("BT health profile is supported");
}
+ } else {
+ result = PlatformResult(ErrorCode::TYPE_MISMATCH_ERR, "Wrong profile type.");
+ }
+
+ if (result.IsSuccess()) {
+ ReportSuccess(out);
+ } else {
+ ReportError(result, &out);
+ }
}
void BluetoothAdapter::GetName(const picojson::value& /* data */, picojson::object& out) {
- LoggerD("Entered");
+ LoggerD("Entered");
- ReportSuccess(picojson::value(get_name()), out);
+ ReportSuccess(picojson::value(get_name()), out);
}
void BluetoothAdapter::GetAddress(const picojson::value& /* data */, picojson::object& out) {
- LoggerD("Entered");
+ LoggerD("Entered");
- if (!is_initialized_) {
- ReportError(PlatformResult(
- ErrorCode::UNKNOWN_ERR, "Bluetooth service is not initialized."), &out);
- return;
- }
+ if (!is_initialized_) {
+ ReportError(PlatformResult(
+ ErrorCode::UNKNOWN_ERR, "Bluetooth service is not initialized."), &out);
+ return;
+ }
- std::string str_address = "";
- char* address = nullptr;
- if (BT_ERROR_NONE == bt_adapter_get_address(&address)) {
- if (address) {
- str_address = address;
- free(address);
- }
+ std::string str_address = "";
+ char* address = nullptr;
+ if (BT_ERROR_NONE == bt_adapter_get_address(&address)) {
+ if (address) {
+ str_address = address;
+ free(address);
}
+ }
- ReportSuccess(picojson::value(str_address), out);
+ ReportSuccess(picojson::value(str_address), out);
}
void BluetoothAdapter::GetPowered(const picojson::value& /* data */, picojson::object& out) {
- LoggerD("Entered");
+ LoggerD("Entered");
- ReportSuccess(picojson::value(is_powered_), out);
+ ReportSuccess(picojson::value(is_powered_), out);
}
void BluetoothAdapter::GetVisible(const picojson::value& /* data */, picojson::object& out) {
- LoggerD("Entered");
+ LoggerD("Entered");
- ReportSuccess(picojson::value(get_visible()), out);
+ ReportSuccess(picojson::value(get_visible()), out);
}
-void BluetoothAdapter::OnSocketConnected(int result,
- bt_socket_connection_state_e state,
- bt_socket_connection_s* connection,
- void* user_data) {
- LoggerD("Entered");
+void BluetoothAdapter::OnSocketConnected(
+ int result,
+ bt_socket_connection_state_e state,
+ bt_socket_connection_s* connection,
+ void* user_data) {
+ LoggerD("Entered");
- BluetoothAdapter* object = static_cast<BluetoothAdapter*>(user_data);
+ BluetoothAdapter* object = static_cast<BluetoothAdapter*>(user_data);
- if (!object) {
- LoggerW("user_data is NULL");
- return;
- }
+ if (!object) {
+ LoggerW("user_data is NULL");
+ return;
+ }
- if (!connection) {
- LoggerW("connection is NULL");
- return;
- }
+ if (!connection) {
+ LoggerW("connection is NULL");
+ return;
+ }
- if (BT_SOCKET_SERVER == connection->local_role) {
- LoggerD("Server");
+ if (BT_SOCKET_SERVER == connection->local_role) {
+ LoggerD("Server");
- const auto iter = object->registered_uuids_.find(connection->service_uuid);
- if (iter == object->registered_uuids_.end()) {
- LoggerW("Connection state has changed unexpectedly");
- return;
- }
+ const auto iter = object->registered_uuids_.find(connection->service_uuid);
+ if (iter == object->registered_uuids_.end()) {
+ LoggerW("Connection state has changed unexpectedly");
+ return;
+ }
- if (BT_SOCKET_CONNECTED == state) { // connected when Server
- if (BT_ERROR_NONE == result) {
- // Update registered_uuids_ state
- iter->second.second = true;
+ if (BT_SOCKET_CONNECTED == state) { // connected when Server
+ if (BT_ERROR_NONE == result) {
+ // Update registered_uuids_ state
+ iter->second.second = true;
- // Call BluetoothServiceHandler.onconnect
- util::FireEvent("BLUETOOTH_SERVICE_ONCONNECT", BluetoothSocket::ToJson(connection));
+ // Call BluetoothServiceHandler.onconnect
+ util::FireEvent("BLUETOOTH_SERVICE_ONCONNECT", BluetoothSocket::ToJson(connection));
- // Update connected_sockets_
- object->connected_sockets_.push_back(connection->socket_fd);
- bt_socket_set_data_received_cb(OnSocketReceivedData, user_data);
- } else {
- LoggerW("Establishing a connection failed");
- }
- return;
- } else { // disconnected when Server
- if (BT_ERROR_NONE == result) {
- // Update registered_uuids_ state
- iter->second.second = false;
+ // Update connected_sockets_
+ object->connected_sockets_.push_back(connection->socket_fd);
+ bt_socket_set_data_received_cb(OnSocketReceivedData, user_data);
+ } else {
+ LoggerW("Establishing a connection failed");
+ }
+ return;
+ } else { // disconnected when Server
+ if (BT_ERROR_NONE == result) {
+ // Update registered_uuids_ state
+ iter->second.second = false;
+ object->RemoveSocket(connection->socket_fd);
+ }
+ else {
+ LoggerW("Disconnecting a connection failed");
+ }
+ }
+ } else if (BT_SOCKET_CLIENT == connection->local_role) {
+ LoggerD("Client");
- object->RemoveSocket(connection->socket_fd);
- }
- else {
- LoggerW("Disconnecting a connection failed");
- }
+ if (BT_SOCKET_CONNECTED == state) { // connected when Client
+ const auto range = object->connection_requests_.equal_range(connection->remote_address);
+ const auto end = object->connection_requests_.end();
+ auto request = end;
+
+ for (auto it = range.first; it != range.second; ++it) {
+ if (strcmp(it->second->uuid_.c_str(), connection->service_uuid) == 0) {
+ request = it;
+ break;
}
- } else if (BT_SOCKET_CLIENT == connection->local_role) {
- LoggerD("Client");
-
- if (BT_SOCKET_CONNECTED == state) { // connected when Client
- const auto range = object->connection_requests_.equal_range(connection->remote_address);
- const auto end = object->connection_requests_.end();
- auto request = end;
-
- for (auto it = range.first; it != range.second; ++it) {
- if (strcmp(it->second->uuid_.c_str(), connection->service_uuid) == 0) {
- request = it;
- break;
- }
- }
+ }
- if (end == request) {
- LoggerW("Connection state has changed unexpectedly");
- return;
- }
+ if (end == request) {
+ LoggerW("Connection state has changed unexpectedly");
+ return;
+ }
-
std::shared_ptr<picojson::value> response =
-
std::shared_ptr<picojson::value>(new picojson::value(picojson::object()));
+ std::shared_ptr<picojson::value> response =
+ std::shared_ptr<picojson::value>(new picojson::value(picojson::object()));
- if (BT_ERROR_NONE == result) {
- object->connected_sockets_.push_back(connection->socket_fd);
- bt_socket_set_data_received_cb(OnSocketReceivedData, user_data);
+ if (BT_ERROR_NONE == result) {
+ object->connected_sockets_.push_back(connection->socket_fd);
+ bt_socket_set_data_received_cb(OnSocketReceivedData, user_data);
- ReportSuccess(BluetoothSocket::ToJson(connection),
- response->get<picojson::object>());
- } else {
- ReportError(PlatformResult(
- ErrorCode::NOT_FOUND_ERR, "Not found"), &response->get<picojson::object>());
- }
+ ReportSuccess(BluetoothSocket::ToJson(connection), response->get<picojson::object>());
+ } else {
+ ReportError(PlatformResult(
+ ErrorCode::NOT_FOUND_ERR, "Not found"), &response->get<picojson::object>());
+ }
- util::AsyncResponse(request->second->callback_handle_, response);
+ util::AsyncResponse(request->second->callback_handle_, response);
- // request has been handled, can be safely removed
- object->connection_requests_.erase(request);
- } else { // disconnected when Client
- if (result == BT_ERROR_NONE) {
- object->RemoveSocket(connection->socket_fd);
- } else {
- LoggerW("Disconnecting a connection failed");
- }
- }
- } else {
- LoggerW("Unknown role");
- return;
+ // request has been handled, can be safely removed
+ object->connection_requests_.erase(request);
+ } else { // disconnected when Client
+ if (result == BT_ERROR_NONE) {
+ object->RemoveSocket(connection->socket_fd);
+ } else {
+ LoggerW("Disconnecting a connection failed");
+ }
}
+ } else {
+ LoggerW("Unknown role");
+ return;
+ }
- if (object->connected_sockets_.size() == 0) {
- bt_socket_unset_data_received_cb();
- }
+ if (object->connected_sockets_.size() == 0) {
+ bt_socket_unset_data_received_cb();
+ }
- if (object->registered_uuids_.size() == 0 &&
- object->connection_requests_.size() == 0 &&
- object->connected_sockets_.size() == 0) {
- bt_socket_unset_connection_state_changed_cb();
- }
+ if (object->registered_uuids_.size() == 0 &&
+ object->connection_requests_.size() == 0 &&
+ object->connected_sockets_.size() == 0) {
+ bt_socket_unset_connection_state_changed_cb();
+ }
}
void BluetoothAdapter::OnSocketReceivedData(bt_socket_received_data_s* data, void* user_data) {
- LoggerD("Entered");
+ LoggerD("Entered");
- BluetoothAdapter* object = static_cast<BluetoothAdapter*>(user_data);
+ BluetoothAdapter* object = static_cast<BluetoothAdapter*>(user_data);
- if (!object) {
- LoggerW("user_data is NULL");
- return;
- }
+ if (!object) {
+ LoggerW("user_data is NULL");
+ return;
+ }
- if (!data) {
- LoggerW("data is NULL");
- return;
- }
+ if (!data) {
+ LoggerW("data is NULL");
+ return;
+ }
- const auto it = std::find(object->connected_sockets_.begin(),
- object->connected_sockets_.end(),
- data->socket_fd);
+ const auto it = std::find(object->connected_sockets_.begin(),
+ object->connected_sockets_.end(),
+ data->socket_fd);
- if (it == object->connected_sockets_.end()) {
- LoggerW("Unknown connected socket: %d", data->socket_fd);
- return;
- }
+ if (it == object->connected_sockets_.end()) {
+ LoggerW("Unknown connected socket: %d", data->socket_fd);
+ return;
+ }
- // Store received data
- object->StoreSocketData(data);
+ // Store received data
+ object->StoreSocketData(data);
- InvokeSocketOnMessageEvent(*it);
+ InvokeSocketOnMessageEvent(*it);
}
-void BluetoothAdapter::ConnectToServiceByUUID(const std::string& address,
- const std::string& uuid,
- double callback_handle) {
- LoggerD("Entered");
+void BluetoothAdapter::ConnectToServiceByUUID(
+ const std::string& address,
+ const std::string& uuid,
+ double callback_handle) {
+ LoggerD("Entered");
- PlatformResult result = PlatformResult(ErrorCode::NO_ERROR);
+ PlatformResult result = PlatformResult(ErrorCode::NO_ERROR);
- if (!IsValidUUID(uuid)) {
- result = PlatformResult(ErrorCode::INVALID_VALUES_ERR, "Wrong UUID");
- }
+ if (!IsValidUUID(uuid)) {
+ result = PlatformResult(ErrorCode::INVALID_VALUES_ERR, "Wrong UUID");
+ }
- if (result.IsSuccess() && is_powered_) {
- int ret = bt_socket_connect_rfcomm(address.c_str(), uuid.c_str());
+ if (result.IsSuccess() && is_powered_) {
+ int ret = bt_socket_connect_rfcomm(address.c_str(), uuid.c_str());
- switch (ret) {
- case BT_ERROR_NONE: {
- LoggerD("bt_socket_connect_rfcomm() succeeded");
+ switch (ret) {
+ case BT_ERROR_NONE: {
+ LoggerD("bt_socket_connect_rfcomm() succeeded");
- ConnectionRequestPtr request{new ConnectionRequest()};
- request->uuid_ = uuid;
- request->callback_handle_ = callback_handle;
- connection_requests_.insert(std::make_pair(address, request));
+ ConnectionRequestPtr request{new ConnectionRequest()};
+ request->uuid_ = uuid;
+ request->callback_handle_ = callback_handle;
+ connection_requests_.insert(std::make_pair(address, request));
- bt_socket_set_connection_state_changed_cb(OnSocketConnected, this);
- break;
- }
+ bt_socket_set_connection_state_changed_cb(OnSocketConnected, this);
+ break;
+ }
- case BT_ERROR_INVALID_PARAMETER:
- case BT_ERROR_REMOTE_DEVICE_NOT_BONDED:
- result = PlatformResult(ErrorCode::INVALID_VALUES_ERR, "Invalid value");
- break;
- default:
- result = PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error");
- break;
- }
- } else if (result.IsSuccess()) {
- result = PlatformResult(
- ErrorCode::SERVICE_NOT_AVAILABLE_ERR, "Bluetooth device is turned off");
+ case BT_ERROR_INVALID_PARAMETER:
+ case BT_ERROR_REMOTE_DEVICE_NOT_BONDED:
+ result = PlatformResult(ErrorCode::INVALID_VALUES_ERR, "Invalid value");
+ break;
+ default:
+ result = PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error");
+ break;
}
+ } else if (result.IsSuccess()) {
+ result = PlatformResult(ErrorCode::SERVICE_NOT_AVAILABLE_ERR, "Bluetooth device is turned off");
+ }
- if (result.IsError()) {
- util::AsyncResponse(callback_handle, result);
- }
+ if (result.IsError()) {
+ util::AsyncResponse(callback_handle, result);
+ }
}
static void InvokeSocketEvent(int id, const char* event) {
- picojson::value value = picojson::value(picojson::object());
-
picojson::object& value_obj = value.get<picojson::object>();
- value_obj.insert(std::make_pair("id", picojson::value(std::to_string(id))));
- value_obj.insert(std::make_pair("event", picojson::value(event)));
- util::FireEvent("BLUETOOTH_SOCKET_STATE_CHANGED", value);
+ picojson::value value = picojson::value(picojson::object());
+ picojson::object& value_obj = value.get<picojson::object>();
+ value_obj.insert(std::make_pair("id", picojson::value(std::to_string(id))));
+ value_obj.insert(std::make_pair("event", picojson::value(event)));
+ util::FireEvent("BLUETOOTH_SOCKET_STATE_CHANGED", value);
}
void BluetoothAdapter::InvokeSocketOnMessageEvent(int id) {
- InvokeSocketEvent(id, "onmessage");
+ InvokeSocketEvent(id, "onmessage");
}
void BluetoothAdapter::InvokeSocketOnCloseEvent(int id) {
- InvokeSocketEvent(id, "onclose");
+ InvokeSocketEvent(id, "onclose");
}
void BluetoothAdapter::RemoveSocket(int socket) {
- const auto data_it = socket_data_.find(socket);
+ const auto data_it = socket_data_.find(socket);
- if (data_it != socket_data_.end()) {
- socket_data_.erase(data_it);
- } else {
- LoggerD("No stored data for socket: %d", socket);
- }
+ if (data_it != socket_data_.end()) {
+ socket_data_.erase(data_it);
+ } else {
+ LoggerD("No stored data for socket: %d", socket);
+ }
- const auto it = std::find(connected_sockets_.begin(),
- connected_sockets_.end(),
- socket);
+ const auto it = std::find(connected_sockets_.begin(), connected_sockets_.end(), socket);
- if (it == connected_sockets_.end()) {
- LoggerW("Unknown connected socket: %d", socket);
- return;
- }
+ if (it == connected_sockets_.end()) {
+ LoggerW("Unknown connected socket: %d", socket);
+ return;
+ }
- connected_sockets_.erase(it);
+ connected_sockets_.erase(it);
- BluetoothAdapter::InvokeSocketOnCloseEvent(*it);
+ BluetoothAdapter::InvokeSocketOnCloseEvent(*it);
}
void BluetoothAdapter::StoreSocketData(bt_socket_received_data_s* data) {
- LoggerD("Entered");
+ LoggerD("Entered");
- auto data_store = socket_data_[data->socket_fd];
+ auto data_store = socket_data_[data->socket_fd];
- for (int i = 0; i < data->data_size; ++i) {
- data_store.push_back(data->data[i]);
- }
+ for (int i = 0; i < data->data_size; ++i) {
+ data_store.push_back(data->data[i]);
+ }
}
const std::list<char>& BluetoothAdapter::ReadSocketData(int socket) {
- LoggerD("Entered");
+ LoggerD("Entered");
- return socket_data_[socket];
+ return socket_data_[socket];
}
void BluetoothAdapter::ClearSocketData(int socket) {
- LoggerD("Entered");
+ LoggerD("Entered");
- const auto data_it = socket_data_.find(socket);
+ const auto data_it = socket_data_.find(socket);
- if (data_it != socket_data_.end()) {
- data_it->second.clear();
- }
+ if (data_it != socket_data_.end()) {
+ data_it->second.clear();
+ }
}
void BluetoothAdapter::IsServiceConnected(const picojson::value& data, picojson::object& out) {
- LoggerD("Entered");
+ LoggerD("Entered");
- const auto& args = util::GetArguments(data);
- const auto& uuid = FromJson<std::string>(args, "uuid");
+ const auto& args = util::GetArguments(data);
+ const auto& uuid = FromJson<std::string>(args, "uuid");
- auto iter = registered_uuids_.find(uuid);
- if (iter == registered_uuids_.end()) {
- ReportError(PlatformResult(
- ErrorCode::INVALID_VALUES_ERR, "Invalid parameter was passed."), &out);
- return;
- }
+ auto iter = registered_uuids_.find(uuid);
+ if (iter == registered_uuids_.end()) {
+ ReportError(PlatformResult(
+ ErrorCode::INVALID_VALUES_ERR, "Invalid parameter was passed."), &out);
+ return;
+ }
- ReportSuccess(picojson::value(iter->second.second), out);
+ ReportSuccess(picojson::value(iter->second.second), out);
}
} // namespace bluetooth
namespace bluetooth {
enum AdapterAsyncEvent {
- SET_POWERED = 0,
- SET_NAME,
- SET_VISIBLE,
- DISCOVER_DEVICES,
- STOP_DISCOVERY
+ SET_POWERED = 0,
+ SET_NAME,
+ SET_VISIBLE,
+ DISCOVER_DEVICES,
+ STOP_DISCOVERY
};
class BluetoothAdapter {
-public:
- /**
- * Signature: @code void setName(name, successCallback, errorCallback); @endcode
- * JSON: @code data: {method: 'BluetoothAdapter_setName', args: {name: name}} @endcode
- * Invocation: @code native.call(request, result_callback); @endcode
- * Return:
- * @code
- * {status: 'error', error: {name, message}}
- * {status: 'success'}
- * @endcode
- * Result callback:
- * @code
- * {status: 'error', error: {name, message}}
- * {status: 'success'}
- * @endcode
- */
- void SetName(const picojson::value& data, picojson::object& out);
-
- /**
- * Signature: @code void setPowered(state, successCallback, errorCallback); @endcode
- * JSON: @code data: {method: 'BluetoothAdapter_setPowered', args: {state: state}} @endcode
- * Invocation: @code native.call(request, result_callback); @endcode
- * Return:
- * @code
- * {status: 'error', error: {name, message}}
- * {status: 'success'}
- * @endcode
- * Result callback:
- * @code
- * {status: 'error', error: {name, message}}
- * {status: 'success'}
- * @endcode
- */
- void SetPowered(const picojson::value& data, picojson::object& out);
-
- /**
- * Signature: @code void setVisible(mode, successCallback, errorCallback, timeout); @endcode
- * JSON: @code data: {method: 'BluetoothAdapter_setVisible', args: {mode: mode, timeout: timeout}} @endcode
- * Invocation: @code native.call(request, result_callback); @endcode
- * Return:
- * @code
- * {status: 'error', error: {name, message}}
- * {status: 'success'}
- * @endcode
- * Result callback:
- * @code
- * {status: 'error', error: {name, message}}
- * {status: 'success'}
- * @endcode
- */
- void SetVisible(const picojson::value& data, picojson::object& out);
-
- /**
- * Signature: @code void discoverDevices(discoveryCallback, errorCallback); @endcode
- * JSON: @code data: {method: 'BluetoothAdapter_discoverDevices', args: {discoveryCallbackId: id}} @endcode
- * Invocation: @code native.callSync(request); @endcode
- * Return:
- * @code
- * {status: 'error', error: {name, message}}
- * {status: 'success'}
- * @endcode
- * Discovery callback:
- * @code
- * {status: 'error', error: {name, message}}
- * {status: 'success', result: {event, eventData}}
- * @endcode
- */
- void DiscoverDevices(const picojson::value& data, picojson::object& out);
-
- /**
- * Signature: @code void stopDiscovery(successCallback, errorCallback); @endcode
- * JSON: @code data: {method: 'BluetoothAdapter_stopDiscovery', args: {}} @endcode
- * Invocation: @code native.call(request, result_callback); @endcode
- * Return:
- * @code
- * {status: 'error', error: {name, message}}
- * {status: 'success'}
- * @endcode
- * Result callback:
- * @code
- * {status: 'error', error: {name, message}}
- * {status: 'success'}
- * @endcode
- */
- void StopDiscovery(const picojson::value& data, picojson::object& out);
-
- /**
- * Signature: @code void getKnownDevices(successCallback, errorCallback); @endcode
- * JSON: @code data: {method: 'BluetoothAdapter_getKnownDevices', args: {}} @endcode
- * Invocation: @code native.call(request, result_callback); @endcode
- * Return:
- * @code
- * {status: 'error', error: {name, message}}
- * {status: 'success'}
- * @endcode
- * Result callback:
- * @code
- * {status: 'error', error: {name, message}}
- * {status: 'success', result: {devices[]}}
- * @endcode
- */
- void GetKnownDevices(const picojson::value& data, picojson::object& out);
-
- /**
- * Signature: @code void getDevice(address, successCallback, errorCallback); @endcode
- * JSON: @code data: {method: 'BluetoothAdapter_getDevice', args: {address: address}} @endcode
- * Invocation: @code native.call(request, result_callback); @endcode
- * Return:
- * @code
- * {status: 'error', error: {name, message}}
- * {status: 'success'}
- * @endcode
- * Result callback:
- * @code
- * {status: 'error', error: {name, message}}
- * {status: 'success', result: {device}}
- * @endcode
- */
- void GetDevice(const picojson::value& data, picojson::object& out);
-
- /**
- * Signature: @code void createBonding(address, successCallback, errorCallback); @endcode
- * JSON: @code data: {method: 'BluetoothAdapter_createBonding', args: {address: address}} @endcode
- * Invocation: @code native.call(request, result_callback); @endcode
- * Return:
- * @code
- * {status: 'error', error: {name, message}}
- * {status: 'success'}
- * @endcode
- * Result callback:
- * @code
- * {status: 'error', error: {name, message}}
- * {status: 'success', result: {device}}
- * @endcode
- */
- void CreateBonding(const picojson::value& data, picojson::object& out);
-
- /**
- * Signature: @code void destroyBonding(address, successCallback, errorCallback); @endcode
- * JSON: @code data: {method: 'BluetoothAdapter_destroyBonding', args: {address: address}} @endcode
- * Invocation: @code native.call(request, result_callback); @endcode
- * Return:
- * @code
- * {status: 'error', error: {name, message}}
- * {status: 'success'}
- * @endcode
- * Result callback:
- * @code
- * {status: 'error', error: {name, message}}
- * {status: 'success'}
- * @endcode
- */
- void DestroyBonding(const picojson::value& data, picojson::object& out);
-
- /**
- * Signature: @code void registerRFCOMMServiceByUUID(uuid, name, successCallback, errorCallback); @endcode
- * JSON: @code data: {method: 'BluetoothAdapter_registerRFCOMMServiceByUUID',
- * args: {uuid: uuid, name: name}} @endcode
- * Invocation: @code native.call(request, result_callback); @endcode
- * Return:
- * @code
- * {status: 'error', error: {name, message}}
- * {status: 'success'}
- * @endcode
- * Result callback:
- * @code
- * {status: 'error', error: {name, message}}
- * {status: 'success', result: {handler}}
- * @endcode
- */
- void RegisterRFCOMMServiceByUUID(const picojson::value& data, picojson::object& out);
-
- /**
- * Signature: @code BluetoothProfileHandler getBluetoothProfileHandler(profileType); @endcode
- * JSON: @code data: {method: 'BluetoothAdapter_getBluetoothProfileHandler',
- * args: {profileType: profileType}} @endcode
- * Invocation: @code native.callSync(request); @endcode
- * Return:
- * @code
- * {status: 'error', error: {name, message}}
- * {status: 'success', result: {BluetoothProfileHandler}}
- * @endcode
- */
- void GetBluetoothProfileHandler(const picojson::value& data, picojson::object& out);
-
- /**
- * Signature: @code BluetoothAdapter.name; @endcode
- * JSON: @code data: {method: 'BluetoothAdapter_getName', args: {}} @endcode
- * Invocation: @code native.callSync(request); @endcode
- * Return:
- * @code
- * {status: 'error', error: {name, message}}
- * {status: 'success', result: name}
- * @endcode
- */
- void GetName(const picojson::value& data, picojson::object& out);
-
- /**
- * Signature: @code BluetoothAdapter.address; @endcode
- * JSON: @code data: {method: 'BluetoothAdapter_getAddress', args: {}} @endcode
- * Invocation: @code native.callSync(request); @endcode
- * Return:
- * @code
- * {status: 'error', error: {name, message}}
- * {status: 'success', result: address}
- * @endcode
- */
- void GetAddress(const picojson::value& data, picojson::object& out);
-
- /**
- * Signature: @code BluetoothAdapter.powered; @endcode
- * JSON: @code data: {method: 'BluetoothAdapter_getPowered', args: {}} @endcode
- * Invocation: @code native.callSync(request); @endcode
- * Return:
- * @code
- * {status: 'error', error: {name, message}}
- * {status: 'success', result: powered}
- * @endcode
- */
- void GetPowered(const picojson::value& data, picojson::object& out);
-
- /**
- * Signature: @code BluetoothAdapter.visible; @endcode
- * JSON: @code data: {method: 'BluetoothAdapter_getVisible', args: {}} @endcode
- * Invocation: @code native.callSync(request); @endcode
- * Return:
- * @code
- * {status: 'error', error: {name, message}}
- * {status: 'success', result: visible}
- * @endcode
- */
- void GetVisible(const picojson::value& data, picojson::object& out);
-
- /**
- * Signature: @code BluetoothServiceHandler.isConnected; @endcode
- * JSON: @code data: {method: 'BluetoothAdapter_isConnected', args: {}} @endcode
- * Invocation: @code native.callSync(request); @endcode
- * Return:
- * @code
- * {status: 'error', error: {name, message}}
- * {status: 'success', result: isConnected}
- * @endcode
- */
- void IsServiceConnected(const picojson::value& data, picojson::object& out);
-
- static BluetoothAdapter& GetInstance();
- virtual ~BluetoothAdapter();
-
- std::string get_name() const;
- bool get_visible() const;
- void set_visible(bool visible);
- bool get_powered();
- void set_powered(bool powered);
- bool is_initialized() const;
-
- void ConnectToServiceByUUID(const std::string& address,
- const std::string& uuid,
- double callback_handle);
-
- const std::list<char>& ReadSocketData(int socket);
-
- void ClearSocketData(int socket);
-
- void UnregisterUUID(const std::string& uuid, int callback_handle);
-
-private:
- BluetoothAdapter();
- BluetoothAdapter(const BluetoothAdapter&) = delete;
- BluetoothAdapter& operator=(const BluetoothAdapter&) = delete;
-
- static void StateChangedCB(int result,
- bt_adapter_state_e state,
- void *user_data);
- static void NameChangedCB(char *name,
- void *user_data);
- static void VisibilityChangedCB(int result,
- bt_adapter_visibility_mode_e mode,
- void *user_data);
- static void DiscoveryStateChangedCB(int result,
- bt_adapter_device_discovery_state_e discovery_state,
- bt_adapter_device_discovery_info_s *discovery_info,
- void *user_data);
-
- void StoreSocketData(bt_socket_received_data_s* data);
-
- void RemoveSocket(int socket);
-
- static void OnSocketConnected(int result,
- bt_socket_connection_state_e state,
- bt_socket_connection_s* connection,
- void* user_data);
-
- static void OnSocketReceivedData(bt_socket_received_data_s* data,
- void* user_data);
-
- static void InvokeSocketOnMessageEvent(int id);
-
- static void InvokeSocketOnCloseEvent(int id);
-
- bool is_visible_;
- bool is_powered_;
- bool is_initialized_;
- bool user_request_list_ [STOP_DISCOVERY + 1];
- double user_request_callback_ [STOP_DISCOVERY + 1];
-
- bool requested_powered_;
- bt_adapter_visibility_mode_e requested_visibility_;
- std::string requested_name_;
-
- picojson::array discovered_devices_;
- std::set<std::string> discovered_addresses_;
- std::set<std::string> disappeared_addresses_;
-
- struct ConnectionRequest {
- std::string uuid_;
- double callback_handle_;
- };
-
- typedef std::shared_ptr<ConnectionRequest> ConnectionRequestPtr;
- typedef std::multimap<std::string, ConnectionRequestPtr> ConnectionRequestMap;
-
- ConnectionRequestMap connection_requests_;
-
- typedef std::list<int> ConnectedSocketList;
-
- ConnectedSocketList connected_sockets_;
+ public:
+ /**
+ * Signature: @code void setName(name, successCallback, errorCallback); @endcode
+ * JSON: @code data: {method: 'BluetoothAdapter_setName', args: {name: name}} @endcode
+ * Invocation: @code native.call(request, result_callback); @endcode
+ * Return:
+ * @code
+ * {status: 'error', error: {name, message}}
+ * {status: 'success'}
+ * @endcode
+ * Result callback:
+ * @code
+ * {status: 'error', error: {name, message}}
+ * {status: 'success'}
+ * @endcode
+ */
+ void SetName(const picojson::value& data, picojson::object& out);
+
+ /**
+ * Signature: @code void setPowered(state, successCallback, errorCallback); @endcode
+ * JSON: @code data: {method: 'BluetoothAdapter_setPowered', args: {state: state}} @endcode
+ * Invocation: @code native.call(request, result_callback); @endcode
+ * Return:
+ * @code
+ * {status: 'error', error: {name, message}}
+ * {status: 'success'}
+ * @endcode
+ * Result callback:
+ * @code
+ * {status: 'error', error: {name, message}}
+ * {status: 'success'}
+ * @endcode
+ */
+ void SetPowered(const picojson::value& data, picojson::object& out);
+
+ /**
+ * Signature: @code void setVisible(mode, successCallback, errorCallback, timeout); @endcode
+ * JSON: @code data: {method: 'BluetoothAdapter_setVisible', args: {mode: mode, timeout: timeout}} @endcode
+ * Invocation: @code native.call(request, result_callback); @endcode
+ * Return:
+ * @code
+ * {status: 'error', error: {name, message}}
+ * {status: 'success'}
+ * @endcode
+ * Result callback:
+ * @code
+ * {status: 'error', error: {name, message}}
+ * {status: 'success'}
+ * @endcode
+ */
+ void SetVisible(const picojson::value& data, picojson::object& out);
+
+ /**
+ * Signature: @code void discoverDevices(discoveryCallback, errorCallback); @endcode
+ * JSON: @code data: {method: 'BluetoothAdapter_discoverDevices', args: {discoveryCallbackId: id}} @endcode
+ * Invocation: @code native.callSync(request); @endcode
+ * Return:
+ * @code
+ * {status: 'error', error: {name, message}}
+ * {status: 'success'}
+ * @endcode
+ * Discovery callback:
+ * @code
+ * {status: 'error', error: {name, message}}
+ * {status: 'success', result: {event, eventData}}
+ * @endcode
+ */
+ void DiscoverDevices(const picojson::value& data, picojson::object& out);
+
+ /**
+ * Signature: @code void stopDiscovery(successCallback, errorCallback); @endcode
+ * JSON: @code data: {method: 'BluetoothAdapter_stopDiscovery', args: {}} @endcode
+ * Invocation: @code native.call(request, result_callback); @endcode
+ * Return:
+ * @code
+ * {status: 'error', error: {name, message}}
+ * {status: 'success'}
+ * @endcode
+ * Result callback:
+ * @code
+ * {status: 'error', error: {name, message}}
+ * {status: 'success'}
+ * @endcode
+ */
+ void StopDiscovery(const picojson::value& data, picojson::object& out);
+
+ /**
+ * Signature: @code void getKnownDevices(successCallback, errorCallback); @endcode
+ * JSON: @code data: {method: 'BluetoothAdapter_getKnownDevices', args: {}} @endcode
+ * Invocation: @code native.call(request, result_callback); @endcode
+ * Return:
+ * @code
+ * {status: 'error', error: {name, message}}
+ * {status: 'success'}
+ * @endcode
+ * Result callback:
+ * @code
+ * {status: 'error', error: {name, message}}
+ * {status: 'success', result: {devices[]}}
+ * @endcode
+ */
+ void GetKnownDevices(const picojson::value& data, picojson::object& out);
+
+ /**
+ * Signature: @code void getDevice(address, successCallback, errorCallback); @endcode
+ * JSON: @code data: {method: 'BluetoothAdapter_getDevice', args: {address: address}} @endcode
+ * Invocation: @code native.call(request, result_callback); @endcode
+ * Return:
+ * @code
+ * {status: 'error', error: {name, message}}
+ * {status: 'success'}
+ * @endcode
+ * Result callback:
+ * @code
+ * {status: 'error', error: {name, message}}
+ * {status: 'success', result: {device}}
+ * @endcode
+ */
+ void GetDevice(const picojson::value& data, picojson::object& out);
+
+ /**
+ * Signature: @code void createBonding(address, successCallback, errorCallback); @endcode
+ * JSON: @code data: {method: 'BluetoothAdapter_createBonding', args: {address: address}} @endcode
+ * Invocation: @code native.call(request, result_callback); @endcode
+ * Return:
+ * @code
+ * {status: 'error', error: {name, message}}
+ * {status: 'success'}
+ * @endcode
+ * Result callback:
+ * @code
+ * {status: 'error', error: {name, message}}
+ * {status: 'success', result: {device}}
+ * @endcode
+ */
+ void CreateBonding(const picojson::value& data, picojson::object& out);
+
+ /**
+ * Signature: @code void destroyBonding(address, successCallback, errorCallback); @endcode
+ * JSON: @code data: {method: 'BluetoothAdapter_destroyBonding', args: {address: address}} @endcode
+ * Invocation: @code native.call(request, result_callback); @endcode
+ * Return:
+ * @code
+ * {status: 'error', error: {name, message}}
+ * {status: 'success'}
+ * @endcode
+ * Result callback:
+ * @code
+ * {status: 'error', error: {name, message}}
+ * {status: 'success'}
+ * @endcode
+ */
+ void DestroyBonding(const picojson::value& data, picojson::object& out);
+
+ /**
+ * Signature: @code void registerRFCOMMServiceByUUID(uuid, name, successCallback, errorCallback); @endcode
+ * JSON: @code data: {method: 'BluetoothAdapter_registerRFCOMMServiceByUUID',
+ * args: {uuid: uuid, name: name}} @endcode
+ * Invocation: @code native.call(request, result_callback); @endcode
+ * Return:
+ * @code
+ * {status: 'error', error: {name, message}}
+ * {status: 'success'}
+ * @endcode
+ * Result callback:
+ * @code
+ * {status: 'error', error: {name, message}}
+ * {status: 'success', result: {handler}}
+ * @endcode
+ */
+ void RegisterRFCOMMServiceByUUID(const picojson::value& data, picojson::object& out);
+
+ /**
+ * Signature: @code BluetoothProfileHandler getBluetoothProfileHandler(profileType); @endcode
+ * JSON: @code data: {method: 'BluetoothAdapter_getBluetoothProfileHandler',
+ * args: {profileType: profileType}} @endcode
+ * Invocation: @code native.callSync(request); @endcode
+ * Return:
+ * @code
+ * {status: 'error', error: {name, message}}
+ * {status: 'success', result: {BluetoothProfileHandler}}
+ * @endcode
+ */
+ void GetBluetoothProfileHandler(const picojson::value& data, picojson::object& out);
+
+ /**
+ * Signature: @code BluetoothAdapter.name; @endcode
+ * JSON: @code data: {method: 'BluetoothAdapter_getName', args: {}} @endcode
+ * Invocation: @code native.callSync(request); @endcode
+ * Return:
+ * @code
+ * {status: 'error', error: {name, message}}
+ * {status: 'success', result: name}
+ * @endcode
+ */
+ void GetName(const picojson::value& data, picojson::object& out);
+
+ /**
+ * Signature: @code BluetoothAdapter.address; @endcode
+ * JSON: @code data: {method: 'BluetoothAdapter_getAddress', args: {}} @endcode
+ * Invocation: @code native.callSync(request); @endcode
+ * Return:
+ * @code
+ * {status: 'error', error: {name, message}}
+ * {status: 'success', result: address}
+ * @endcode
+ */
+ void GetAddress(const picojson::value& data, picojson::object& out);
+
+ /**
+ * Signature: @code BluetoothAdapter.powered; @endcode
+ * JSON: @code data: {method: 'BluetoothAdapter_getPowered', args: {}} @endcode
+ * Invocation: @code native.callSync(request); @endcode
+ * Return:
+ * @code
+ * {status: 'error', error: {name, message}}
+ * {status: 'success', result: powered}
+ * @endcode
+ */
+ void GetPowered(const picojson::value& data, picojson::object& out);
+
+ /**
+ * Signature: @code BluetoothAdapter.visible; @endcode
+ * JSON: @code data: {method: 'BluetoothAdapter_getVisible', args: {}} @endcode
+ * Invocation: @code native.callSync(request); @endcode
+ * Return:
+ * @code
+ * {status: 'error', error: {name, message}}
+ * {status: 'success', result: visible}
+ * @endcode
+ */
+ void GetVisible(const picojson::value& data, picojson::object& out);
+
+ /**
+ * Signature: @code BluetoothServiceHandler.isConnected; @endcode
+ * JSON: @code data: {method: 'BluetoothAdapter_isConnected', args: {}} @endcode
+ * Invocation: @code native.callSync(request); @endcode
+ * Return:
+ * @code
+ * {status: 'error', error: {name, message}}
+ * {status: 'success', result: isConnected}
+ * @endcode
+ */
+ void IsServiceConnected(const picojson::value& data, picojson::object& out);
+
+ static BluetoothAdapter& GetInstance();
+ virtual ~BluetoothAdapter();
+
+ std::string get_name() const;
+ bool get_visible() const;
+ void set_visible(bool visible);
+ bool get_powered();
+ void set_powered(bool powered);
+ bool is_initialized() const;
+
+ void ConnectToServiceByUUID(const std::string& address,
+ const std::string& uuid,
+ double callback_handle);
+
+ const std::list<char>& ReadSocketData(int socket);
+
+ void ClearSocketData(int socket);
+
+ void UnregisterUUID(const std::string& uuid, int callback_handle);
+
+ private:
+ BluetoothAdapter();
+ BluetoothAdapter(const BluetoothAdapter&) = delete;
+ BluetoothAdapter& operator=(const BluetoothAdapter&) = delete;
+
+ static void StateChangedCB(int result,
+ bt_adapter_state_e state,
+ void *user_data);
+ static void NameChangedCB(char *name,
+ void *user_data);
+ static void VisibilityChangedCB(int result,
+ bt_adapter_visibility_mode_e mode,
+ void *user_data);
+ static void DiscoveryStateChangedCB(int result,
+ bt_adapter_device_discovery_state_e discovery_state,
+ bt_adapter_device_discovery_info_s *discovery_info,
+ void *user_data);
+
+ void StoreSocketData(bt_socket_received_data_s* data);
+
+ void RemoveSocket(int socket);
+
+ static void OnSocketConnected(int result,
+ bt_socket_connection_state_e state,
+ bt_socket_connection_s* connection,
+ void* user_data);
+
+ static void OnSocketReceivedData(bt_socket_received_data_s* data,
+ void* user_data);
+
+ static void InvokeSocketOnMessageEvent(int id);
+
+ static void InvokeSocketOnCloseEvent(int id);
+
+ bool is_visible_;
+ bool is_powered_;
+ bool is_initialized_;
+ bool user_request_list_ [STOP_DISCOVERY + 1];
+ double user_request_callback_ [STOP_DISCOVERY + 1];
+
+ bool requested_powered_;
+ bt_adapter_visibility_mode_e requested_visibility_;
+ std::string requested_name_;
+
+ picojson::array discovered_devices_;
+ std::set<std::string> discovered_addresses_;
+ std::set<std::string> disappeared_addresses_;
+
+ struct ConnectionRequest {
+ std::string uuid_;
+ double callback_handle_;
+ };
+
+ typedef std::shared_ptr<ConnectionRequest> ConnectionRequestPtr;
+ typedef std::multimap<std::string, ConnectionRequestPtr> ConnectionRequestMap;
+
+ ConnectionRequestMap connection_requests_;
+
+ typedef std::list<int> ConnectedSocketList;
+
+ ConnectedSocketList connected_sockets_;
- typedef std::pair<int, bool> BluetoothServicePair; //registered socket - connection state
- typedef std::map<std::string, BluetoothServicePair> RegisteredUuidMap;
+ typedef std::pair<int, bool> BluetoothServicePair; //registered socket - connection state
+ typedef std::map<std::string, BluetoothServicePair> RegisteredUuidMap;
- RegisteredUuidMap registered_uuids_;
+ RegisteredUuidMap registered_uuids_;
- std::unordered_map<int, std::list<char>> socket_data_;
+ std::unordered_map<int, std::list<char>> socket_data_;
};
} // namespace bluetooth
unsigned long BluetoothClass::GetMajorValue(bt_major_device_class_e major)
{
- auto iter = g_major_enum_map.find(major);
- if (iter != g_major_enum_map.end()) {
- return iter->second;
- }
+ auto iter = g_major_enum_map.find(major);
+ if (iter != g_major_enum_map.end()) {
+ return iter->second;
+ }
- return 0;
+ return 0;
}
unsigned long BluetoothClass::GetMinorValue(bt_minor_device_class_e minor)
{
- auto iter = g_minor_enum_map.find(minor);
- if (iter != g_minor_enum_map.end()) {
- return iter->second;
- }
+ auto iter = g_minor_enum_map.find(minor);
+ if (iter != g_minor_enum_map.end()) {
+ return iter->second;
+ }
- return 0;
+ return 0;
}
std::vector<unsigned long> BluetoothClass::getServiceValues(int serviceMask)
{
- std::vector<unsigned long> ret;
- for (auto iter = g_service_enum_map.begin(); iter != g_service_enum_map.end(); iter++) {
- if (iter->first & serviceMask) {
- ret.push_back(iter->second);
- }
+ std::vector<unsigned long> ret;
+ for (auto iter = g_service_enum_map.begin(); iter != g_service_enum_map.end(); iter++) {
+ if (iter->first & serviceMask) {
+ ret.push_back(iter->second);
}
+ }
- return ret;
+ return ret;
}
} // namespace bluetooth
namespace bluetooth {
class BluetoothClass {
-public:
- static unsigned long GetMajorValue(bt_major_device_class_e major);
- static unsigned long GetMinorValue(bt_minor_device_class_e minor);
- static std::vector<unsigned long> getServiceValues(int serviceMask);
+ public:
+ static unsigned long GetMajorValue(bt_major_device_class_e major);
+ static unsigned long GetMinorValue(bt_minor_device_class_e minor);
+ static std::vector<unsigned long> getServiceValues(int serviceMask);
};
} // namespace bluetooth
}
static void ToJsonFromBTClass(bt_class_s bluetooth_class, picojson::object* device) {
- LoggerD("Entered");
+ LoggerD("Entered");
- picojson::object& bt = device->insert(std::make_pair(kDeviceClass, picojson::value(picojson::object())))
- .first->second.get<picojson::object>();
+ picojson::object& bt = device->insert(std::make_pair(kDeviceClass, picojson::value(picojson::object())))
+
.first->second.get<picojson::object>();
- bt.insert(std::make_pair(kDeviceClassMajor, picojson::value(static_cast<double>(
- BluetoothClass::GetMajorValue(bluetooth_class.major_device_class)))));
- bt.insert(std::make_pair(kDeviceClassMinor, picojson::value(static_cast<double>(
- BluetoothClass::GetMinorValue(bluetooth_class.minor_device_class)))));
+ bt.insert(std::make_pair(kDeviceClassMajor, picojson::value(static_cast<double>(
+ BluetoothClass::GetMajorValue(bluetooth_class.major_device_class)))));
+ bt.insert(std::make_pair(kDeviceClassMinor, picojson::value(static_cast<double>(
+ BluetoothClass::GetMinorValue(bluetooth_class.minor_device_class)))));
- picojson::array& array = bt.insert(std::make_pair(kDeviceClassService,
-
picojson::value(picojson::array()))).first->second.get<picojson::array>();
+ picojson::array& array = bt.insert(std::make_pair(
+
kDeviceClassService, picojson::value(picojson::array()))).first->second.get<picojson::array>();
- std::vector<unsigned long> services_vector = BluetoothClass::getServiceValues(
- bluetooth_class.major_service_class_mask);
+ std::vector<unsigned long> services_vector = BluetoothClass::getServiceValues(
+ bluetooth_class.major_service_class_mask);
- for (auto v : services_vector) {
- array.push_back(picojson::value(static_cast<double>(v)));
- }
+ for (auto v : services_vector) {
+ array.push_back(picojson::value(static_cast<double>(v)));
+ }
}
static void ToJsonFromUUID(char **service_uuid, int service_count, picojson::object* device) {
- LoggerD("Entered");
+ LoggerD("Entered");
- picojson::array& array = device->insert(std::make_pair(kDeviceUuids, picojson::value(picojson::array())))
- .first->second.get<picojson::array>();
+ picojson::array& array = device->insert(std::make_pair(kDeviceUuids, picojson::value(picojson::array())))
+
.first->second.get<picojson::array>();
- for (int i = 0; i < service_count; i++) {
- array.push_back(picojson::value(service_uuid[i]));
- }
+ for (int i = 0; i < service_count; i++) {
+ array.push_back(picojson::value(service_uuid[i]));
+ }
}
void BluetoothDevice::ToJson(bt_device_info_s* info, picojson::object* device) {
- LoggerD("Entered");
- device->insert(std::make_pair(kDeviceName, picojson::value(std::string(info->remote_name))));
- device->insert(std::make_pair(kDeviceAddress, picojson::value(std::string(info->remote_address))));
+ LoggerD("Entered");
+ device->insert(std::make_pair(kDeviceName, picojson::value(std::string(info->remote_name))));
+ device->insert(std::make_pair(kDeviceAddress, picojson::value(std::string(info->remote_address))));
- ToJsonFromBTClass(info->bt_class, device);
- ToJsonFromUUID(info->service_uuid, info->service_count, device);
+ ToJsonFromBTClass(info->bt_class, device);
+ ToJsonFromUUID(info->service_uuid, info->service_count, device);
}
void BluetoothDevice::ToJson(bt_adapter_device_discovery_info_s *info, picojson::object* device) {
- LoggerD("Entered");
+ LoggerD("Entered");
- device->insert(std::make_pair(kDeviceName, picojson::value(info->remote_name)));
- device->insert(std::make_pair(kDeviceAddress, picojson::value(info->remote_address)));
+ device->insert(std::make_pair(kDeviceName, picojson::value(info->remote_name)));
+ device->insert(std::make_pair(kDeviceAddress, picojson::value(info->remote_address)));
- ToJsonFromBTClass(info->bt_class, device);
- ToJsonFromUUID(info->service_uuid, info->service_count, device);
+ ToJsonFromBTClass(info->bt_class, device);
+ ToJsonFromUUID(info->service_uuid, info->service_count, device);
}
void BluetoothDevice::ConnectToServiceByUUID(const picojson::value& data, picojson::object& out) {
- LoggerD("Entered");
+ LoggerD("Entered");
- util::CheckAccess(Privilege::kBluetoothSpp);
+ util::CheckAccess(Privilege::kBluetoothSpp);
- const auto& args = util::GetArguments(data);
+ const auto& args = util::GetArguments(data);
- BluetoothAdapter::GetInstance().ConnectToServiceByUUID(
- FromJson<std::string>(args, "address"),
- FromJson<std::string>(args, "uuid"),
- util::GetAsyncCallbackHandle(data));
+ BluetoothAdapter::GetInstance().ConnectToServiceByUUID(
+ FromJson<std::string>(args, "address"),
+ FromJson<std::string>(args, "uuid"),
+ util::GetAsyncCallbackHandle(data));
- ReportSuccess(out);
+ ReportSuccess(out);
}
-void BluetoothDevice::GetBoolValue(const picojson::value& data, picojson::object& out)
-{
- LoggerD("Entered");
-
- const auto& args = util::GetArguments(data);
- const auto& address = FromJson<std::string>(args, "address");
- const auto& field = FromJson<std::string>(args, "field");
-
- PlatformResult result = PlatformResult(ErrorCode::NO_ERROR);
- bool value = false;
- bt_device_info_s *info = nullptr;
- if (bt_adapter_get_bonded_device_info(address.c_str(), &info) == BT_ERROR_NONE &&
- info != nullptr) {
- if (kDeviceIsBonded == field) {
- value = info->is_bonded;
- } else if (kDeviceIsTrusted == field) {
- value = info->is_authorized;
- } else if (kDeviceIsConnected == field) {
- value = info->is_connected;
- } else {
- result = PlatformResult(ErrorCode::UNKNOWN_ERR, "Wrong field passed.");
- }
- bt_adapter_free_device_info(info);
- } else {
- result = PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error");
- }
-
- if (result.IsSuccess()) {
- ReportSuccess(picojson::value(value), out);
+void BluetoothDevice::GetBoolValue(const picojson::value& data, picojson::object& out) {
+ LoggerD("Entered");
+
+ const auto& args = util::GetArguments(data);
+ const auto& address = FromJson<std::string>(args, "address");
+ const auto& field = FromJson<std::string>(args, "field");
+
+ PlatformResult result = PlatformResult(ErrorCode::NO_ERROR);
+ bool value = false;
+ bt_device_info_s *info = nullptr;
+ if (bt_adapter_get_bonded_device_info(address.c_str(), &info) == BT_ERROR_NONE &&
+ info != nullptr) {
+ if (kDeviceIsBonded == field) {
+ value = info->is_bonded;
+ } else if (kDeviceIsTrusted == field) {
+ value = info->is_authorized;
+ } else if (kDeviceIsConnected == field) {
+ value = info->is_connected;
} else {
- ReportError(result, &out);
+ result = PlatformResult(ErrorCode::UNKNOWN_ERR, "Wrong field passed.");
}
+ bt_adapter_free_device_info(info);
+ } else {
+ result = PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error");
+ }
+
+ if (result.IsSuccess()) {
+ ReportSuccess(picojson::value(value), out);
+ } else {
+ ReportError(result, &out);
+ }
}
} // namespace bluetooth
namespace bluetooth {
class BluetoothDevice {
-public:
- /**
- * Signature: @code void connectToServiceByUUID(uuid, successCallback, errorCallback); @endcode
- * JSON: @code data: {method: 'BluetoothDevice_connectToServiceByUUID', args: {uuid: uuid}} @endcode
- * Invocation: @code native.call(request, result_callback); @endcode
- * Return:
- * @code
- * {status: 'error', error: {name, message}}
- * {status: 'success'}
- * @endcode
- * Result callback:
- * @code
- * {status: 'error', error: {name, message}}
- * {status: 'success', result: {socket}}
- * @endcode
- */
- void ConnectToServiceByUUID(const picojson::value& data, picojson::object& out);
+ public:
+ /**
+ * Signature: @code void connectToServiceByUUID(uuid, successCallback, errorCallback); @endcode
+ * JSON: @code data: {method: 'BluetoothDevice_connectToServiceByUUID', args: {uuid: uuid}} @endcode
+ * Invocation: @code native.call(request, result_callback); @endcode
+ * Return:
+ * @code
+ * {status: 'error', error: {name, message}}
+ * {status: 'success'}
+ * @endcode
+ * Result callback:
+ * @code
+ * {status: 'error', error: {name, message}}
+ * {status: 'success', result: {socket}}
+ * @endcode
+ */
+ void ConnectToServiceByUUID(const picojson::value& data, picojson::object& out);
- /**
- * Signature: @code BluetoothDevice.is(Bonded, Trusted, Connected); @endcode
- * JSON: @code data: {method: 'BluetoothDevice_GetBoolValue', args: {address: address,
- * field: field}} @endcode
- * Invocation: @code native.callSync(request); @endcode
- * Return:
- * @code
- * {status: 'error', error: {name, message}}
- * {status: 'success', result: name}
- * @endcode
- */
- void GetBoolValue(const picojson::value& data, picojson::object& out);
+ /**
+ * Signature: @code BluetoothDevice.is(Bonded, Trusted, Connected); @endcode
+ * JSON: @code data: {method: 'BluetoothDevice_GetBoolValue', args: {address: address,
+ * field: field}} @endcode
+ * Invocation: @code native.callSync(request); @endcode
+ * Return:
+ * @code
+ * {status: 'error', error: {name, message}}
+ * {status: 'success', result: name}
+ * @endcode
+ */
+ void GetBoolValue(const picojson::value& data, picojson::object& out);
- static void ToJson(bt_device_info_s* info,
- picojson::object* device);
- static void ToJson(bt_adapter_device_discovery_info_s *info,
- picojson::object* device);
+ static void ToJson(bt_device_info_s* info,
+ picojson::object* device);
+ static void ToJson(bt_adapter_device_discovery_info_s *info,
+ picojson::object* device);
};
} // namespace bluetooth
#include "bluetooth_instance.h"
namespace {
- const char* kBluetooth = "tizen.bluetooth";
+const char* kBluetooth = "tizen.bluetooth";
}
// This will be generated from bluetooth_api.js.
extern const char kSource_bluetooth_api[];
SetExtensionName(kBluetooth);
SetJavaScriptAPI(kSource_bluetooth_api);
const char* entry_points[] = {
- NULL
+ NULL
};
SetExtraJSEntryPoints(entry_points);
}
using namespace common;
void BluetoothHealthApplication::Unregister(const picojson::value& data, picojson::object& out) {
- LoggerD("Entered");
+ LoggerD("Entered");
- util::CheckAccess(Privilege::kBluetoothHealth);
+ util::CheckAccess(Privilege::kBluetoothHealth);
- const auto& args = util::GetArguments(data);
+ const auto& args = util::GetArguments(data);
- BluetoothHealthProfileHandler::GetInstance().UnregisterSinkAppAsync(
- FromJson<std::string>(args, "id"),
- util::GetAsyncCallbackHandle(data));
+ BluetoothHealthProfileHandler::GetInstance().UnregisterSinkAppAsync(
+ FromJson<std::string>(args, "id"),
+ util::GetAsyncCallbackHandle(data));
- tools::ReportSuccess(out);
+ tools::ReportSuccess(out);
}
void BluetoothHealthApplication::ToJson(short data_type,
const std::string& name,
const char* id,
picojson::object* out) {
- out->insert(std::make_pair(kDataType, picojson::value(static_cast<double>(data_type))));
- out->insert(std::make_pair(kName, picojson::value(name)));
- out->insert(std::make_pair(kId, picojson::value(id)));
+ out->insert(std::make_pair(kDataType, picojson::value(static_cast<double>(data_type))));
+ out->insert(std::make_pair(kName, picojson::value(name)));
+ out->insert(std::make_pair(kId, picojson::value(id)));
}
} // namespace bluetooth
namespace bluetooth {
class BluetoothHealthApplication {
-public:
- /**
- * Signature: @code void unregister(successCallback, errorCallback); @endcode
- * JSON: @code data: {method: 'BluetoothHealthApplication_unregister', args: {}} @endcode
- * Invocation: @code native.call(request, result_callback); @endcode
- * Return:
- * @code
- * {status: 'error', error: {name, message}}
- * {status: 'success'}
- * @endcode
- * Result callback:
- * @code
- * {status: 'error', error: {name, message}}
- * {status: 'success'}
- * @endcode
- */
- void Unregister(const picojson::value& data, picojson::object& out);
-
- static void ToJson(short data_type,
- const std::string& name,
- const char* id,
- picojson::object* out);
+ public:
+ /**
+ * Signature: @code void unregister(successCallback, errorCallback); @endcode
+ * JSON: @code data: {method: 'BluetoothHealthApplication_unregister', args: {}} @endcode
+ * Invocation: @code native.call(request, result_callback); @endcode
+ * Return:
+ * @code
+ * {status: 'error', error: {name, message}}
+ * {status: 'success'}
+ * @endcode
+ * Result callback:
+ * @code
+ * {status: 'error', error: {name, message}}
+ * {status: 'success'}
+ * @endcode
+ */
+ void Unregister(const picojson::value& data, picojson::object& out);
+
+ static void ToJson(short data_type,
+ const std::string& name,
+ const char* id,
+ picojson::object* out);
};
} // namespace bluetooth
} // namespace
void BluetoothHealthChannel::Close(const picojson::value& data , picojson::object& out) {
- LoggerD("Entered");
+ LoggerD("Entered");
- util::CheckAccess(Privilege::kBluetoothHealth);
+ util::CheckAccess(Privilege::kBluetoothHealth);
- const auto& args = util::GetArguments(data);
+ const auto& args = util::GetArguments(data);
- unsigned int channel = common::stol(FromJson<std::string>(args, "channel"));
- const auto& address = FromJson<std::string>(args, "address");
+ unsigned int channel = common::stol(FromJson<std::string>(args, "channel"));
+ const auto& address = FromJson<std::string>(args, "address");
- if (BT_ERROR_NONE != bt_hdp_disconnect(address.c_str(), channel)) {
- ReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error"), &out);
- return;
- }
+ if (BT_ERROR_NONE != bt_hdp_disconnect(address.c_str(), channel)) {
+ ReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error"), &out);
+ return;
+ }
- ReportSuccess(out);
+ ReportSuccess(out);
}
void BluetoothHealthChannel::SendData(const picojson::value& data, picojson::object& out) {
- LoggerD("Entered");
+ LoggerD("Entered");
- util::CheckAccess(Privilege::kBluetoothHealth);
+ util::CheckAccess(Privilege::kBluetoothHealth);
- const auto& args = util::GetArguments(data);
+ const auto& args = util::GetArguments(data);
- unsigned int channel = common::stol(FromJson<std::string>(args, "channel"));
-
const auto& binary_data = FromJson<picojson::array>(args, "data");
- const auto data_size = binary_data.size();
+ unsigned int channel = common::stol(FromJson<std::string>(args, "channel"));
+ const auto& binary_data = FromJson<picojson::array>(args, "data");
+ const auto data_size = binary_data.size();
- std::unique_ptr<char[]> data_ptr{new char[data_size]};
+ std::unique_ptr<char[]> data_ptr{new char[data_size]};
- for (std::size_t i = 0; i < data_size; ++i) {
- data_ptr[i] = static_cast<char>(binary_data[i].get<double>());
- }
+ for (std::size_t i = 0; i < data_size; ++i) {
+ data_ptr[i] = static_cast<char>(binary_data[i].get<double>());
+ }
- if (BT_ERROR_NONE != bt_hdp_send_data(channel, data_ptr.get(), data_size)) {
- LoggerE("bt_hdp_send_data() failed");
- ReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error"), &out);
- return;
- }
+ if (BT_ERROR_NONE != bt_hdp_send_data(channel, data_ptr.get(), data_size)) {
+ LoggerE("bt_hdp_send_data() failed");
+ ReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error"), &out);
+ return;
+ }
- ReportSuccess(picojson::value(static_cast<double>(data_size)), out);
+ ReportSuccess(picojson::value(static_cast<double>(data_size)), out);
}
void BluetoothHealthChannel::ToJson(unsigned int channel,
bt_hdp_channel_type_e type,
picojson::object* out) {
- const char* type_str = "UNKNOWN";
+ const char* type_str = "UNKNOWN";
- switch (type) {
- case BT_HDP_CHANNEL_TYPE_RELIABLE:
- type_str = "RELIABLE";
- break;
+ switch (type) {
+ case BT_HDP_CHANNEL_TYPE_RELIABLE:
+ type_str = "RELIABLE";
+ break;
- case BT_HDP_CHANNEL_TYPE_STREAMING:
- type_str = "STREAMING";
- break;
+ case BT_HDP_CHANNEL_TYPE_STREAMING:
+ type_str = "STREAMING";
+ break;
- default:
- LoggerE("Unknown HDP channel type: %d", type);
- break;
- }
+ default:
+ LoggerE("Unknown HDP channel type: %d", type);
+ break;
+ }
- out->insert(std::make_pair(kId, picojson::value(std::to_string(channel))));
- out->insert(std::make_pair(kChannelType, picojson::value(type_str)));
- out->insert(std::make_pair(kIsConnected, picojson::value(true)));
+ out->insert(std::make_pair(kId, picojson::value(std::to_string(channel))));
+ out->insert(std::make_pair(kChannelType, picojson::value(type_str)));
+ out->insert(std::make_pair(kIsConnected, picojson::value(true)));
}
void BluetoothHealthChannel::ToJson(unsigned int channel,
bt_device_info_s* device_info,
const char* app_id,
picojson::object* out) {
- ToJson(channel, type, out);
- auto& device = out->insert(std::make_pair(kPeer, picojson::value(picojson::object())))
- .first->second.get<picojson::object>();
- BluetoothDevice::ToJson(device_info, &device);
- out->insert(std::make_pair(kApplication, picojson::value(app_id)));
+ ToJson(channel, type, out);
+ auto& device = out->insert(
+ std::make_pair(kPeer, picojson::value(picojson::object()))) .first->second.get<picojson::object>();
+
+ BluetoothDevice::ToJson(device_info, &device);
+ out->insert(std::make_pair(kApplication, picojson::value(app_id)));
}
} // namespace bluetooth
namespace bluetooth {
class BluetoothHealthChannel {
-public:
- /**
- * Signature: @code void close(); @endcode
- * JSON: @code data: {method: 'BluetoothHealthChannel_close', args: {}} @endcode
- * Invocation: @code native.callSync(request); @endcode
- * Return:
- * @code
- * {status: 'error', error: {name, message}}
- * {status: 'success'}
- * @endcode
- */
- void Close(const picojson::value& data, picojson::object& out);
+ public:
+ /**
+ * Signature: @code void close(); @endcode
+ * JSON: @code data: {method: 'BluetoothHealthChannel_close', args: {}} @endcode
+ * Invocation: @code native.callSync(request); @endcode
+ * Return:
+ * @code
+ * {status: 'error', error: {name, message}}
+ * {status: 'success'}
+ * @endcode
+ */
+ void Close(const picojson::value& data, picojson::object& out);
- /**
- * Signature: @code unsigned long sendData(data[]); @endcode
- * JSON: @code data: {method: 'BluetoothHealthChannel_sendData', args: {data: data}} @endcode
- * Invocation: @code native.callSync(request); @endcode
- * Return:
- * @code
- * {status: 'error', error: {name, message}}
- * {status: 'success', result: {bytes_sent}}
- */
- void SendData(const picojson::value& data, picojson::object& out);
+ /**
+ * Signature: @code unsigned long sendData(data[]); @endcode
+ * JSON: @code data: {method: 'BluetoothHealthChannel_sendData', args: {data: data}} @endcode
+ * Invocation: @code native.callSync(request); @endcode
+ * Return:
+ * @code
+ * {status: 'error', error: {name, message}}
+ * {status: 'success', result: {bytes_sent}}
+ */
+ void SendData(const picojson::value& data, picojson::object& out);
- static void ToJson(unsigned int channel,
- bt_hdp_channel_type_e type,
- picojson::object* out);
+ static void ToJson(unsigned int channel,
+ bt_hdp_channel_type_e type,
+ picojson::object* out);
- static void ToJson(unsigned int channel,
- bt_hdp_channel_type_e type,
- bt_device_info_s* device_info,
- const char* app_id,
- picojson::object* out);
+ static void ToJson(unsigned int channel,
+ bt_hdp_channel_type_e type,
+ bt_device_info_s* device_info,
+ const char* app_id,
+ picojson::object* out);
};
} // namespace bluetooth
} //namespace
BluetoothHealthProfileHandler& BluetoothHealthProfileHandler::GetInstance() {
- static BluetoothHealthProfileHandler instance;
- return instance;
+ static BluetoothHealthProfileHandler instance;
+ return instance;
}
BluetoothHealthProfileHandler::BluetoothHealthProfileHandler() {
- // initialize listeners
- if (BT_ERROR_NONE != bt_hdp_set_connection_state_changed_cb(OnConnected,
- OnDisconnected,
- this)) {
- LoggerE("bt_hdp_set_connection_state_changed_cb() failed");
- }
-
- if (BT_ERROR_NONE != bt_hdp_set_data_received_cb(OnDataReceived, this)) {
- LoggerE("bt_hdp_set_data_received_cb() failed");
- }
+ // initialize listeners
+ if (BT_ERROR_NONE != bt_hdp_set_connection_state_changed_cb(OnConnected, OnDisconnected, this)) {
+ LoggerE("bt_hdp_set_connection_state_changed_cb() failed");
+ }
+
+ if (BT_ERROR_NONE != bt_hdp_set_data_received_cb(OnDataReceived, this)) {
+ LoggerE("bt_hdp_set_data_received_cb() failed");
+ }
}
BluetoothHealthProfileHandler::~BluetoothHealthProfileHandler() {
- bt_hdp_unset_connection_state_changed_cb();
- bt_hdp_unset_data_received_cb();
+ bt_hdp_unset_connection_state_changed_cb();
+ bt_hdp_unset_data_received_cb();
- for (auto& it : registered_health_apps_) {
- bt_hdp_unregister_sink_app(it.c_str());
- }
+ for (auto& it : registered_health_apps_) {
+ bt_hdp_unregister_sink_app(it.c_str());
+ }
}
void BluetoothHealthProfileHandler::OnConnected(int result,
bt_hdp_channel_type_e type,
unsigned int channel,
void* user_data) {
- LoggerD("Entered");
+ LoggerD("Entered");
- BluetoothHealthProfileHandler* object = static_cast<BluetoothHealthProfileHandler*>(user_data);
+ BluetoothHealthProfileHandler* object = static_cast<BluetoothHealthProfileHandler*>(user_data);
- if (!object) {
- LoggerW("user_data is NULL");
- return;
- }
+ if (!object) {
+ LoggerW("user_data is NULL");
+ return;
+ }
- if (BT_ERROR_NONE != result) {
- LoggerD("Not BT_ERROR_NONE: %d", result);
- }
+ if (BT_ERROR_NONE != result) {
+ LoggerD("Not BT_ERROR_NONE: %d", result);
+ }
- LoggerD("Connected app: %s", app_id);
- LoggerD("Connected channel: %u", channel);
+ LoggerD("Connected app: %s", app_id);
+ LoggerD("Connected channel: %u", channel);
- const auto iter = object->registered_health_apps_.find(app_id);
+ const auto iter = object->registered_health_apps_.find(app_id);
- if (iter == object->registered_health_apps_.end()) {
- LoggerW("This app is not registered: %s", app_id);
- return;
- }
+ if (iter == object->registered_health_apps_.end()) {
+ LoggerW("This app is not registered: %s", app_id);
+ return;
+ }
- bool channel_added = false;
+ bool channel_added = false;
- if (BT_ERROR_NONE == result) {
- // send BluetoothHealthApplication.onconnect notification
- bt_device_info_s* device_info = nullptr;
+ if (BT_ERROR_NONE == result) {
+ // send BluetoothHealthApplication.onconnect notification
+ bt_device_info_s* device_info = nullptr;
- if (BT_ERROR_NONE == bt_adapter_get_bonded_device_info(remote_address, &device_info) &&
- nullptr != device_info) {
- LoggerD("invoke BluetoothHealthApplication.onconnect");
+ if (BT_ERROR_NONE == bt_adapter_get_bonded_device_info(remote_address, &device_info) &&
+ nullptr != device_info) {
+ LoggerD("invoke BluetoothHealthApplication.onconnect");
- object->connected_channels_.insert(channel);
- channel_added = true;
+ object->connected_channels_.insert(channel);
+ channel_added = true;
- picojson::value response{picojson::object()};
-
picojson::object& response_obj = response.get<picojson::object>();
- response_obj.insert(std::make_pair(kId, picojson::value(app_id)));
- response_obj.insert(std::make_pair(kEvent, picojson::value(kOnConnect)));
+ picojson::value response{picojson::object()};
+ picojson::object& response_obj = response.get<picojson::object>();
+ response_obj.insert(std::make_pair(kId, picojson::value(app_id)));
+ response_obj.insert(std::make_pair(kEvent, picojson::value(kOnConnect)));
- picojson::value result = picojson::value(picojson::object());
+ picojson::value result = picojson::value(picojson::object());
- BluetoothHealthChannel::ToJson(channel,
- type,
- device_info,
- app_id,
-
&result.get<picojson::object>());
+ BluetoothHealthChannel::ToJson(channel,
+ type,
+ device_info,
+ app_id,
+ &result.get<picojson::object>());
- ReportSuccess(result, response_obj);
- bt_adapter_free_device_info(device_info);
+ ReportSuccess(result, response_obj);
+ bt_adapter_free_device_info(device_info);
- util::FireEvent("BLUETOOTH_HEALTH_APPLICATION_CHANGED", response);
- } else {
- LoggerE("Failed to get device info");
- }
+ util::FireEvent("BLUETOOTH_HEALTH_APPLICATION_CHANGED", response);
+ } else {
+ LoggerE("Failed to get device info");
}
+ }
- // Handle requests from BluetoothHealthProfileHandler.connectToSource()
- const auto request = object->connection_requests_.find(app_id);
+ // Handle requests from BluetoothHealthProfileHandler.connectToSource()
+ const auto request = object->connection_requests_.find(app_id);
- if (request != object->connection_requests_.end()) {
- LoggerD("Requested connection");
+ if (request != object->connection_requests_.end()) {
+ LoggerD("Requested connection");
- std::shared_ptr<picojson::value> response{new picojson::value(picojson::object())};
-
- if (BT_ERROR_NONE == result) {
- if (!channel_added) {
- object->connected_channels_.insert(channel);
- }
-
- picojson::value result = picojson::value(picojson::object());
-
- BluetoothHealthChannel::ToJson(channel,
- type,
- &result.get<picojson::object>());
+ std::shared_ptr<picojson::value> response{new picojson::value(picojson::object())};
- ReportSuccess(result, response->get<picojson::object>());
- } else {
- LoggerE("Failed to establish a connection with health profile");
- ReportError(PlatformResult(
- ErrorCode::UNKNOWN_ERR, "Failed to establish a connection with health profile"),
- &response->get<picojson::object>());
- }
+ if (BT_ERROR_NONE == result) {
+ if (!channel_added) {
+ object->connected_channels_.insert(channel);
+ }
+
+ picojson::value result = picojson::value(picojson::object());
+
+ BluetoothHealthChannel::ToJson(channel,
+ type,
+ &result.get<picojson::object>());
+
+ ReportSuccess(result, response->get<picojson::object>());
+ } else {
+ LoggerE("Failed to establish a connection with health profile");
+ ReportError(PlatformResult(
+ ErrorCode::UNKNOWN_ERR, "Failed to establish a connection with health profile"),
+ &response->get<picojson::object>());
+ }
- util::AsyncResponse(request->second, response);
+ util::AsyncResponse(request->second, response);
- // request was handled, remove
- object->connection_requests_.erase(request);
- }
- else {
- LoggerD("This connection was not requested.");
- }
+ // request was handled, remove
+ object->connection_requests_.erase(request);
+ }
+ else {
+ LoggerD("This connection was not requested.");
+ }
}
void BluetoothHealthProfileHandler::OnDisconnected(int result,
const char* /* remote_address */,
unsigned int channel,
void* user_data) {
- LoggerD("Entered");
+ LoggerD("Entered");
- BluetoothHealthProfileHandler* object = static_cast<BluetoothHealthProfileHandler*>(user_data);
+ BluetoothHealthProfileHandler* object = static_cast<BluetoothHealthProfileHandler*>(user_data);
- if (!object) {
- LoggerW("user_data is NULL");
- return;
- }
+ if (!object) {
+ LoggerW("user_data is NULL");
+ return;
+ }
- auto it = object->connected_channels_.find(channel);
- if (BT_ERROR_NONE == result && object->connected_channels_.end() != it) {
- object->connected_channels_.erase(it);
- picojson::value value = picojson::value(picojson::object());
-
picojson::object* data_obj = &value.get<picojson::object>();
+ auto it = object->connected_channels_.find(channel);
+ if (BT_ERROR_NONE == result && object->connected_channels_.end() != it) {
+ object->connected_channels_.erase(it);
+ picojson::value value = picojson::value(picojson::object());
+ picojson::object* data_obj = &value.get<picojson::object>();
- data_obj->insert(std::make_pair(kEvent, picojson::value(kOnClose)));
- data_obj->insert(std::make_pair(kId, picojson::value(std::to_string(channel))));
- util::FireEvent(kChangeCallback, value);
- }
+ data_obj->insert(std::make_pair(kEvent, picojson::value(kOnClose)));
+ data_obj->insert(std::make_pair(kId, picojson::value(std::to_string(channel))));
+ util::FireEvent(kChangeCallback, value);
+ }
}
void BluetoothHealthProfileHandler::OnDataReceived(unsigned int channel,
const char* data,
unsigned int size,
void* user_data) {
- LoggerD("Entered");
-
- BluetoothHealthProfileHandler* object = static_cast<BluetoothHealthProfileHandler*>(user_data);
+ LoggerD("Entered");
- if (!object) {
- LoggerW("user_data is NULL");
- return;
- }
+ BluetoothHealthProfileHandler* object = static_cast<BluetoothHealthProfileHandler*>(user_data);
- auto it = object->connected_channels_.find(channel);
- if (object->connected_channels_.end() != it) {
- picojson::value value = picojson::value(picojson::object());
- picojson::object* data_obj = &value.get<picojson::object>();
+ if (!object) {
+ LoggerW("user_data is NULL");
+ return;
+ }
- data_obj->insert(std::make_pair(kEvent, picojson::value(kOnMessage)));
- data_obj->insert(std::make_pair(kId, picojson::value(std::to_string(channel))));
+ auto it = object->connected_channels_.find(channel);
+ if (object->connected_channels_.end() != it) {
+ picojson::value value = picojson::value(picojson::object());
+ picojson::object* data_obj = &value.get<picojson::object>();
- picojson::array& array = data_obj->insert(std::make_pair(kData, picojson::value(
- picojson::array()))).first->second.get<picojson::array>();
+ data_obj->insert(std::make_pair(kEvent, picojson::value(kOnMessage)));
+ data_obj->insert(std::make_pair(kId, picojson::value(std::to_string(channel))));
- for (unsigned int i = 0; i < size; i++) {
- array.push_back(picojson::value(static_cast<double>(data[i])));
- }
+ picojson::array& array = data_obj->insert(std::make_pair(kData, picojson::value(
+ picojson::array()))).first->second.get<picojson::array>();
- util::FireEvent(kChangeCallback, value);
+ for (unsigned int i = 0; i < size; i++) {
+ array.push_back(picojson::value(static_cast<double>(data[i])));
}
+
+ util::FireEvent(kChangeCallback, value);
+ }
}
void BluetoothHealthProfileHandler::RegisterSinkApp(const picojson::value& data, picojson::object& out) {
- LoggerD("Entered");
-
- util::CheckAccess(Privilege::kBluetoothHealth);
-
- const auto& args = util::GetArguments(data);
- const auto data_type = static_cast<short>(FromJson<double>(args, "dataType"));
- const auto& name = FromJson<std::string>(args, "name");
+ LoggerD("Entered");
- const auto callback_handle = util::GetAsyncCallbackHandle(data);
+ util::CheckAccess(Privilege::kBluetoothHealth);
- auto register_app = [data_type, name, this](const std::shared_ptr<picojson::value>& response) -> void {
- LoggerD("Entered");
+ const auto& args = util::GetArguments(data);
+ const auto data_type = static_cast<short>(FromJson<double>(args, "dataType"));
+ const auto& name = FromJson<std::string>(args, "name");
- PlatformResult platform_result = PlatformResult(ErrorCode::NO_ERROR);
- char* app_id = nullptr;
- const int ret = bt_hdp_register_sink_app(data_type, &app_id);
+ const auto callback_handle = util::GetAsyncCallbackHandle(data);
- switch (ret) {
- case BT_ERROR_NONE:
- {
- LoggerD("Registered app: %s", app_id);
+ auto register_app = [data_type, name, this](const std::shared_ptr<picojson::value>& response) -> void {
+ LoggerD("Entered");
- this->registered_health_apps_.insert(app_id);
+ PlatformResult platform_result = PlatformResult(ErrorCode::NO_ERROR);
+ char* app_id = nullptr;
+ const int ret = bt_hdp_register_sink_app(data_type, &app_id);
- picojson::value result = picojson::value(picojson::object());
- BluetoothHealthApplication::ToJson(data_type,
- name,
- app_id,
- &result.get<picojson::object>());
- ReportSuccess(result, response->get<picojson::object>());
- return;
- }
+ switch (ret) {
+ case BT_ERROR_NONE:
+ {
+ LoggerD("Registered app: %s", app_id);
- case BT_ERROR_NOT_ENABLED:
- LoggerE("Bluetooth device is turned off");
- platform_result = PlatformResult(
- ErrorCode::SERVICE_NOT_AVAILABLE_ERR, "Bluetooth device is turned off");
- break;
+ this->registered_health_apps_.insert(app_id);
- default:
- LoggerE("bt_hdp_register_sink_app() failed: %d", ret);
- platform_result = PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error");
- break;
- }
+ picojson::value result = picojson::value(picojson::object());
+ BluetoothHealthApplication::ToJson(data_type,
+ name,
+ app_id,
+ &result.get<picojson::object>());
+ ReportSuccess(result, response->get<picojson::object>());
+ return;
+ }
+
+ case BT_ERROR_NOT_ENABLED:
+ LoggerE("Bluetooth device is turned off");
+ platform_result = PlatformResult(
+ ErrorCode::SERVICE_NOT_AVAILABLE_ERR, "Bluetooth device is turned off");
+ break;
+
+ default:
+ LoggerE("bt_hdp_register_sink_app() failed: %d", ret);
+ platform_result = PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error");
+ break;
+ }
-
ReportError(platform_result, &response->get<picojson::object>());
- };
+ ReportError(platform_result, &response->get<picojson::object>());
+ };
-
auto register_app_response = [callback_handle](const std::shared_ptr<picojson::value>& response) -> void {
- util::SyncResponse(callback_handle, response);
- };
+ auto register_app_response = [callback_handle](const std::shared_ptr<picojson::value>& response) -> void {
+ util::SyncResponse(callback_handle, response);
+ };
- TaskQueue::GetInstance().Queue<picojson::value>(register_app,
- register_app_response,
- std::shared_ptr<picojson::value>(new picojson::value(picojson::object())));
+ TaskQueue::GetInstance().Queue<picojson::value>(
+ register_app,
+ register_app_response,
+ std::shared_ptr<picojson::value>(new picojson::value(picojson::object())));
- ReportSuccess(out);
+ ReportSuccess(out);
}
void BluetoothHealthProfileHandler::ConnectToSource(const picojson::value& data, picojson::object& out) {
- LoggerD("Entered");
+ LoggerD("Entered");
- util::CheckAccess(Privilege::kBluetoothHealth);
+ util::CheckAccess(Privilege::kBluetoothHealth);
- const auto& args = util::GetArguments(data);
- const auto& address = FromJson<std::string>(args, "address");
- const auto& app_id = FromJson<std::string>(args, "appId");
+ const auto& args = util::GetArguments(data);
+ const auto& address = FromJson<std::string>(args, "address");
+ const auto& app_id = FromJson<std::string>(args, "appId");
- LoggerD("address: %s", address.c_str());
- LoggerD("app ID: %s", app_id.c_str());
+ LoggerD("address: %s", address.c_str());
+ LoggerD("app ID: %s", app_id.c_str());
- const auto callback_handle = util::GetAsyncCallbackHandle(data);
+ const auto callback_handle = util::GetAsyncCallbackHandle(data);
- PlatformResult result = PlatformResult(ErrorCode::NO_ERROR);
- const int ret = bt_hdp_connect_to_source(address.c_str(), app_id.c_str());
+ PlatformResult result = PlatformResult(ErrorCode::NO_ERROR);
+ const int ret = bt_hdp_connect_to_source(address.c_str(), app_id.c_str());
- switch (ret) {
- case BT_ERROR_NONE: {
- LoggerD("bt_hdp_connect_to_source() succeeded");
+ switch (ret) {
+ case BT_ERROR_NONE: {
+ LoggerD("bt_hdp_connect_to_source() succeeded");
- connection_requests_.insert(std::make_pair(app_id, callback_handle));
- break;
- }
+ connection_requests_.insert(std::make_pair(app_id, callback_handle));
+ break;
+ }
- case BT_ERROR_NOT_ENABLED:
- result = PlatformResult(
- ErrorCode::SERVICE_NOT_AVAILABLE_ERR, "Bluetooth device is turned off");
- break;
+ case BT_ERROR_NOT_ENABLED:
+ result = PlatformResult(
+ ErrorCode::SERVICE_NOT_AVAILABLE_ERR, "Bluetooth device is turned off");
+ break;
- case BT_ERROR_INVALID_PARAMETER:
- case BT_ERROR_REMOTE_DEVICE_NOT_BONDED:
- result = PlatformResult(ErrorCode::INVALID_VALUES_ERR, "Invalid value");
- break;
+ case BT_ERROR_INVALID_PARAMETER:
+ case BT_ERROR_REMOTE_DEVICE_NOT_BONDED:
+ result = PlatformResult(ErrorCode::INVALID_VALUES_ERR, "Invalid value");
+ break;
- default:
- result = PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown exception");
- break;
- }
+ default:
+ result = PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown exception");
+ break;
+ }
- if (result.IsError()) {
- util::AsyncResponse(callback_handle, result);
- }
+ if (result.IsError()) {
+ util::AsyncResponse(callback_handle, result);
+ }
- ReportSuccess(out);
+ ReportSuccess(out);
}
void BluetoothHealthProfileHandler::UnregisterSinkAppAsync(const std::string& app_id,
int callback_handle) {
+ LoggerD("Entered");
+
+ auto unregister_app = [app_id, this](const std::shared_ptr<picojson::value>& response) -> void {
LoggerD("Entered");
- auto unregister_app = [app_id, this](const std::shared_ptr<picojson::value>& response) -> void {
- LoggerD("Entered");
-
- PlatformResult result = PlatformResult(ErrorCode::NO_ERROR);
- auto iter = this->registered_health_apps_.find(app_id);
-
- if (iter != this->registered_health_apps_.end()) {
- LoggerD("Found registered Health Application: %s", app_id.c_str());
-
- const int ret = bt_hdp_unregister_sink_app(app_id.c_str());
-
- switch(ret) {
- case BT_ERROR_NONE:
- this->registered_health_apps_.erase(iter);
- break;
-
- case BT_ERROR_NOT_ENABLED:
- LoggerE("Bluetooth device is turned off");
- result = PlatformResult(
- ErrorCode::SERVICE_NOT_AVAILABLE_ERR, "Bluetooth device is turned off");
- break;
-
- default:
- LoggerE("bt_hdp_unregister_sink_app() failed: %d", ret);
- result = PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown exception");
- break;
- }
- } else {
- LoggerD("Already unregistered");
- }
-
- if (result.IsSuccess()) {
- ReportSuccess(response->get<picojson::object>());
- } else {
- ReportError(result, &response->get<picojson::object>());
- }
- };
-
- auto unregister_app_response = [callback_handle](const std::shared_ptr<picojson::value>& response) -> void {
- util::SyncResponse(callback_handle, response);
- };
-
- TaskQueue::GetInstance().Queue<picojson::value>(unregister_app,
- unregister_app_response,
- std::shared_ptr<picojson::value>(new picojson::value(picojson::object())));
+ PlatformResult result = PlatformResult(ErrorCode::NO_ERROR);
+ auto iter = this->registered_health_apps_.find(app_id);
+
+ if (iter != this->registered_health_apps_.end()) {
+ LoggerD("Found registered Health Application: %s", app_id.c_str());
+
+ const int ret = bt_hdp_unregister_sink_app(app_id.c_str());
+
+ switch(ret) {
+ case BT_ERROR_NONE:
+ this->registered_health_apps_.erase(iter);
+ break;
+
+ case BT_ERROR_NOT_ENABLED:
+ LoggerE("Bluetooth device is turned off");
+ result = PlatformResult(
+ ErrorCode::SERVICE_NOT_AVAILABLE_ERR, "Bluetooth device is turned off");
+ break;
+
+ default:
+ LoggerE("bt_hdp_unregister_sink_app() failed: %d", ret);
+ result = PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown exception");
+ break;
+ }
+ } else {
+ LoggerD("Already unregistered");
+ }
+
+ if (result.IsSuccess()) {
+ ReportSuccess(response->get<picojson::object>());
+ } else {
+ ReportError(result, &response->get<picojson::object>());
+ }
+ };
+
+ auto unregister_app_response = [callback_handle](const std::shared_ptr<picojson::value>& response) -> void {
+ util::SyncResponse(callback_handle, response);
+ };
+
+ TaskQueue::GetInstance().Queue<picojson::value>(
+ unregister_app,
+ unregister_app_response,
+ std::shared_ptr<picojson::value>(new picojson::value(picojson::object())));
}
} // namespace bluetooth
namespace bluetooth {
class BluetoothHealthProfileHandler {
-public:
- /**
- * Signature: @code void registerSinkApp(dataType, name, successCallback, errorCallback); @endcode
- * JSON: @code data: {method: 'BluetoothHealthProfileHandler_registerSinkApp',
- * args: {dataType: dataType, name: name}} @endcode
- * Invocation: @code native.call(request, result_callback); @endcode
- * Return:
- * @code
- * {status: 'error', error: {name, message}}
- * {status: 'success'}
- * @endcode
- * Result callback:
- * @code
- * {status: 'error', error: {name, message}}
- * {status: 'success', result: {application}}
- * @endcode
- */
- void RegisterSinkApp(const picojson::value& data, picojson::object& out);
-
- /**
- * Signature: @code void connectToSource(peer, application, successCallback, errorCallback); @endcode
- * JSON: @code data: {method: 'BluetoothHealthProfileHandler_connectToSource',
- * args: {peer: peer, application: application}} @endcode
- * Invocation: @code native.call(request, result_callback); @endcode
- * Return:
- * @code
- * {status: 'error', error: {name, message}}
- * {status: 'success'}
- * @endcode
- * Result callback:
- * @code
- * {status: 'error', error: {name, message}}
- * {status: 'success', result: {channel}}
- * @endcode
- */
- void ConnectToSource(const picojson::value& data, picojson::object& out);
-
- static BluetoothHealthProfileHandler& GetInstance();
-
- ~BluetoothHealthProfileHandler();
-
- void UnregisterSinkAppAsync(const std::string& app_id, int callback_handle);
-
-private:
- BluetoothHealthProfileHandler();
- BluetoothHealthProfileHandler(const BluetoothHealthProfileHandler&) = delete;
- BluetoothHealthProfileHandler& operator=(const BluetoothHealthProfileHandler&) = delete;
-
- static void OnConnected(int result,
- const char* remote_address,
- const char* app_id,
- bt_hdp_channel_type_e type,
- unsigned int channel,
- void* user_data);
-
- static void OnDisconnected(int result,
- const char* remote_address,
- unsigned int channel,
- void* user_data);
-
- static void OnDataReceived(unsigned int channel,
- const char* data,
- unsigned int size,
- void* user_data);
-
- std::set<std::string> registered_health_apps_;
- std::map<std::string, double> connection_requests_;
- std::set<unsigned int> connected_channels_;
+ public:
+ /**
+ * Signature: @code void registerSinkApp(dataType, name, successCallback, errorCallback); @endcode
+ * JSON: @code data: {method: 'BluetoothHealthProfileHandler_registerSinkApp',
+ * args: {dataType: dataType, name: name}} @endcode
+ * Invocation: @code native.call(request, result_callback); @endcode
+ * Return:
+ * @code
+ * {status: 'error', error: {name, message}}
+ * {status: 'success'}
+ * @endcode
+ * Result callback:
+ * @code
+ * {status: 'error', error: {name, message}}
+ * {status: 'success', result: {application}}
+ * @endcode
+ */
+ void RegisterSinkApp(const picojson::value& data, picojson::object& out);
+
+ /**
+ * Signature: @code void connectToSource(peer, application, successCallback, errorCallback); @endcode
+ * JSON: @code data: {method: 'BluetoothHealthProfileHandler_connectToSource',
+ * args: {peer: peer, application: application}} @endcode
+ * Invocation: @code native.call(request, result_callback); @endcode
+ * Return:
+ * @code
+ * {status: 'error', error: {name, message}}
+ * {status: 'success'}
+ * @endcode
+ * Result callback:
+ * @code
+ * {status: 'error', error: {name, message}}
+ * {status: 'success', result: {channel}}
+ * @endcode
+ */
+ void ConnectToSource(const picojson::value& data, picojson::object& out);
+
+ static BluetoothHealthProfileHandler& GetInstance();
+
+ ~BluetoothHealthProfileHandler();
+
+ void UnregisterSinkAppAsync(const std::string& app_id, int callback_handle);
+
+ private:
+ BluetoothHealthProfileHandler();
+ BluetoothHealthProfileHandler(const BluetoothHealthProfileHandler&) = delete;
+ BluetoothHealthProfileHandler& operator=(const BluetoothHealthProfileHandler&) = delete;
+
+ static void OnConnected(int result,
+ const char* remote_address,
+ const char* app_id,
+ bt_hdp_channel_type_e type,
+ unsigned int channel,
+ void* user_data);
+
+ static void OnDisconnected(int result,
+ const char* remote_address,
+ unsigned int channel,
+ void* user_data);
+
+ static void OnDataReceived(unsigned int channel,
+ const char* data,
+ unsigned int size,
+ void* user_data);
+
+ std::set<std::string> registered_health_apps_;
+ std::map<std::string, double> connection_requests_;
+ std::set<unsigned int> connected_channels_;
};
} // namespace bluetooth
void CheckPrivilege(const picojson::value& data, picojson::object& out)
{
- const auto& args = util::GetArguments(data);
- const auto& privilege = FromJson<std::string>(args, "privilege");
- util::CheckAccess(privilege);
+ const auto& args = util::GetArguments(data);
+ const auto& privilege = FromJson<std::string>(args, "privilege");
+ util::CheckAccess(privilege);
- tools::ReportSuccess(out);
+ tools::ReportSuccess(out);
}
} // namespace
BluetoothInstance& BluetoothInstance::GetInstance()
{
- static BluetoothInstance instance;
- return instance;
+ static BluetoothInstance instance;
+ return instance;
}
BluetoothInstance::BluetoothInstance()
{
- LoggerD("Entered");
- using namespace std::placeholders;
-
- // BluetoothAdapter
- RegisterHandler("BluetoothAdapter_setName",
- std::bind(&BluetoothAdapter::SetName, bluetooth_adapter, _1, _2));
- RegisterHandler("BluetoothAdapter_setPowered",
- std::bind(&BluetoothAdapter::SetPowered, bluetooth_adapter, _1, _2));
- RegisterHandler("BluetoothAdapter_setVisible",
- std::bind(&BluetoothAdapter::SetVisible, bluetooth_adapter, _1, _2));
- RegisterSyncHandler("BluetoothAdapter_discoverDevices",
- std::bind(&BluetoothAdapter::DiscoverDevices, bluetooth_adapter, _1, _2));
- RegisterHandler("BluetoothAdapter_stopDiscovery",
- std::bind(&BluetoothAdapter::StopDiscovery, bluetooth_adapter, _1, _2));
- RegisterHandler("BluetoothAdapter_getKnownDevices",
- std::bind(&BluetoothAdapter::GetKnownDevices, bluetooth_adapter, _1, _2));
- RegisterHandler("BluetoothAdapter_getDevice",
- std::bind(&BluetoothAdapter::GetDevice, bluetooth_adapter, _1, _2));
- RegisterHandler("BluetoothAdapter_createBonding",
- std::bind(&BluetoothAdapter::CreateBonding, bluetooth_adapter, _1, _2));
- RegisterHandler("BluetoothAdapter_destroyBonding",
- std::bind(&BluetoothAdapter::DestroyBonding, bluetooth_adapter, _1, _2));
- RegisterHandler("BluetoothAdapter_registerRFCOMMServiceByUUID",
- std::bind(&BluetoothAdapter::RegisterRFCOMMServiceByUUID, bluetooth_adapter, _1, _2));
- RegisterSyncHandler("BluetoothAdapter_getBluetoothProfileHandler",
- std::bind(&BluetoothAdapter::GetBluetoothProfileHandler, bluetooth_adapter, _1, _2));
- RegisterSyncHandler("BluetoothAdapter_getName",
- std::bind(&BluetoothAdapter::GetName, bluetooth_adapter, _1, _2));
- RegisterSyncHandler("BluetoothAdapter_getAddress",
- std::bind(&BluetoothAdapter::GetAddress, bluetooth_adapter, _1, _2));
- RegisterSyncHandler("BluetoothAdapter_getPowered",
- std::bind(&BluetoothAdapter::GetPowered, bluetooth_adapter, _1, _2));
- RegisterSyncHandler("BluetoothAdapter_getVisible",
- std::bind(&BluetoothAdapter::GetVisible, bluetooth_adapter, _1, _2));
- RegisterSyncHandler("BluetoothAdapter_isServiceConnected",
- std::bind(&BluetoothAdapter::IsServiceConnected, bluetooth_adapter, _1, _2));
-
- // BluetoothDevice
- RegisterHandler("BluetoothDevice_connectToServiceByUUID",
- std::bind(&BluetoothDevice::ConnectToServiceByUUID, &bluetooth_device, _1, _2));
- RegisterSyncHandler("BluetoothDevice_getBoolValue",
- std::bind(&BluetoothDevice::GetBoolValue, &bluetooth_device, _1, _2));
-
- // BluetoothHealthApplication
- RegisterHandler("BluetoothHealthApplication_unregister",
- std::bind(&BluetoothHealthApplication::Unregister, &bluetooth_health_application, _1, _2));
-
- // BluetoothHealthChannel
- RegisterSyncHandler("BluetoothHealthChannel_close",
- std::bind(&BluetoothHealthChannel::Close, &bluetooth_health_channel, _1, _2));
- RegisterSyncHandler("BluetoothHealthChannel_sendData",
- std::bind(&BluetoothHealthChannel::SendData, &bluetooth_health_channel, _1, _2));
-
- // BluetoothHealthProfileHandler
- RegisterHandler("BluetoothHealthProfileHandler_registerSinkApp",
- std::bind(&BluetoothHealthProfileHandler::RegisterSinkApp, bluetooth_health_profile_handler, _1, _2));
- RegisterHandler("BluetoothHealthProfileHandler_connectToSource",
- std::bind(&BluetoothHealthProfileHandler::ConnectToSource, bluetooth_health_profile_handler, _1, _2));
-
- // BluetoothServiceHandler
- RegisterHandler("BluetoothServiceHandler_unregister",
- std::bind(&BluetoothServiceHandler::Unregister, &bluetooth_service_handler, _1, _2));
-
- // BluetoothSocket
- RegisterSyncHandler("BluetoothSocket_writeData",
- std::bind(&BluetoothSocket::WriteData, &bluetooth_socket, _1, _2));
- RegisterSyncHandler("BluetoothSocket_readData",
- std::bind(&BluetoothSocket::ReadData, &bluetooth_socket, _1, _2));
- RegisterSyncHandler("BluetoothSocket_close",
- std::bind(&BluetoothSocket::Close, &bluetooth_socket, _1, _2));
-
- // other
- RegisterSyncHandler("Bluetooth_checkPrivilege", CheckPrivilege);
+ LoggerD("Entered");
+ using namespace std::placeholders;
+
+ // BluetoothAdapter
+ RegisterHandler("BluetoothAdapter_setName",
+ std::bind(&BluetoothAdapter::SetName, bluetooth_adapter, _1, _2));
+ RegisterHandler("BluetoothAdapter_setPowered",
+ std::bind(&BluetoothAdapter::SetPowered, bluetooth_adapter, _1, _2));
+ RegisterHandler("BluetoothAdapter_setVisible",
+ std::bind(&BluetoothAdapter::SetVisible, bluetooth_adapter, _1, _2));
+ RegisterSyncHandler("BluetoothAdapter_discoverDevices",
+ std::bind(&BluetoothAdapter::DiscoverDevices, bluetooth_adapter, _1, _2));
+ RegisterHandler("BluetoothAdapter_stopDiscovery",
+ std::bind(&BluetoothAdapter::StopDiscovery, bluetooth_adapter, _1, _2));
+ RegisterHandler("BluetoothAdapter_getKnownDevices",
+ std::bind(&BluetoothAdapter::GetKnownDevices, bluetooth_adapter, _1, _2));
+ RegisterHandler("BluetoothAdapter_getDevice",
+ std::bind(&BluetoothAdapter::GetDevice, bluetooth_adapter, _1, _2));
+ RegisterHandler("BluetoothAdapter_createBonding",
+ std::bind(&BluetoothAdapter::CreateBonding, bluetooth_adapter, _1, _2));
+ RegisterHandler("BluetoothAdapter_destroyBonding",
+ std::bind(&BluetoothAdapter::DestroyBonding, bluetooth_adapter, _1, _2));
+ RegisterHandler("BluetoothAdapter_registerRFCOMMServiceByUUID",
+ std::bind(&BluetoothAdapter::RegisterRFCOMMServiceByUUID, bluetooth_adapter, _1, _2));
+ RegisterSyncHandler("BluetoothAdapter_getBluetoothProfileHandler",
+ std::bind(&BluetoothAdapter::GetBluetoothProfileHandler, bluetooth_adapter, _1, _2));
+ RegisterSyncHandler("BluetoothAdapter_getName",
+ std::bind(&BluetoothAdapter::GetName, bluetooth_adapter, _1, _2));
+ RegisterSyncHandler("BluetoothAdapter_getAddress",
+ std::bind(&BluetoothAdapter::GetAddress, bluetooth_adapter, _1, _2));
+ RegisterSyncHandler("BluetoothAdapter_getPowered",
+ std::bind(&BluetoothAdapter::GetPowered, bluetooth_adapter, _1, _2));
+ RegisterSyncHandler("BluetoothAdapter_getVisible",
+ std::bind(&BluetoothAdapter::GetVisible, bluetooth_adapter, _1, _2));
+ RegisterSyncHandler("BluetoothAdapter_isServiceConnected",
+ std::bind(&BluetoothAdapter::IsServiceConnected, bluetooth_adapter, _1, _2));
+
+ // BluetoothDevice
+ RegisterHandler("BluetoothDevice_connectToServiceByUUID",
+ std::bind(&BluetoothDevice::ConnectToServiceByUUID, &bluetooth_device, _1, _2));
+ RegisterSyncHandler("BluetoothDevice_getBoolValue",
+ std::bind(&BluetoothDevice::GetBoolValue, &bluetooth_device, _1, _2));
+
+ // BluetoothHealthApplication
+ RegisterHandler("BluetoothHealthApplication_unregister",
+ std::bind(&BluetoothHealthApplication::Unregister, &bluetooth_health_application, _1, _2));
+
+ // BluetoothHealthChannel
+ RegisterSyncHandler("BluetoothHealthChannel_close",
+ std::bind(&BluetoothHealthChannel::Close, &bluetooth_health_channel, _1, _2));
+ RegisterSyncHandler("BluetoothHealthChannel_sendData",
+ std::bind(&BluetoothHealthChannel::SendData, &bluetooth_health_channel, _1, _2));
+
+ // BluetoothHealthProfileHandler
+ RegisterHandler("BluetoothHealthProfileHandler_registerSinkApp",
+ std::bind(&BluetoothHealthProfileHandler::RegisterSinkApp, bluetooth_health_profile_handler, _1, _2));
+ RegisterHandler("BluetoothHealthProfileHandler_connectToSource",
+ std::bind(&BluetoothHealthProfileHandler::ConnectToSource, bluetooth_health_profile_handler, _1, _2));
+
+ // BluetoothServiceHandler
+ RegisterHandler("BluetoothServiceHandler_unregister",
+ std::bind(&BluetoothServiceHandler::Unregister, &bluetooth_service_handler, _1, _2));
+
+ // BluetoothSocket
+ RegisterSyncHandler("BluetoothSocket_writeData",
+ std::bind(&BluetoothSocket::WriteData, &bluetooth_socket, _1, _2));
+ RegisterSyncHandler("BluetoothSocket_readData",
+ std::bind(&BluetoothSocket::ReadData, &bluetooth_socket, _1, _2));
+ RegisterSyncHandler("BluetoothSocket_close",
+ std::bind(&BluetoothSocket::Close, &bluetooth_socket, _1, _2));
+
+ // other
+ RegisterSyncHandler("Bluetooth_checkPrivilege", CheckPrivilege);
}
BluetoothInstance::~BluetoothInstance()
{
- LoggerD("Entered");
+ LoggerD("Entered");
}
} // namespace bluetooth
namespace bluetooth {
class BluetoothInstance: public common::ParsedInstance {
-public:
- static BluetoothInstance& GetInstance();
-private:
- BluetoothInstance();
- virtual ~BluetoothInstance();
+ public:
+ static BluetoothInstance& GetInstance();
+ private:
+ BluetoothInstance();
+ virtual ~BluetoothInstance();
};
} // namespace bluetooth
using namespace common;
void BluetoothServiceHandler::Unregister(const picojson::value& data, picojson::object& out) {
- LoggerD("Entered");
+ LoggerD("Entered");
- util::CheckAccess(Privilege::kBluetoothSpp);
+ util::CheckAccess(Privilege::kBluetoothSpp);
- const auto& args = util::GetArguments(data);
+ const auto& args = util::GetArguments(data);
- BluetoothAdapter::GetInstance().UnregisterUUID(
- FromJson<std::string>(args, "uuid"),
- util::GetAsyncCallbackHandle(data));
+ BluetoothAdapter::GetInstance().UnregisterUUID(
+ FromJson<std::string>(args, "uuid"),
+ util::GetAsyncCallbackHandle(data));
- tools::ReportSuccess(out);
+ tools::ReportSuccess(out);
}
} // namespace bluetooth
namespace bluetooth {
class BluetoothServiceHandler {
-public:
- /**
- * Signature: @code void unregister(successCallback, errorCallback); @endcode
- * JSON: @code data: {method: 'BluetoothServiceHandler_unregister', args: {}} @endcode
- * Invocation: @code native.call(request, result_callback); @endcode
- * Return:
- * @code
- * {status: 'error', error: {name, message}}
- * {status: 'success'}
- * @endcode
- * Result callback:
- * @code
- * {status: 'error', error: {name, message}}
- * {status: 'success'}
- * @endcode
- */
- void Unregister(const picojson::value& data, picojson::object& out);
+ public:
+ /**
+ * Signature: @code void unregister(successCallback, errorCallback); @endcode
+ * JSON: @code data: {method: 'BluetoothServiceHandler_unregister', args: {}} @endcode
+ * Invocation: @code native.call(request, result_callback); @endcode
+ * Return:
+ * @code
+ * {status: 'error', error: {name, message}}
+ * {status: 'success'}
+ * @endcode
+ * Result callback:
+ * @code
+ * {status: 'error', error: {name, message}}
+ * {status: 'success'}
+ * @endcode
+ */
+ void Unregister(const picojson::value& data, picojson::object& out);
};
} // namespace bluetooth
using namespace common::tools;
void BluetoothSocket::WriteData(const picojson::value& data, picojson::object& out) {
- LoggerD("Enter");
+ LoggerD("Enter");
- util::CheckAccess(Privilege::kBluetoothSpp);
+ util::CheckAccess(Privilege::kBluetoothSpp);
- const auto& args = util::GetArguments(data);
+ const auto& args = util::GetArguments(data);
- int socket = common::stol(FromJson<std::string>(args, "id"));
-
const auto& binary_data = FromJson<picojson::array>(args, "data");
- const auto data_size = binary_data.size();
+ int socket = common::stol(FromJson<std::string>(args, "id"));
+ const auto& binary_data = FromJson<picojson::array>(args, "data");
+ const auto data_size = binary_data.size();
- std::unique_ptr<char[]> data_ptr{new char[data_size]};
+ std::unique_ptr<char[]> data_ptr{new char[data_size]};
- for (std::size_t i = 0; i < data_size; ++i) {
- data_ptr[i] = static_cast<char>(binary_data[i].get<double>());
- }
+ for (std::size_t i = 0; i < data_size; ++i) {
+ data_ptr[i] = static_cast<char>(binary_data[i].get<double>());
+ }
- if (kBluetoothError == bt_socket_send_data(socket, data_ptr.get(), data_size)) {
- LoggerE("bt_socket_send_data() failed");
- ReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error"), &out);
- return;
- }
+ if (kBluetoothError == bt_socket_send_data(socket, data_ptr.get(), data_size)) {
+ LoggerE("bt_socket_send_data() failed");
+ ReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error"), &out);
+ return;
+ }
- ReportSuccess(picojson::value(static_cast<double>(data_size)), out);
+ ReportSuccess(picojson::value(static_cast<double>(data_size)), out);
}
void BluetoothSocket::ReadData(const picojson::value& data, picojson::object& out) {
- LoggerD("Enter");
+ LoggerD("Enter");
- util::CheckAccess(Privilege::kBluetoothSpp);
+ util::CheckAccess(Privilege::kBluetoothSpp);
- const auto& args = util::GetArguments(data);
+ const auto& args = util::GetArguments(data);
- int socket = common::stol(FromJson<std::string>(args, "id"));
+ int socket = common::stol(FromJson<std::string>(args, "id"));
- auto binary_data = BluetoothAdapter::GetInstance().ReadSocketData(socket);
- picojson::value ret = picojson::value(picojson::array());
-
picojson::array& array = ret.get<picojson::array>();
+ auto binary_data = BluetoothAdapter::GetInstance().ReadSocketData(socket);
+ picojson::value ret = picojson::value(picojson::array());
+ picojson::array& array = ret.get<picojson::array>();
- for (auto val : binary_data) {
- array.push_back(picojson::value(static_cast<double>(val)));
- }
+ for (auto val : binary_data) {
+ array.push_back(picojson::value(static_cast<double>(val)));
+ }
- BluetoothAdapter::GetInstance().ClearSocketData(socket);
+ BluetoothAdapter::GetInstance().ClearSocketData(socket);
- ReportSuccess(ret, out);
+ ReportSuccess(ret, out);
}
void BluetoothSocket::Close(const picojson::value& data, picojson::object& out) {
- LoggerD("Enter");
+ LoggerD("Enter");
- util::CheckAccess(Privilege::kBluetoothSpp);
+ util::CheckAccess(Privilege::kBluetoothSpp);
- const auto& args = util::GetArguments(data);
+ const auto& args = util::GetArguments(data);
- int socket = common::stol(FromJson<std::string>(args, "id"));
+ int socket = common::stol(FromJson<std::string>(args, "id"));
- if (BT_ERROR_NONE != bt_socket_disconnect_rfcomm(socket)) {
- LoggerE("bt_socket_disconnect_rfcomm() failed");
- ReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error"), &out);
- return;
- }
+ if (BT_ERROR_NONE != bt_socket_disconnect_rfcomm(socket)) {
+ LoggerE("bt_socket_disconnect_rfcomm() failed");
+ ReportError(PlatformResult(ErrorCode::UNKNOWN_ERR, "Unknown error"), &out);
+ return;
+ }
- ReportSuccess(out);
+ ReportSuccess(out);
}
picojson::value BluetoothSocket::ToJson(bt_socket_connection_s* connection) {
- LoggerD("Enter");
-
- picojson::value ret = picojson::value(picojson::object());
- auto& ret_obj = ret.get<picojson::object>();
-
- ret_obj.insert(std::make_pair(kBluetoothSocketId,
- picojson::value(std::to_string(connection->socket_fd))));
- ret_obj.insert(std::make_pair(kBluetoothSocketUuid,
- picojson::value(connection->service_uuid)));
- ret_obj.insert(std::make_pair(kBluetoothSocketState,
- picojson::value(kBluetoothSocketStateOpen)));
-
- bt_device_info_s* device_info = nullptr;
-
- if (BT_ERROR_NONE == bt_adapter_get_bonded_device_info(connection->remote_address, &device_info) &&
- nullptr != device_info) {
- picojson::value& device = ret_obj.insert(std::make_pair(kBluetoothSocketPeer,
- picojson::value(picojson::object()))).first->second;
- BluetoothDevice::ToJson(device_info, &device.get<picojson::object>());
- bt_adapter_free_device_info(device_info);
- } else {
- LoggerE("Peer not found");
- }
-
- return ret;
+ LoggerD("Enter");
+
+ picojson::value ret = picojson::value(picojson::object());
+ auto& ret_obj = ret.get<picojson::object>();
+
+ ret_obj.insert(std::make_pair(kBluetoothSocketId,
+ picojson::value(std::to_string(connection->socket_fd))));
+ ret_obj.insert(std::make_pair(kBluetoothSocketUuid,
+ picojson::value(connection->service_uuid)));
+ ret_obj.insert(std::make_pair(kBluetoothSocketState,
+ picojson::value(kBluetoothSocketStateOpen)));
+
+ bt_device_info_s* device_info = nullptr;
+
+ if (BT_ERROR_NONE == bt_adapter_get_bonded_device_info(connection->remote_address, &device_info) &&
+ nullptr != device_info) {
+ picojson::value& device = ret_obj.insert(std::make_pair(
+ kBluetoothSocketPeer, picojson::value(picojson::object()))).first->second;
+
+ BluetoothDevice::ToJson(device_info, &device.get<picojson::object>());
+ bt_adapter_free_device_info(device_info);
+ } else {
+ LoggerE("Peer not found");
+ }
+
+ return ret;
}
} // namespace bluetooth
namespace bluetooth {
class BluetoothSocket {
-public:
- /**
- * Signature: @code unsigned long writeData(data[]); @endcode
- * JSON: @code data: {method: 'BluetoothSocket_writeData', args: {data: data}} @endcode
- * Invocation: @code native.callSync(request); @endcode
- * Return:
- * @code
- * {status: 'error', error: {name, message}}
- * {status: 'success', result: {bytes_sent}}
- * @endcode
- */
- void WriteData(const picojson::value& data, picojson::object& out);
+ public:
+ /**
+ * Signature: @code unsigned long writeData(data[]); @endcode
+ * JSON: @code data: {method: 'BluetoothSocket_writeData', args: {data: data}} @endcode
+ * Invocation: @code native.callSync(request); @endcode
+ * Return:
+ * @code
+ * {status: 'error', error: {name, message}}
+ * {status: 'success', result: {bytes_sent}}
+ * @endcode
+ */
+ void WriteData(const picojson::value& data, picojson::object& out);
- /**
- * Signature: @code byte[] readData(); @endcode
- * JSON: @code data: {method: 'BluetoothSocket_readData', args: {}} @endcode
- * Invocation: @code native.callSync(request); @endcode
- * Return:
- * @code
- * {status: 'error', error: {name, message}}
- * {status: 'success', result: {bytes_read}}
- * @endcode
- */
- void ReadData(const picojson::value& data, picojson::object& out);
+ /**
+ * Signature: @code byte[] readData(); @endcode
+ * JSON: @code data: {method: 'BluetoothSocket_readData', args: {}} @endcode
+ * Invocation: @code native.callSync(request); @endcode
+ * Return:
+ * @code
+ * {status: 'error', error: {name, message}}
+ * {status: 'success', result: {bytes_read}}
+ * @endcode
+ */
+ void ReadData(const picojson::value& data, picojson::object& out);
- /**
- * Signature: @code void close(); @endcode
- * JSON: @code data: {method: 'BluetoothSocket_close', args: {}} @endcode
- * Invocation: @code native.callSync(request); @endcode
- * Return:
- * @code
- * {status: 'error', error: {name, message}}
- * {status: 'success'}
- * @endcode
- */
- void Close(const picojson::value& data, picojson::object& out);
+ /**
+ * Signature: @code void close(); @endcode
+ * JSON: @code data: {method: 'BluetoothSocket_close', args: {}} @endcode
+ * Invocation: @code native.callSync(request); @endcode
+ * Return:
+ * @code
+ * {status: 'error', error: {name, message}}
+ * {status: 'success'}
+ * @endcode
+ */
+ void Close(const picojson::value& data, picojson::object& out);
- static picojson::value ToJson(bt_socket_connection_s* connection);
+ static picojson::value ToJson(bt_socket_connection_s* connection);
};
} // namespace bluetooth
void CheckAccess(const std::string& privilege) {
- // TODO: check access to privilege, throw exception on failure
+ // TODO: check access to privilege, throw exception on failure
}
void AsyncResponse(double callback_handle, const std::shared_ptr<picojson::value>& response) {
-
common::TaskQueue::GetInstance().Async<picojson::value>([callback_handle](const std::shared_ptr<picojson::value>& response) {
- SyncResponse(callback_handle, response);
- }, response);
+ common::TaskQueue::GetInstance().Async<picojson::value>([callback_handle](const std::shared_ptr<picojson::value>& response) {
+ SyncResponse(callback_handle, response);
+ }, response);
}
void AsyncResponse(double callback_handle, const PlatformResult& result) {
-
std::shared_ptr<picojson::value> response =
-
std::shared_ptr<picojson::value>(new picojson::value(picojson::object()));
-
- if (result.IsError()) {
-
tools::ReportError(result, &response->get<picojson::object>());
- } else {
-
tools::ReportSuccess(response->get<picojson::object>());
- }
-
-
TaskQueue::GetInstance().Async<picojson::value>([callback_handle](const std::shared_ptr<picojson::value>& response) {
- SyncResponse(callback_handle, response);
- }, response);
+ std::shared_ptr<picojson::value> response =
+ std::shared_ptr<picojson::value>(new picojson::value(picojson::object()));
+
+ if (result.IsError()) {
+ tools::ReportError(result, &response->get<picojson::object>());
+ } else {
+ tools::ReportSuccess(response->get<picojson::object>());
+ }
+
+ TaskQueue::GetInstance().Async<picojson::value>([callback_handle](const std::shared_ptr<picojson::value>& response) {
+ SyncResponse(callback_handle, response);
+ }, response);
}
void SyncResponse(double callback_handle, const std::shared_ptr<picojson::value>& response) {
-
auto& obj = response->get<picojson::object>();
- obj[JSON_CALLBACK_ID] = picojson::value(callback_handle);
- BluetoothInstance::GetInstance().PostMessage(response->serialize().c_str());
+ auto& obj = response->get<picojson::object>();
+ obj[JSON_CALLBACK_ID] = picojson::value(callback_handle);
+ BluetoothInstance::GetInstance().PostMessage(response->serialize().c_str());
}
void FireEvent(const std::string& event, picojson::value& value) {
-
auto& obj = value.get<picojson::object>();
- obj[JSON_LISTENER_ID] = picojson::value(event);
- BluetoothInstance::GetInstance().PostMessage(value.serialize().c_str());
+ auto& obj = value.get<picojson::object>();
+ obj[JSON_LISTENER_ID] = picojson::value(event);
+ BluetoothInstance::GetInstance().PostMessage(value.serialize().c_str());
}
void FireEvent(const std::string& event, const picojson::value& value) {
- picojson::value v{value};
- FireEvent(event, v);
+ picojson::value v{value};
+ FireEvent(event, v);
}
void FireEvent(const std::string& event, const std::shared_ptr<picojson::value>& value) {
- FireEvent(event, *value.get());
+ FireEvent(event, *value.get());
}
double GetAsyncCallbackHandle(const picojson::value& data) {
- return data.get(JSON_CALLBACK_ID).get<double>();
+ return data.get(JSON_CALLBACK_ID).get<double>();
}
const picojson::object& GetArguments(const picojson::value& data) {
-
return data.get<picojson::object>();
+ return data.get<picojson::object>();
}
} // util
projects / platform / core / api / webapi-plugins.git / commitdiff