src/FNetBt_BluetoothAdapterUtility.cpp

   1 //
   2 // Open Service Platform
   3 // Copyright (c) 2012-2013 Samsung Electronics Co., Ltd.
   4 //
   5 // Licensed under the Apache License, Version 2.0 (the License);
   6 // you may not use this file except in compliance with the License.
   7 // You may obtain a copy of the License at
   8 //
   9 //     http://www.apache.org/licenses/LICENSE-2.0
  10 //
  11 // Unless required by applicable law or agreed to in writing, software
  12 // distributed under the License is distributed on an "AS IS" BASIS,
  13 // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  14 // See the License for the specific language governing permissions and
  15 // limitations under the License.
  16 //
  17 // @file        FNetBt_BluetoothAdapterUtility.cpp
  18 // @brief       This is the implementation file for the _BluetoothAdapterUtility class.
  19 //
  20
  21 #include <unique_ptr.h>
  22 #include <FBaseColAllElementsDeleter.h>
  23 #include <FBaseByteBuffer.h>
  24 #include <FBaseUuId.h>
  25 #include <FBaseInteger.h>
  26 #include <FBaseSysLog.h>
  27 #include <FBaseLong.h>
  28 #include <FBaseColHashMap.h>
  29 #include <FBaseUtilStringUtil.h>
  30 #include <FNetBtBluetoothDevice.h>
  31 #include <FNetBtBluetoothTypes.h>
  32 #include <FNetBtBluetoothDevice.h>
  33 #include <FBase_StringConverter.h>
  34 #include <FNetBt_BluetoothDeviceImpl.h>
  35 #include "FNetBt_BluetoothAdapterUtility.h"
  36
  37 using namespace std;
  38 using namespace Tizen::Base;
  39 using namespace Tizen::Base::Collection;
  40 using namespace Tizen::Base::Utility;
  41
  42
  43 namespace Tizen { namespace Net { namespace Bluetooth
  44 {
  45 class _BluetoothUuidMap;
  46
  47 static _BluetoothUuidMap* pMapSingleton = null;
  48
  49 /*
  50  * @class               _BluetoothUuidMap
  51  * @brief               The _BluetoothUuidMap class provides the method which converts UUID string to the long type value of
  52  *              BluetoothServiceType defined "FNetBtBluetoothTypes.h".
  53  */
  54 class _BluetoothUuidMap
  55         : public Tizen::Base::Object
  56 {
  57 public:
  58         _BluetoothUuidMap(void) {}
  59
  60         virtual ~_BluetoothUuidMap(void)
  61         {
  62                 //Clear all entries in the map
  63                 (void) __uuidMap.RemoveAll(true);
  64         }
  65
  66         static _BluetoothUuidMap* GetInstance(void)
  67         {
  68                 static _BluetoothUuidMap uuidMap;
  69
  70                 // TODO: this singleton pattern to use a local static instance is not thread-safe.
  71                 if (!pMapSingleton)
  72                 {
  73                         if (uuidMap.Initialise() == E_SUCCESS)
  74                         {
  75                                 pMapSingleton = &uuidMap;
  76                         }
  77                 }
  78
  79                 return pMapSingleton;
  80         }
  81
  82         long GetUuidLong(const Tizen::Base::String& uuidString) const
  83         {
  84                 UuId uuid;
  85                 UuId::Parse(uuidString, uuid);
  86                 const Long* pUuidLongValue = null;
  87
  88                 pUuidLongValue = dynamic_cast<const Long*> (__uuidMap.GetValue(uuid));
  89                 SysTryReturn(NID_NET_BT, pUuidLongValue != null, 0, E_SYSTEM,
  90                                 "Getting UUID(%ls) value from <UUID string, UUID enum type> map has failed.", uuidString.GetPointer());
  91
  92                 return pUuidLongValue->ToLong();
  93         }
  94
  95 private:
  96         _BluetoothUuidMap(const _BluetoothUuidMap& value);
  97         _BluetoothUuidMap& operator =(const _BluetoothUuidMap& value);
  98
  99         result Initialise(void)
 100         {
 101                 result r = E_SUCCESS;
 102
 103                 r = __uuidMap.Construct();
 104                 SysTryReturnResult(NID_NET_BT, r == E_SUCCESS, E_SYSTEM, "Construction of <UUID string, UUID enum type> map has failed.");
 105
 106                 __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_SPP)), *(new Long((long)(BT_SVC_SPP_SERVICE))));
 107                 __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_LAP)), *(new Long((long) BT_SVC_LAP_SERVICE)));
 108                 __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_DUN)), *(new Long((long) BT_SVC_DUN_SERVICE)));
 109                 __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_SYNC)), *(new Long((long) BT_SVC_SYNC_SERVICE)));
 110                 __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_OPP)), *(new Long((long) BT_SVC_OPP_SERVICE)));
 111                 __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_FTP)), *(new Long((long) BT_SVC_FTP_SERVICE)));
 112                 __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_SYNC_COMMAND)), *(new Long((long) BT_SVC_SYNC_SERVICE)));
 113                 __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_HSP)), *(new Long((long) BT_SVC_HSP_SERVICE)));
 114                 __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_CTP)), *(new Long((long) BT_SVC_CTP_SERVICE)));
 115                 __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_A2DP_SOURCE)), *(new Long((long) BT_SVC_A2DP_SERVICE)));
 116                 __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_A2DP_SINK)), *(new Long((long) BT_SVC_A2DP_SERVICE)));
 117                 __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_AVRCP_TARGET)), *(new Long((long) BT_SVC_AVRCP_SERVICE)));
 118                 __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_A2DP)), *(new Long((long) BT_SVC_A2DP_SERVICE)));
 119                 __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_AVRCP)), *(new Long((long) BT_SVC_AVRCP_SERVICE)));
 120                 __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_AVRCP_CONTROLLER)), *(new Long((long) BT_SVC_AVRCP_SERVICE)));
 121                 __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_ICP)), *(new Long((long) BT_SVC_ICP_SERVICE)));
 122                 __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_FAX)), *(new Long((long) BT_SVC_FAX_SERVICE)));
 123                 __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_HSP_AG)), *(new Long((long) BT_SVC_HSP_SERVICE)));
 124                 __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_PAN_PANU)), *(new Long((long) BT_SVC_PANU_SERVICE)));
 125                 __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_PAN_NAP)), *(new Long((long) BT_SVC_NAP_SERVICE)));
 126                 __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_PAN_GN)), *(new Long((long) BT_SVC_GN_SERVICE)));
 127                 __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_BPP_DIRECT_PRINTING)), *(new Long((long) BT_SVC_BPP_SERVICE)));
 128                 __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_BPP_REFERENCE_PRINTING)), *(new Long((long) BT_SVC_BPP_SERVICE)));
 129                 __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_BIP)), *(new Long((long) BT_SVC_BIP_SERVICE)));
 130                 __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_BIP_RESPONDER)), *(new Long((long) BT_SVC_BIP_SERVICE)));
 131                 __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_BIP_AUTOMATIC_ARCHIVE)), *(new Long((long) BT_SVC_BIP_SERVICE)));
 132                 __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_BIP_REFERENCED_OBJECTS)), *(new Long((long) BT_SVC_BIP_SERVICE)));
 133                 __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_HFP)), *(new Long((long) BT_SVC_HFP_HS_SERVICE)));
 134                 __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_HFP_AG)), *(new Long((long) BT_SVC_HFP_SERVICE)));
 135                 __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_BPP_DIRECT_PRINTING_RO)), *(new Long((long) BT_SVC_BPP_SERVICE)));
 136                 __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_BPP_REFLECTED_UI)), *(new Long((long) BT_SVC_BPP_SERVICE)));
 137                 __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_BPP_BASIC_PRINTING)), *(new Long((long) BT_SVC_BPP_SERVICE)));
 138                 __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_BPP_PRINTING_STATUS)), *(new Long((long) BT_SVC_BPP_SERVICE)));
 139                 __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_HID)), *(new Long((long) BT_SVC_HID_SERVICE)));
 140                 __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_HCRP)), *(new Long((long) BT_SVC_HCRP_SERVICE)));
 141                 __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_HCRP_PRINT)), *(new Long((long) BT_SVC_HCRP_SERVICE)));
 142                 __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_HCRP_SCAN)), *(new Long((long) BT_SVC_HCRP_SERVICE)));
 143                 __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_SAP)), *(new Long((long) BT_SVC_SAP_SERVICE)));
 144                 __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_PBAP_PCE)), *(new Long((long) BT_SVC_PBAP_SERVICE)));
 145                 __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_PBAP_PSE)), *(new Long((long) BT_SVC_PBAP_SERVICE)));
 146                 __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_PBAP)), *(new Long((long) BT_SVC_PBAP_SERVICE)));
 147                 __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_HSP_HS)), *(new Long((long) BT_SVC_HSP_HS_SERVICE)));
 148                 __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_MAP_ACCESS_SERVER)), *(new Long((long) BT_SVC_MAP_SERVICE)));
 149                 __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_MAP_NOTIFICATION_SERVER)), *(new Long((long) BT_SVC_MAP_SERVICE)));
 150                 __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_MAP_ACCESS_PROFILE)), *(new Long((long) BT_SVC_MAP_SERVICE)));
 151                 __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_DID_PNP_INFORMATION)), *(new Long((long) BT_SVC_DID_SERVICE)));
 152                 __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_GENERIC_NETWORKING)), *(new Long((long) BT_SVC_NONE)));
 153                 __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_GENERIC_FILE_TRANSFER)), *(new Long((long) BT_SVC_NONE)));
 154                 __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_GENERIC_AUDIO)), *(new Long((long) BT_SVC_NONE)));
 155                 __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_GENERIC_TELEPHONY)), *(new Long((long) BT_SVC_NONE)));
 156                 __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_VDP_SOURCE)), *(new Long((long) BT_SVC_VDP_SERVICE)));
 157                 __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_VDP_SINK)), *(new Long((long) BT_SVC_VDP_SERVICE)));
 158                 __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_VDP_DISTRIBUTION)), *(new Long((long) BT_SVC_VDP_SERVICE)));
 159                 __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_HDP)), *(new Long((long) BT_SVC_HDP_SERVICE)));
 160                 __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_HDP_SOURCE)), *(new Long((long) BT_SVC_HDP_SERVICE)));
 161                 __uuidMap.Add(*(new Tizen::Base::UuId(BT_SVC_UUID_HDP_SINK)), *(new Long((long) BT_SVC_HDP_SERVICE)));
 162
 163                 return E_SUCCESS;
 164         }
 165
 166 private:
 167         Tizen::Base::Collection::HashMap __uuidMap;
 168
 169 };      //_BluetoothUuidMap
 170
 171 // defines local methods
 172 void PrintMajorDeviceClass(BluetoothMajorDeviceClassType type);
 173 void PrintMinorDeviceClass(BluetoothMajorDeviceClassType majType, BluetoothMinorDeviceClassType minType);
 174 void PrintServiceClassList(unsigned long type);
 175
 176
 177 _BluetoothAdapterUtility::_BluetoothAdapterUtility(void)
 178 {
 179 }
 180
 181 _BluetoothAdapterUtility::~_BluetoothAdapterUtility(void)
 182 {
 183 }
 184
 185
 186 BluetoothMajorDeviceClassType
 187 _BluetoothAdapterUtility::ConvertToMajorDeviceClassType(bt_major_device_class_e majorClass)
 188 {
 189         BluetoothMajorDeviceClassType convertedType = BT_COD_MAJ_DEV_CLS_UNCLASSIFIED;
 190
 191         switch (majorClass)
 192         {
 193         case BT_MAJOR_DEVICE_CLASS_MISC:
 194                 convertedType = BT_COD_MAJ_DEV_CLS_MISC;
 195                 break;
 196
 197         case BT_MAJOR_DEVICE_CLASS_COMPUTER:
 198                 convertedType = BT_COD_MAJ_DEV_CLS_COMPUTER;
 199                 break;
 200
 201         case BT_MAJOR_DEVICE_CLASS_PHONE:
 202                 convertedType = BT_COD_MAJ_DEV_CLS_PHONE;
 203                 break;
 204
 205         case BT_MAJOR_DEVICE_CLASS_LAN_NETWORK_ACCESS_POINT:
 206                 convertedType = BT_COD_MAJ_DEV_CLS_LAN_ACCESS_POINT;
 207                 break;
 208
 209         case BT_MAJOR_DEVICE_CLASS_AUDIO_VIDEO:
 210                 convertedType = BT_COD_MAJ_DEV_CLS_AUDIO;
 211                 break;
 212
 213         case BT_MAJOR_DEVICE_CLASS_PERIPHERAL:
 214                 convertedType = BT_COD_MAJ_DEV_CLS_PERIPHERAL;
 215                 break;
 216
 217         case BT_MAJOR_DEVICE_CLASS_IMAGING:
 218                 convertedType = BT_COD_MAJ_DEV_CLS_IMAGING;
 219                 break;
 220
 221         case BT_MAJOR_DEVICE_CLASS_WEARABLE:
 222         case BT_MAJOR_DEVICE_CLASS_TOY:
 223         case BT_MAJOR_DEVICE_CLASS_HEALTH:
 224         case BT_MAJOR_DEVICE_CLASS_UNCATEGORIZED:
 225         default:
 226                 convertedType = BT_COD_MAJ_DEV_CLS_UNCLASSIFIED;
 227                 break;
 228         }
 229
 230         return convertedType;
 231 }
 232
 233 BluetoothMinorDeviceClassType
 234 _BluetoothAdapterUtility::ConvertToMinorDeviceClassType(bt_major_device_class_e majorClass, bt_minor_device_class_e minorClass)
 235 {
 236         BluetoothMinorDeviceClassType convertedType = BT_COD_MIN_DEV_CLS_UNCLASSIFIED;
 237
 238         if (majorClass == BT_MAJOR_DEVICE_CLASS_COMPUTER)
 239         {
 240                 switch (minorClass)
 241                 {
 242                 case BT_MINOR_DEVICE_CLASS_COMPUTER_DESKTOP_WORKSTATION:
 243                         convertedType = BT_COD_MIN_DEV_CLS_DESKTOP_WORKSTATION;
 244                         break;
 245
 246                 case BT_MINOR_DEVICE_CLASS_COMPUTER_SERVER_CLASS:
 247                         convertedType = BT_COD_MIN_DEV_CLS_SERVER_CLASS_COMPUTER;
 248                         break;
 249
 250                 case BT_MINOR_DEVICE_CLASS_COMPUTER_LAPTOP:
 251                         convertedType = BT_COD_MIN_DEV_CLS_LAPTOP;
 252                         break;
 253
 254                 case BT_MINOR_DEVICE_CLASS_COMPUTER_HANDHELD_PC_OR_PDA:
 255                         convertedType = BT_COD_MIN_DEV_CLS_HANDHELD_PC_OR_PDA;
 256                         break;
 257
 258                 case BT_MINOR_DEVICE_CLASS_COMPUTER_PALM_SIZED_PC_OR_PDA:
 259                         convertedType = BT_COD_MIN_DEV_CLS_PALM_SIZED_PC_OR_PDA;
 260                         break;
 261
 262                 case BT_MINOR_DEVICE_CLASS_COMPUTER_WEARABLE_COMPUTER:
 263                         convertedType = BT_COD_MIN_DEV_CLS_WEARABLE_COMPUTER;
 264                         break;
 265
 266                 default:
 267                         convertedType = BT_COD_MIN_DEV_CLS_UNCLASSIFIED;
 268                         break;
 269                 }
 270         }
 271         else if (majorClass == BT_MAJOR_DEVICE_CLASS_PHONE)
 272         {
 273                 switch (minorClass)
 274                 {
 275                 case BT_MINOR_DEVICE_CLASS_PHONE_CELLULAR:
 276                         convertedType = BT_COD_MIN_DEV_CLS_CELLULAR;
 277                         break;
 278
 279                 case BT_MINOR_DEVICE_CLASS_PHONE_CORDLESS:
 280                         convertedType = BT_COD_MIN_DEV_CLS_CORDLESS;
 281                         break;
 282
 283                 case BT_MINOR_DEVICE_CLASS_PHONE_SMART_PHONE:
 284                         convertedType = BT_COD_MIN_DEV_CLS_SMART_PHONE;
 285                         break;
 286
 287                 case BT_MINOR_DEVICE_CLASS_PHONE_WIRED_MODEM_OR_VOICE_GATEWAY:
 288                         convertedType = BT_COD_MIN_DEV_CLS_WIRED_MODEM_OR_VOICE_GATEWAY;
 289                         break;
 290
 291                 case BT_MINOR_DEVICE_CLASS_PHONE_COMMON_ISDN_ACCESS:
 292                         convertedType = BT_COD_MIN_DEV_CLS_COMMON_ISDN_ACCESS;
 293                         break;
 294
 295                 default:
 296                         convertedType = BT_COD_MIN_DEV_CLS_UNCLASSIFIED;
 297                         break;
 298                 }
 299         }
 300         else if (majorClass == BT_MAJOR_DEVICE_CLASS_LAN_NETWORK_ACCESS_POINT)
 301         {
 302                 switch (minorClass)
 303                 {
 304                 case BT_MINOR_DEVICE_CLASS_LAN_NETWORK_ACCESS_POINT_FULLY_AVAILABLE:
 305                         convertedType = BT_COD_MIN_DEV_CLS_FULLY_AVAILABLE;
 306                         break;
 307
 308                 case BT_MINOR_DEVICE_CLASS_LAN_NETWORK_ACCESS_POINT_1_TO_17_PERCENT_UTILIZED:
 309                         convertedType = BT_COD_MIN_DEV_CLS_1_TO_17_PERCENT_UTILIZED;
 310                         break;
 311
 312                 case BT_MINOR_DEVICE_CLASS_LAN_NETWORK_ACCESS_POINT_17_TO_33_PERCENT_UTILIZED:
 313                         convertedType = BT_COD_MIN_DEV_CLS_17_TO_33_PERCENT_UTILIZED;
 314                         break;
 315
 316                 case BT_MINOR_DEVICE_CLASS_LAN_NETWORK_ACCESS_POINT_33_TO_50_PERCENT_UTILIZED :
 317                         convertedType = BT_COD_MIN_DEV_CLS_33_TO_50_PERCENT_UTILIZED;
 318                         break;
 319
 320                 case BT_MINOR_DEVICE_CLASS_LAN_NETWORK_ACCESS_POINT_50_to_67_PERCENT_UTILIZED:
 321                         convertedType = BT_COD_MIN_DEV_CLS_50_to_67_PERCENT_UTILIZED;
 322                         break;
 323
 324                 case BT_MINOR_DEVICE_CLASS_LAN_NETWORK_ACCESS_POINT_67_TO_83_PERCENT_UTILIZED:
 325                         convertedType = BT_COD_MIN_DEV_CLS_67_TO_83_PERCENT_UTILIZED;
 326                         break;
 327
 328                 case BT_MINOR_DEVICE_CLASS_LAN_NETWORK_ACCESS_POINT_83_TO_99_PERCENT_UTILIZED:
 329                         convertedType = BT_COD_MIN_DEV_CLS_83_TO_99_PERCENT_UTILIZED;
 330                         break;
 331
 332                 case BT_MINOR_DEVICE_CLASS_LAN_NETWORK_ACCESS_POINT_NO_SERVICE_AVAILABLE :
 333                         convertedType = BT_COD_MIN_DEV_CLS_NO_SERVICE_AVAILABLE;
 334                         break;
 335
 336                 default:
 337                         convertedType = BT_COD_MIN_DEV_CLS_UNCLASSIFIED;
 338                         break;
 339                 }
 340         }
 341         else if (majorClass == BT_MAJOR_DEVICE_CLASS_AUDIO_VIDEO)
 342         {
 343                 switch (minorClass)
 344                 {
 345                 case BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_WEARABLE_HEADSET:
 346                         convertedType = BT_COD_MIN_DEV_CLS_HEADSET_PROFILE;
 347                         break;
 348
 349                 case BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_HANDS_FREE :
 350                         convertedType = BT_COD_MIN_DEV_CLS_HANDSFREE;
 351                         break;
 352
 353                 case BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_MICROPHONE:
 354                 case BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_LOUDSPEAKER:
 355                 case BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_HEADPHONES:
 356                 case BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_PORTABLE_AUDIO:
 357                 case BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_CAR_AUDIO:
 358                 case BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_SET_TOP_BOX:
 359                 case BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_HIFI_AUDIO_DEVICE:
 360                 case BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_VCR:
 361                 case BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_VIDEO_CAMERA:
 362                 case BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_CAMCORDER :
 363                 case BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_VIDEO_MONITOR:
 364                 case BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_VIDEO_DISPLAY_LOUDSPEAKER:
 365                 case BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_VIDEO_CONFERENCING:
 366                 case BT_MINOR_DEVICE_CLASS_AUDIO_VIDEO_GAMING_TOY:
 367                 default:
 368                         convertedType = BT_COD_MIN_DEV_CLS_UNCLASSIFIED;
 369                         break;
 370                 }
 371         }
 372         else if (majorClass == BT_MAJOR_DEVICE_CLASS_PERIPHERAL)
 373         {
 374                 switch (minorClass)
 375                 {
 376                 case BT_MINOR_DEVICE_CLASS_PERIPHERAL_KEY_BOARD:
 377                 case BT_MINOR_DEVICE_CLASS_PERIPHERAL_POINTING_DEVICE:
 378                 case BT_MINOR_DEVICE_CLASS_PERIPHERAL_COMBO_KEYBOARD_POINTING_DEVICE :
 379                 case BT_MINOR_DEVICE_CLASS_PERIPHERAL_JOYSTICK:
 380                 case BT_MINOR_DEVICE_CLASS_PERIPHERAL_GAME_PAD:
 381                 case BT_MINOR_DEVICE_CLASS_PERIPHERAL_REMOTE_CONTROL:
 382                 case BT_MINOR_DEVICE_CLASS_PERIPHERAL_SENSING_DEVICE:
 383                 case BT_MINOR_DEVICE_CLASS_PERIPHERAL_DIGITIZER_TABLET:
 384                 case BT_MINOR_DEVICE_CLASS_PERIPHERAL_CARD_READER:
 385                         convertedType = BT_COD_MIN_DEV_CLS_SIM_CARD_READER;
 386                         break;
 387
 388                 case BT_MINOR_DEVICE_CLASS_PERIPHERAL_DIGITAL_PEN:
 389                 case BT_MINOR_DEVICE_CLASS_PERIPHERAL_HANDHELD_SCANNER:
 390                 case BT_MINOR_DEVICE_CLASS_PERIPHERAL_HANDHELD_GESTURAL_INPUT_DEVICE :
 391                 default:
 392                         convertedType = BT_COD_MIN_DEV_CLS_UNCLASSIFIED;
 393                         break;
 394                 }
 395         }
 396         else if (majorClass == BT_MAJOR_DEVICE_CLASS_IMAGING)
 397         {
 398                 switch (minorClass)
 399                 {
 400                 case BT_MINOR_DEVICE_CLASS_IMAGING_DISPLAY:
 401                 case BT_MINOR_DEVICE_CLASS_IMAGING_CAMERA:
 402                 case BT_MINOR_DEVICE_CLASS_IMAGING_SCANNER:
 403                 case BT_MINOR_DEVICE_CLASS_IMAGING_PRINTER:
 404                 default:
 405                         convertedType = BT_COD_MIN_DEV_CLS_UNCLASSIFIED;
 406                         break;
 407                 }
 408         }
 409         else if (majorClass == BT_MAJOR_DEVICE_CLASS_WEARABLE)
 410         {
 411                 switch (minorClass)
 412                 {
 413                 case BT_MINOR_DEVICE_CLASS_WEARABLE_WRIST_WATCH:
 414                 case BT_MINOR_DEVICE_CLASS_WEARABLE_PAGER:
 415                 case BT_MINOR_DEVICE_CLASS_WEARABLE_JACKET:
 416                 case BT_MINOR_DEVICE_CLASS_WEARABLE_HELMET:
 417                 case BT_MINOR_DEVICE_CLASS_WEARABLE_GLASSES:
 418                 default:
 419                         convertedType = BT_COD_MIN_DEV_CLS_UNCLASSIFIED;
 420                         break;
 421                 }
 422         }
 423         else if (majorClass == BT_MAJOR_DEVICE_CLASS_TOY)
 424         {
 425                 switch (minorClass)
 426                 {
 427                 case BT_MINOR_DEVICE_CLASS_TOY_ROBOT:
 428                 case BT_MINOR_DEVICE_CLASS_TOY_VEHICLE:
 429                 case BT_MINOR_DEVICE_CLASS_TOY_DOLL_ACTION:
 430                 case BT_MINOR_DEVICE_CLASS_TOY_CONTROLLER:
 431                 case BT_MINOR_DEVICE_CLASS_TOY_GAME:
 432                 default:
 433                         convertedType = BT_COD_MIN_DEV_CLS_UNCLASSIFIED;
 434                         break;
 435                 }
 436         }
 437         else if (majorClass == BT_MAJOR_DEVICE_CLASS_HEALTH)
 438         {
 439                 switch (minorClass)
 440                 {
 441                 case BT_MINOR_DEVICE_CLASS_HEATH_BLOOD_PRESSURE_MONITOR:
 442                 case BT_MINOR_DEVICE_CLASS_HEATH_THERMOMETER :
 443                 case BT_MINOR_DEVICE_CLASS_HEATH_WEIGHING_SCALE:
 444                 case BT_MINOR_DEVICE_CLASS_HEATH_GLUCOSE_METER:
 445                 case BT_MINOR_DEVICE_CLASS_HEATH_PULSE_OXIMETER:
 446                 case BT_MINOR_DEVICE_CLASS_HEATH_HEART_PULSE_RATE_MONITOR:
 447                 case BT_MINOR_DEVICE_CLASS_HEATH_DATA_DISPLAY:
 448                 case BT_MINOR_DEVICE_CLASS_HEATH_STEP_COUNTER:
 449                 case BT_MINOR_DEVICE_CLASS_HEATH_BODY_COMPOSITION_ANALYZER:
 450                 case BT_MINOR_DEVICE_CLASS_HEATH_PEAK_FLOW_MONITOR:
 451                 case BT_MINOR_DEVICE_CLASS_HEATH_MEDICATION_MONITOR :
 452                 case BT_MINOR_DEVICE_CLASS_HEATH_KNEE_PROSTHESIS:
 453                 case BT_MINOR_DEVICE_CLASS_HEATH_ANKLE_PROSTHESIS:
 454                 default:
 455                         convertedType = BT_COD_MIN_DEV_CLS_UNCLASSIFIED;
 456                         break;
 457                 }
 458         }
 459         else
 460         {
 461                 convertedType = BT_COD_MIN_DEV_CLS_UNCLASSIFIED;
 462         }
 463
 464         return convertedType;
 465 }
 466
 467 unsigned long
 468 _BluetoothAdapterUtility::ConvertToServiceClassList(int serviceClass)
 469 {
 470         unsigned long serviceClassMask = 0;
 471
 472         bt_major_service_class_e origianlClassList[] =
 473         {
 474                 BT_MAJOR_SERVICE_CLASS_INFORMATION,
 475                 BT_MAJOR_SERVICE_CLASS_TELEPHONY,
 476                 BT_MAJOR_SERVICE_CLASS_AUDIO,
 477                 BT_MAJOR_SERVICE_CLASS_OBJECT_TRANSFER,
 478                 BT_MAJOR_SERVICE_CLASS_CAPTURING,
 479                 BT_MAJOR_SERVICE_CLASS_RENDERING,
 480                 BT_MAJOR_SERVICE_CLASS_NETWORKING,
 481                 BT_MAJOR_SERVICE_CLASS_POSITIONING,
 482                 BT_MAJOR_SERVICE_CLASS_LIMITED_DISCOVERABLE_MODE
 483         };
 484
 485         BluetoothServiceClassType convertedClassList[] =
 486         {
 487                 BT_COD_SVC_INFORMATION,
 488                 BT_COD_SVC_TELEPHONY,
 489                 BT_COD_SVC_AUDIO,
 490                 BT_COD_SVC_OBJECT_TRANSFER,
 491                 BT_COD_SVC_CAPTURING,
 492                 BT_COD_SVC_RENDERING,
 493                 BT_COD_SVC_NETWORKING,
 494                 BT_COD_SVC_POSITIONING,
 495                 BT_COD_SVC_LIMITED_DISCOVERABLE_MODE
 496         };
 497
 498         for (int i = 0; i < 9; i++)
 499         {
 500                 // checks the input value, 'serviceClass', has each value of the class list using bit masking
 501                 if (origianlClassList[i] == (serviceClass & origianlClassList[i]))
 502                 {
 503                         serviceClassMask += convertedClassList[i];
 504                 }
 505         }
 506
 507         return serviceClassMask;
 508 }
 509
 510 unsigned long
 511 _BluetoothAdapterUtility::ConvertToServiceList(char** pServiceUuid, int& serviceUuidCount)
 512 {
 513         unsigned long serviceListMask = 0;
 514         _BluetoothUuidMap* pMap = null;
 515
 516         pMap = _BluetoothUuidMap::GetInstance();
 517         SysTryReturn(NID_NET_BT, pMap != null, 0, E_SYSTEM, "Converting UUID strings to a masked BluetoothServiceType value faild.");
 518
 519         for (int i = 0; i < serviceUuidCount; i++)
 520         {
 521                 String uuidString(pServiceUuid[i]);
 522                 long uuidLongValue = pMap->GetUuidLong(uuidString);
 523
 524                 serviceListMask |= uuidLongValue;
 525         }
 526
 527         return serviceListMask;
 528 }
 529
 530 Tizen::Base::Collection::IList*
 531 _BluetoothAdapterUtility::ConvertServiceUuidListN(char** pServiceUuid, int& serviceUuidCount)
 532 {
 533         unique_ptr<ArrayList, AllElementsDeleter> pList;
 534         UuId* pUuid = null;
 535
 536         pList.reset(new (std::nothrow) ArrayList());
 537         SysTryReturn(NID_NET_BT, pList != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient.");
 538
 539         for (int i = 0; i < serviceUuidCount; i++)
 540         {
 541                 String uuidString(pServiceUuid[i]);
 542                 pUuid = new (std::nothrow) UuId();
 543                 SysTryReturn(NID_NET_BT, pUuid != null, null, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient.");
 544                 uuidString.ToUpperCase();
 545                 UuId::Parse(uuidString, *pUuid);
 546
 547                 pList->Add(*pUuid);
 548         }
 549
 550         return pList.release();
 551 }
 552
 553 void
 554 _BluetoothAdapterUtility::PrintDeviceInfo(const BluetoothDevice& device)
 555 {
 556         SysLog(NID_NET_BT, "Bluetooth Device Information =============");
 557         SysLog(NID_NET_BT, "+ Address: [%ls]", _BluetoothDeviceImpl::GetAddressString(*(device.GetAddress())).GetPointer());
 558         SysLog(NID_NET_BT, "+ Name: %ls", device.GetName().GetPointer());
 559         SysLog(NID_NET_BT, "+ %s", device.IsPaired() ? "Paired" : "Not Paired");
 560         SysLog(NID_NET_BT, "+ RSSI: %d", device.GetRssi());
 561         PrintMajorDeviceClass(device.GetMajorDeviceClassType());
 562         PrintMinorDeviceClass(device.GetMajorDeviceClassType(), device.GetMinorDeviceClassType());
 563         PrintServiceClassList(device.GetServiceClassList());
 564         PrintServiceList(device.GetServiceList());
 565         PrintServiceUuidList(device.GetServiceUuidList());
 566 }
 567
 568 void
 569 _BluetoothAdapterUtility::PrintServiceList(unsigned long type)
 570 {
 571         int index = 0;
 572         unsigned long typeList[] =
 573         {
 574                 BT_SVC_MAP_SERVICE,
 575                 BT_SVC_HDP_SERVICE,
 576                 BT_SVC_DID_SERVICE,
 577                 BT_SVC_HCRP_SERVICE,
 578                 BT_SVC_HFP_HS_SERVICE,
 579                 BT_SVC_HSP_HS_SERVICE,
 580                 BT_SVC_PBAP_SERVICE,
 581                 BT_SVC_VDP_SERVICE,
 582                 BT_SVC_HID_SERVICE,
 583                 BT_SVC_AVRCP_SERVICE,
 584                 BT_SVC_A2DP_SERVICE,
 585                 BT_SVC_SAP_SERVICE,
 586                 BT_SVC_GN_SERVICE,
 587                 BT_SVC_NAP_SERVICE,
 588                 BT_SVC_PANU_SERVICE,
 589                 BT_SVC_BIP_SERVICE,
 590                 BT_SVC_BPP_SERVICE,
 591                 BT_SVC_SYNC_SERVICE,
 592                 BT_SVC_ICP_SERVICE,
 593                 BT_SVC_CTP_SERVICE,
 594                 BT_SVC_FTP_SERVICE,
 595                 BT_SVC_OPP_SERVICE,
 596                 BT_SVC_HFP_SERVICE,
 597                 BT_SVC_HSP_SERVICE,
 598                 BT_SVC_LAP_SERVICE,
 599                 BT_SVC_FAX_SERVICE,
 600                 BT_SVC_DUN_SERVICE,
 601                 BT_SVC_SPP_SERVICE,
 602                 BT_SVC_RES_SERVICE
 603         };
 604         const char* typeStrList[] =
 605         {
 606                 "BT_SVC_MAP_SERVICE",
 607                 "BT_SVC_HDP_SERVICE",
 608                 "BT_SVC_DID_SERVICE",
 609                 "BT_SVC_HCRP_SERVICE",
 610                 "BT_SVC_HFP_HS_SERVICE",
 611                 "BT_SVC_HSP_HS_SERVICE",
 612                 "BT_SVC_PBAP_SERVICE",
 613                 "BT_SVC_VDP_SERVICE",
 614                 "BT_SVC_HID_SERVICE",
 615                 "BT_SVC_AVRCP_SERVICE",
 616                 "BT_SVC_A2DP_SERVICE",
 617                 "BT_SVC_SAP_SERVICE",
 618                 "BT_SVC_GN_SERVICE",
 619                 "BT_SVC_NAP_SERVICE",
 620                 "BT_SVC_PANU_SERVICE",
 621                 "BT_SVC_BIP_SERVICE",
 622                 "BT_SVC_BPP_SERVICE",
 623                 "BT_SVC_SYNC_SERVICE",
 624                 "BT_SVC_ICP_SERVICE",
 625                 "BT_SVC_CTP_SERVICE",
 626                 "BT_SVC_FTP_SERVICE",
 627                 "BT_SVC_OPP_SERVICE",
 628                 "BT_SVC_HFP_SERVICE",
 629                 "BT_SVC_HSP_SERVICE",
 630                 "BT_SVC_LAP_SERVICE",
 631                 "BT_SVC_FAX_SERVICE",
 632                 "BT_SVC_DUN_SERVICE",
 633                 "BT_SVC_SPP_SERVICE",
 634                 "BT_SVC_RES_SERVICE"
 635         };
 636
 637         for (int i = 0; i < 29; i++)
 638         {
 639                 // checks the input value, 'type', has each value of the service list using bit masking
 640                 if (typeList[i] == (type & typeList[i]))
 641                 {
 642                         SysLog(NID_NET_BT, "+ Service List[%d]: %s", index++, typeStrList[i]);
 643                 }
 644         }
 645 }
 646
 647 void
 648 _BluetoothAdapterUtility::PrintServiceUuidList(const Tizen::Base::Collection::IList* pList)
 649 {
 650         int count = 0;
 651         const UuId* pUuid = null;
 652
 653         if (pList == null)
 654         {
 655                 SysLog(NID_NET_BT, "+ No Service UUID (with error)");
 656         }
 657         else
 658         {
 659                 count = pList->GetCount();
 660
 661                 if (count == 0)
 662                 {
 663                         SysLog(NID_NET_BT, "+ No Service UUID");
 664                 }
 665
 666                 for (int i = 0; i < count; i++)
 667                 {
 668                         pUuid = dynamic_cast<const UuId*>(pList->GetAt(i));
 669                         if (pUuid != null)
 670                         {
 671                                 SysLog(NID_NET_BT, "+ Service UUID[%d]: %ls", i, pUuid->ToString().GetPointer());
 672                         }
 673                 }
 674         }
 675 }
 676
 677 void PrintMajorDeviceClass(BluetoothMajorDeviceClassType type)
 678 {
 679         const char* pTypeString = null;
 680
 681         switch (type)
 682         {
 683         case BT_COD_MAJ_DEV_CLS_MISC:
 684                 pTypeString = "BT_COD_MAJ_DEV_CLS_MISC";
 685                 break;
 686
 687         case BT_COD_MAJ_DEV_CLS_COMPUTER:
 688                 pTypeString = "BT_COD_MAJ_DEV_CLS_COMPUTER";
 689                 break;
 690
 691         case BT_COD_MAJ_DEV_CLS_PHONE:
 692                 pTypeString = "BT_COD_MAJ_DEV_CLS_PHONE";
 693                 break;
 694
 695         case BT_COD_MAJ_DEV_CLS_LAN_ACCESS_POINT:
 696                 pTypeString = "BT_COD_MAJ_DEV_CLS_LAN_ACCESS_POINT";
 697                 break;
 698
 699         case BT_COD_MAJ_DEV_CLS_AUDIO:
 700                 pTypeString = "BT_COD_MAJ_DEV_CLS_AUDIO";
 701                 break;
 702
 703         case BT_COD_MAJ_DEV_CLS_PERIPHERAL:
 704                 pTypeString = "BT_COD_MAJ_DEV_CLS_PERIPHERAL";
 705                 break;
 706
 707         case BT_COD_MAJ_DEV_CLS_IMAGING:
 708                 pTypeString = "BT_COD_MAJ_DEV_CLS_IMAGING";
 709                 break;
 710
 711         case BT_COD_MAJ_DEV_CLS_UNCLASSIFIED:
 712                 pTypeString = "BT_COD_MAJ_DEV_CLS_UNCLASSIFIED";
 713                 break;
 714
 715         default:
 716                 pTypeString = "Unknown";
 717                 break;
 718         }
 719
 720         SysLog(NID_NET_BT, "+ Major Device Type: %s", pTypeString);
 721 }
 722
 723 void PrintMinorDeviceClass(BluetoothMajorDeviceClassType majType, BluetoothMinorDeviceClassType minType)
 724 {
 725         const char* pTypeString = null;
 726
 727         switch (majType)
 728         {
 729         case BT_COD_MAJ_DEV_CLS_COMPUTER:
 730                 switch (minType)
 731                 {
 732                 case BT_COD_MIN_DEV_CLS_DESKTOP_WORKSTATION:
 733                         pTypeString = "BT_COD_MIN_DEV_CLS_DESKTOP_WORKSTATION";
 734                         break;
 735
 736                 case BT_COD_MIN_DEV_CLS_SERVER_CLASS_COMPUTER:
 737                         pTypeString = "BT_COD_MIN_DEV_CLS_SERVER_CLASS_COMPUTER";
 738                         break;
 739
 740                 case BT_COD_MIN_DEV_CLS_LAPTOP:
 741                         pTypeString = "BT_COD_MIN_DEV_CLS_LAPTOP";
 742                         break;
 743
 744                 case BT_COD_MIN_DEV_CLS_HANDHELD_PC_OR_PDA:
 745                         pTypeString = "BT_COD_MIN_DEV_CLS_HANDHELD_PC_OR_PDA";
 746                         break;
 747
 748                 case BT_COD_MIN_DEV_CLS_PALM_SIZED_PC_OR_PDA:
 749                         pTypeString = "BT_COD_MIN_DEV_CLS_PALM_SIZED_PC_OR_PDA";
 750                         break;
 751
 752                 case BT_COD_MIN_DEV_CLS_WEARABLE_COMPUTER:
 753                         pTypeString = "BT_COD_MIN_DEV_CLS_WEARABLE_COMPUTER";
 754                         break;
 755
 756                 default:
 757                         pTypeString = "Unclassified";
 758                         break;
 759                 }
 760                 break;
 761
 762         case BT_COD_MAJ_DEV_CLS_PHONE:
 763                 switch (minType)
 764                 {
 765                 case BT_COD_MIN_DEV_CLS_CELLULAR:
 766                         pTypeString = "BT_COD_MIN_DEV_CLS_CELLULAR";
 767                         break;
 768
 769                 case BT_COD_MIN_DEV_CLS_CORDLESS:
 770                         pTypeString = "BT_COD_MIN_DEV_CLS_CORDLESS";
 771                         break;
 772
 773                 case BT_COD_MIN_DEV_CLS_SMART_PHONE:
 774                         pTypeString = "BT_COD_MIN_DEV_CLS_SMART_PHONE";
 775                         break;
 776
 777                 case BT_COD_MIN_DEV_CLS_WIRED_MODEM_OR_VOICE_GATEWAY:
 778                         pTypeString = "BT_COD_MIN_DEV_CLS_WIRED_MODEM_OR_VOICE_GATEWAY";
 779                         break;
 780
 781                 case BT_COD_MIN_DEV_CLS_COMMON_ISDN_ACCESS:
 782                         pTypeString = "BT_COD_MIN_DEV_CLS_COMMON_ISDN_ACCESS";
 783                         break;
 784
 785                 default:
 786                         pTypeString = "Unclassified";
 787                         break;
 788                 }
 789                 break;
 790
 791         case BT_COD_MAJ_DEV_CLS_LAN_ACCESS_POINT:
 792                 switch (minType)
 793                 {
 794                 case BT_COD_MIN_DEV_CLS_FULLY_AVAILABLE:
 795                         pTypeString = "BT_COD_MAJ_DEV_CLS_LAN_ACCESS_POINT";
 796                         break;
 797
 798                 case BT_COD_MIN_DEV_CLS_1_TO_17_PERCENT_UTILIZED:
 799                         pTypeString = "BT_COD_MIN_DEV_CLS_1_TO_17_PERCENT_UTILIZED";
 800                         break;
 801
 802                 case BT_COD_MIN_DEV_CLS_17_TO_33_PERCENT_UTILIZED:
 803                         pTypeString = "BT_COD_MIN_DEV_CLS_17_TO_33_PERCENT_UTILIZED";
 804                         break;
 805
 806                 case BT_COD_MIN_DEV_CLS_33_TO_50_PERCENT_UTILIZED:
 807                         pTypeString = "BT_COD_MIN_DEV_CLS_33_TO_50_PERCENT_UTILIZED";
 808                         break;
 809
 810                 case BT_COD_MIN_DEV_CLS_50_to_67_PERCENT_UTILIZED:
 811                         pTypeString = "BT_COD_MIN_DEV_CLS_50_to_67_PERCENT_UTILIZED";
 812                         break;
 813
 814                 case BT_COD_MIN_DEV_CLS_67_TO_83_PERCENT_UTILIZED:
 815                         pTypeString = "BT_COD_MIN_DEV_CLS_67_TO_83_PERCENT_UTILIZED";
 816                         break;
 817
 818                 case BT_COD_MIN_DEV_CLS_83_TO_99_PERCENT_UTILIZED:
 819                         pTypeString = "BT_COD_MIN_DEV_CLS_83_TO_99_PERCENT_UTILIZED";
 820                         break;
 821
 822                 case BT_COD_MIN_DEV_CLS_NO_SERVICE_AVAILABLE:
 823                         pTypeString = "BT_COD_MIN_DEV_CLS_NO_SERVICE_AVAILABLE";
 824                         break;
 825
 826                 default:
 827                         pTypeString = "Unclassified";
 828                         break;
 829                 }
 830                 break;
 831
 832         case BT_COD_MAJ_DEV_CLS_AUDIO:
 833                 switch (minType)
 834                 {
 835                 case BT_COD_MIN_DEV_CLS_HEADSET_PROFILE:
 836                         pTypeString = "BT_COD_MIN_DEV_CLS_HEADSET_PROFILE";
 837                         break;
 838
 839                 case BT_COD_MIN_DEV_CLS_HANDSFREE:
 840                         pTypeString = "BT_COD_MIN_DEV_CLS_HANDSFREE";
 841                         break;
 842
 843                 default:
 844                         pTypeString = "Unclassified";
 845                         break;
 846                 }
 847                 break;
 848
 849         case BT_COD_MAJ_DEV_CLS_PERIPHERAL:
 850                 switch (minType)
 851                 {
 852                 case BT_COD_MIN_DEV_CLS_SIM_CARD_READER:
 853                         pTypeString = "BT_COD_MIN_DEV_CLS_SIM_CARD_READER";
 854                         break;
 855
 856                 default:
 857                         pTypeString = "Unclassified";
 858                         break;
 859                 }
 860                 break;
 861
 862         case BT_COD_MAJ_DEV_CLS_IMAGING:
 863         case BT_COD_MAJ_DEV_CLS_MISC:
 864         case BT_COD_MAJ_DEV_CLS_UNCLASSIFIED:
 865         default:
 866                 pTypeString = "Unclassified";
 867                 break;
 868         }
 869
 870         SysLog(NID_NET_BT, "+ Minor Device Type: %s", pTypeString);
 871 }
 872
 873 void PrintServiceClassList(unsigned long type)
 874 {
 875         int index = 0;
 876         unsigned long typeList[] =
 877         {
 878                 BT_COD_SVC_INFORMATION,
 879                 BT_COD_SVC_TELEPHONY,
 880                 BT_COD_SVC_AUDIO,
 881                 BT_COD_SVC_OBJECT_TRANSFER,
 882                 BT_COD_SVC_CAPTURING,
 883                 BT_COD_SVC_RENDERING,
 884                 BT_COD_SVC_NETWORKING,
 885                 BT_COD_SVC_POSITIONING,
 886                 BT_COD_SVC_LIMITED_DISCOVERABLE_MODE
 887         };
 888         const char* typeStrList[] =
 889         {
 890                 "BT_COD_SVC_INFORMATION",
 891                 "BT_COD_SVC_TELEPHONY",
 892                 "BT_COD_SVC_AUDIO",
 893                 "BT_COD_SVC_OBJECT_TRANSFER",
 894                 "BT_COD_SVC_CAPTURING",
 895                 "BT_COD_SVC_RENDERING",
 896                 "BT_COD_SVC_NETWORKING",
 897                 "BT_COD_SVC_POSITIONING",
 898                 "BT_COD_SVC_LIMITED_DISCOVERABLE_MODE"
 899         };
 900
 901         for (int i = 0; i < 9; i++)
 902         {
 903                 if (typeList[i] == (type & typeList[i]))
 904                 {
 905                         // checks the input value, 'type', has each value of the service class list using bit masking
 906                         SysLog(NID_NET_BT, "+ Service Class List[%d]: %s", index++, typeStrList[i]);
 907                 }
 908         }
 909 }
 910
 911 } } } // Tizen::Net::Bluetooth