void BluetoothAdapter::onStateChangedCB(int result, bt_adapter_state_e adapterState, void *userData)
{
- LogDebug("Entered");
+ LoggerD("Entered");
BluetoothAdapterPtr object = static_cast<BluetoothAdapterPtr>(userData);
if(!object) {
- LogWarning("userData is NULL");
+ LoggerW("userData is NULL");
return;
}
object->mEnabled = (adapterState == BT_ADAPTER_ENABLED) ? true : false;
if(object->mUserDataList[SET_POWERED] != NULL) { // requested event
bool state = (adapterState == BT_ADAPTER_ENABLED) ? true : false;
if(object->mRequestedState != state) {
- LogWarning("Requested state is same to current state");
+ LoggerW("Requested state is same to current state");
return;
}
}
}
else { // unexpected event
- LogWarning("Bluetooth state is changed unexpectedly");
+ LoggerW("Bluetooth state is changed unexpectedly");
}
}
void BluetoothAdapter::onNameChangedCB(char *name, void *userData)
{
- LogDebug("Entered");
+ LoggerD("Entered");
BluetoothAdapterPtr object = static_cast<BluetoothAdapterPtr>(userData);
if(!object) {
- LogWarning("userData is NULL");
+ LoggerW("userData is NULL");
return;
}
bt_adapter_unset_name_changed_cb();
}
else { // unexpected event
- LogWarning("Bluetooth name is changed unexpectedly");
+ LoggerW("Bluetooth name is changed unexpectedly");
}
}
void BluetoothAdapter::onVisibilityChangedCB(int result, bt_adapter_visibility_mode_e visibilityMode, void *userData)
{
- LogDebug("Entered");
+ LoggerD("Entered");
BluetoothAdapterPtr object = static_cast<BluetoothAdapterPtr>(userData);
if(!object) {
- LogWarning("userData is NULL");
+ LoggerW("userData is NULL");
return;
}
if(object->mUserDataList[SET_VISIBLE] != NULL) { // requested event
//bool visibility = (visibilityMode == BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE) ? false : true;
if(object->mRequestedVisibility != visibilityMode) {
- LogWarning("Requested visibility is not same to current visibility");
+ LoggerW("Requested visibility is not same to current visibility");
return;
}
bt_adapter_unset_visibility_mode_changed_cb();
}
else { // unexpected event
- LogWarning("Bluetooth visibility is changed unexpectedly");
+ LoggerW("Bluetooth visibility is changed unexpectedly");
}
}
void BluetoothAdapter::onDiscoveryStateChangedCB(int result, bt_adapter_device_discovery_state_e discoveryState,
bt_adapter_device_discovery_info_s *discoveryInfo, void *userData)
{
- LogDebug("Entered");
+ LoggerD("Entered");
BluetoothAdapterPtr object = static_cast<BluetoothAdapterPtr>(userData);
if(!object) {
- LogWarning("userData is NULL");
+ LoggerW("userData is NULL");
return;
}
switch(discoveryState) {
case BT_ADAPTER_DEVICE_DISCOVERY_STARTED:
{
- LogDebug("BT_ADAPTER_DEVICE_DISCOVERY_STARTED");
+ LoggerD("BT_ADAPTER_DEVICE_DISCOVERY_STARTED");
if(object->mUserDataList[DISCOVER_DEVICES] != NULL) { // requested event
MultiCallbackUserDataPtr callback =
static_cast<MultiCallbackUserDataPtr>(object->mUserDataList[DISCOVER_DEVICES]);
}
else {
if(callback) {
- LogDebug("Reset DISCOVER_DEVICES");
+ LoggerD("Reset DISCOVER_DEVICES");
object->mUserDataList[DISCOVER_DEVICES].reset();
JSContextRef context = callback->getContext();
}
}
else { // unexpected event
- LogWarning("Unexpected discovery");
+ LoggerW("Unexpected discovery");
}
break;
}
case BT_ADAPTER_DEVICE_DISCOVERY_FINISHED:
{
- LogDebug("BT_ADAPTER_DEVICE_DISCOVERY_FINISHED");
+ LoggerD("BT_ADAPTER_DEVICE_DISCOVERY_FINISHED");
if(result == BT_ERROR_NONE || result == BT_ERROR_CANCELLED) {
// in case of discoverDevices()
if(object->mUserDataList[DISCOVER_DEVICES] != NULL) {
static_cast<MultiCallbackUserDataPtr>(object->mUserDataList[DISCOVER_DEVICES]);
if(callback) {
- LogDebug("Call onfinished()");
+ LoggerD("Call onfinished()");
if(object->mDisappearedDevices.size() > 0) {
- LogDebug("There are disappeared devices");
+ LoggerD("There are disappeared devices");
for(std::vector<std::string>::iterator iter = object->mDisappearedDevices.begin();
iter != object->mDisappearedDevices.end(); iter++) {
}
if(object->mFoundDevices.size() > 0) { // There are found devices
- LogDebug("There are found devices");
+ LoggerD("There are found devices");
int num = object->mFoundDevices.size();
JSObjectRef devices[num];
for(int i = 0; i < num; i++) {
devices[i] = deviceObj;
}
- LogDebug("Reset DISCOVER_DEVICES");
+ LoggerD("Reset DISCOVER_DEVICES");
object->mUserDataList[DISCOVER_DEVICES].reset();
callback->invokeCallback(
JSObjectMakeArray(callback->getContext(), num, devices, NULL) );
}
else { // There is no found device
- LogDebug("There is no found device");
+ LoggerD("There is no found device");
- LogDebug("Reset DISCOVER_DEVICES");
+ LoggerD("Reset DISCOVER_DEVICES");
object->mUserDataList[DISCOVER_DEVICES].reset();
callback->invokeCallback(
static_cast<MultiCallbackUserDataPtr>(object->mUserDataList[STOP_DISCOVERY]);
if(callback) {
- LogDebug("Call successCallback of stopDiscovery()");
+ LoggerD("Call successCallback of stopDiscovery()");
object->mUserDataList[STOP_DISCOVERY].reset();
callback->invokeCallback("success");
}
//bt_adapter_unset_device_discovery_state_changed_cb();
}
else {
- LogWarning("result MUST be BT_ERROR_NONE or BT_ERROR_CANCELLED when BT_ADAPTER_DEVICE_DISCOVERY_FINISHED");
+ LoggerW("result MUST be BT_ERROR_NONE or BT_ERROR_CANCELLED when BT_ADAPTER_DEVICE_DISCOVERY_FINISHED");
}
break;
}
case BT_ADAPTER_DEVICE_DISCOVERY_FOUND:
{
- LogDebug("BT_ADAPTER_DEVICE_DISCOVERY_FOUND");
+ LoggerD("BT_ADAPTER_DEVICE_DISCOVERY_FOUND");
if(!discoveryInfo) {
- LogWarning("discoveryInfo is NULL");
+ LoggerW("discoveryInfo is NULL");
return;
}
for(std::vector<std::string>::iterator iter = object->mDisappearedDevices.begin();
iter != object->mDisappearedDevices.end(); iter++) {
if(!strcmp(discoveryInfo->remote_address, (*iter).c_str())) {
- LogDebug("This device is still found");
+ LoggerD("This device is still found");
object->mDisappearedDevices.erase(iter);
break;
}
callback->invokeCallback("ondevicefound", deviceObj);
}
else {
- LogWarning("result MUST be BT_ERROR_NONE when BT_ADAPTER_DEVICE_DISCOVERY_FOUND");
+ LoggerW("result MUST be BT_ERROR_NONE when BT_ADAPTER_DEVICE_DISCOVERY_FOUND");
}
}
else { // unexpected event
- LogWarning("Unexpected discovery");
+ LoggerW("Unexpected discovery");
}
break;
}
default:
{
- LogWarning("Unknown state");
+ LoggerW("Unknown state");
}
}
}
bool BluetoothAdapter::foreachBondedDevicesCB(bt_device_info_s *deviceInfo, void *userData)
{
- LogDebug("Entered");
+ LoggerD("Entered");
BluetoothAdapterPtr adapter = static_cast<BluetoothAdapterPtr>(userData);
if(!adapter) {
- LogWarning("userData is NULL");
+ LoggerW("userData is NULL");
return true;
}
if(deviceInfo == NULL) {
- LogWarning("deviceInfo is NULL");
+ LoggerW("deviceInfo is NULL");
return true;
}
BluetoothDeviceSharedPtr foundDevice = *iter;
if(!strcmp(foundDevice->getAddress().c_str(), deviceInfo->remote_address)) {
- LogDebug("Already known device");
+ LoggerD("Already known device");
foundDevice->updateInfo(deviceInfo);
break;
}
}
if(iter == adapter->knownDevices.end()) {
- LogDebug("Add a device into foundDevices");
+ LoggerD("Add a device into foundDevices");
BluetoothDeviceSharedPtr device(new BluetoothDevice(deviceInfo));
adapter->knownDevices.push_back(device);
}
void BluetoothAdapter::onBondCreatedCB(int result, bt_device_info_s *deviceInfo, void *userData)
{
- LogDebug("Entered");
+ LoggerD("Entered");
BluetoothAdapterPtr object = static_cast<BluetoothAdapterPtr>(userData);
if(!object) {
- LogWarning("userData is NULL");
+ LoggerW("userData is NULL");
return;
}
if(!deviceInfo) {
- LogWarning("deviceInfo is NULL");
+ LoggerW("deviceInfo is NULL");
return;
}
object->mCreateBondingAddress.clear();
}
else { // unexpected event
- LogWarning("A bonding is created unexpectedly");
+ LoggerW("A bonding is created unexpectedly");
}
}
void BluetoothAdapter::onBondDestroyedCB(int result, char *remoteAddress, void *userData)
{
- LogDebug("Entered");
+ LoggerD("Entered");
BluetoothAdapterPtr object = static_cast<BluetoothAdapterPtr>(userData);
if(!object) {
- LogWarning("userData is NULL");
+ LoggerW("userData is NULL");
return;
}
object->mDestroyBondingAddress.clear();
}
else { // unexpected event
- LogWarning("A bonding is created unexpectedly");
+ LoggerW("A bonding is created unexpectedly");
}
}
void BluetoothAdapter::onSocketConnected(int result, bt_socket_connection_state_e state, bt_socket_connection_s *connection, void *userData)
{
- LogDebug("Entered");
+ LoggerD("Entered");
BluetoothAdapterPtr object = static_cast<BluetoothAdapterPtr>(userData);
if(!object) {
- LogWarning("userData is NULL");
+ LoggerW("userData is NULL");
return;
}
if(!connection) {
- LogWarning("connection is NULL");
+ LoggerW("connection is NULL");
return;
}
if(connection->local_role == BT_SOCKET_SERVER) {
RegisteredUUIDMapT::iterator iter = object->mRegisteredUUID.find(connection->service_uuid);
if(iter == object->mRegisteredUUID.end()) {
- LogWarning("Connection state is changed unexpectedly");
+ LoggerW("Connection state is changed unexpectedly");
return;
}
bt_socket_set_data_received_cb(onSocketReceivedCB, userData);
}
else {
- LogWarning("Establishing a connection failed");
+ LoggerW("Establishing a connection failed");
}
return;
}
// call BluetoothSocket.onclose;
ConnectedSocketMapT::iterator i = object->mConnectedSocket.find(connection->socket_fd);
if(i == object->mConnectedSocket.end()) {
- LogWarning("Unknown connected socket");
+ LoggerW("Unknown connected socket");
return;
}
//BluetoothSocketSharedPtr socket = i->second;
object->mConnectedSocket.erase(i);
}
else {
- LogWarning("Disconnecting a connection failed");
+ LoggerW("Disconnecting a connection failed");
}
}
}
do {
iter = object->mConnReqMap.find(remoteAddress);
if(iter != object->mConnReqMap.end() && !strcmp(iter->second->mUUID.c_str(), connection->service_uuid)) {
- LogDebug("Find");
+ LoggerD("Find");
break;
}
} while(iter != object->mConnReqMap.end());
if(iter == object->mConnReqMap.end()) {
- LogWarning("Connection state is changed unexpectedly");
+ LoggerW("Connection state is changed unexpectedly");
return;
}
// call BluetoothSocket.onclose;
ConnectedSocketMapT::iterator i = object->mConnectedSocket.find(connection->socket_fd);
if(i == object->mConnectedSocket.end()) {
- LogWarning("Unknown connected socket");
+ LoggerW("Unknown connected socket");
return;
}
object->mConnectedSocket.erase(i);
}
else {
- LogWarning("Disconnecting a connection failed");
+ LoggerW("Disconnecting a connection failed");
}
}
}
else {
- LogWarning("Unknown role");
+ LoggerW("Unknown role");
return;
}
}
if(object->mRegisteredUUID.size() == 0 && object->mConnReqMap.size() == 0 && object->mConnectedSocket.size() == 0) {
- LogDebug("mRegisteredUUID.size()=%d, mConnReqMap.size()=%d, mConnectedSocket.size()=%d",
+ LoggerD("mRegisteredUUID.size()=%d, mConnReqMap.size()=%d, mConnectedSocket.size()=%d",
object->mRegisteredUUID.size(), object->mConnReqMap.size(), object->mConnectedSocket.size());
bt_socket_unset_connection_state_changed_cb();
}
void BluetoothAdapter::onSocketReceivedCB(bt_socket_received_data_s *data, void *userData)
{
- LogDebug("Entered");
+ LoggerD("Entered");
BluetoothAdapterPtr object = static_cast<BluetoothAdapterPtr>(userData);
if(!object) {
- LogWarning("userData is NULL");
+ LoggerW("userData is NULL");
return;
}
if(!data) {
- LogWarning("data is NULL");
+ LoggerW("data is NULL");
return;
}
ConnectedSocketMapT::iterator i = object->mConnectedSocket.find(data->socket_fd);
if(i == object->mConnectedSocket.end()) {
- LogWarning("Unknown connected socket");
+ LoggerW("Unknown connected socket");
return;
}
BluetoothAdapter::BluetoothAdapter():
mEnabled(false)
{
- LogDebug("Entered");
+ LoggerD("Entered");
if(bt_initialize() != BT_ERROR_NONE) {
- LogError("bt_initialize() failed");
+ LoggerE("bt_initialize() failed");
}
bt_adapter_state_e state;
}
if(bt_adapter_set_state_changed_cb(onStateChangedCB, this) != BT_ERROR_NONE) {
- LogError("bt_adapter_set_state_changed_cb() failed");
+ LoggerE("bt_adapter_set_state_changed_cb() failed");
}
if(bt_adapter_set_device_discovery_state_changed_cb(onDiscoveryStateChangedCB, this) != BT_ERROR_NONE) {
- LogError("bt_adapter_set_device_discovery_state_changed_cb() failed");
+ LoggerE("bt_adapter_set_device_discovery_state_changed_cb() failed");
}
}
BluetoothAdapter::~BluetoothAdapter()
{
- LogDebug("Entered");
+ LoggerD("Entered");
// unset platform callback
bt_adapter_unset_state_changed_cb();
void BluetoothAdapter::unloadFrame(JSContextRef context)
{
- LogDebug("Entered");
+ LoggerD("Entered");
- LogDebug("Clean mUserDataList");
+ LoggerD("Clean mUserDataList");
for(int i = 0; i <= DESTROY_BONDING; i++) {
if(mUserDataList[i]) {
MultiCallbackUserDataPtr callback = mUserDataList[i];
if(!GlobalContextManager::getInstance()->isAliveGlobalContext(callback->getContext())) {
- LogDebug("reset an userData");
+ LoggerD("reset an userData");
mUserDataList[i].reset();
}
}
}
- LogDebug("Clean mConnReqMap");
+ LoggerD("Clean mConnReqMap");
for(ConnReqMultiMapT::iterator iter = mConnReqMap.begin(); iter != mConnReqMap.end(); ) {
ConnReqMultiMapT::iterator temp = iter++;
MultiCallbackUserDataPtr callback = temp->second->mUserData;
if(!callback && !GlobalContextManager::getInstance()->isAliveGlobalContext(callback->getContext())) {
- LogDebug("erase a connectionRequest");
+ LoggerD("erase a connectionRequest");
mConnReqMap.erase(temp);
}
}
void BluetoothAdapter::unregisterUUID(std::string &uuid)
{
- LogDebug("Entered");
+ LoggerD("Entered");
mRegisteredUUID.erase(mRegisteredUUID.find(uuid));
if(mRegisteredUUID.size() == 0 && mConnReqMap.size() == 0 && mConnectedSocket.size() == 0) {
- LogDebug("mRegisteredUUID.size()=%d, mConnReqMap.size()=%d, mConnectedSocket.size()=%d",
+ LoggerD("mRegisteredUUID.size()=%d, mConnReqMap.size()=%d, mConnectedSocket.size()=%d",
mRegisteredUUID.size(), mConnReqMap.size(), mConnectedSocket.size());
bt_socket_unset_connection_state_changed_cb();
}
bool BluetoothAdapter::closeConnectedSocket(int socket)
{
- LogDebug("Entered");
+ LoggerD("Entered");
if(mEnabled == true) {
ConnectedSocketMapT::iterator iter = mConnectedSocket.find(socket);
if(iter == mConnectedSocket.end()) {
- LogWarning("Already disconnected");
+ LoggerW("Already disconnected");
return true;
}
}
if(mRegisteredUUID.size() == 0 && mConnReqMap.size() == 0 && mConnectedSocket.size() == 0) {
- LogDebug("mRegisteredUUID.size()=%d, mConnReqMap.size()=%d, mConnectedSocket.size()=%d",
+ LoggerD("mRegisteredUUID.size()=%d, mConnReqMap.size()=%d, mConnectedSocket.size()=%d",
mRegisteredUUID.size(), mConnReqMap.size(), mConnectedSocket.size());
bt_socket_unset_connection_state_changed_cb();
}
return true;
}
else {
- LogError("Bluetooth is not powered");
+ LoggerE("Bluetooth is not powered");
return false;
}
}
void BluetoothAdapter::removeConnReq(std::string &remoteAddress)
{
- LogDebug("Entered");
+ LoggerD("Entered");
mConnReqMap.erase(remoteAddress);
if(mRegisteredUUID.size() == 0 && mConnReqMap.size() == 0 && mConnectedSocket.size() == 0) {
- LogDebug("mRegisteredUUID.size()=%d, mConnReqMap.size()=%d, mConnectedSocket.size()=%d",
+ LoggerD("mRegisteredUUID.size()=%d, mConnReqMap.size()=%d, mConnectedSocket.size()=%d",
mRegisteredUUID.size(), mConnReqMap.size(), mConnectedSocket.size());
if(bt_socket_unset_connection_state_changed_cb() != BT_ERROR_NONE) {
- LogWarning("Unsetting connection event callback failed");
+ LoggerW("Unsetting connection event callback failed");
}
}
}
BluetoothAdapter* BluetoothAdapter::getInstance()
{
- LogDebug("Entered");
+ LoggerD("Entered");
static BluetoothAdapter instance;
return &instance;
bool isSupported = false;
if(system_info_get_value_bool(SYSTEM_INFO_KEY_BLUETOOTH_SUPPORTED, &isSupported) != SYSTEM_INFO_ERROR_NONE) {
- LogError("Can't know whether Bluetooth is supported or not");
+ LoggerE("Can't know whether Bluetooth is supported or not");
}
return isSupported;
bool BluetoothAdapter::isValidAddress(std::string &address)
{
- LogDebug("Entered");
+ LoggerD("Entered");
pcrecpp::RE re("(([0-9a-zA-Z]+):)+([0-9a-zA-Z]+)");
std::string compareAddress = "00:12:47:08:9A:A6";
if (!re.FullMatch(address)) {
- LogError("Invalid address");
+ LoggerE("Invalid address");
return false;
}
if (address.size() != compareAddress.size())
{
- LogError("Invalid size");
+ LoggerE("Invalid size");
return false;
}
if (!re.FullMatch(uuid))
{
- LogError("Invalid UUID");
+ LoggerE("Invalid UUID");
return false;
}
if (uuid.size() != compareUUID.size())
{
- LogError("Invalid size");
+ LoggerE("Invalid size");
return false;
}
std::string BluetoothAdapter::getName() const
{
- LogDebug("Entered");
+ LoggerD("Entered");
char* name = NULL;
std::string str = "";
{
str = name;
free(name);
- LogDebug("name" << str);
+ LoggerD("name" << str);
}
}
else {
- LogError("bt_adapter_get_name() failed");
+ LoggerE("bt_adapter_get_name() failed");
}
return str;
void BluetoothAdapter::setName(std::string &name, MultiCallbackUserDataPtr userData)
{
- LogDebug("Entered");
+ LoggerD("Entered");
if(mEnabled == true) {
std::string adapterName = getName();
if(adapterName == name) { // in case of same name
- LogDebug("same name");
+ LoggerD("same name");
BluetoothCallbackUtil::syncToAsyncSuccessCallback(userData);
return;
}
bt_adapter_set_name_changed_cb(onNameChangedCB, this);
mUserDataList[SET_NAME] = userData;
} else {
- LogError("Already requested");
+ LoggerE("Already requested");
UnknownException *error = new UnknownException("Already requested");
BluetoothCallbackUtil::syncToAsyncErrorCallback(userData, error);
return;
switch(ret) {
case BT_ERROR_NONE:
{
- LogDebug("bt_adapter_set_name() succeeded");
+ LoggerD("bt_adapter_set_name() succeeded");
mRequestedName = name;
return;
}
case BT_ERROR_INVALID_PARAMETER:
{
- LogError("Invalid value");
+ LoggerE("Invalid value");
InvalidValuesException *error = new InvalidValuesException("Invalid value");
BluetoothCallbackUtil::syncToAsyncErrorCallback(userData, error);
break;
}
default:
{
- LogError("Invalid value");
+ LoggerE("Invalid value");
UnknownException *error = new UnknownException("Unknown exception");
BluetoothCallbackUtil::syncToAsyncErrorCallback(userData, error);
}
bt_adapter_unset_name_changed_cb();
mUserDataList[SET_NAME].reset();
} else { // Not enabled
- LogError("Bluetooth device is turned off");
+ LoggerE("Bluetooth device is turned off");
ServiceNotAvailableException *error = new ServiceNotAvailableException("Bluetooth device is turned off");
BluetoothCallbackUtil::syncToAsyncErrorCallback(userData, error);
}
std::string BluetoothAdapter::getAddress() const
{
- LogDebug("Entered");
+ LoggerD("Entered");
char* address = NULL;
std::string str = "";
if (address != NULL) {
str = address;
free(address);
- LogDebug("address: " << str);
+ LoggerD("address: " << str);
}
else {
- LogWarning("address is NULL");
+ LoggerW("address is NULL");
}
}
else {
- LogError("bt_adapter_get_address() failed");
+ LoggerE("bt_adapter_get_address() failed");
}
return str;
bool BluetoothAdapter::getPowered() const
{
- LogDebug("Entered");
+ LoggerD("Entered");
return mEnabled;
}
void BluetoothAdapter::setPowered(bool powered, MultiCallbackUserDataPtr userData)
{
- LogDebug("Entered");
+ LoggerD("Entered");
if(powered == mEnabled) {
- LogDebug("same state");
+ LoggerD("same state");
BluetoothCallbackUtil::syncToAsyncSuccessCallback(userData);
return;
}
mUserDataList[SET_POWERED] = userData;
} else {
// Already requested
- LogError("Already requested");
+ LoggerE("Already requested");
ServiceNotAvailableException *error = new ServiceNotAvailableException("Already requested");
BluetoothCallbackUtil::syncToAsyncErrorCallback(userData, error);
return;
switch(ret) {
case BT_ERROR_NONE:
{
- LogDebug("bt_adapter_enable() succeeded");
+ LoggerD("bt_adapter_enable() succeeded");
return;
}
case BT_ERROR_ALREADY_DONE:
{
// call successCallback
- LogDebug("BT_ERROR_ALREADY_DONE");
+ LoggerD("BT_ERROR_ALREADY_DONE");
BluetoothCallbackUtil::syncToAsyncSuccessCallback(userData);
break;
}
case BT_ERROR_NOW_IN_PROGRESS:
{
- LogDebug("BT_ERROR_NOW_IN_PROGRESS");
+ LoggerD("BT_ERROR_NOW_IN_PROGRESS");
ServiceNotAvailableException *error = new ServiceNotAvailableException("Bluetooth device is busy");
BluetoothCallbackUtil::syncToAsyncErrorCallback(userData, error);
break;
}
default:
{
- LogDebug("Unknown error");
+ LoggerD("Unknown error");
UnknownException *error = new UnknownException("Unknown error");
BluetoothCallbackUtil::syncToAsyncErrorCallback(userData, error);
}
switch(ret) {
case BT_ERROR_NONE:
{
- LogDebug("bt_adapter_disable() succeeded");
+ LoggerD("bt_adapter_disable() succeeded");
return;
}
case BT_ERROR_NOT_ENABLED:
{
// call successCallback
- LogDebug("Already disabled");
+ LoggerD("Already disabled");
BluetoothCallbackUtil::syncToAsyncSuccessCallback(userData);
break;
}
case BT_ERROR_NOW_IN_PROGRESS:
{
- LogDebug("BT_ERROR_NOW_IN_PROGRESS");
+ LoggerD("BT_ERROR_NOW_IN_PROGRESS");
ServiceNotAvailableException *error = new ServiceNotAvailableException("Bluetooth device is busy");
BluetoothCallbackUtil::syncToAsyncErrorCallback(userData, error);
break;
}
default:
{
- LogDebug("Unknown error");
+ LoggerD("Unknown error");
UnknownException *error = new UnknownException("Unknown error");
BluetoothCallbackUtil::syncToAsyncErrorCallback(userData, error);
}
bool BluetoothAdapter::getVisible() const
{
- LogDebug("Entered");
+ LoggerD("Entered");
bt_adapter_visibility_mode_e mode;
void BluetoothAdapter::setVisible(bool visible, unsigned int timeout, MultiCallbackUserDataPtr userData)
{
- LogDebug("Entered");
+ LoggerD("Entered");
if(mEnabled == true) {
bt_adapter_visibility_mode_e discoverable_mode = BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE;
bt_adapter_visibility_mode_e current = BT_ADAPTER_VISIBILITY_MODE_NON_DISCOVERABLE;
int time = 0;
if(bt_adapter_get_visibility(¤t , &time) != BT_ERROR_NONE) {
- LogError("bt_adapter_get_visibility() failed");
+ LoggerE("bt_adapter_get_visibility() failed");
UnknownException *error = new UnknownException("Can't get current visibility");
BluetoothCallbackUtil::syncToAsyncErrorCallback(userData, error);
return;
if(discoverable_mode == current) {
if(discoverable_mode != BT_ADAPTER_VISIBILITY_MODE_LIMITED_DISCOVERABLE) {
- LogDebug("same visibility");
+ LoggerD("same visibility");
BluetoothCallbackUtil::syncToAsyncSuccessCallback(userData);
return;
}
else if((unsigned int)time == timeout) {
- LogDebug("same visibility");
+ LoggerD("same visibility");
BluetoothCallbackUtil::syncToAsyncSuccessCallback(userData);
return;
}
switch(ret) {
case BT_ERROR_NONE:
{
- LogDebug("bt_adapter_set_visibility() succeeded");
+ LoggerD("bt_adapter_set_visibility() succeeded");
return;
}
case BT_ERROR_INVALID_PARAMETER:
void BluetoothAdapter::discoverDevices(MultiCallbackUserDataPtr userData)
{
- LogDebug("Entered");
+ LoggerD("Entered");
if(mUserDataList[DISCOVER_DEVICES] == NULL) {
mUserDataList[DISCOVER_DEVICES] = userData;
bt_adapter_set_device_discovery_state_changed_cb(onDiscoveryStateChangedCB, this);
*/
} else {
- LogError("Already requested");
+ LoggerE("Already requested");
UnknownException *error = new UnknownException("Already requested");
BluetoothCallbackUtil::syncToAsyncErrorCallback(userData, error);
return;
switch(ret) {
case BT_ERROR_NONE:
{
- LogDebug("bt_adapter_start_device_discovery() succeeded");
+ LoggerD("bt_adapter_start_device_discovery() succeeded");
return;
}
default:
{
- LogError("Unknown exception");
+ LoggerE("Unknown exception");
UnknownException *error = new UnknownException("Unknown error");
BluetoothCallbackUtil::syncToAsyncErrorCallback(userData, error);
}
}
} else { // Not enabled
- LogError("Bluetooth device is turned off");
+ LoggerE("Bluetooth device is turned off");
ServiceNotAvailableException *error = new ServiceNotAvailableException("Bluetooth device is turned off");
BluetoothCallbackUtil::syncToAsyncErrorCallback(userData, error);
}
void BluetoothAdapter::stopDiscovery(MultiCallbackUserDataPtr userData)
{
- LogDebug("Entered");
+ LoggerD("Entered");
if(mEnabled == true) {
bt_adapter_set_device_discovery_state_changed_cb(onDiscoveryStateChangedCB, this);
*/
} else {
- LogDebug("Already requested");
+ LoggerD("Already requested");
UnknownException *error = new UnknownException("Already requested");
BluetoothCallbackUtil::syncToAsyncErrorCallback(userData, error);
return;
switch(ret) {
case BT_ERROR_NONE:
{
- LogDebug("bt_adapter_stop_device_discovery() succeeded");
+ LoggerD("bt_adapter_stop_device_discovery() succeeded");
return;
}
default:
void BluetoothAdapter::getKnownDevices(MultiCallbackUserDataPtr userData)
{
- LogDebug("Entered");
+ LoggerD("Entered");
BluetoothCallbackUtil::syncToAsyncDeviceArrayCallback(userData);
}
void BluetoothAdapter::getDevice(std::string &address, MultiCallbackUserDataPtr userData)
{
- LogDebug("Entered");
+ LoggerD("Entered");
BluetoothCallbackUtil::syncToAsyncDeviceCallback(userData, address);
}
void BluetoothAdapter::createBonding(std::string &address, MultiCallbackUserDataPtr userData)
{
- LogDebug("Entered");
+ LoggerD("Entered");
if(!isValidAddress(address)) {
- LogError("Wrong address");
+ LoggerE("Wrong address");
NotFoundException *error = new NotFoundException("Wrong address");
BluetoothCallbackUtil::syncToAsyncErrorCallback(userData, error);
return;
mCreateBondingAddress = address;
mUserDataList[CREATE_BONDING] = userData;
} else {
- LogError("Already requested");
+ LoggerE("Already requested");
UnknownException *error = new UnknownException("Already requested");
BluetoothCallbackUtil::syncToAsyncErrorCallback(userData, error);
return;
switch(ret) {
case BT_ERROR_NONE:
{
- LogDebug("bt_device_create_bond() succeeded");
+ LoggerD("bt_device_create_bond() succeeded");
return;
}
case BT_ERROR_INVALID_PARAMETER:
{
- LogError("Not found");
+ LoggerE("Not found");
NotFoundException *error = new NotFoundException("Not found");
BluetoothCallbackUtil::syncToAsyncErrorCallback(userData, error);
break;
}
default:
{
- LogError("Unknown exception");
+ LoggerE("Unknown exception");
UnknownException *error = new UnknownException("Unknown error");
BluetoothCallbackUtil::syncToAsyncErrorCallback(userData, error);
}
}
} else { // Not enabled
- LogError("Bluetooth device is turned off");
+ LoggerE("Bluetooth device is turned off");
ServiceNotAvailableException *error = new ServiceNotAvailableException("Bluetooth device is turned off");
BluetoothCallbackUtil::syncToAsyncErrorCallback(userData, error);
}
void BluetoothAdapter::destroyBonding(std::string &address, MultiCallbackUserDataPtr userData)
{
- LogDebug("Entered");
+ LoggerD("Entered");
if(!isValidAddress(address)) {
- LogError("Wrong address");
+ LoggerE("Wrong address");
NotFoundException *error = new NotFoundException("Wrong address");
BluetoothCallbackUtil::syncToAsyncErrorCallback(userData, error);
return;
mDestroyBondingAddress = address;
mUserDataList[DESTROY_BONDING] = userData;
} else {
- LogDebug("Already requested");
+ LoggerD("Already requested");
UnknownException *error = new UnknownException("Already requested");
BluetoothCallbackUtil::syncToAsyncErrorCallback(userData, error);
return;
if(mEnabled == true) {
bt_device_info_s *deviceInfo = NULL;
if(bt_adapter_get_bonded_device_info(address.c_str(), &deviceInfo) != BT_ERROR_NONE || deviceInfo == NULL) {
- LogDebug("There is no bonding");
+ LoggerD("There is no bonding");
NotFoundException *error = new NotFoundException("Not found");
BluetoothCallbackUtil::syncToAsyncErrorCallback(userData, error);
}
switch(ret) {
case BT_ERROR_NONE:
{
- LogDebug("bt_device_destroy_bond() succeeded");
+ LoggerD("bt_device_destroy_bond() succeeded");
return;
}
case BT_ERROR_INVALID_PARAMETER:
void BluetoothAdapter::registerRFCOMMServiceByUUID(std::string &uuid, std::string &name, MultiCallbackUserDataPtr userData)
{
- LogDebug("Entered");
+ LoggerD("Entered");
BluetoothCallbackUtil::syncToAsyncServiceCallback(userData, uuid, name);
}
void BluetoothAdapter::connectToServiceByUUID(std::string &remoteAddress, std::string &uuid, Common::MultiCallbackUserDataPtr userData)
{
- LogDebug("Entered");
+ LoggerD("Entered");
if(!isValidUUID(uuid)) {
- LogError("Wrong UUID");
+ LoggerE("Wrong UUID");
InvalidValuesException *error = new InvalidValuesException("Wrong UUID");
BluetoothCallbackUtil::syncToAsyncErrorCallback(userData, error);
return;
switch(ret) {
case BT_ERROR_NONE:
{
- LogDebug("bt_socket_connect_rfcomm() succeeded");
+ LoggerD("bt_socket_connect_rfcomm() succeeded");
bt_socket_set_connection_state_changed_cb(onSocketConnected, this);
BluetoothConnReqPtr connReq = new BluetoothConnReq(uuid, userData);
void BluetoothAdapter::returnKnownDevices(Common::MultiCallbackUserDataPtr userData)
{
- LogDebug("Entered");
+ LoggerD("Entered");
if(mEnabled == true) {
knownDevices = mFoundDevices;
if(bt_adapter_foreach_bonded_device(foreachBondedDevicesCB, this) == BT_ERROR_NONE) {
if(knownDevices.size() > 0) { // There are found devices
- LogDebug("There are found devices");
+ LoggerD("There are found devices");
int num = knownDevices.size();
JSObjectRef devices[num];
for(int i = 0; i < num; i++) {
devices[i] = deviceObj;
}
- LogDebug("invoke successCallback");
+ LoggerD("invoke successCallback");
userData->invokeCallback("success", JSObjectMakeArray(userData->getContext(), num, devices, NULL));
}
else { // There is no found device
- LogDebug("There is no found device");
+ LoggerD("There is no found device");
userData->invokeCallback("success", JSObjectMakeArray(userData->getContext(), 0, NULL, NULL) );
}
}
else {
- LogError("Unknown exception");
+ LoggerE("Unknown exception");
userData->invokeCallback(
"error",
JSWebAPIError::makeJSWebAPIError(userData->getContext(), UnknownException("Unknown exception"))
);
}
} else { // Not enabled
- LogError("Bluetooth device is turned off");
+ LoggerE("Bluetooth device is turned off");
userData->invokeCallback(
"error",
JSWebAPIError::makeJSWebAPIError(userData->getContext(), ServiceNotAvailableException("Bluetooth device is turned off"))
void BluetoothAdapter::returnDevice(std::string &address, Common::MultiCallbackUserDataPtr userData)
{
- LogDebug("Entered");
+ LoggerD("Entered");
if(!isValidAddress(address)) {
- LogError("Wrong address");
+ LoggerE("Wrong address");
userData->invokeCallback("error", JSWebAPIError::makeJSWebAPIError(userData->getContext(), NotFoundException("Wrong address")));
return;
}
BluetoothDeviceSharedPtr device(new BluetoothDevice(deviceInfo));
bt_adapter_free_device_info(deviceInfo);
- LogDebug("invoke successCallback");
+ LoggerD("invoke successCallback");
userData->invokeCallback("success", JSBluetoothDevice::createJSObject(userData->getContext(), device));
return;
}
for(iter = mFoundDevices.begin(); iter != mFoundDevices.end(); ++iter) {
BluetoothDeviceSharedPtr foundDevice = *iter;
if(!strcmp(foundDevice->getAddress().c_str(), address.c_str())) {
- LogDebug("Found in mFoundDevices");
+ LoggerD("Found in mFoundDevices");
userData->invokeCallback("success", JSBluetoothDevice::createJSObject(userData->getContext(), foundDevice));
break;
}
}
if(iter == mFoundDevices.end()) {
- LogError("Can't find this device");
+ LoggerE("Can't find this device");
userData->invokeCallback(
"error",
}
} else { // Not enabled
- LogError("Bluetooth device is turned off");
+ LoggerE("Bluetooth device is turned off");
userData->invokeCallback(
"error",
JSWebAPIError::makeJSWebAPIError(userData->getContext(), ServiceNotAvailableException("Bluetooth device is turned off"))
void BluetoothAdapter::returnRegisteredService(std::string &uuid, std::string &name, Common::MultiCallbackUserDataPtr userData)
{
- LogDebug("Entered");
+ LoggerD("Entered");
if(!isValidUUID(uuid)) {
- LogError("Wrong UUID");
+ LoggerE("Wrong UUID");
userData->invokeCallback("error", JSWebAPIError::makeJSWebAPIError(userData->getContext(), InvalidValuesException("Wrong UUID")));
return;
}
bool isRegistered;
if(bt_adapter_is_service_used(uuid.c_str(), &isRegistered) == BT_ERROR_NONE && isRegistered == true) {
- LogDebug("Already registered");
+ LoggerD("Already registered");
userData->invokeCallback("error", JSWebAPIError::makeJSWebAPIError(userData->getContext(), InvalidValuesException("Already registered")));
return;
}
switch(ret) {
case BT_ERROR_NONE:
{
- LogDebug("bt_socket_create_rfcomm() succeeded");
+ LoggerD("bt_socket_create_rfcomm() succeeded");
int ret = bt_socket_listen_and_accept_rfcomm(socket, 0);
switch(ret) {
case BT_ERROR_NONE:
{
- LogDebug("bt_socket_listen() succeeded");
+ LoggerD("bt_socket_listen() succeeded");
bt_socket_set_connection_state_changed_cb(onSocketConnected, this);
BluetoothServiceHandlerPtr serviceHandler = new BluetoothServiceHandler(uuid, name, socket);
}
case BT_ERROR_INVALID_PARAMETER:
{
- LogDebug("Invalid value");
+ LoggerD("Invalid value");
userData->invokeCallback("error", JSWebAPIError::makeJSWebAPIError(userData->getContext(), InvalidValuesException("Invalid value")));
break;
}
default:
{
- LogDebug("Unknown exception");
+ LoggerD("Unknown exception");
userData->invokeCallback("error", JSWebAPIError::makeJSWebAPIError(userData->getContext(), UnknownException("Unknown exception")));
}
}
}
case BT_ERROR_INVALID_PARAMETER:
{
- LogDebug("Invalid value");
+ LoggerD("Invalid value");
userData->invokeCallback("error", JSWebAPIError::makeJSWebAPIError(userData->getContext(), InvalidValuesException("Invalid value")));
break;
}
default:
{
- LogDebug("Unknown exception");
+ LoggerD("Unknown exception");
userData->invokeCallback("error", JSWebAPIError::makeJSWebAPIError(userData->getContext(), UnknownException("Unknown exception")));
}
}
} else { // Not enabled
- LogError("Bluetooth device is turned off");
+ LoggerE("Bluetooth device is turned off");
userData->invokeCallback(
"error",
JSWebAPIError::makeJSWebAPIError(userData->getContext(), ServiceNotAvailableException("Bluetooth device is turned off"))
projects / framework / web / wrt-plugins-tizen.git / blobdiff