src/standards/Tizen/Bluetooth/BluetoothAdapterListener.cpp

   1 /*
   2  * Copyright (c) 2011 Samsung Electronics Co., Ltd All Rights Reserved
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the License);
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  * http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an AS IS BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 #include <JavaScriptCore/JavaScript.h>
  18 #include <dpl/log/log.h>
  19 #include <dpl/shared_ptr.h>
  20 #include <CommonsJavaScript/PrivateObject.h>
  21 #include <CommonsJavaScript/JSCallbackManager.h>
  22 #include <CommonsJavaScript/Converter.h>
  23 #include <Commons/IEvent.h>
  24 #include <CommonsJavaScript/Utils.h>
  25 #include "BluetoothAdapterListener.h"
  26 #include "JSBluetoothDevice.h"
  27 #include <API/Bluetooth/BluetoothFactory.h>
  28 #include <CommonsJavaScript/JSUtils.h>
  29 #include "BluetoothMultiCallback.h"
  30 #include "JSBluetoothSocket.h"
  31 #include "JSBluetoothServiceHandler.h"
  32 #include "BluetoothConverter.h"
  33 #include <Tizen/Common/JSTizenExceptionFactory.h>
  34 #include <Tizen/Common/JSTizenException.h>
  35
  36 using namespace TizenApis::Commons;
  37
  38 namespace TizenApis {
  39 namespace Tizen1_0 {
  40
  41
  42 BluetoothAdapterListener::~BluetoothAdapterListener()
  43 {
  44         LogDebug("entered");
  45 }
  46
  47 BluetoothAdapterListener::BluetoothAdapterListener() :
  48         EventBTCreateDestroyBondingAnswerReceiver(ThreadEnum::NULL_THREAD),
  49         EventBTGetKnownDevicesAnswerReceiver(ThreadEnum::NULL_THREAD),
  50         EventBTGetDeviceAnswerReceiver(ThreadEnum::NULL_THREAD),
  51         EventBTSetPoweredAnswerReceiver(ThreadEnum::NULL_THREAD),
  52         EventBTSetVisibleAnswerReceiver(ThreadEnum::NULL_THREAD),
  53         EventBTOnDiscoveryDevicesListener(ThreadEnum::NULL_THREAD),
  54         EventBTRegisterRFCOMMAnswerReceiver(ThreadEnum::NULL_THREAD),
  55         EventBTUnregisterRFCOMMServiceAnswerReceiver(ThreadEnum::NULL_THREAD),
  56         EventBTStopDiscoveryAnswerReceiver(ThreadEnum::NULL_THREAD),
  57         EventBTSetNameAnswerReceiver(ThreadEnum::NULL_THREAD),
  58         EventBTServiceOnConnectListener(ThreadEnum::NULL_THREAD)
  59 {
  60         LogDebug("entered");
  61 }
  62
  63
  64 BluetoothAdapterListener& BluetoothAdapterListener::getInstance()
  65 {
  66         static BluetoothAdapterListener instance;
  67         return instance;
  68
  69 }
  70
  71 void BluetoothAdapterListener::MakeErrorJSCallBack(JSCallbackManagerPtr cbm, JSContextRef globalContext, unsigned short error)
  72 {
  73         LogDebug("Enter");
  74         JSValueRef err = 0;
  75
  76         switch (error)
  77         {
  78                 case ExceptionCodes::SecurityException:
  79                         err = JSTizenExceptionFactory::makeErrorObject(globalContext,
  80                                 JSTizenException::PERMISSION_DENIED_ERROR, "permission denied error");
  81
  82                         break;
  83                 case ExceptionCodes::UnsupportedException:
  84                         err = JSTizenExceptionFactory::makeErrorObject(globalContext,
  85                                 JSTizenException::NOT_SUPPORTED_ERROR, "unsupport error");
  86                         break;
  87                 case ExceptionCodes::UnknownException:
  88                 default:
  89                         err = JSTizenExceptionFactory::makeErrorObject(globalContext,
  90                                 JSTizenException::UNKNOWN_ERROR, "unknown error");
  91                         break;
  92         }
  93         cbm->callOnError(err);
  94 }
  95
  96 void BluetoothAdapterListener::OnAnswerReceived(const EventBTCreateDestroyBondingPtr& event)
  97 {
  98         LogDebug("Enter - EventBTCreateDestroyBondingPtr");
  99         JSCallbackManagerPtr callbackManager = DPL::StaticPointerCast<JSCallbackManager > (event->getPrivateData());
 100         JSContextRef l_globalContext = callbackManager->getContext();
 101
 102         if (event->getExceptionCode() == ExceptionCodes::None)
 103         {
 104                 BluetoothDeviceData device = event->getDevice();
 105                 JSObjectRef deviceObject = JSBluetoothDevice::createJSObject(l_globalContext, device);
 106                 callbackManager->callOnSuccess(deviceObject);
 107         }
 108         else
 109         {
 110                 MakeErrorJSCallBack(callbackManager, l_globalContext, event->getExceptionCode());
 111         }
 112 }
 113
 114 void BluetoothAdapterListener::OnAnswerReceived(const EventBTGetKnownDevicesPtr& event)
 115 {
 116         LogDebug("Enter - EventBTGetKnownDevicesPtr");
 117         JSCallbackManagerPtr callbackManager = DPL::StaticPointerCast<JSCallbackManager > (event->getPrivateData());
 118         JSContextRef l_globalContext = callbackManager->getContext();
 119
 120         if (event->getExceptionCode() == ExceptionCodes::None)
 121         {
 122                 std::vector<BluetoothDeviceData> devices = event->getDevices();
 123                 BluetoothConverter converter(l_globalContext);
 124                 JSObjectRef result = converter.toBluetoothDevices(devices);
 125                 callbackManager->callOnSuccess(result);
 126         }
 127         else
 128         {
 129                 MakeErrorJSCallBack(callbackManager, l_globalContext, event->getExceptionCode());
 130         }
 131
 132
 133         }
 134
 135
 136 void BluetoothAdapterListener::OnAnswerReceived(const EventBTSetPoweredPtr& event)
 137 {
 138         LogDebug("Enter - EventBTSetPoweredPtr");
 139         JSCallbackManagerPtr callbackManager = DPL::StaticPointerCast<JSCallbackManager > (event->getPrivateData());
 140         JSContextRef l_globalContext = callbackManager->getContext();
 141
 142
 143         if (event->getExceptionCode() == ExceptionCodes::None)
 144         {
 145                 callbackManager->callOnSuccess();
 146         }
 147         else
 148         {
 149                 MakeErrorJSCallBack(callbackManager, l_globalContext, event->getExceptionCode());
 150         }
 151 }
 152
 153 void BluetoothAdapterListener::OnAnswerReceived(const EventBTGetDevicePtr& event)
 154 {
 155         LogDebug("Enter - EventBTGetDevicePtr");
 156         JSCallbackManagerPtr callbackManager = DPL::StaticPointerCast<JSCallbackManager > (event->getPrivateData());
 157         JSContextRef l_globalContext = callbackManager->getContext();
 158
 159         if (event->getExceptionCode() == ExceptionCodes::None)
 160         {
 161                 BluetoothDeviceData device = event->getDevice();
 162                 LogDebug("Enter" << device.name << " " << device.address << "major: " << device.btClass.major << "minor: " << device.btClass.minor);
 163                 JSObjectRef adapterObject = JSBluetoothDevice::createJSObject(callbackManager->getContext(), device);
 164                 callbackManager->callOnSuccess(adapterObject);
 165         }
 166         else
 167         {
 168                 MakeErrorJSCallBack(callbackManager, l_globalContext, event->getExceptionCode());
 169         }
 170
 171 }
 172
 173
 174 void BluetoothAdapterListener::OnAnswerReceived(const EventBTSetVisiblePtr& event)
 175 {
 176         LogDebug("Enter - EventBTSetVisiblePtr");
 177         JSCallbackManagerPtr callbackManager = DPL::StaticPointerCast<JSCallbackManager > (event->getPrivateData());
 178         JSContextRef l_globalContext = callbackManager->getContext();
 179
 180         if (event->getExceptionCode() == ExceptionCodes::None)
 181         {
 182                 callbackManager->callOnSuccess();
 183         }
 184         else
 185         {
 186                 MakeErrorJSCallBack(callbackManager, l_globalContext, event->getExceptionCode());
 187         }
 188 }
 189
 190 void BluetoothAdapterListener::OnAnswerReceived(const EventBTUnregisterRFCOMMServicePtr& event)
 191 {
 192         LogDebug("Enter - EventBTUnregisterRFCOMMServicePtr");
 193         JSCallbackManagerPtr callbackManager = DPL::StaticPointerCast<JSCallbackManager > (event->getPrivateData());
 194         JSContextRef l_globalContext = callbackManager->getContext();
 195
 196         if (event->getExceptionCode() == ExceptionCodes::None)
 197         {
 198                 callbackManager->callOnSuccess();
 199         }
 200         else
 201         {
 202                 MakeErrorJSCallBack(callbackManager, l_globalContext, event->getExceptionCode());
 203         }
 204 }
 205
 206
 207 void BluetoothAdapterListener::onAnswerReceived(const EventBTOnDiscoveryDevicesPtr& event)
 208 {
 209         LogDebug("Enter");
 210
 211         EventBTOnDiscoveryDevicesPrivateDataPtr multiCallbacks =
 212                 DPL::DynamicPointerCast<EventBTOnDiscoveryDevicesPrivateData>(event->getPrivateData());
 213         JSCallbackManagerPtr defaultCbm = multiCallbacks->getOnSuccess();
 214         std::vector<BluetoothDeviceData> devices;
 215
 216         assert(multiCallbacks != NULL);
 217         assert(defaultCbm != NULL);
 218         assert(multiCallbacks->getOnFound() != NULL);
 219         assert(multiCallbacks->getOnFinished() != NULL);
 220
 221         if (event->getExceptionCode() == ExceptionCodes::None)
 222         {
 223                 switch(event->getDiscoveryState())
 224                 {
 225                 case EventBTOnDiscoveryDevices::STARTED:
 226                         multiCallbacks->getOnSuccess()->callOnSuccess();
 227                         break;
 228                 case EventBTOnDiscoveryDevices::DISCOVERYING:
 229                 {
 230                         JSObjectRef adapterObject;
 231                         devices = event->getDevices();
 232                         defaultCbm = multiCallbacks->getOnFound();
 233                         adapterObject = JSBluetoothDevice::createJSObject(defaultCbm->getContext(), devices[0]);
 234                         defaultCbm->callOnSuccess(adapterObject);
 235                 }
 236                         break;
 237
 238                 case EventBTOnDiscoveryDevices::FINISHED:
 239                 {
 240                         devices = event->getDevices();
 241                         defaultCbm = multiCallbacks->getOnFinished();
 242
 243                         BluetoothConverter converter(defaultCbm->getContext());
 244                         JSObjectRef result = converter.toBluetoothDevices(devices);
 245                         defaultCbm->callOnSuccess(result);
 246                 }
 247                         break;
 248                 default:
 249                         MakeErrorJSCallBack(defaultCbm, defaultCbm->getContext(), event->getExceptionCode());
 250                         break;
 251
 252                 }
 253         }
 254         else
 255         {
 256                 MakeErrorJSCallBack(defaultCbm, defaultCbm->getContext(), event->getExceptionCode());
 257         }
 258 }
 259
 260 void BluetoothAdapterListener::OnAnswerReceived(const EventBTRegisterRFCOMMPtr& event)
 261 {
 262
 263         LogDebug("Enter - EventBTRegisterRFCOMMPtr");
 264
 265         JSCallbackManagerPtr callbackManager = DPL::StaticPointerCast<JSCallbackManager > (event->getPrivateData());
 266         JSContextRef l_globalContext = callbackManager->getContext();
 267
 268         if (event->getExceptionCode() == ExceptionCodes::None)
 269         {
 270                 JSObjectRef adapterObject;
 271                 int socketFd = event->getSocketFd();
 272                 std::string uuid = event->getUuid();
 273                 std::string name = event->getName();
 274                 adapterObject = JSBluetoothServiceHandler::createJSObject(l_globalContext, name, uuid, socketFd);
 275                 callbackManager->callOnSuccess(adapterObject);
 276         }
 277         else
 278         {
 279                 MakeErrorJSCallBack(callbackManager, l_globalContext, event->getExceptionCode());
 280         }
 281
 282
 283 }
 284
 285 void BluetoothAdapterListener::OnAnswerReceived(const EventBTStopDiscoveryPtr& event)
 286 {
 287         LogDebug("Enter - EventBTStopDiscoveryPtr");
 288         JSCallbackManagerPtr callbackManager = DPL::StaticPointerCast<JSCallbackManager > (event->getPrivateData());
 289         JSContextRef l_globalContext = callbackManager->getContext();
 290
 291         if (event->getExceptionCode() == ExceptionCodes::None)
 292         {
 293                 callbackManager->callOnSuccess();
 294         }
 295         else
 296         {
 297                 MakeErrorJSCallBack(callbackManager, l_globalContext, event->getExceptionCode());
 298         }
 299 }
 300
 301 void BluetoothAdapterListener::OnAnswerReceived(const EventBTSetNamePtr& event)
 302 {
 303         LogDebug("Enter - EventBTStopDiscoveryPtr");
 304         JSCallbackManagerPtr callbackManager = DPL::StaticPointerCast<JSCallbackManager > (event->getPrivateData());
 305         JSContextRef l_globalContext = callbackManager->getContext();
 306
 307         if (event->getExceptionCode() == ExceptionCodes::None)
 308         {
 309                 callbackManager->callOnSuccess();
 310         }
 311         else
 312         {
 313                 MakeErrorJSCallBack(callbackManager, l_globalContext, event->getExceptionCode());
 314         }
 315 }
 316
 317 void BluetoothAdapterListener::onAnswerReceived(const EventBTServiceOnConnectPtr& event)
 318 {
 319         LogDebug("Enter - EventBTServiceOnConnectPtr");
 320
 321         JSCallbackManagerPtr callbackManager = DPL::StaticPointerCast<JSCallbackManager > (event->getPrivateData());
 322         JSContextRef l_globalContext = callbackManager->getContext();
 323
 324         BluetoothSocketData socketData;
 325         JSObjectRef adapterObject;
 326
 327         if (event->getExceptionCode() == ExceptionCodes::None)
 328         {
 329                 socketData = event->getSocketData();
 330                 adapterObject = JSBluetoothSocket::createJSObject(l_globalContext, socketData);
 331                 callbackManager->callOnSuccess(adapterObject);
 332         }
 333         else
 334         {
 335                 MakeErrorJSCallBack(callbackManager, l_globalContext, event->getExceptionCode());
 336         }
 337
 338 }
 339
 340
 341
 342 }
 343 }