RDK Documentation (Open Sourced RDK Components)
btrCore_dbus_bluez5.c
1 /*
2  * If not stated otherwise in this file or this component's Licenses.txt file the
3  * following copyright and licenses apply:
4  *
5  * Copyright 2016 RDK Management
6  *
7  * Licensed under the Apache License, Version 2.0 (the "License");
8  * you may not use this file except in compliance with the License.
9  * You may obtain a copy of the License at
10  *
11  * http://www.apache.org/licenses/LICENSE-2.0
12  *
13  * Unless required by applicable law or agreed to in writing, software
14  * distributed under the License is distributed on an "AS IS" BASIS,
15  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
16  * See the License for the specific language governing permissions and
17  * limitations under the License.
18 */
19 /*
20  * btrCore_dbus_bluez5.c
21  * Implementation of DBus layer abstraction for BT functionality (BlueZ 5.37)
22  */
23 
24 /* System Headers */
25 #include <stdio.h>
26 #include <stdlib.h>
27 #include <string.h>
28 #include <stdint.h>
29 #include <unistd.h>
30 #include <stdbool.h>
31 #include <limits.h>
32 
33 /* External Library Headers */
34 #include <dbus/dbus.h>
35 
36 /* Interface lib Headers */
37 #include "btrCore_logger.h"
38 
39 /* Local Headers */
40 #include "btrCore_bt_ifce.h"
41 
42 #ifdef LIBSYSWRAPPER_BUILD
43 #include "secure_wrapper.h"
44 #endif
45 
46 #define DBUS_INTERFACE_OBJECT_MANAGER "org.freedesktop.DBus.ObjectManager"
47 
48 #define BT_DBUS_BLUEZ_PATH "org.bluez"
49 
50 #define BT_DBUS_BLUEZ_ADAPTER_PATH "org.bluez.Adapter1"
51 
52 #define BT_DBUS_BLUEZ_DEVICE_PATH "org.bluez.Device1"
53 
54 #define BT_DBUS_BLUEZ_AGENT_PATH "org.bluez.Agent1"
55 #define BT_DBUS_BLUEZ_AGENT_MGR_PATH "org.bluez.AgentManager1"
56 
57 #define BT_DBUS_BLUEZ_MEDIA_PATH "org.bluez.Media1"
58 #define BT_DBUS_BLUEZ_MEDIA_ENDPOINT_PATH "org.bluez.MediaEndpoint1"
59 #define BT_DBUS_BLUEZ_MEDIA_TRANSPORT_PATH "org.bluez.MediaTransport1"
60 #define BT_DBUS_BLUEZ_MEDIA_CTRL_PATH "org.bluez.MediaControl1"
61 #define BT_DBUS_BLUEZ_MEDIA_PLAYER_PATH "org.bluez.MediaPlayer1"
62 #define BT_DBUS_BLUEZ_MEDIA_ITEM_PATH "org.bluez.MediaItem1"
63 #define BT_DBUS_BLUEZ_MEDIA_FOLDER_PATH "org.bluez.MediaFolder1"
64 
65 #define BT_DBUS_BLUEZ_GATT_SERVICE_PATH "org.bluez.GattService1"
66 #define BT_DBUS_BLUEZ_GATT_CHAR_PATH "org.bluez.GattCharacteristic1"
67 #define BT_DBUS_BLUEZ_GATT_DESCRIPTOR_PATH "org.bluez.GattDescriptor1"
68 #define BT_DBUS_BLUEZ_GATT_MGR_PATH "org.bluez.GattManager1"
69 
70 #define BT_DBUS_BLUEZ_LE_ADV_PATH "org.bluez.LEAdvertisement1"
71 #define BT_DBUS_BLUEZ_LE_ADV_MGR_PATH "org.bluez.LEAdvertisingManager1"
72 
73 #define BT_MEDIA_SBC_A2DP_SINK_ENDPOINT "/MediaEndpoint/SBC/A2DP/Sink"
74 #define BT_MEDIA_SBC_A2DP_SOURCE_ENDPOINT "/MediaEndpoint/SBC/A2DP/Source"
75 #define BT_MEDIA_MP3_A2DP_SINK_ENDPOINT "/MediaEndpoint/Mp3/A2DP/Sink"
76 #define BT_MEDIA_MP3_A2DP_SOURCE_ENDPOINT "/MediaEndpoint/Mp3/A2DP/Source"
77 #define BT_MEDIA_AAC_A2DP_SINK_ENDPOINT "/MediaEndpoint/AAC/A2DP/Sink"
78 #define BT_MEDIA_AAC_A2DP_SOURCE_ENDPOINT "/MediaEndpoint/AAC/A2DP/Source"
79 #define BT_MEDIA_PCM_HFP_AG_ENDPOINT "/MediaEndpoint/PCM/HFP/AudioGateway"
80 #define BT_MEDIA_SBC_HFP_AG_ENDPOINT "/MediaEndpoint/SBC/HFP/AudioGateway"
81 #define BT_MEDIA_PCM_HFP_HS_ENDPOINT "/MediaEndpoint/PCM/HFP/Headset"
82 
83 #define BT_LE_GATT_SERVER_ENDPOINT "/org/bluez/hci0/dev_XX_XX_XX_XX_XX_XX"
84 #define BT_LE_GATT_SERVER_ADVERTISEMENT "/LeGattAdvert"
85 
86 #define BT_BLUEZ_VERSION_5_45 "5.45"
87 #define BT_BLUEZ_VERSION_5_48 "5.48"
88 #define BT_BLUEZ_VERSION_5_54 "5.54"
89 
90 
91 typedef struct _stBTMediaInfo {
92  unsigned char ui8Codec;
93  char pcState[BT_MAX_STR_LEN];
94  char pcUUID[BT_MAX_STR_LEN];
95  unsigned short ui16Delay;
96  unsigned short ui16Volume;
97 } stBTMediaInfo;
98 
99 
100 typedef struct _stBtIfceHdl {
101 
102  DBusConnection* pDBusConn;
103 
104  char* pcBTAgentPath;
105  char* pcBTDAdapterPath;
106  char* pcBTDAdapterAddr;
107  char* pcBTAdapterPath;
108  char* pcDevTransportPath;
109 
110  char* pcBTOutPassCode;
111 
112  void* pcBAdapterStatusUserData;
113  void* pcBDevStatusUserData;
114  void* pcBMediaStatusUserData;
115  void* pcBNegMediaUserData;
116  void* pcBTransPathMediaUserData;
117  void* pcBMediaPlayerPathUserData;
118  void* pcBMediaBrowserPathUserData;
119  void* pcBConnIntimUserData;
120  void* pcBConnAuthUserData;
121  void* pcBLePathUserData;
122  void* pcBLeAdvUserData;
123 
124  int i32DoReject;
125 
126  unsigned int ui32cBConnAuthPassKey;
127  unsigned int ui32DevLost;
128 
129  unsigned int ui32IsAdapterDiscovering;
130 
131  char pcBTVersion[BT_MAX_STR_LEN];
132  char pcDeviceCurrState[BT_MAX_STR_LEN];
133  char pcLeDeviceCurrState[BT_MAX_STR_LEN];
134  char pcLeDeviceAddress[BT_MAX_STR_LEN];
135  char pcMediaCurrState[BT_MAX_STR_LEN];
136 
137  stBTAdapterInfo lstBTAdapterInfo;
138  stBTDeviceInfo lstBTDeviceInfo;
139  stBTMediaInfo lstBTMediaInfo;
140 
141  stBTLeGattInfo stBTLeGatt;
142  stBTLeCustomAdv stBTLeCustAdvt;
143  char pcBTAdapterGattSrvEpPath[BT_MAX_DEV_PATH_LEN];
144 
145  fPtr_BtrCore_BTAdapterStatusUpdateCb fpcBAdapterStatusUpdate;
146  fPtr_BtrCore_BTDevStatusUpdateCb fpcBDevStatusUpdate;
147  fPtr_BtrCore_BTMediaStatusUpdateCb fpcBMediaStatusUpdate;
148  fPtr_BtrCore_BTNegotiateMediaCb fpcBNegotiateMedia;
149  fPtr_BtrCore_BTTransportPathMediaCb fpcBTransportPathMedia;
150  fPtr_BtrCore_BTMediaPlayerPathCb fpcBTMediaPlayerPath;
151  fPtr_BtrCore_BTMediaBrowserPathCb fpcBTMediaBrowserPath;
152  fPtr_BtrCore_BTConnIntimCb fpcBConnectionIntimation;
153  fPtr_BtrCore_BTConnAuthCb fpcBConnectionAuthentication;
154  fPtr_BtrCore_BTLeGattPathCb fpcBTLeGattPath;
155  fPtr_BtrCore_BTLeAdvertisementCb fpcBTLeAdvPath;
156 
157 } stBtIfceHdl;
158 
159 
160 /* Static Function Prototypes */
161 static int btrCore_BTHandleDusError (DBusError* aDBusErr, int aErrline, const char* aErrfunc);
162 static const char* btrCore_DBusType2Name (int ai32DBusMessageType);
163 static enBTDeviceType btrCore_BTMapServiceClasstoDevType(unsigned int aui32Class);
164 static enBTDeviceType btrCore_BTMapDevClasstoDevType(unsigned int aui32Class);
165 static char* btrCore_BTGetDefaultAdapterPath (stBtIfceHdl* apstlhBtIfce);
166 static int btrCore_BTReleaseDefaultAdapterPath (stBtIfceHdl* apstlhBtIfce);
167 static int btrCore_BTGetDevAddressFromDevPath (const char* deviceIfcePath, char* devAddr);
168 static tBTMediaItemId btrCore_BTGetMediaItemIdFromMediaPath (const char* mediaIfcePath);
169 static enBTMediaFolderType btrCore_BTGetMediaFolderType (const char* apcFolderType);
170 static const char* btrCore_BTGetMediaItemAbsoluteName (const char* apcMediaItemName);
171 
172 static DBusHandlerResult btrCore_BTAgentRelease (DBusConnection* apDBusConn, DBusMessage* apDBusMsg, void* apvUserData);
173 static DBusHandlerResult btrCore_BTAgentRequestPincode (DBusConnection* apDBusConn, DBusMessage* apDBusMsg, void* apvUserData);
174 static DBusHandlerResult btrCore_BTAgentRequestPasskey (DBusConnection* apDBusConn, DBusMessage* apDBusMsg, void* apvUserData);
175 static DBusHandlerResult btrCore_BTAgentRequestConfirmation(DBusConnection* apDBusConn, DBusMessage* apDBusMsg, void* apvUserData);
176 static DBusHandlerResult btrCore_BTAgentAuthorize (DBusConnection* apDBusConn, DBusMessage* apDBusMsg, void* apvUserData);
177 static DBusHandlerResult btrCore_BTAgentDisplayPinCodePassKey (DBusConnection* apDBusConn, DBusMessage* apDBusMsg, bool abPinCode, void* apvUserData);
178 static DBusHandlerResult btrCore_BTAgentCancelMessage (DBusConnection* apDBusConn, DBusMessage* apDBusMsg, void* apvUserData);
179 
180 static DBusMessage* btrCore_BTSendMethodCall (DBusConnection* apDBusConn, const char* objectpath, const char* interfacename, const char* methodname);
181 static void btrCore_BTPendingCallCheckReply (DBusPendingCall* apDBusPendC, void* apvUserData);
182 
183 static int btrCore_BTParseAdapter (DBusMessageIter* apDBusMsgIter, stBTAdapterInfo* apstBTAdapterInfo);
184 static int btrCore_BTGetDeviceInfo (DBusConnection* apDBusConn, stBTDeviceInfo* apstBTDeviceInfo, const char* apcIface);
185 static int btrCore_BTParseDevice (DBusMessage* apDBusMsg, stBTDeviceInfo* apstBTDeviceInfo);
186 
187 #if 0
188 static int btrCore_BTParsePropertyChange (DBusMessage* apDBusMsg, stBTDeviceInfo* apstBTDeviceInfo);
189 static int btrCore_BTGetGattInfo (enBTOpIfceType aenBTOpIfceType, void* apvGattInfo, const char* apcIface);
190 #endif
191 
192 static int btrCore_BTGetMediaInfo (DBusConnection* apDBusConn, stBTMediaInfo* apstBTDeviceInfo, const char* apcIface);
193 static int btrCore_BTParseMediaTransport (DBusMessage* apDBusMsg, stBTMediaInfo* apstBTMediaInfo);
194 static int btrCore_BTParseMediaTrackMetadata (DBusMessage* apDBusMsg, stBTMediaTrackInfo* apstBTMediaTrackInfo);
195 
196 static DBusMessage* btrCore_BTMediaEndpointSelectConfiguration (DBusMessage* apDBusMsg, enBTDeviceType aenBTDeviceType, enBTMediaType aenBTMediaType, void* apvUserData);
197 static DBusMessage* btrCore_BTMediaEndpointSetConfiguration (DBusMessage* apDBusMsg, enBTDeviceType aenBTDeviceType, enBTMediaType aenBTMediaType, void* apvUserData);
198 static DBusMessage* btrCore_BTMediaEndpointClearConfiguration (DBusMessage* apDBusMsg, enBTDeviceType aenBTDeviceType, enBTMediaType aenBTMediaType, void* apvUserData);
199 
200 static int btrCore_BTGetMediaIfceProperty (DBusConnection* apDBusConn, const char* apBtObjectPath, const char* apBtInterfacePath, const char* mediaProperty, void* mediaPropertyValue);
201 
202 static DBusMessage* btrCore_BTRegisterGattService (DBusConnection* apDBusConn, DBusMessage* apDBusMsg, stBtIfceHdl* apstlhBtIfce, stBTLeGattService *lpstBTRCoreLeGattService, int aNumOfGattServices);
203 static int btrCore_BTUnRegisterGattService (DBusConnection* apDBusConn, const char* apui8SCDGattPath);
204 static int btrCore_BTRegisterLeAdvGetProp (DBusConnection* apDBusConn, DBusMessage* apDBusMsg, stBtIfceHdl* apstlhBtIfce);
205 static DBusMessage* btrCore_BTLEGattOps (DBusMessage* apDBusMsg, stBtIfceHdl* apstlhBtIfce, enBTOpIfceType aenIfceType, enBTLeGattOp aenGattOp);
206 static int btrCore_BTReleaseLEGattObjPath(char* apstObjPath, void* apvUserData);
207 /* Incoming Callbacks Prototypes */
208 static DBusHandlerResult btrCore_BTDBusConnectionFilterCb (DBusConnection* apDBusConn, DBusMessage* apDBusMsg, void* apvUserData);
209 static DBusHandlerResult btrCore_BTMediaEndpointHandlerCb (DBusConnection* apDBusConn, DBusMessage* apDBusMsg, void* apvUserData);
210 static DBusHandlerResult btrCore_BTAgentMessageHandlerCb (DBusConnection* apDBusConn, DBusMessage* apDBusMsg, void* apvUserData);
211 static DBusHandlerResult btrCore_BTLeGattEndpointHandlerCb(DBusConnection* apDBusConn, DBusMessage* apDBusMsg, void* apvUserData);
212 static DBusHandlerResult btrCore_BTLeGattMessageHandlerCb (DBusConnection* apDBusConn, DBusMessage* apDBusMsg, void* apvUserData);
213 
214 
215 static const DBusObjectPathVTable gDBusMediaEndpointVTable = {
216  .message_function = btrCore_BTMediaEndpointHandlerCb,
217 };
218 
219 static const DBusObjectPathVTable gDBusAgentVTable = {
220  .message_function = btrCore_BTAgentMessageHandlerCb,
221 };
222 
223 static const DBusObjectPathVTable gDBusLeGattEndpointVTable = {
224  .message_function = btrCore_BTLeGattEndpointHandlerCb,
225 };
226 
227 static const DBusObjectPathVTable gDBusLeGattSCDVTable = {
228  .message_function = btrCore_BTLeGattMessageHandlerCb,
229 };
230 
231 
232 /* Static Function Defs */
233 static inline int
234 btrCore_BTHandleDusError (
235  DBusError* apDBusErr,
236  int aErrline,
237  const char* apErrfunc
238 ) {
239  if (dbus_error_is_set(apDBusErr)) {
240  BTRCORELOG_ERROR ("%d\t: %s - DBus Error is %s - Name: %s \n", aErrline, apErrfunc, apDBusErr->message, apDBusErr->name);
241  dbus_error_free(apDBusErr);
242  return 1;
243  }
244  return 0;
245 }
246 
247 
248 static const char*
249 btrCore_DBusType2Name (
250  int ai32MessageType
251 ) {
252  switch (ai32MessageType) {
253  case DBUS_MESSAGE_TYPE_SIGNAL:
254  return "Signal ";
255  case DBUS_MESSAGE_TYPE_METHOD_CALL:
256  return "MethodCall";
257  case DBUS_MESSAGE_TYPE_METHOD_RETURN:
258  return "MethodReturn";
259  case DBUS_MESSAGE_TYPE_ERROR:
260  return "Error";
261  default:
262  return "Unknown";
263  }
264 }
265 
266 static enBTDeviceType
267 btrCore_BTMapServiceClasstoDevType (
268  unsigned int aui32Class
269 ) {
270  enBTDeviceType lenBtDevType = enBTDevUnknown;
271 
272  /* Refer https://www.bluetooth.com/specifications/assigned-numbers/baseband
273  * The bit 18 set to represent AUDIO OUT service Devices.
274  * The bit 19 can be set to represent AUDIO IN Service devices
275  * The bit 21 set to represent AUDIO Services (Mic, Speaker, headset).
276  * The bit 22 set to represent Telephone Services (headset).
277  */
278 
279  if (0x40000u & aui32Class) {
280  BTRCORELOG_DEBUG ("Its a enBTDevAudioSink : Rendering Class of Service\n");
281  lenBtDevType = enBTDevAudioSink;
282  }
283  else if (0x80000u & aui32Class) {
284  if (enBTDCMicrophone & aui32Class) {
285  BTRCORELOG_DEBUG ("Its a enBTDevAudioSource : Capturing Service and Mic Device\n");
286  lenBtDevType = enBTDevAudioSource;
287  }
288  }
289  //Audio device but not a peripheral (mouse, joystick, keyboards etc )
290  else if ((0x200000u & aui32Class) && ((0x500u & aui32Class) != 0x500u )) {
291  if (enBTDCMicrophone & aui32Class) {
292  BTRCORELOG_DEBUG ("Its a enBTDevAudioSource : Audio Class of Service and Mic Device\n");
293  lenBtDevType = enBTDevAudioSource;
294  }
295  else {
296  BTRCORELOG_DEBUG ("Its a enBTDevAudioSink : Audio Class of Service. Not a Mic\n");
297  lenBtDevType = enBTDevAudioSink;
298  }
299  }
300  else if (0x400000u & aui32Class) {
301  BTRCORELOG_DEBUG ("Its a enBTDevAudioSink : Telephony Class of Service\n");
302  lenBtDevType = enBTDevAudioSink;
303  }
304 
305  return lenBtDevType;
306 }
307 
308 static enBTDeviceType
309 btrCore_BTMapDevClasstoDevType (
310  unsigned int aui32Class
311 ) {
312  enBTDeviceType lenBtDevType = enBTDevUnknown;
313 
314  if ((lenBtDevType = btrCore_BTMapServiceClasstoDevType(aui32Class)) != enBTDevUnknown)
315  return lenBtDevType;
316 
317 
318  if (((aui32Class & 0x100u) == 0x100u) ||
319  ((aui32Class & 0x200u) == 0x200u) ||
320  ((aui32Class & 0x400u) == 0x400u) ||
321  ((aui32Class & 0x500u) == 0x500u) ||
322  ((aui32Class & 0x540u) == 0x540u) ||
323  ((aui32Class & 0x580u) == 0x580u) ||
324  ((aui32Class & 0x5C0u) == 0x5C0u) ||
325  ((aui32Class & 0x504u) == 0x504u) ||
326  ((aui32Class & 0x508u) == 0x508u) ||
327  ((aui32Class & 0x50Cu) == 0x50Cu)) {
328 
329  unsigned int ui32DevClassID = aui32Class & 0xFFFu;
330 
331  switch (ui32DevClassID){
332  case enBTDCSmartPhone:
333  case enBTDCTablet:
334  case enBTDCMicrophone:
335  BTRCORELOG_DEBUG ("Its a enBTDevAudioSource\n");
336  lenBtDevType = enBTDevAudioSource;
337  break;
338  case enBTDCWearableHeadset:
339  case enBTDCHeadphones:
340  case enBTDCLoudspeaker:
341  case enBTDCHIFIAudioDevice:
342  BTRCORELOG_DEBUG ("Its a enBTDevAudioSink\n");
343  lenBtDevType = enBTDevAudioSink;
344  break;
345  case enBTDCKeyboard:
346  case enBTDCMouse:
347  case enBTDCMouseKeyBoard:
348  case enBTDCJoystick:
349  case enBTDCGamePad:
350  case enBTDCAudioRemote:
351  BTRCORELOG_DEBUG ("Its a enBTDevHID\n");
352  lenBtDevType = enBTDevHID;
353  break;
354  default:
355  BTRCORELOG_DEBUG ("Its a enBTDevUnknown\n");
356  lenBtDevType = enBTDevUnknown;
357  break;
358  }
359  }
360 
361  return lenBtDevType;
362 }
363 
364 static int
365 btrCore_BTGetDevAddressFromDevPath (
366  const char* deviceIfcePath,
367  char* devAddr
368 ) {
369  // DevIfcePath format /org/bluez/hci0/dev_DC_1A_C5_62_F5_EA
370  deviceIfcePath = strstr(deviceIfcePath, "dev") + 4;
371 
372  devAddr[0] = deviceIfcePath[0];
373  devAddr[1] = deviceIfcePath[1];
374  devAddr[2] = ':';
375  devAddr[3] = deviceIfcePath[3];
376  devAddr[4] = deviceIfcePath[4];
377  devAddr[5] = ':';
378  devAddr[6] = deviceIfcePath[6];
379  devAddr[7] = deviceIfcePath[7];
380  devAddr[8] = ':';
381  devAddr[9] = deviceIfcePath[9];
382  devAddr[10] = deviceIfcePath[10];
383  devAddr[11] = ':';
384  devAddr[12] = deviceIfcePath[12];
385  devAddr[13] = deviceIfcePath[13];
386  devAddr[14] = ':';
387  devAddr[15] = deviceIfcePath[15];
388  devAddr[16] = deviceIfcePath[16];
389 
390  devAddr[17] = '\0';
391 
392  return 0;
393 }
394 
395 static tBTMediaItemId
396 btrCore_BTGetMediaItemIdFromMediaPath (
397  const char* mediaIfcePath
398 ) {
399  tBTMediaItemId mediaItemId = 0;
400  char* ptr = 0;
401  unsigned int ui32Index = 0;
402  char iArray[BT_MAX_STR_LEN] = {'\0'};
403  /* To change the logic later to enable index based searching for better performance */
404  ptr = strstr(mediaIfcePath, "item");
405 
406  if (ptr != NULL) {
407 
408  while (ptr && *ptr) {
409  if (*ptr<=57 && *ptr>=48) {
410  iArray[ui32Index++] = *ptr;
411  }
412  ptr++;
413  }
414 
415  iArray[ui32Index] = '\0';
416 
417  /* In mediaIfcePath if big value comes,
418  * mediaItemId is limiting the range from the 1 to LLONG_MAX.
419  * mediaItemId MSB bit is used for differentiating the items from which path
420  * either NowPlaying or Filesystem.
421  */
422  ui32Index = 0;
423  do {
424  mediaItemId = strtoull (iArray + ui32Index++, NULL, 10);
425  } while ((mediaItemId > LLONG_MAX) || (mediaItemId == 0));
426  }
427 
428  if (strstr(mediaIfcePath, "NowPlaying")) {
429  mediaItemId |= 0x8000000000000000;
430  }
431  else if (!strstr(mediaIfcePath, "Filesystem")) {
432  mediaItemId = 0xFFFFFFFFFFFFFFFF;
433  }
434 
435  return mediaItemId;
436 }
437 
438 static const char*
439 btrCore_BTGetMediaItemAbsoluteName (
440  const char* apcMediaItemName
441 ) {
442  const char* ptr = 0;
443  /* /Filesystem/Album/XYZ_Album should return XYZ_Album */
444  /* /Filesystem should return Filesystem */
445  /* ABC_SongName should return ABC_SongName */
446 
447  if (!apcMediaItemName) {
448  return NULL;
449  }
450 
451  ptr = &apcMediaItemName[strlen(apcMediaItemName)];
452 
453  while (--ptr >= apcMediaItemName && *ptr != '/');
454 
455  return ptr +1;
456 }
457 
458 static enBTMediaFolderType
459 btrCore_BTGetMediaFolderType (
460  const char* apcFolderType
461 ) {
462  enBTMediaFolderType eMediaFolderType;
463 
464  if (!strncmp(apcFolderType, "albums", strlen("albums"))) {
465  eMediaFolderType = enBTMediaFldTypAlbum;
466  } else
467  if (!strncmp(apcFolderType, "artists", strlen("artists"))) {
468  eMediaFolderType = enBTMediaFldTypArtist;
469  } else
470  if (!strncmp(apcFolderType, "genres", strlen("genres"))) {
471  eMediaFolderType = enBTMediaFldTypGenre;
472  } else
473  if (!strncmp(apcFolderType, "compilation", strlen("compilation"))) {
474  eMediaFolderType = enBTMediaFldTypCompilation;
475  } else
476  if (!strncmp(apcFolderType, "playlists", strlen("playlists"))) {
477  eMediaFolderType = enBTMediaFldTypPlayList;
478  } else
479  if (!strncmp(apcFolderType, "titles", strlen("titles"))) {
480  eMediaFolderType = enBTMediaFldTypTrackList;
481  } else
482  if (!strncmp(apcFolderType, "mixed", strlen("mixed"))) {
483  eMediaFolderType = enBTMediaFldTypTrackList;
484  } else
485  if (!strncmp(apcFolderType, "track", strlen("track"))) {
486  eMediaFolderType = enBTMediaFldTypTrack;
487  }
488  else {
489  eMediaFolderType = enBTMediaFldTypTrackList;
490  }
491 
492  return eMediaFolderType;
493 }
494 
495 static char*
496 btrCore_BTGetDefaultAdapterPath (
497  stBtIfceHdl* apstlhBtIfce
498 ) {
499  DBusMessage* lpDBusReply = NULL;
500  DBusMessageIter rootIter;
501  int a = 0;
502  int b = 0;
503  bool adapterFound = FALSE;
504  char* adapter_path;
505  char objectPath[BT_MAX_DEV_PATH_LEN] = {'\0'};
506  char objectData[BT_MAX_DEV_PATH_LEN] = {'\0'};
507 
508 
509  lpDBusReply = btrCore_BTSendMethodCall(apstlhBtIfce->pDBusConn, "/", DBUS_INTERFACE_OBJECT_MANAGER, "GetManagedObjects");
510 
511  if (lpDBusReply &&
512  dbus_message_iter_init(lpDBusReply, &rootIter) && //point iterator to lpDBusReply message
513  DBUS_TYPE_ARRAY == dbus_message_iter_get_arg_type(&rootIter)) { //get the type of message that iter points to
514 
515  DBusMessageIter arrayElementIter;
516  dbus_message_iter_recurse(&rootIter, &arrayElementIter); //assign new iterator to first element of array
517 
518  while (!adapterFound) {
519 
520  if (DBUS_TYPE_DICT_ENTRY == dbus_message_iter_get_arg_type(&arrayElementIter)) {
521  DBusMessageIter dictEntryIter;
522 
523  dbus_message_iter_recurse(&arrayElementIter,&dictEntryIter ); //assign new iterator to first element of (get all dict entries of 1st level (all object paths)
524  if (DBUS_TYPE_OBJECT_PATH == dbus_message_iter_get_arg_type(&dictEntryIter)) {
525  dbus_message_iter_get_basic(&dictEntryIter, &adapter_path);
526  strncpy(objectPath, adapter_path, (strlen(adapter_path) < BT_MAX_DEV_PATH_LEN) ? strlen(adapter_path) : BT_MAX_DEV_PATH_LEN - 1);
527  ++a;
528  }
529 
530  dbus_message_iter_next(&dictEntryIter);
531  if (DBUS_TYPE_ARRAY == dbus_message_iter_get_arg_type(&dictEntryIter)) {
532  DBusMessageIter innerArrayIter;
533 
534  dbus_message_iter_recurse(&dictEntryIter, &innerArrayIter);
535 
536  while (dbus_message_iter_has_next(&innerArrayIter)) {
537 
538  if (DBUS_TYPE_DICT_ENTRY == dbus_message_iter_get_arg_type(&innerArrayIter)) {
539  DBusMessageIter innerDictEntryIter;
540  dbus_message_iter_recurse(&innerArrayIter,&innerDictEntryIter ); //assign new iterator to first element of
541 
542  if (DBUS_TYPE_STRING == dbus_message_iter_get_arg_type(&innerDictEntryIter)) {
543  char *dbusObject;
544  dbus_message_iter_get_basic(&innerDictEntryIter, &dbusObject);
545 
546  ////// getting default adapter path //////
547 
548  if (strcmp(dbusObject, BT_DBUS_BLUEZ_ADAPTER_PATH) == 0) {
549  apstlhBtIfce->pcBTDAdapterPath = strndup(adapter_path, (strlen(adapter_path) < BT_MAX_DEV_PATH_LEN) ? strlen(adapter_path) : BT_MAX_DEV_PATH_LEN - 1);
550  adapterFound = TRUE;
551  break;
552  }
553  }
554 
555  /////// NEW //////////
556  dbus_message_iter_next(&innerDictEntryIter);
557  if (DBUS_TYPE_ARRAY == dbus_message_iter_get_arg_type(&innerDictEntryIter)) {
558  DBusMessageIter innerArrayIter2;
559  dbus_message_iter_recurse(&innerDictEntryIter, &innerArrayIter2);
560 
561  while (dbus_message_iter_has_next(&innerArrayIter2)) {
562  if (DBUS_TYPE_DICT_ENTRY == dbus_message_iter_get_arg_type(&innerArrayIter2)) {
563  DBusMessageIter innerDictEntryIter2;
564 
565  dbus_message_iter_recurse(&innerArrayIter2,&innerDictEntryIter2); //assign new iterator to first element of
566  if (DBUS_TYPE_STRING == dbus_message_iter_get_arg_type(&innerDictEntryIter2)) {
567  char *dbusObject2;
568  dbus_message_iter_get_basic(&innerDictEntryIter2, &dbusObject2);
569  }
570 
571  ////////////// NEW 2 ////////////
572  dbus_message_iter_next(&innerDictEntryIter2);
573  DBusMessageIter innerDictEntryIter3;
574  char *dbusObject3;
575 
576  dbus_message_iter_recurse(&innerDictEntryIter2,&innerDictEntryIter3);
577  if (DBUS_TYPE_STRING == dbus_message_iter_get_arg_type(&innerDictEntryIter3)) {
578  dbus_message_iter_get_basic(&innerDictEntryIter3, &dbusObject3);
579  memset(objectData, '\0', BT_MAX_DEV_PATH_LEN);
580  strncpy(objectData, dbusObject3, (strlen(dbusObject3) < BT_MAX_DEV_PATH_LEN) ? strlen(dbusObject3) : BT_MAX_DEV_PATH_LEN - 1);
581  ++b;
582  }
583  else if (DBUS_TYPE_BOOLEAN == dbus_message_iter_get_arg_type(&innerDictEntryIter3)) {
584  bool *device_prop = FALSE;
585  dbus_message_iter_get_basic(&innerDictEntryIter3, &device_prop);
586  }
587 
588  }
589 
590  if (!dbus_message_iter_has_next(&innerArrayIter2)) {
591  break; //check to see if end of 3rd array
592  }
593  else {
594  dbus_message_iter_next(&innerArrayIter2);
595  }
596  }
597  }
598  }
599 
600  if (!dbus_message_iter_has_next(&innerArrayIter)) {
601  break; //check to see if end of 2nd array
602  }
603  else {
604  dbus_message_iter_next(&innerArrayIter);
605  }
606  }
607  }
608 
609  if (!dbus_message_iter_has_next(&arrayElementIter)) {
610  break; //check to see if end of 1st array
611  }
612  else {
613  dbus_message_iter_next(&arrayElementIter);
614  }
615  } //while loop end --used to traverse arra
616  }
617 
618  dbus_message_unref(lpDBusReply);
619  }
620 
621  if (apstlhBtIfce->pcBTDAdapterPath) {
622  BTRCORELOG_WARN ("Default Adapter Path is : %s - %p\n", apstlhBtIfce->pcBTDAdapterPath, apstlhBtIfce->pcBTDAdapterPath);
623 
624  }
625  return apstlhBtIfce->pcBTDAdapterPath;
626 }
627 
628 
629 static int
630 btrCore_BTReleaseDefaultAdapterPath (
631  stBtIfceHdl* apstlhBtIfce
632 ) {
633  if (apstlhBtIfce->pcBTDAdapterAddr) {
634  BTRCORELOG_WARN ("Adapter Addr is : %s - %p\n", apstlhBtIfce->pcBTDAdapterAddr, apstlhBtIfce->pcBTDAdapterAddr);
635  free(apstlhBtIfce->pcBTDAdapterAddr);
636  apstlhBtIfce->pcBTDAdapterAddr = NULL;
637  }
638 
639  if (apstlhBtIfce->pcBTDAdapterPath) {
640  BTRCORELOG_WARN ("Default Adapter Path is : %s - %p\n", apstlhBtIfce->pcBTDAdapterPath, apstlhBtIfce->pcBTDAdapterPath);
641  free(apstlhBtIfce->pcBTDAdapterPath);
642  apstlhBtIfce->pcBTDAdapterPath = NULL;
643  }
644 
645  return 0;
646 }
647 
648 
649 static DBusHandlerResult
650 btrCore_BTAgentRelease (
651  DBusConnection* apDBusConn,
652  DBusMessage* apDBusMsg,
653  void* apvUserData
654 ) {
655  DBusMessage* lpDBusReply = NULL;
656  stBtIfceHdl* pstlhBtIfce = (stBtIfceHdl*)apvUserData;
657 
658  (void)pstlhBtIfce;
659 
660 
661  if (!dbus_message_get_args(apDBusMsg, NULL, DBUS_TYPE_INVALID)) {
662  BTRCORELOG_ERROR ("Invalid arguments for Release method");
663  return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
664  }
665 
666  lpDBusReply = dbus_message_new_method_return(apDBusMsg);
667 
668  if (!lpDBusReply) {
669  BTRCORELOG_ERROR ("Unable to create lpDBusReply message\n");
670  return DBUS_HANDLER_RESULT_NEED_MEMORY;
671  }
672 
673  dbus_connection_send(apDBusConn, lpDBusReply, NULL);
674  dbus_connection_flush(apDBusConn);
675 
676  dbus_message_unref(lpDBusReply);
677  //return the result
678  return DBUS_HANDLER_RESULT_HANDLED;
679 }
680 
681 
682 static DBusHandlerResult
683 btrCore_BTAgentRequestPincode (
684  DBusConnection* apDBusConn,
685  DBusMessage* apDBusMsg,
686  void* apvUserData
687 ) {
688  DBusMessage* lpDBusReply = NULL;
689  const char* lpcPath = NULL;
690  stBtIfceHdl* pstlhBtIfce = (stBtIfceHdl*)apvUserData;
691 
692 
693  if (!pstlhBtIfce->pcBTOutPassCode)
694  return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
695 
696  if (!dbus_message_get_args(apDBusMsg, NULL, DBUS_TYPE_OBJECT_PATH, &lpcPath, DBUS_TYPE_INVALID)) {
697  BTRCORELOG_ERROR ("Invalid arguments for RequestPinCode method");
698  return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
699  }
700 
701  if (pstlhBtIfce->i32DoReject) {
702  lpDBusReply = dbus_message_new_error(apDBusMsg, "org.bluez.Error.Rejected", "");
703  goto sendmsg;
704  }
705 
706  lpDBusReply = dbus_message_new_method_return(apDBusMsg);
707  if (!lpDBusReply) {
708  BTRCORELOG_ERROR ("Can't create lpDBusReply message\n");
709  return DBUS_HANDLER_RESULT_NEED_MEMORY;
710  }
711 
712  BTRCORELOG_INFO ("Pincode request for device %s\n", lpcPath);
713  dbus_message_append_args(lpDBusReply, DBUS_TYPE_STRING, &pstlhBtIfce->pcBTOutPassCode, DBUS_TYPE_INVALID);
714 
715 sendmsg:
716  dbus_connection_send(apDBusConn, lpDBusReply, NULL);
717  dbus_connection_flush(apDBusConn);
718 
719  dbus_message_unref(lpDBusReply);
720 
721  return DBUS_HANDLER_RESULT_HANDLED;
722 }
723 
724 
725 static DBusHandlerResult
726 btrCore_BTAgentRequestPasskey (
727  DBusConnection* apDBusConn,
728  DBusMessage* apDBusMsg,
729  void* apvUserData
730 ) {
731  DBusMessage* lpDBusReply = NULL;
732  const char* lpcPath = NULL;
733  unsigned int ui32PassCode= 0;
734  stBtIfceHdl* pstlhBtIfce = (stBtIfceHdl*)apvUserData;
735 
736 
737  if (!pstlhBtIfce->pcBTOutPassCode)
738  return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
739 
740  if (!dbus_message_get_args(apDBusMsg, NULL, DBUS_TYPE_OBJECT_PATH, &lpcPath, DBUS_TYPE_INVALID)) {
741  BTRCORELOG_ERROR ("Incorrect args btrCore_BTAgentRequestPasskey");
742  return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
743  }
744 
745  lpDBusReply = dbus_message_new_method_return(apDBusMsg);
746  if (!lpDBusReply) {
747  BTRCORELOG_ERROR ("Can't create lpDBusReply message\n");
748  return DBUS_HANDLER_RESULT_NEED_MEMORY;
749  }
750 
751  BTRCORELOG_INFO ("Pass code request for device %s\n", lpcPath);
752  ui32PassCode = strtoul(pstlhBtIfce->pcBTOutPassCode, NULL, 10);
753  dbus_message_append_args(lpDBusReply, DBUS_TYPE_UINT32, &ui32PassCode, DBUS_TYPE_INVALID);
754 
755  dbus_connection_send(apDBusConn, lpDBusReply, NULL);
756  dbus_connection_flush(apDBusConn);
757  dbus_message_unref(lpDBusReply);
758 
759  return DBUS_HANDLER_RESULT_HANDLED;
760 }
761 
762 
763 static DBusHandlerResult
764 btrCore_BTAgentRequestConfirmation (
765  DBusConnection* apDBusConn,
766  DBusMessage* apDBusMsg,
767  void* apvUserData
768 ) {
769  DBusMessage* lpDBusReply = NULL;
770  const char* lpcPath = NULL;
771  unsigned int ui32PassCode= 0;
772  int yesNo = 0;
773  int i32OpRet = -1;
774  stBTDeviceInfo lstBTDeviceInfo;
775  stBtIfceHdl* pstlhBtIfce = (stBtIfceHdl*)apvUserData;
776 
777 
778  memset(&lstBTDeviceInfo, 0, sizeof(stBTDeviceInfo));
779 
780 
781  if (!dbus_message_get_args(apDBusMsg, NULL, DBUS_TYPE_OBJECT_PATH, &lpcPath, DBUS_TYPE_UINT32, &ui32PassCode, DBUS_TYPE_INVALID)) {
782  BTRCORELOG_ERROR ("Invalid arguments for Authorize method");
783  return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
784  }
785 
786 
787  BTRCORELOG_INFO ("btrCore_BTAgentRequestConfirmation: PASS Code for %s is %6d\n", lpcPath, ui32PassCode);
788 
789  if (lpcPath) {
790  i32OpRet = btrCore_BTGetDeviceInfo(apDBusConn, &lstBTDeviceInfo, lpcPath);
791  enBTDeviceType lenBTDevType = btrCore_BTMapDevClasstoDevType(lstBTDeviceInfo.ui32Class);
792 
793  /* Set the ucIsReqConfirmation as 1; as we expect confirmation from the user */
794  if (pstlhBtIfce->fpcBConnectionIntimation) {
795  BTRCORELOG_INFO ("calling ConnIntimation cb for %s - OpRet = %d\n", lpcPath, i32OpRet);
796  yesNo = pstlhBtIfce->fpcBConnectionIntimation(lenBTDevType, &lstBTDeviceInfo, ui32PassCode, 1, pstlhBtIfce->pcBConnIntimUserData);
797  }
798  }
799 
800  pstlhBtIfce->ui32cBConnAuthPassKey = ui32PassCode;
801 
802 
803  if (yesNo == 0) {
804  BTRCORELOG_ERROR ("Sorry, you cant connect....\n");
805  lpDBusReply = dbus_message_new_error(apDBusMsg, "org.bluez.Error.Rejected", "");
806  }
807  else {
808  lpDBusReply = dbus_message_new_method_return(apDBusMsg);
809  }
810 
811 
812  if (!lpDBusReply) {
813  BTRCORELOG_ERROR ("Can't create lpDBusReply message\n");
814  return DBUS_HANDLER_RESULT_NEED_MEMORY;
815  }
816  else {
817  BTRCORELOG_INFO ("Intimating request for %s\n", lpcPath);
818  dbus_connection_send(apDBusConn, lpDBusReply, NULL);
819  dbus_connection_flush(apDBusConn);
820  dbus_message_unref(lpDBusReply);
821  return DBUS_HANDLER_RESULT_HANDLED;
822  }
823 }
824 
825 static DBusHandlerResult
826 btrCore_BTAgentDisplayPinCodePassKey (
827  DBusConnection* apDBusConn,
828  DBusMessage* apDBusMsg,
829  bool abPinCode,
830  void* apvUserData
831 ) {
832  DBusMessage* lpDBusReply = NULL;
833  const char* lpcPath = NULL;
834  const char* pinCode = NULL;
835  unsigned int ui32PassCode= 0;
836  enBTDeviceType lenBTDevType= enBTDevUnknown;
837  stBTDeviceInfo lstBTDeviceInfo;
838  stBtIfceHdl* pstlhBtIfce = (stBtIfceHdl*)apvUserData;
839 
840  memset(&lstBTDeviceInfo, 0, sizeof(stBTDeviceInfo));
841 
842  if (abPinCode == TRUE) {
843  if (!dbus_message_get_args(apDBusMsg, NULL, DBUS_TYPE_OBJECT_PATH, &lpcPath, DBUS_TYPE_STRING, &pinCode, DBUS_TYPE_INVALID)) {
844  BTRCORELOG_ERROR ("Invalid arguments for PINCode Display method");
845  return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
846  }
847  BTRCORELOG_INFO ("btrCore_BTAgentDisplayPinCode: PINCode is @@%s@@\n", pinCode);
848  ui32PassCode = (unsigned int) atoi(pinCode);
849  BTRCORELOG_DEBUG ("btrCore_BTAgentDisplayPinCode: PINCode in decimal @@%06d@@\n", ui32PassCode);
850  }
851  else {
852  unsigned short ui16Entered = 0;
853  if (!dbus_message_get_args(apDBusMsg, NULL, DBUS_TYPE_OBJECT_PATH, &lpcPath, DBUS_TYPE_UINT32, &ui32PassCode, DBUS_TYPE_UINT16, &ui16Entered, DBUS_TYPE_INVALID)) {
854  BTRCORELOG_ERROR ("Invalid arguments for PINCode Display method");
855  return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
856  }
857  BTRCORELOG_DEBUG ("btrCore_BTAgentDisplayPassKey : PassKey in decimal @@%06d@@ Entered is %d\n", ui32PassCode, ui16Entered);
858  }
859 
860  if (lpcPath) {
861  btrCore_BTGetDeviceInfo(apDBusConn, &lstBTDeviceInfo, lpcPath);
862  lenBTDevType = btrCore_BTMapDevClasstoDevType(lstBTDeviceInfo.ui32Class);
863  pstlhBtIfce->ui32cBConnAuthPassKey = ui32PassCode;
864 
865  /* Set the ucIsReqConfirmation as 0; as we do not expect confirmation */
866  if (pstlhBtIfce->fpcBConnectionIntimation) {
867  pstlhBtIfce->fpcBConnectionIntimation(lenBTDevType, &lstBTDeviceInfo, ui32PassCode, 0, pstlhBtIfce->pcBConnIntimUserData);
868  }
869  }
870 
871  lpDBusReply = dbus_message_new_method_return(apDBusMsg);
872  dbus_connection_send(apDBusConn, lpDBusReply, NULL);
873  dbus_connection_flush(apDBusConn);
874  dbus_message_unref(lpDBusReply);
875  return DBUS_HANDLER_RESULT_HANDLED;
876 }
877 
878 static DBusHandlerResult
879 btrCore_BTAgentAuthorize (
880  DBusConnection* apDBusConn,
881  DBusMessage* apDBusMsg,
882  void* apvUserData
883 ) {
884  DBusMessage* lpDBusReply = NULL;
885  const char* lpcPath = NULL;
886  const char* uuid = NULL;
887  int yesNo = 0;
888  int i32OpRet = -1;
889  enBTDeviceType lenBTDevType= enBTDevUnknown;
890  stBTDeviceInfo lstBTDeviceInfo;
891  stBtIfceHdl* pstlhBtIfce = (stBtIfceHdl*)apvUserData;
892 
893 
894  memset(&lstBTDeviceInfo, 0, sizeof(stBTDeviceInfo));
895 
896 
897  if (!dbus_message_get_args(apDBusMsg, NULL, DBUS_TYPE_OBJECT_PATH, &lpcPath, DBUS_TYPE_STRING, &uuid, DBUS_TYPE_INVALID)) {
898  BTRCORELOG_ERROR ("Invalid arguments for Authorize method");
899  return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
900  }
901 
902  if (lpcPath) {
903  i32OpRet = btrCore_BTGetDeviceInfo(apDBusConn, &lstBTDeviceInfo, lpcPath);
904  lenBTDevType = btrCore_BTMapDevClasstoDevType(lstBTDeviceInfo.ui32Class);
905 
906  if (pstlhBtIfce->fpcBConnectionAuthentication) {
907  BTRCORELOG_INFO ("calling ConnAuth cb for %s - OpRet = %d\n", lpcPath, i32OpRet);
908  yesNo = pstlhBtIfce->fpcBConnectionAuthentication(lenBTDevType, &lstBTDeviceInfo, pstlhBtIfce->pcBConnAuthUserData);
909  }
910  }
911 
912  pstlhBtIfce->ui32cBConnAuthPassKey = 0;
913 
914 
915  if (yesNo == 0) {
916  BTRCORELOG_ERROR ("Sorry, you cant connect....\n");
917  lpDBusReply = dbus_message_new_error(apDBusMsg, "org.bluez.Error.Rejected", "");
918  }
919  else {
920  lpDBusReply = dbus_message_new_method_return(apDBusMsg);
921  }
922 
923 
924  if (!lpDBusReply) {
925  BTRCORELOG_ERROR ("Can't create lpDBusReply message\n");
926  return DBUS_HANDLER_RESULT_NEED_MEMORY;
927  }
928  else {
929  BTRCORELOG_INFO ("Authorizing request for %s\n", lpcPath);
930  if (enBTDevAudioSource == lenBTDevType && yesNo) {
931  strcpy(lstBTDeviceInfo.pcDeviceCurrState,"connected");
932 
933  if (pstlhBtIfce->fpcBDevStatusUpdate) {
934  pstlhBtIfce->fpcBDevStatusUpdate(lenBTDevType, enBTDevStPropChanged, &lstBTDeviceInfo, pstlhBtIfce->pcBDevStatusUserData);
935  }
936  }
937 
938  dbus_connection_send(apDBusConn, lpDBusReply, NULL);
939  dbus_connection_flush(apDBusConn);
940  dbus_message_unref(lpDBusReply);
941  return DBUS_HANDLER_RESULT_HANDLED;
942  }
943 }
944 
945 
946 static DBusHandlerResult
947 btrCore_BTAgentCancelMessage (
948  DBusConnection* apDBusConn,
949  DBusMessage* apDBusMsg,
950  void* apvUserData
951 ) {
952  DBusMessage* lpDBusReply = NULL;
953  stBtIfceHdl* pstlhBtIfce = (stBtIfceHdl*)apvUserData;
954 
955  (void)pstlhBtIfce;
956 
957  if (!dbus_message_get_args(apDBusMsg, NULL, DBUS_TYPE_INVALID)) {
958  BTRCORELOG_ERROR ("Invalid arguments for confirmation method");
959  return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
960  }
961  BTRCORELOG_INFO ("Request canceled\n");
962  lpDBusReply = dbus_message_new_method_return(apDBusMsg);
963 
964  if (!lpDBusReply) {
965  BTRCORELOG_ERROR ("Can't create lpDBusReply message\n");
966  return DBUS_HANDLER_RESULT_NEED_MEMORY;
967  }
968 
969  dbus_connection_send(apDBusConn, lpDBusReply, NULL);
970  dbus_connection_flush(apDBusConn);
971 
972  dbus_message_unref(lpDBusReply);
973  return DBUS_HANDLER_RESULT_HANDLED;
974 }
975 
976 
977 static DBusMessage*
978 btrCore_BTSendMethodCall (
979  DBusConnection* apDBusConn,
980  const char* apcObjectPath,
981  const char* apcInterface,
982  const char* apcMethod
983 ) {
984  DBusMessage* lpDBusMsg = NULL;
985  DBusMessage* lpDBusReply = NULL;
986  DBusPendingCall* lpDBusPendC = NULL;
987 
988 
989  lpDBusMsg = dbus_message_new_method_call(BT_DBUS_BLUEZ_PATH,
990  apcObjectPath,
991  apcInterface,
992  apcMethod);
993 
994  if (!lpDBusMsg) {
995  BTRCORELOG_ERROR ("Cannot allocate DBus message!\n");
996  return NULL;
997  }
998 
999  if (!dbus_connection_send_with_reply(apDBusConn, lpDBusMsg, &lpDBusPendC, -1)) {
1000  BTRCORELOG_ERROR ("failed to send message!\n");
1001  return NULL;
1002  }
1003 
1004  dbus_connection_flush(apDBusConn);
1005 
1006  if (lpDBusPendC != NULL) {
1007  dbus_pending_call_block(lpDBusPendC);
1008 
1009  if ((lpDBusReply = dbus_pending_call_steal_reply(lpDBusPendC))) {
1010  if (dbus_message_get_type(lpDBusReply) == DBUS_MESSAGE_TYPE_ERROR) {
1011  BTRCORELOG_ERROR ("Error : %s\n\n", dbus_message_get_error_name(lpDBusReply));
1012  dbus_message_unref(lpDBusReply);
1013  lpDBusReply = NULL;
1014  }
1015  }
1016 
1017  dbus_pending_call_unref(lpDBusPendC);
1018  lpDBusPendC = NULL;
1019  }
1020 
1021  dbus_message_unref(lpDBusMsg);
1022  lpDBusMsg = NULL;
1023 
1024  return lpDBusReply;
1025 }
1026 
1027 
1028 static void
1029 btrCore_BTPendingCallCheckReply (
1030  DBusPendingCall* apDBusPendC,
1031  void* apvUserData
1032 ) {
1033  DBusMessage *lpDBusReply = NULL;
1034  DBusError lDBusErr;
1035 
1036  BTRCORELOG_DEBUG("btrCore_BTPendingCallCheckReply\n");
1037 
1038  if ((lpDBusReply = dbus_pending_call_steal_reply(apDBusPendC))) {
1039  dbus_error_init(&lDBusErr);
1040  if (dbus_set_error_from_message(&lDBusErr, lpDBusReply) == TRUE) {
1041  BTRCORELOG_ERROR ("Error : %s\n\n", dbus_message_get_error_name(lpDBusReply));
1042  btrCore_BTHandleDusError(&lDBusErr, __LINE__, __FUNCTION__);
1043  }
1044 
1045  dbus_message_unref(lpDBusReply);
1046  }
1047 
1048  dbus_pending_call_unref(apDBusPendC); //Free pending call handle
1049 }
1050 
1051 
1052 static int
1053 btrCore_BTParseAdapter (
1054  DBusMessageIter* apDBusMsgIter,
1055  stBTAdapterInfo* apstBTAdapterInfo
1056 ) {
1057  DBusMessageIter dict_iter;
1058  DBusMessageIter dict_entry_iter;
1059  DBusMessageIter dict_entry_value_iter;
1060  int dbus_type;
1061  const char* pcKey = NULL;
1062  const char* pcVal = NULL;
1063 
1064  // 'out' parameter of org.freedesktop.DBus.Properties.GetAll call has format 'DICT<STRING,VARIANT> props'
1065  for (dbus_message_iter_recurse(apDBusMsgIter, &dict_iter); // recurse into array (of dictionary entries)
1066  (dbus_type = dbus_message_iter_get_arg_type(&dict_iter)) != DBUS_TYPE_INVALID;
1067  dbus_message_iter_next(&dict_iter)) {
1068 
1069  if (dbus_type == DBUS_TYPE_DICT_ENTRY) {
1070  dbus_message_iter_recurse(&dict_iter, &dict_entry_iter); // recurse into dictionary entry at this position in dictionary
1071 
1072  dbus_message_iter_get_basic(&dict_entry_iter, &pcKey); // get dictionary entry's first item (key) which is a string
1073 
1074  // move to dictionary entry's next item (value associated with key) which should be a variant
1075  if (!dbus_message_iter_next(&dict_entry_iter) || dbus_message_iter_get_arg_type(&dict_entry_iter) != DBUS_TYPE_VARIANT)
1076  continue; // either this dictionary entry does not have a value (or) the value is not a variant
1077 
1078  dbus_message_iter_recurse(&dict_entry_iter, &dict_entry_value_iter); // recurse into dictionary entry's variant value
1079  dbus_type = dbus_message_iter_get_arg_type (&dict_entry_value_iter);
1080 
1081  if (strcmp (pcKey, "Address") == 0 && dbus_type == DBUS_TYPE_STRING) {
1082  dbus_message_iter_get_basic(&dict_entry_value_iter, &pcVal);
1083  strncpy(apstBTAdapterInfo->pcAddress, pcVal, BT_MAX_STR_LEN-1); // TODO strncpy is unsafe; use snprintf instead
1084  BTRCORELOG_TRACE ("pcAddress = %s\n", apstBTAdapterInfo->pcAddress);
1085  }
1086  else if (strcmp (pcKey, "Name") == 0 && dbus_type == DBUS_TYPE_STRING) {
1087  dbus_message_iter_get_basic(&dict_entry_value_iter, &pcVal);
1088  strncpy(apstBTAdapterInfo->pcName, pcVal, BT_MAX_STR_LEN-1);
1089  BTRCORELOG_TRACE ("pcName = %s\n", apstBTAdapterInfo->pcName);
1090  }
1091  else if (strcmp (pcKey, "Alias") == 0 && dbus_type == DBUS_TYPE_STRING) {
1092  dbus_message_iter_get_basic(&dict_entry_value_iter, &pcVal);
1093  strncpy(apstBTAdapterInfo->pcAlias, pcVal, BT_MAX_STR_LEN-1);
1094  BTRCORELOG_TRACE ("pcAlias = %s\n", apstBTAdapterInfo->pcAlias);
1095  }
1096  else if (strcmp (pcKey, "Class") == 0 && dbus_type == DBUS_TYPE_UINT32) {
1097  dbus_message_iter_get_basic(&dict_entry_value_iter, &apstBTAdapterInfo->ui32Class);
1098  BTRCORELOG_TRACE ("ui32Class = %u\n", apstBTAdapterInfo->ui32Class);
1099  }
1100  else if (strcmp (pcKey, "Powered") == 0 && dbus_type == DBUS_TYPE_BOOLEAN) {
1101  dbus_message_iter_get_basic(&dict_entry_value_iter, &apstBTAdapterInfo->bPowered);
1102  BTRCORELOG_TRACE ("bPowered = %d\n", apstBTAdapterInfo->bPowered);
1103  }
1104  else if (strcmp (pcKey, "Discoverable") == 0 && dbus_type == DBUS_TYPE_BOOLEAN) {
1105  dbus_message_iter_get_basic(&dict_entry_value_iter, &apstBTAdapterInfo->bDiscoverable);
1106  BTRCORELOG_TRACE ("bDiscoverable = %d\n", apstBTAdapterInfo->bDiscoverable);
1107  }
1108  else if (strcmp (pcKey, "DiscoverableTimeout") == 0 && dbus_type == DBUS_TYPE_UINT32) {
1109  dbus_message_iter_get_basic(&dict_entry_value_iter, &apstBTAdapterInfo->ui32DiscoverableTimeout);
1110  BTRCORELOG_TRACE ("ui32DiscoverableTimeout = %u\n", apstBTAdapterInfo->ui32DiscoverableTimeout);
1111  }
1112  else if (strcmp (pcKey, "Pairable") == 0 && dbus_type == DBUS_TYPE_BOOLEAN) {
1113  dbus_message_iter_get_basic(&dict_entry_value_iter, &apstBTAdapterInfo->bPairable);
1114  BTRCORELOG_TRACE ("bPairable = %d\n", apstBTAdapterInfo->bPairable);
1115  }
1116  else if (strcmp (pcKey, "PairableTimeout") == 0 && dbus_type == DBUS_TYPE_UINT32) {
1117  dbus_message_iter_get_basic(&dict_entry_value_iter, &apstBTAdapterInfo->ui32PairableTimeout);
1118  BTRCORELOG_TRACE ("ui32PairableTimeout = %u\n", apstBTAdapterInfo->ui32PairableTimeout);
1119  }
1120  else if (strcmp (pcKey, "Discovering") == 0 && dbus_type == DBUS_TYPE_BOOLEAN) {
1121  dbus_message_iter_get_basic(&dict_entry_value_iter, &apstBTAdapterInfo->bDiscovering);
1122  BTRCORELOG_DEBUG ("bDiscovering = %d\n", apstBTAdapterInfo->bDiscovering);
1123  }
1124  else if (strcmp (pcKey, "Modalias") == 0 && dbus_type == DBUS_TYPE_STRING) {
1125  dbus_message_iter_get_basic(&dict_entry_value_iter, &pcVal);
1126  strncpy(apstBTAdapterInfo->pcModalias, pcVal, BT_MAX_STR_LEN-1);
1127  BTRCORELOG_TRACE ("pcModalias = %s\n", apstBTAdapterInfo->pcModalias);
1128  }
1129  else if (strcmp (pcKey, "UUIDs") == 0 && dbus_type == DBUS_TYPE_ARRAY) {
1130  DBusMessageIter uuid_array_iter;
1131  int count = 0;
1132  for (dbus_message_iter_recurse(&dict_entry_value_iter, &uuid_array_iter);
1133  (dbus_type = dbus_message_iter_get_arg_type (&uuid_array_iter)) != DBUS_TYPE_INVALID;
1134  dbus_message_iter_next (&uuid_array_iter)) {
1135  if ((dbus_type == DBUS_TYPE_STRING) && (count < BT_MAX_DEVICE_PROFILE)) {
1136  dbus_message_iter_get_basic (&uuid_array_iter, &pcVal);
1137  strncpy(apstBTAdapterInfo->ppcUUIDs[count], pcVal, (BT_MAX_UUID_STR_LEN - 1));
1138  BTRCORELOG_TRACE ("UUID value is %s\n", apstBTAdapterInfo->ppcUUIDs[count]);
1139  count++;
1140  }
1141  }
1142  }
1143  }
1144  }
1145 
1146  return 0;
1147 }
1148 
1149 
1150 static int
1151 btrCore_BTGetDeviceInfo (
1152  DBusConnection* apDBusConn,
1153  stBTDeviceInfo* apstBTDeviceInfo,
1154  const char* apcIface
1155 ) {
1156  char* pdeviceInterface = BT_DBUS_BLUEZ_DEVICE_PATH;
1157  DBusMessage* lpDBusMsg = NULL;
1158  DBusMessage* lpDBusReply = NULL;
1159  DBusError lDBusErr;
1160  DBusPendingCall* lpDBusPendC;
1161 
1162 
1163  if (!apcIface)
1164  return -1;
1165 
1166  BTRCORELOG_DEBUG ("Getting properties for the device %s\n", apcIface);
1167 
1168  lpDBusMsg = dbus_message_new_method_call(BT_DBUS_BLUEZ_PATH,
1169  apcIface,
1170  DBUS_INTERFACE_PROPERTIES,
1171  "GetAll");
1172 
1173  dbus_message_append_args(lpDBusMsg, DBUS_TYPE_STRING, &pdeviceInterface, DBUS_TYPE_INVALID);
1174 
1175  dbus_error_init(&lDBusErr);
1176  if (!dbus_connection_send_with_reply(apDBusConn, lpDBusMsg, &lpDBusPendC, -1)) {
1177  BTRCORELOG_ERROR ("failed to send message");
1178  return -1;
1179  }
1180 
1181  dbus_connection_flush(apDBusConn);
1182  dbus_message_unref(lpDBusMsg);
1183  lpDBusMsg = NULL;
1184 
1185  dbus_pending_call_block(lpDBusPendC);
1186  lpDBusReply = dbus_pending_call_steal_reply(lpDBusPendC);
1187  dbus_pending_call_unref(lpDBusPendC);
1188 
1189  if (lpDBusReply != NULL) {
1190  if (0 != btrCore_BTParseDevice(lpDBusReply, apstBTDeviceInfo)) {
1191  BTRCORELOG_ERROR ("Parsing the device %s failed..\n", apcIface);
1192  dbus_message_unref(lpDBusReply);
1193  return -1;
1194  }
1195  else {
1196  strncpy(apstBTDeviceInfo->pcDevicePath, apcIface, (strlen(apcIface) < BT_MAX_DEV_PATH_LEN) ? strlen(apcIface) : BT_MAX_DEV_PATH_LEN - 1 );
1197  dbus_message_unref(lpDBusReply);
1198  return 0;
1199  }
1200  }
1201 
1202  dbus_message_unref(lpDBusReply);
1203  return 0;
1204 }
1205 
1206 
1207 static int
1208 btrCore_BTParseDevice (
1209  DBusMessage* apDBusMsg,
1210  stBTDeviceInfo* apstBTDeviceInfo
1211 ) {
1212  DBusMessageIter arg_i;
1213  DBusMessageIter element_i;
1214  DBusMessageIter variant_i;
1215  int dbus_type;
1216 
1217  const char* pcKey = NULL;
1218  int bPaired = 0;
1219  int bConnected = 0;
1220  int bTrusted = 0;
1221  int bBlocked = 0;
1222  unsigned short ui16Vendor = 0;
1223  unsigned short ui16VendorSource = 0;
1224  unsigned short ui16Product = 0;
1225  unsigned short ui16Version = 0;
1226  unsigned int ui32Class = 0;
1227  short i16RSSI = 0;
1228  const char* pcName = NULL;
1229  const char* pcAddress = NULL;
1230  const char* pcAlias = NULL;
1231  const char* pcDevAdapterObjPath = NULL;
1232  const char* pcIcon = NULL;
1233  unsigned short ui16Appearance = 0;
1234 
1235  if (!dbus_message_iter_init(apDBusMsg, &arg_i)) {
1236  BTRCORELOG_ERROR ("dbus_message_iter_init Failed\n");
1237  return -1;
1238  }
1239 
1240  dbus_type = dbus_message_iter_get_arg_type(&arg_i);
1241  if (dbus_message_iter_get_arg_type(&arg_i) != DBUS_TYPE_ARRAY) {
1242  dbus_message_iter_next(&arg_i);
1243  dbus_type = dbus_message_iter_get_arg_type(&arg_i);
1244 
1245  if (dbus_message_iter_get_arg_type(&arg_i) != DBUS_TYPE_ARRAY) {
1246  BTRCORELOG_ERROR ("Unknown Prop structure from Bluez\n");
1247  return -1;
1248  }
1249  }
1250 
1251  dbus_message_iter_recurse(&arg_i, &element_i);
1252  while (dbus_message_iter_get_arg_type(&element_i) != DBUS_TYPE_INVALID) {
1253  if (dbus_message_iter_get_arg_type(&element_i) == DBUS_TYPE_DICT_ENTRY) {
1254  DBusMessageIter dict_i;
1255 
1256  dbus_message_iter_recurse(&element_i, &dict_i);
1257  dbus_message_iter_get_basic(&dict_i, &pcKey);
1258 
1259  if (strcmp (pcKey, "Address") == 0) {
1260  dbus_message_iter_next(&dict_i);
1261  dbus_message_iter_recurse(&dict_i, &variant_i);
1262  dbus_message_iter_get_basic(&variant_i, &pcAddress);
1263  strncpy(apstBTDeviceInfo->pcAddress, pcAddress, BT_MAX_STR_LEN-1); //CID-163720 -Buffer not null terminated
1264  BTRCORELOG_TRACE ("pcAddress = %s\n", apstBTDeviceInfo->pcAddress);
1265 
1266  #if 1
1267  char lcDevVen[4] = {'\0'};
1268 
1269  lcDevVen[0]=pcAddress[12];
1270  lcDevVen[1]=pcAddress[15];
1271  lcDevVen[2]=pcAddress[16];
1272  lcDevVen[3]='\0';
1273  ui16Vendor = strtoll(lcDevVen, NULL, 16);
1274  apstBTDeviceInfo->ui16Vendor = ui16Vendor;
1275  BTRCORELOG_TRACE ("ui16Vendor = %d\n", apstBTDeviceInfo->ui16Vendor);
1276  #endif
1277  }
1278  else if (strcmp (pcKey, "Appearance") == 0) {
1279  dbus_message_iter_next(&dict_i);
1280  dbus_message_iter_recurse(&dict_i, &variant_i);
1281  dbus_message_iter_get_basic(&variant_i, &ui16Appearance);
1282  apstBTDeviceInfo->ui16Appearance = ui16Appearance;
1283  BTRCORELOG_TRACE ("ui16Appeaerance = %d\n", apstBTDeviceInfo->ui16Appearance);
1284  }
1285  else if (strcmp (pcKey, "Name") == 0) {
1286  dbus_message_iter_next(&dict_i);
1287  dbus_message_iter_recurse(&dict_i, &variant_i);
1288  dbus_message_iter_get_basic(&variant_i, &pcName);
1289  strncpy(apstBTDeviceInfo->pcName, pcName, BT_MAX_STR_LEN-1); //CID-163720 -Buffer not null terminated
1290  BTRCORELOG_TRACE ("pcName = %s\n", apstBTDeviceInfo->pcName);
1291 
1292  }
1293  else if (strcmp (pcKey, "Vendor") == 0) {
1294  dbus_message_iter_next(&dict_i);
1295  dbus_message_iter_recurse(&dict_i, &variant_i);
1296  dbus_message_iter_get_basic(&variant_i, &ui16Vendor);
1297  apstBTDeviceInfo->ui16Vendor = ui16Vendor;
1298  BTRCORELOG_TRACE ("ui16Vendor = %d\n", apstBTDeviceInfo->ui16Vendor);
1299  }
1300  else if (strcmp (pcKey, "VendorSource") == 0) {
1301  dbus_message_iter_next(&dict_i);
1302  dbus_message_iter_recurse(&dict_i, &variant_i);
1303  dbus_message_iter_get_basic(&variant_i, &ui16VendorSource);
1304  apstBTDeviceInfo->ui16VendorSource = ui16VendorSource;
1305  BTRCORELOG_TRACE ("ui16VendorSource= %d\n", apstBTDeviceInfo->ui16VendorSource);
1306  }
1307  else if (strcmp (pcKey, "Product") == 0) {
1308  dbus_message_iter_next(&dict_i);
1309  dbus_message_iter_recurse(&dict_i, &variant_i);
1310  dbus_message_iter_get_basic(&variant_i, &ui16Product);
1311  apstBTDeviceInfo->ui16Product = ui16Product;
1312  BTRCORELOG_TRACE ("ui16Product = %d\n", apstBTDeviceInfo->ui16Product);
1313  }
1314  else if (strcmp (pcKey, "Version") == 0) {
1315  dbus_message_iter_next(&dict_i);
1316  dbus_message_iter_recurse(&dict_i, &variant_i);
1317  dbus_message_iter_get_basic(&variant_i, &ui16Version);
1318  apstBTDeviceInfo->ui16Version = ui16Version;
1319  BTRCORELOG_TRACE ("ui16Version = %d\n", apstBTDeviceInfo->ui16Version);
1320  }
1321  else if (strcmp (pcKey, "Icon") == 0) {
1322  dbus_message_iter_next(&dict_i);
1323  dbus_message_iter_recurse(&dict_i, &variant_i);
1324  dbus_message_iter_get_basic(&variant_i, &pcIcon);
1325  strncpy(apstBTDeviceInfo->pcIcon, pcIcon, BT_MAX_STR_LEN-1); //CID-163720 -Buffer not null terminated
1326  BTRCORELOG_TRACE ("pcIcon = %s\n", apstBTDeviceInfo->pcIcon);
1327  }
1328  else if (strcmp (pcKey, "Class") == 0) {
1329  dbus_message_iter_next(&dict_i);
1330  dbus_message_iter_recurse(&dict_i, &variant_i);
1331  dbus_message_iter_get_basic(&variant_i, &ui32Class);
1332  apstBTDeviceInfo->ui32Class = ui32Class;
1333  BTRCORELOG_DEBUG ("ui32Class = %d\n", apstBTDeviceInfo->ui32Class);
1334  }
1335  else if (strcmp (pcKey, "Paired") == 0) {
1336  dbus_message_iter_next(&dict_i);
1337  dbus_message_iter_recurse(&dict_i, &variant_i);
1338  dbus_message_iter_get_basic(&variant_i, &bPaired);
1339  apstBTDeviceInfo->bPaired = bPaired;
1340  BTRCORELOG_DEBUG ("bPaired = %d\n", apstBTDeviceInfo->bPaired);
1341  }
1342  else if (strcmp (pcKey, "Connected") == 0) {
1343  dbus_message_iter_next(&dict_i);
1344  dbus_message_iter_recurse(&dict_i, &variant_i);
1345  dbus_message_iter_get_basic(&variant_i, &bConnected);
1346  apstBTDeviceInfo->bConnected = bConnected;
1347  BTRCORELOG_DEBUG ("bConnected = %d\n", apstBTDeviceInfo->bConnected);
1348  }
1349  else if (strcmp (pcKey, "Trusted") == 0) {
1350  dbus_message_iter_next(&dict_i);
1351  dbus_message_iter_recurse(&dict_i, &variant_i);
1352  dbus_message_iter_get_basic(&variant_i, &bTrusted);
1353  apstBTDeviceInfo->bTrusted = bTrusted;
1354  BTRCORELOG_TRACE ("bTrusted = %d\n", apstBTDeviceInfo->bTrusted);
1355  }
1356  else if (strcmp (pcKey, "Blocked") == 0) {
1357  dbus_message_iter_next(&dict_i);
1358  dbus_message_iter_recurse(&dict_i, &variant_i);
1359  dbus_message_iter_get_basic(&variant_i, &bBlocked);
1360  apstBTDeviceInfo->bBlocked = bBlocked;
1361  BTRCORELOG_TRACE ("bBlocked = %d\n", apstBTDeviceInfo->bBlocked);
1362  }
1363  else if (strcmp (pcKey, "Alias") == 0) {
1364  dbus_message_iter_next(&dict_i);
1365  dbus_message_iter_recurse(&dict_i, &variant_i);
1366  dbus_message_iter_get_basic(&variant_i, &pcAlias);
1367  strncpy(apstBTDeviceInfo->pcAlias, pcAlias, BT_MAX_STR_LEN-1); //CID-163720 -Buffer not null terminated
1368  BTRCORELOG_TRACE ("pcAlias = %s\n", apstBTDeviceInfo->pcAlias);
1369  }
1370  else if (strcmp (pcKey, "Adapter") == 0) {
1371  dbus_message_iter_next(&dict_i);
1372  dbus_message_iter_recurse(&dict_i, &variant_i);
1373  dbus_message_iter_get_basic(&variant_i, &pcDevAdapterObjPath);
1374  BTRCORELOG_TRACE ("pcDevAdapterObjPath = %s\n", pcDevAdapterObjPath);
1375  }
1376  else if (strcmp (pcKey, "RSSI") == 0) {
1377  dbus_message_iter_next(&dict_i);
1378  dbus_message_iter_recurse(&dict_i, &variant_i);
1379  dbus_message_iter_get_basic(&variant_i, &i16RSSI);
1380  apstBTDeviceInfo->i32RSSI = i16RSSI;
1381  BTRCORELOG_DEBUG ("i32RSSI = %d\n", apstBTDeviceInfo->i32RSSI);
1382  }
1383  else if (strcmp (pcKey, "UUIDs") == 0) {
1384  dbus_message_iter_next(&dict_i);
1385  dbus_message_iter_recurse(&dict_i, &variant_i);
1386 
1387  dbus_type = dbus_message_iter_get_arg_type (&variant_i);
1388  if (dbus_type == DBUS_TYPE_ARRAY) {
1389  int count = 0;
1390  DBusMessageIter variant_j;
1391  dbus_message_iter_recurse(&variant_i, &variant_j);
1392 
1393  while ((dbus_type = dbus_message_iter_get_arg_type (&variant_j)) != DBUS_TYPE_INVALID) {
1394  if ((dbus_type == DBUS_TYPE_STRING) && (count < BT_MAX_DEVICE_PROFILE)) {
1395  char *pVal = NULL;
1396  dbus_message_iter_get_basic (&variant_j, &pVal);
1397  BTRCORELOG_TRACE ("UUID value is %s\n", pVal);
1398  strncpy(apstBTDeviceInfo->aUUIDs[count], pVal, (BT_MAX_UUID_STR_LEN - 1));
1399  count++;
1400  }
1401  dbus_message_iter_next (&variant_j);
1402  }
1403  }
1404  else {
1405  BTRCORELOG_ERROR ("Services; Not an Array\n");
1406  }
1407  }
1408  else if (strcmp (pcKey, "ServiceData") == 0) {
1409  dbus_message_iter_next(&dict_i);
1410  dbus_message_iter_recurse(&dict_i, &variant_i);
1411  dbus_type = dbus_message_iter_get_arg_type (&variant_i);
1412 
1413  if (dbus_type == DBUS_TYPE_ARRAY) {
1414  DBusMessageIter variant_j;
1415 
1416  dbus_message_iter_recurse(&variant_i, &variant_j);
1417  //dbus_type = dbus_message_iter_get_arg_type (&variant_j);
1418 
1419  DBusMessageIter dict_j;
1420  int count = 0;
1421 
1422 
1423  while ((dbus_message_iter_get_arg_type (&variant_j) == DBUS_TYPE_DICT_ENTRY) &&
1424  (count < BT_MAX_DEVICE_PROFILE)){
1425  const char* uuid_str = NULL;
1426  dbus_message_iter_recurse(&variant_j, &dict_j);
1427  dbus_message_iter_get_basic(&dict_j, &uuid_str);
1428 
1429  if (uuid_str) {
1430  strncpy(apstBTDeviceInfo->saServices[count].pcUUIDs, uuid_str, (BT_MAX_UUID_STR_LEN - 1));
1431  //BTRCORELOG_TRACE ("Service advertisement data, Key UUID is [%s]\n", apstBTDeviceInfo->saServices[count].pcUUIDs);
1432 
1433  DBusMessageIter variant_k;
1434  dbus_message_iter_next(&dict_j);
1435  dbus_message_iter_recurse(&dict_j, &variant_k);
1436 
1437  dbus_type = dbus_message_iter_get_arg_type (&variant_k);
1438  if (dbus_type == DBUS_TYPE_ARRAY) {
1439  DBusMessageIter variant_l;
1440  uint8_t *service_data;
1441  int len;
1442 
1443  dbus_message_iter_recurse(&variant_k, &variant_l);
1444  dbus_message_iter_get_fixed_array(&variant_l, &service_data, &len);
1445 
1446  if(service_data && len) {
1447  if(len <= BT_MAX_SERVICE_DATA_LEN) {
1448  apstBTDeviceInfo->saServices[count].len = len;
1449  memcpy(apstBTDeviceInfo->saServices[count].pcData, service_data, len);
1450  }
1451  else {
1452  BTRCORELOG_ERROR ("Failed to populate the ServiceData since the ServiceData length [%d] is more than BT_MAX_SERVICE_DATA_LEN [%d].\n", len, BT_MAX_SERVICE_DATA_LEN);
1453  }
1454 
1455  //for (int i=0; i<len; i++) {
1456  //BTRCORELOG_TRACE ("ServiceData [%d] [%x]\n",i, *(service_data+i));
1457  //}
1458  }
1459  }
1460 
1461  BTRCORELOG_TRACE ("Service advertisement data, Data is: \n " );
1462  BTRCORELOG_TRACE ("------------------\n" );
1463  for (int i =0; i < apstBTDeviceInfo->saServices[count].len; i++){
1464  BTRCORELOG_TRACE ("ServiceData[%d] = [%x]\n ", i, apstBTDeviceInfo->saServices[count].pcData[i]);
1465  }
1466  BTRCORELOG_TRACE ("------------------\n" );
1467  }
1468  count++;
1469  dbus_message_iter_next (&variant_j);
1470  }
1471  }
1472  }
1473  }
1474 
1475  if (!dbus_message_iter_next(&element_i)) {
1476  break;
1477  }
1478  }
1479  (void)dbus_type;
1480 
1481  if (strlen(apstBTDeviceInfo->pcAlias))
1482  strncpy(apstBTDeviceInfo->pcName, apstBTDeviceInfo->pcAlias, BT_MAX_STR_LEN-1);
1483 
1484  return 0;
1485 }
1486 
1487 #if 0
1488 static int
1489 btrCore_BTParsePropertyChange (
1490  DBusMessage* apDBusMsg,
1491  stBTDeviceInfo* apstBTDeviceInfo
1492 ) {
1493  DBusMessageIter arg_i, variant_i;
1494  const char* value;
1495  const char* bd_addr;
1496  int dbus_type;
1497 
1498  if (!dbus_message_iter_init(apDBusMsg, &arg_i)) {
1499  BTRCORELOG_ERROR ("GetProperties lpDBusReply has no arguments.");
1500  }
1501 
1502  if (!dbus_message_get_args( apDBusMsg, NULL,
1503  DBUS_TYPE_STRING, &bd_addr,
1504  DBUS_TYPE_INVALID)) {
1505  BTRCORELOG_ERROR ("Invalid arguments for NameOwnerChanged signal");
1506  return -1;
1507  }
1508 
1509  BTRCORELOG_ERROR (" Name: %s\n",bd_addr);//"State" then the variant is a string
1510  if (strcmp(bd_addr,"State") == 0) {
1511  dbus_type = dbus_message_iter_get_arg_type(&arg_i);
1512  //BTRCORELOG_ERROR ("type is %d\n", dbus_type);
1513 
1514  if (dbus_type == DBUS_TYPE_STRING) {
1515  dbus_message_iter_next(&arg_i);
1516  dbus_message_iter_recurse(&arg_i, &variant_i);
1517  dbus_message_iter_get_basic(&variant_i, &value);
1518  // BTRCORELOG_ERROR (" the new state is: %s\n", value);
1519  strncpy(apstBTDeviceInfo->pcDevicePrevState, gpcDeviceCurrState, BT_MAX_STR_LEN - 1);
1520  strncpy(apstBTDeviceInfo->pcDeviceCurrState, value, BT_MAX_STR_LEN - 1);
1521  strncpy(gpcDeviceCurrState, value, BT_MAX_STR_LEN - 1);
1522  }
1523  }
1524 
1525  return 0;
1526 }
1527 #endif
1528 
1529 #if 0
1530 static int
1531 btrCore_BTGetGattInfo (
1532  enBTOpIfceType aenBTOpIfceType,
1533  void* apvGattInfo,
1534  const char* apcIface
1535 ) {
1536  char* pGattInterface = NULL;
1537  DBusMessage* lpDBusMsg = NULL;
1538  DBusMessage* lpDBusReply = NULL;
1539  DBusError lDBusErr;
1540  DBusPendingCall* lpDBusPendC;
1541 
1542  if (!apcIface)
1543  return -1;
1544 
1545  BTRCORELOG_DEBUG ("Getting properties for the Gatt Ifce %s\n", apcIface);
1546 
1547  lpDBusMsg = dbus_message_new_method_call(BT_DBUS_BLUEZ_PATH,
1548  apcIface,
1549  DBUS_INTERFACE_PROPERTIES,
1550  "GetAll");
1551 
1552  if (aenBTOpIfceType == enBTGattService) {
1553  pGattInterface = BT_DBUS_BLUEZ_GATT_SERVICE_PATH;
1554  } else if (aenBTOpIfceType == enBTGattCharacteristic) {
1555  pGattInterface = BT_DBUS_BLUEZ_GATT_CHAR_PATH;
1556  } else if (aenBTOpIfceType == enBTGattDescriptor) {
1557  pGattInterface = BT_DBUS_BLUEZ_GATT_DESCRIPTOR_PATH;
1558  }
1559 
1560  dbus_message_append_args(lpDBusMsg, DBUS_TYPE_STRING, &pGattInterface, DBUS_TYPE_INVALID);
1561 
1562  dbus_error_init(&lDBusErr);
1563  if (!dbus_connection_send_with_reply(gpDBusConn, lpDBusMsg, &lpDBusPendC, -1)) {
1564  BTRCORELOG_ERROR ("failed to send message");
1565  return -1;
1566  }
1567 
1568  dbus_connection_flush(gpDBusConn);
1569  dbus_message_unref(lpDBusMsg);
1570  lpDBusMsg = NULL;
1571 
1572  dbus_pending_call_block(lpDBusPendC);
1573  lpDBusReply = dbus_pending_call_steal_reply(lpDBusPendC);
1574  dbus_pending_call_unref(lpDBusPendC);
1575 
1576  if (lpDBusReply != NULL) {
1577 
1578  DBusMessageIter arg_i;
1579  DBusMessageIter element_i;
1580  DBusMessageIter variant_i;
1581  int dbus_type;
1582 
1583  char *pcKey = NULL;
1584  char *devicePath = NULL;
1585  char *servicePath = NULL;
1586  char *characteristicPath = NULL;
1587  char uuid[BT_MAX_UUID_STR_LEN] = "\0";
1588  char flags[16][BT_MAX_STR_LEN];
1589  //char value[10][BT_MAX_STR_LEN];
1590  int primary = 0;
1591  int notifying = 0;
1592  int fCount = 0, vCount = 0;
1593 
1594  if (!dbus_message_iter_init(lpDBusReply, &arg_i)) {
1595  BTRCORELOG_ERROR ("dbus_message_iter_init Failed\n");
1596  return -1;
1597  }
1598 
1599  dbus_type = dbus_message_iter_get_arg_type(&arg_i);
1600  if (dbus_message_iter_get_arg_type(&arg_i) != DBUS_TYPE_ARRAY) {
1601  dbus_message_iter_next(&arg_i);
1602  dbus_type = dbus_message_iter_get_arg_type(&arg_i);
1603 
1604  if (dbus_message_iter_get_arg_type(&arg_i) != DBUS_TYPE_ARRAY) {
1605  BTRCORELOG_ERROR ("Unknown Prop structure from Bluez\n");
1606  return -1;
1607  }
1608  }
1609 
1610  dbus_message_iter_recurse(&arg_i, &element_i);
1611  while (dbus_message_iter_get_arg_type(&element_i) != DBUS_TYPE_INVALID) {
1612  if (dbus_message_iter_get_arg_type(&element_i) == DBUS_TYPE_DICT_ENTRY) {
1613  DBusMessageIter dict_i;
1614 
1615  dbus_message_iter_recurse(&element_i, &dict_i);
1616  dbus_message_iter_get_basic(&dict_i, &pcKey);
1617 
1618  if (strcmp (pcKey, "UUID") == 0) {
1619  dbus_message_iter_next(&dict_i);
1620  dbus_message_iter_recurse(&dict_i, &variant_i);
1621  dbus_message_iter_get_basic(&variant_i, &uuid);
1622  BTRCORELOG_INFO ("UUID : %s\n", uuid);
1623  }
1624  else if (strcmp (pcKey, "Device") == 0) {
1625  dbus_message_iter_next(&dict_i);
1626  dbus_message_iter_recurse(&dict_i, &variant_i);
1627  dbus_message_iter_get_basic(&variant_i, &devicePath);
1628  //strncpy(apstBTMediaInfo->pcState, pcState, BT_MAX_STR_LEN);
1629  BTRCORELOG_INFO ("Device : %s\n", devicePath);
1630  }
1631  else if (strcmp (pcKey, "Service") == 0) {
1632  dbus_message_iter_next(&dict_i);
1633  dbus_message_iter_recurse(&dict_i, &variant_i);
1634  dbus_message_iter_get_basic(&variant_i, &servicePath);
1635  //strncpy(apstBTMediaInfo->pcState, pcState, BT_MAX_STR_LEN);
1636  BTRCORELOG_INFO ("Service : %s\n", servicePath);
1637  }
1638  else if (strcmp (pcKey, "Characteristic") == 0) {
1639  dbus_message_iter_next(&dict_i);
1640  dbus_message_iter_recurse(&dict_i, &variant_i);
1641  dbus_message_iter_get_basic(&variant_i, &characteristicPath);
1642  //strncpy(apstBTMediaInfo->pcState, pcState, BT_MAX_STR_LEN);
1643  BTRCORELOG_INFO ("Characteristic : %s\n", characteristicPath);
1644  }
1645  else if (strcmp (pcKey, "Primary") == 0) {
1646  dbus_message_iter_next(&dict_i);
1647  dbus_message_iter_recurse(&dict_i, &variant_i);
1648  dbus_message_iter_get_basic(&variant_i, &primary);
1649  //strncpy(apstBTMediaInfo->pcState, pcState, BT_MAX_STR_LEN);
1650  BTRCORELOG_INFO ("Primary : %d\n", primary);
1651  }
1652  else if (strcmp (pcKey, "Notifying") == 0) {
1653  dbus_message_iter_next(&dict_i);
1654  dbus_message_iter_recurse(&dict_i, &variant_i);
1655  dbus_message_iter_get_basic(&variant_i, &notifying);
1656  //strncpy(apstBTMediaInfo->pcState, pcState, BT_MAX_STR_LEN);
1657  BTRCORELOG_INFO ("notifying : %d\n", notifying);
1658  }
1659  else if (strcmp (pcKey, "Flags") == 0) {
1660  dbus_message_iter_next(&dict_i);
1661  dbus_message_iter_recurse(&dict_i, &variant_i);
1662 
1663  dbus_type = dbus_message_iter_get_arg_type (&variant_i);
1664  if (dbus_type == DBUS_TYPE_ARRAY) {
1665  DBusMessageIter variant_j;
1666  dbus_message_iter_recurse(&variant_i, &variant_j);
1667 
1668  while ((dbus_type = dbus_message_iter_get_arg_type (&variant_j)) != DBUS_TYPE_INVALID) {
1669  if ((dbus_type == DBUS_TYPE_STRING)) {
1670  char *pVal = NULL;
1671  dbus_message_iter_get_basic (&variant_j, &pVal);
1672  BTRCORELOG_INFO ("Flags value is %s\n", pVal);
1673  strncpy(flags[fCount], pVal, (BT_MAX_UUID_STR_LEN - 1));
1674  fCount++;
1675  }
1676  dbus_message_iter_next (&variant_j);
1677  }
1678  }
1679  else {
1680  BTRCORELOG_ERROR ("Services; Not an Array\n");
1681  }
1682  }
1683  else if (strcmp (pcKey, "Value") == 0) {
1684  dbus_message_iter_next(&dict_i);
1685  dbus_message_iter_recurse(&dict_i, &variant_i);
1686 
1687  dbus_type = dbus_message_iter_get_arg_type (&variant_i);
1688  if (dbus_type == DBUS_TYPE_ARRAY) {
1689  DBusMessageIter variant_j;
1690  dbus_message_iter_recurse(&variant_i, &variant_j);
1691 
1692  while ((dbus_type = dbus_message_iter_get_arg_type (&variant_j)) != DBUS_TYPE_INVALID) {
1693  if ((dbus_type == DBUS_TYPE_BYTE)) {
1694  char *pVal = NULL;
1695  dbus_message_iter_get_basic (&variant_j, &pVal);
1696  BTRCORELOG_INFO ("Value is %s\n", pVal);
1697  //strncpy(value[count], pVal, (BT_MAX_UUID_STR_LEN - 1));
1698  vCount++;
1699  }
1700  dbus_message_iter_next (&variant_j);
1701  }
1702  }
1703  else {
1704  BTRCORELOG_ERROR ("Services; Not an Array\n");
1705  }
1706  }
1707  }
1708 
1709  if (!dbus_message_iter_next(&element_i)) {
1710  break;
1711  }
1712  }
1713 
1714  dbus_message_unref(lpDBusReply);
1715 
1716  if (aenBTOpIfceType == enBTGattService) {
1717  stBTGattServiceInfo* gattServiceInfo = (stBTGattServiceInfo*)apvGattInfo;
1718 
1719  strncpy(gattServiceInfo->uuid, uuid, BT_MAX_UUID_STR_LEN - 1);
1720  strncpy(gattServiceInfo->gattDevicePath, devicePath, BT_MAX_STR_LEN - 1);
1721  gattServiceInfo->ui16Primary = primary;
1722  }
1723  else if (aenBTOpIfceType == enBTGattCharacteristic) {
1724  stBTGattCharInfo* gattCharInfo = (stBTGattCharInfo*)apvGattInfo;
1725  int i=0;
1726 
1727  strncpy(gattCharInfo->uuid, uuid, BT_MAX_UUID_STR_LEN - 1);
1728  strncpy(gattCharInfo->gattServicePath, servicePath, BT_MAX_STR_LEN - 1);
1729  gattCharInfo->ui16Notifying = notifying;
1730  for (;i<fCount;i++) {
1731  strncpy(gattCharInfo->flags[i], flags[i], BT_MAX_STR_LEN - 1);
1732  }/*
1733  for (;i<fCount;i++) {
1734  strncpy(gattCharInfo->value, value[i], BT_MAX_STR_LEN - 1);
1735  }*/
1736  }
1737  else if (aenBTOpIfceType == enBTGattDescriptor) {
1738  stBTGattDescInfo* gattDescInfo = (stBTGattDescInfo*)apvGattInfo;
1739  int i=0;
1740 
1741  strncpy(gattDescInfo->uuid, uuid, BT_MAX_UUID_STR_LEN - 1);
1742  strncpy(gattDescInfo->gattCharPath, characteristicPath, BT_MAX_STR_LEN - 1);
1743  for (;i<fCount;i++) {
1744  strncpy(gattDescInfo->flags[i], flags[i], BT_MAX_STR_LEN - 1);
1745  }/*
1746  for (;i<fCount;i++) {
1747  strncpy(gattCharInfo->value, value[i], BT_MAX_STR_LEN - 1);
1748  }*/
1749  }
1750  }
1751 
1752  return 0;
1753 }
1754 #endif
1755 
1756 
1757 static int
1758 btrCore_BTGetMediaInfo (
1759  DBusConnection* apDBusConn,
1760  stBTMediaInfo* apstBTMediaInfo,
1761  const char* apcIface
1762 ) {
1763  char* pdeviceInterface = BT_DBUS_BLUEZ_MEDIA_TRANSPORT_PATH;
1764  DBusMessage* lpDBusMsg = NULL;
1765  DBusMessage* lpDBusReply = NULL;
1766  DBusError lDBusErr;
1767  DBusPendingCall* lpDBusPendC;
1768 
1769 
1770  if (!apcIface)
1771  return -1;
1772 
1773  BTRCORELOG_DEBUG ("Getting properties for the Media Ifce %s\n", apcIface);
1774 
1775  lpDBusMsg = dbus_message_new_method_call(BT_DBUS_BLUEZ_PATH,
1776  apcIface,
1777  DBUS_INTERFACE_PROPERTIES,
1778  "GetAll");
1779 
1780  dbus_message_append_args(lpDBusMsg, DBUS_TYPE_STRING, &pdeviceInterface, DBUS_TYPE_INVALID);
1781 
1782  dbus_error_init(&lDBusErr);
1783  if (!dbus_connection_send_with_reply(apDBusConn, lpDBusMsg, &lpDBusPendC, -1)) {
1784  BTRCORELOG_ERROR ("failed to send message");
1785  return -1;
1786  }
1787 
1788  dbus_connection_flush(apDBusConn);
1789  dbus_message_unref(lpDBusMsg);
1790  lpDBusMsg = NULL;
1791 
1792  dbus_pending_call_block(lpDBusPendC);
1793  lpDBusReply = dbus_pending_call_steal_reply(lpDBusPendC);
1794  dbus_pending_call_unref(lpDBusPendC);
1795 
1796  if (lpDBusReply != NULL) {
1797  if (0 != btrCore_BTParseMediaTransport(lpDBusReply, apstBTMediaInfo)) {
1798  BTRCORELOG_ERROR ("Parsing the device %s failed..\n", apcIface);
1799  dbus_message_unref(lpDBusReply);
1800  return -1;
1801  }
1802  else {
1803  dbus_message_unref(lpDBusReply);
1804  return 0;
1805  }
1806  }
1807 
1808  dbus_message_unref(lpDBusReply);
1809  return 0;
1810 
1811 }
1812 
1813 
1814 static int
1815 btrCore_BTParseMediaTransport (
1816  DBusMessage* apDBusMsg,
1817  stBTMediaInfo* apstBTMediaInfo
1818 ) {
1819  DBusMessageIter arg_i;
1820  DBusMessageIter element_i;
1821  DBusMessageIter variant_i;
1822  int dbus_type;
1823 
1824  char* pcKey = NULL;
1825  unsigned char ui8Codec = 0;
1826  char* pcState = NULL;
1827  char* pcUUID = NULL;
1828  unsigned short ui16Delay = 0;
1829  unsigned short ui16Volume = 0;
1830 
1831  if (!dbus_message_iter_init(apDBusMsg, &arg_i)) {
1832  BTRCORELOG_ERROR ("dbus_message_iter_init Failed\n");
1833  return -1;
1834  }
1835 
1836  dbus_type = dbus_message_iter_get_arg_type(&arg_i);
1837  if (dbus_message_iter_get_arg_type(&arg_i) != DBUS_TYPE_ARRAY) {
1838  dbus_message_iter_next(&arg_i);
1839  dbus_type = dbus_message_iter_get_arg_type(&arg_i);
1840 
1841  if (dbus_message_iter_get_arg_type(&arg_i) != DBUS_TYPE_ARRAY) {
1842  BTRCORELOG_ERROR ("Unknown Prop structure from Bluez\n");
1843  return -1;
1844  }
1845  }
1846 
1847  dbus_message_iter_recurse(&arg_i, &element_i);
1848  while (dbus_message_iter_get_arg_type(&element_i) != DBUS_TYPE_INVALID) {
1849  if (dbus_message_iter_get_arg_type(&element_i) == DBUS_TYPE_DICT_ENTRY) {
1850  DBusMessageIter dict_i;
1851 
1852  dbus_message_iter_recurse(&element_i, &dict_i);
1853  dbus_message_iter_get_basic(&dict_i, &pcKey);
1854 
1855  if (strcmp (pcKey, "Codec") == 0) {
1856  dbus_message_iter_next(&dict_i);
1857  dbus_message_iter_recurse(&dict_i, &variant_i);
1858  dbus_message_iter_get_basic(&variant_i, &ui8Codec);
1859  apstBTMediaInfo->ui8Codec = ui8Codec;
1860  BTRCORELOG_INFO ("apstBTMediaInfo->ui8Codec : %d\n", apstBTMediaInfo->ui8Codec);
1861  }
1862  else if (strcmp (pcKey, "State") == 0) {
1863  dbus_message_iter_next(&dict_i);
1864  dbus_message_iter_recurse(&dict_i, &variant_i);
1865  dbus_message_iter_get_basic(&variant_i, &pcState);
1866  strncpy(apstBTMediaInfo->pcState, pcState, BT_MAX_STR_LEN-1); //CID-163623 : Buffer not null terminated
1867  BTRCORELOG_INFO ("apstBTMediaInfo->pcState: %s\n", apstBTMediaInfo->pcState);
1868 
1869  }
1870  else if (strcmp (pcKey, "UUID") == 0) {
1871  dbus_message_iter_next(&dict_i);
1872  dbus_message_iter_recurse(&dict_i, &variant_i);
1873  dbus_message_iter_get_basic(&variant_i, &pcUUID);
1874  strncpy(apstBTMediaInfo->pcUUID, pcUUID, BT_MAX_STR_LEN-1); //CID-163623 : Buffer not null terminated
1875  BTRCORELOG_INFO ("apstBTMediaInfo->pcUUID: %s\n", apstBTMediaInfo->pcUUID);
1876  }
1877  else if (strcmp (pcKey, "Delay") == 0) {
1878  dbus_message_iter_next(&dict_i);
1879  dbus_message_iter_recurse(&dict_i, &variant_i);
1880  dbus_message_iter_get_basic(&variant_i, &ui16Delay);
1881  apstBTMediaInfo->ui16Delay = ui16Delay;
1882  BTRCORELOG_INFO ("apstBTMediaInfo->ui16Delay = %d\n", apstBTMediaInfo->ui16Delay);
1883  }
1884  else if (strcmp (pcKey, "Volume") == 0) {
1885  dbus_message_iter_next(&dict_i);
1886  dbus_message_iter_recurse(&dict_i, &variant_i);
1887  dbus_message_iter_get_basic(&variant_i, &ui16Volume);
1888  apstBTMediaInfo->ui16Volume = ui16Volume;
1889  BTRCORELOG_INFO ("apstBTMediaInfo->ui16Volume = %d\n", apstBTMediaInfo->ui16Volume);
1890  }
1891  }
1892 
1893  if (!dbus_message_iter_next(&element_i)) {
1894  break;
1895  }
1896  }
1897 
1898  (void)dbus_type;
1899 
1900  return 0;
1901 }
1902 
1903 
1904 static int
1905 btrCore_BTParseMediaTrackMetadata (
1906  DBusMessage* apDBusMsg,
1907  stBTMediaTrackInfo* apstBTMediaTrackInfo
1908 ) {
1909  int dbus_type = DBUS_TYPE_INVALID;
1910  DBusMessageIter lDBusReplyIter;
1911  DBusMessageIter arrayMsgIter;
1912  DBusMessageIter dictMsgIter;
1913  DBusMessageIter element;
1914  DBusMessageIter elementBasic;
1915 
1916  unsigned int ui32Value = 0;
1917  char* pcKey = "\0";
1918  char* pcValue = "\0";
1919 
1920  if (!apDBusMsg) {
1921  BTRCORELOG_ERROR ("DBusMessage is NULL !\n");
1922  return -1;
1923  }
1924 
1925  if (!dbus_message_iter_init(apDBusMsg, &lDBusReplyIter)) { // lpDBusMsg is pointer to dbus message received
1926  BTRCORELOG_ERROR ("dbus_message_iter_init Failed\n");
1927  return -1;
1928  }
1929 
1930  if ((dbus_message_iter_get_arg_type (&lDBusReplyIter)) == DBUS_TYPE_INVALID) {
1931  BTRCORELOG_ERROR ("DBUS_TYPE_INVALID\n");
1932  return -1;
1933  }
1934 
1935  dbus_message_iter_recurse(&lDBusReplyIter, &arrayMsgIter); // pointer to first element ARRAY of the dbus messge received
1936  if ((dbus_message_iter_get_arg_type (&arrayMsgIter)) == DBUS_TYPE_INVALID) {
1937  BTRCORELOG_ERROR ("DBUS_TYPE_INVALID\n");
1938  return -1;
1939  }
1940 
1941  dbus_message_iter_recurse(&arrayMsgIter, &dictMsgIter); // pointer to first element DICTIONARY of the dbus messge received
1942 
1943 
1944  while ((dbus_type = dbus_message_iter_get_arg_type(&dictMsgIter)) != DBUS_TYPE_INVALID) {
1945  if (DBUS_TYPE_DICT_ENTRY == dbus_type) {
1946  dbus_message_iter_recurse(&dictMsgIter,&element); // pointer to element STRING of the dbus messge received
1947 
1948  if (DBUS_TYPE_STRING == dbus_message_iter_get_arg_type(&element)) {
1949  dbus_message_iter_get_basic(&element, &pcKey);
1950 
1951  if (!strcmp("Album", pcKey)) {
1952  dbus_message_iter_next(&element); // next element is VARIANT of the dbus messge received
1953  dbus_message_iter_recurse(&element, &elementBasic); // pointer to element STRING/UINT32 w.r.t dbus messge received here
1954  dbus_message_iter_get_basic(&elementBasic, &pcValue);
1955  strncpy(apstBTMediaTrackInfo->pcAlbum, pcValue, BT_MAX_STR_LEN);
1956  BTRCORELOG_DEBUG ("lpstBTMediaTrackInfo->pcAlbum : %s\n", apstBTMediaTrackInfo->pcAlbum);
1957  }
1958  else if (!strcmp("Artist", pcKey)) {
1959  dbus_message_iter_next(&element); // next element is VARIANT of the dbus messge received
1960  dbus_message_iter_recurse(&element, &elementBasic); // pointer to element STRING/UINT32 w.r.t dbus messge received here
1961  dbus_message_iter_get_basic(&elementBasic, &pcValue);
1962  strncpy(apstBTMediaTrackInfo->pcArtist, pcValue, BT_MAX_STR_LEN);
1963  BTRCORELOG_DEBUG ("lpstBTMediaTrackInfo->pcArtist : %s\n", apstBTMediaTrackInfo->pcArtist);
1964  }
1965  else if (!strcmp("Genre", pcKey)) {
1966  dbus_message_iter_next(&element); // next element is VARIANT of the dbus messge received
1967  dbus_message_iter_recurse(&element, &elementBasic); // pointer to element STRING/UINT32 w.r.t dbus messge received here
1968  dbus_message_iter_get_basic(&elementBasic, &pcValue);
1969  strncpy(apstBTMediaTrackInfo->pcGenre, pcValue, BT_MAX_STR_LEN);
1970  BTRCORELOG_DEBUG ("lpstBTMediaTrackInfo->pcGenre : %s\n", apstBTMediaTrackInfo->pcGenre);
1971  }
1972  else if (!strcmp("Title", pcKey)) {
1973  dbus_message_iter_next(&element); // next element is VARIANT of the dbus messge received
1974  dbus_message_iter_recurse(&element, &elementBasic); // pointer to element STRING/UINT32 w.r.t dbus messge received here
1975  dbus_message_iter_get_basic(&elementBasic, &pcValue);
1976  strncpy(apstBTMediaTrackInfo->pcTitle, pcValue, BT_MAX_STR_LEN);
1977  BTRCORELOG_DEBUG ("lpstBTMediaTrackInfo->pcTitle : %s\n", apstBTMediaTrackInfo->pcTitle);
1978  }
1979  else if (!strcmp("NumberOfTracks", pcKey)) {
1980  dbus_message_iter_next(&element); // next element is VARIANT of the dbus messge received
1981  dbus_message_iter_recurse(&element, &elementBasic); // pointer to element STRING/UINT32 w.r.t dbus messge received here
1982  dbus_message_iter_get_basic(&elementBasic, (void*)&ui32Value);
1983  apstBTMediaTrackInfo->ui32NumberOfTracks = ui32Value;
1984  BTRCORELOG_DEBUG ("lpstBTMediaTrackInfo->ui32NumberOfTracks : %d\n", apstBTMediaTrackInfo->ui32NumberOfTracks);
1985  }
1986  else if (!strcmp("TrackNumber", pcKey)) {
1987  dbus_message_iter_next(&element); // next element is VARIANT of the dbus messge received
1988  dbus_message_iter_recurse(&element, &elementBasic); // pointer to element STRING/UINT32 w.r.t dbus messge received here
1989  dbus_message_iter_get_basic(&elementBasic, (void*)&ui32Value);
1990  apstBTMediaTrackInfo->ui32TrackNumber = ui32Value;
1991  BTRCORELOG_DEBUG ("lpstBTMediaTrackInfo->ui32TrackNumber : %d\n", apstBTMediaTrackInfo->ui32TrackNumber);
1992  }
1993  else if (!strcmp("Duration", pcKey)) {
1994  dbus_message_iter_next(&element); // next element is VARIANT of the dbus messge received
1995  dbus_message_iter_recurse(&element, &elementBasic); // pointer to element STRING/UINT32 w.r.t dbus messge received here
1996  dbus_message_iter_get_basic(&elementBasic, (void*)&ui32Value);
1997  apstBTMediaTrackInfo->ui32Duration = ui32Value;
1998  BTRCORELOG_DEBUG ("lpstBTMediaTrackInfo->ui32Duration : %d\n", apstBTMediaTrackInfo->ui32Duration);
1999  }
2000  }
2001  }
2002 
2003  if (!dbus_message_iter_has_next(&dictMsgIter)) {
2004  break;
2005  }
2006  else {
2007  dbus_message_iter_next(&dictMsgIter);
2008  }
2009  }
2010 
2011  return 0;
2012 }
2013 
2014 
2015 static DBusMessage*
2016 btrCore_BTMediaEndpointSelectConfiguration (
2017  DBusMessage* apDBusMsg,
2018  enBTDeviceType aenBTDeviceType,
2019  enBTMediaType aenBTMediaType,
2020  void* apvUserData
2021 ) {
2022  DBusMessage* lpDBusReply = NULL;
2023  DBusError lDBusErr;
2024  void* lpMediaCapsInput = NULL;
2025  void* lpMediaCapsOutput= NULL;
2026  int lDBusArgsSize;
2027  stBtIfceHdl* pstlhBtIfce = (stBtIfceHdl*)apvUserData;
2028 
2029 
2030  dbus_error_init(&lDBusErr);
2031 
2032  if (!dbus_message_get_args(apDBusMsg, &lDBusErr, DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, &lpMediaCapsInput, &lDBusArgsSize, DBUS_TYPE_INVALID)) {
2033  btrCore_BTHandleDusError(&lDBusErr, __LINE__, __FUNCTION__);
2034  return dbus_message_new_error(apDBusMsg, "org.bluez.MediaEndpoint1.Error.InvalidArguments", "Unable to select configuration");
2035  }
2036 
2037  if (pstlhBtIfce->fpcBNegotiateMedia) {
2038  if(pstlhBtIfce->fpcBNegotiateMedia(lpMediaCapsInput, &lpMediaCapsOutput, aenBTDeviceType, aenBTMediaType, pstlhBtIfce->pcBNegMediaUserData)) {
2039  return dbus_message_new_error(apDBusMsg, "org.bluez.MediaEndpoint1.Error.InvalidArguments", "Unable to select configuration");
2040  }
2041  }
2042 
2043  lpDBusReply = dbus_message_new_method_return(apDBusMsg);
2044  dbus_message_append_args (lpDBusReply, DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, &lpMediaCapsOutput, lDBusArgsSize, DBUS_TYPE_INVALID);
2045 
2046  return lpDBusReply;
2047 }
2048 
2049 
2050 static DBusMessage*
2051 btrCore_BTMediaEndpointSetConfiguration (
2052  DBusMessage* apDBusMsg,
2053  enBTDeviceType aenBTDeviceType,
2054  enBTMediaType aenBTMediaType,
2055  void* apvUserData
2056 ) {
2057  const char* lpcDevTransportPath = NULL;
2058  const char* lpcDevPath = NULL;
2059  const char* lpcUuid = NULL;
2060  unsigned char* lpui8Config = NULL;
2061  int i32ConfSize = 0;
2062 
2063  DBusMessageIter lDBusMsgIter;
2064  DBusMessageIter lDBusMsgIterProp;
2065  DBusMessageIter lDBusMsgIterEntry;
2066  DBusMessageIter lDBusMsgIterValue;
2067  DBusMessageIter lDBusMsgIterArr;
2068 
2069  stBtIfceHdl* pstlhBtIfce = (stBtIfceHdl*)apvUserData;
2070 
2071 
2072  dbus_message_iter_init(apDBusMsg, &lDBusMsgIter);
2073  dbus_message_iter_get_basic(&lDBusMsgIter, &lpcDevTransportPath);
2074  if (!dbus_message_iter_next(&lDBusMsgIter))
2075  return dbus_message_new_error(apDBusMsg, "org.bluez.MediaEndpoint1.Error.InvalidArguments", "Unable to set configuration");
2076 
2077  dbus_message_iter_recurse(&lDBusMsgIter, &lDBusMsgIterProp);
2078  if (dbus_message_iter_get_arg_type(&lDBusMsgIterProp) != DBUS_TYPE_DICT_ENTRY)
2079  return dbus_message_new_error(apDBusMsg, "org.bluez.MediaEndpoint1.Error.InvalidArguments", "Unable to set configuration");
2080 
2081  while (dbus_message_iter_get_arg_type(&lDBusMsgIterProp) == DBUS_TYPE_DICT_ENTRY) {
2082  const char *key;
2083  int ldBusType;
2084 
2085  dbus_message_iter_recurse(&lDBusMsgIterProp, &lDBusMsgIterEntry);
2086  dbus_message_iter_get_basic(&lDBusMsgIterEntry, &key);
2087 
2088  dbus_message_iter_next(&lDBusMsgIterEntry);
2089  dbus_message_iter_recurse(&lDBusMsgIterEntry, &lDBusMsgIterValue);
2090 
2091  ldBusType = dbus_message_iter_get_arg_type(&lDBusMsgIterValue);
2092  if (strcasecmp(key, "UUID") == 0) {
2093  if (ldBusType != DBUS_TYPE_STRING)
2094  return dbus_message_new_error(apDBusMsg, "org.bluez.MediaEndpoint1.Error.InvalidArguments", "Unable to set configuration");
2095 
2096  dbus_message_iter_get_basic(&lDBusMsgIterValue, &lpcUuid);
2097  }
2098  else if (strcasecmp(key, "Device") == 0) {
2099  if (ldBusType != DBUS_TYPE_OBJECT_PATH)
2100  return dbus_message_new_error(apDBusMsg, "org.bluez.MediaEndpoint1.Error.InvalidArguments", "Unable to set configuration");
2101 
2102  dbus_message_iter_get_basic(&lDBusMsgIterValue, &lpcDevPath);
2103  }
2104  else if (strcasecmp(key, "Configuration") == 0) {
2105  if (ldBusType != DBUS_TYPE_ARRAY)
2106  return dbus_message_new_error(apDBusMsg, "org.bluez.MediaEndpoint1.Error.InvalidArguments", "Unable to set configuration");
2107 
2108  dbus_message_iter_recurse(&lDBusMsgIterValue, &lDBusMsgIterArr);
2109  dbus_message_iter_get_fixed_array(&lDBusMsgIterArr, &lpui8Config, &i32ConfSize);
2110  }
2111  dbus_message_iter_next(&lDBusMsgIterProp);
2112  }
2113 
2114  BTRCORELOG_INFO ("Set configuration - Transport Path %s\n", lpcDevTransportPath);
2115  BTRCORELOG_INFO ("Set configuration - Transport Path UUID %s\n", lpcUuid);
2116  BTRCORELOG_TRACE("Set configuration - Device Path %s\n", lpcDevPath);
2117 
2118  if (pstlhBtIfce->pcDevTransportPath) {
2119  free(pstlhBtIfce->pcDevTransportPath);
2120  pstlhBtIfce->pcDevTransportPath = NULL;
2121  }
2122 
2123  pstlhBtIfce->pcDevTransportPath = strdup(lpcDevTransportPath);
2124 
2125  if (pstlhBtIfce->fpcBTransportPathMedia) {
2126  if(!pstlhBtIfce->fpcBTransportPathMedia(lpcDevTransportPath, lpcUuid, lpui8Config, aenBTDeviceType, aenBTMediaType, pstlhBtIfce->pcBTransPathMediaUserData)) {
2127  BTRCORELOG_INFO ("Stored - Transport Path: %s\n", lpcDevTransportPath);
2128  }
2129  }
2130 
2131  return dbus_message_new_method_return(apDBusMsg);
2132 }
2133 
2134 
2135 static DBusMessage*
2136 btrCore_BTMediaEndpointClearConfiguration (
2137  DBusMessage* apDBusMsg,
2138  enBTDeviceType aenBTDeviceType,
2139  enBTMediaType aenBTMediaType,
2140  void* apvUserData
2141 ) {
2142  DBusMessage* lpDBusReply;
2143  DBusError lDBusErr;
2144  DBusMessageIter lDBusMsgIter;
2145  const char* lDevTransportPath = NULL;
2146 
2147  stBtIfceHdl* pstlhBtIfce = (stBtIfceHdl*)apvUserData;
2148 
2149 
2150  dbus_error_init(&lDBusErr);
2151  dbus_message_iter_init(apDBusMsg, &lDBusMsgIter);
2152  dbus_message_iter_get_basic(&lDBusMsgIter, &lDevTransportPath);
2153  BTRCORELOG_DEBUG ("Clear configuration - Transport Path %s\n", lDevTransportPath);
2154 
2155  if (pstlhBtIfce->pcDevTransportPath) {
2156  free(pstlhBtIfce->pcDevTransportPath);
2157  pstlhBtIfce->pcDevTransportPath = NULL;
2158  }
2159 
2160  if (pstlhBtIfce->fpcBTransportPathMedia) {
2161  if(!pstlhBtIfce->fpcBTransportPathMedia(lDevTransportPath, NULL, NULL, aenBTDeviceType, aenBTMediaType, pstlhBtIfce->pcBTransPathMediaUserData)) {
2162  BTRCORELOG_INFO ("Cleared - Transport Path %s\n", lDevTransportPath);
2163  }
2164  }
2165 
2166  lpDBusReply = dbus_message_new_method_return(apDBusMsg);
2167 
2168  return lpDBusReply;
2169 }
2170 
2171 
2172 static int
2173 btrCore_BTGetMediaIfceProperty (
2174  DBusConnection* apDBusConn,
2175  const char* apBtObjectPath,
2176  const char* apBtInterfacePath,
2177  const char* property,
2178  void* propertyValue
2179 ) {
2180  DBusMessage* lpDBusMsg = NULL;
2181  DBusMessage* lpDBusReply = NULL;
2182  DBusError lDBusErr;
2183  DBusMessageIter lDBusMsgIter;
2184  DBusMessageIter lDBusReplyIter;
2185  DBusMessageIter element;
2186  int dbus_type = DBUS_TYPE_INVALID;
2187 
2188 
2189  lpDBusMsg = dbus_message_new_method_call(BT_DBUS_BLUEZ_PATH,
2190  apBtObjectPath,
2191  DBUS_INTERFACE_PROPERTIES,
2192  "Get");
2193  if (!lpDBusMsg) {
2194  BTRCORELOG_ERROR ("Can't allocate new method call\n");
2195  return -1;
2196  }
2197 
2198 
2199  dbus_message_iter_init_append(lpDBusMsg, &lDBusMsgIter);
2200  dbus_message_iter_append_basic(&lDBusMsgIter, DBUS_TYPE_STRING, &apBtInterfacePath);
2201  dbus_message_iter_append_basic(&lDBusMsgIter, DBUS_TYPE_STRING, &property);
2202 
2203  dbus_error_init(&lDBusErr);
2204  lpDBusReply = dbus_connection_send_with_reply_and_block(apDBusConn, lpDBusMsg, -1, &lDBusErr);
2205  dbus_message_unref(lpDBusMsg);
2206 
2207  if (!lpDBusReply) {
2208  BTRCORELOG_ERROR ("lpDBusReply NULL\n");
2209  btrCore_BTHandleDusError(&lDBusErr, __LINE__, __FUNCTION__);
2210  return -1;
2211  }
2212 
2213  dbus_connection_flush(apDBusConn);
2214 
2215  dbus_message_iter_init(lpDBusReply, &lDBusReplyIter); // lpDBusMsg is pointer to dbus message received
2216  if ((dbus_message_iter_get_arg_type (&lDBusReplyIter)) == DBUS_TYPE_INVALID) {
2217  BTRCORELOG_ERROR ("DBUS_TYPE_INVALID\n");
2218  dbus_message_unref(lpDBusReply);
2219  return -1;
2220  }
2221 
2222  dbus_message_iter_recurse(&lDBusReplyIter, &element); // pointer to first element of the dbus messge received
2223  dbus_type = dbus_message_iter_get_arg_type(&element);
2224 
2225  if (DBUS_TYPE_STRING == dbus_type ||
2226  DBUS_TYPE_UINT32 == dbus_type ||
2227  DBUS_TYPE_BOOLEAN == dbus_type ||
2228  DBUS_TYPE_OBJECT_PATH == dbus_type ||
2229  DBUS_TYPE_UINT16 == dbus_type ||
2230  DBUS_TYPE_UINT64 == dbus_type ||
2231  DBUS_TYPE_INT16 == dbus_type ||
2232  DBUS_TYPE_INT32 == dbus_type ||
2233  DBUS_TYPE_INT64 == dbus_type ||
2234  DBUS_TYPE_BYTE == dbus_type ||
2235  DBUS_TYPE_DOUBLE == dbus_type) {
2236  dbus_message_iter_get_basic(&element, propertyValue);
2237  }
2238 
2239  dbus_message_unref(lpDBusReply);
2240  return 0;
2241 }
2242 
2243 static int
2244 btrCore_BTGattGetCharFlag (
2245  unsigned short aflag,
2246  char (*aFlagProp)[BT_MAX_UUID_STR_LEN],
2247  int nMaxFlags,
2248  int* apnFlags
2249 ) {
2250  int index = 0;
2251  int lIdx = 0;
2252 
2253  const char *lGattFlags[BT_MAX_UUID_STR_LEN] = { "read", "write", "encrypt-read", "encrypt-write", "encrypt-authenticated-read",
2254  "encrypt-authenticated-write", "secure-read", "secure-write", "notify", "indicate",
2255  "broadcast", "write-without-response", "authenticated-signed-writes", "reliable-write",
2256  "writable-auxiliaries"
2257  };
2258 
2259  for (index = 0; index < nMaxFlags; index++) {
2260  if ((aflag & (1 << index)) != 0) {
2261  strncpy(aFlagProp[lIdx], lGattFlags[index], (BT_MAX_UUID_STR_LEN-1));
2262  lIdx += 1;
2263  }
2264  }
2265 
2266  *apnFlags = lIdx;
2267  return 0;
2268 }
2269 
2270 static DBusMessage*
2271 btrCore_BTRegisterGattService (
2272  DBusConnection* apDBusConn,
2273  DBusMessage* apDBusMsg,
2274  stBtIfceHdl* apstlhBtIfce,
2275  stBTLeGattService* apstBTRCoreLeGattService,
2276  int aNumOfGattServices
2277 ) {
2278  DBusMessage* lpDBusReply = NULL;
2279  DBusMessageIter lDBusMsgIter;
2280  DBusMessageIter lDBusMsgIterDict;
2281  DBusError lDBusErr;
2282  dbus_bool_t lDBusOp;
2283  const char* lui8ConnName = NULL;
2284  char* param = "";
2285 
2286  // read the arguments
2287  if (!dbus_message_iter_init(apDBusMsg, &lDBusMsgIter)) {
2288  BTRCORELOG_TRACE("Message has no arguments!\n");
2289  }
2290  else if (DBUS_TYPE_STRING != dbus_message_iter_get_arg_type(&lDBusMsgIter)) {
2291  BTRCORELOG_TRACE("Argument is not string!\n");
2292  }
2293  else {
2294  dbus_message_iter_get_basic(&lDBusMsgIter, &param);
2295  }
2296 
2297  BTRCORELOG_TRACE("Method called with %s\n", param);
2298 
2299  lui8ConnName = dbus_bus_get_unique_name(apDBusConn);
2300  BTRCORELOG_DEBUG("!!! Gatt connection name : %s\n", lui8ConnName);
2301 
2302  lpDBusReply = dbus_message_new_method_return(apDBusMsg);
2303 
2304  dbus_message_iter_init_append(lpDBusReply, &lDBusMsgIter);
2305  dbus_message_iter_open_container(&lDBusMsgIter,
2306  DBUS_TYPE_ARRAY,
2307  DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
2308  DBUS_TYPE_OBJECT_PATH_AS_STRING
2309  DBUS_TYPE_ARRAY_AS_STRING
2310  DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
2311  DBUS_TYPE_STRING_AS_STRING
2312  DBUS_TYPE_ARRAY_AS_STRING
2313  DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
2314  DBUS_TYPE_STRING_AS_STRING
2315  DBUS_TYPE_VARIANT_AS_STRING
2316  DBUS_DICT_ENTRY_END_CHAR_AS_STRING
2317  DBUS_DICT_ENTRY_END_CHAR_AS_STRING
2318  DBUS_DICT_ENTRY_END_CHAR_AS_STRING,
2319  &lDBusMsgIterDict);
2320 
2321  for (int serviceIndex = 0; serviceIndex < aNumOfGattServices; serviceIndex++) {
2322  stBTLeGattService *lpstBTRCoreLeGattService = &apstBTRCoreLeGattService[serviceIndex];
2323 
2324  const char* lpui8SrvGattPath = strdup(lpstBTRCoreLeGattService->servicePath);
2325  BTRCORELOG_INFO("Inside btrCore_BTRegisterGattService - %s \n", lpui8SrvGattPath);
2326 
2327  /* Register service path */
2328  dbus_error_init(&lDBusErr);
2329  lDBusOp = dbus_connection_try_register_object_path(apDBusConn, lpui8SrvGattPath, &gDBusLeGattSCDVTable, apstlhBtIfce, &lDBusErr);
2330  if (!lDBusOp) {
2331  btrCore_BTHandleDusError(&lDBusErr, __LINE__, __FUNCTION__);
2332  BTRCORELOG_ERROR("Can't Register Le Gatt Object - %s\n", lpui8SrvGattPath);
2333  }
2334 
2335  { // Service
2336  DBusMessageIter lDBusMsgIterDictObjPath, lDBusMsgIterDictArr;
2337 
2338  dbus_message_iter_open_container(&lDBusMsgIterDict, DBUS_TYPE_DICT_ENTRY, NULL, &lDBusMsgIterDictObjPath);
2339  dbus_message_iter_append_basic(&lDBusMsgIterDictObjPath, DBUS_TYPE_OBJECT_PATH, &lpui8SrvGattPath);
2340  dbus_message_iter_open_container(&lDBusMsgIterDictObjPath,
2341  DBUS_TYPE_ARRAY,
2342  DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
2343  DBUS_TYPE_STRING_AS_STRING
2344  DBUS_TYPE_ARRAY_AS_STRING
2345  DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
2346  DBUS_TYPE_STRING_AS_STRING
2347  DBUS_TYPE_VARIANT_AS_STRING
2348  DBUS_DICT_ENTRY_END_CHAR_AS_STRING
2349  DBUS_DICT_ENTRY_END_CHAR_AS_STRING,
2350  &lDBusMsgIterDictArr);
2351  {
2352  DBusMessageIter lDBusMsgIterDictStrIfce, lDBusMsgIterDictArrStr;
2353  char* lpcIfce = BT_DBUS_BLUEZ_GATT_SERVICE_PATH;
2354 
2355  dbus_message_iter_open_container(&lDBusMsgIterDictArr, DBUS_TYPE_DICT_ENTRY, NULL, &lDBusMsgIterDictStrIfce);
2356  dbus_message_iter_append_basic(&lDBusMsgIterDictStrIfce, DBUS_TYPE_STRING, &lpcIfce);
2357  dbus_message_iter_open_container(&lDBusMsgIterDictStrIfce,
2358  DBUS_TYPE_ARRAY,
2359  DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
2360  DBUS_TYPE_STRING_AS_STRING
2361  DBUS_TYPE_VARIANT_AS_STRING
2362  DBUS_DICT_ENTRY_END_CHAR_AS_STRING,
2363  &lDBusMsgIterDictArrStr);
2364  {
2365  DBusMessageIter lDBusMsgIterDictStrUUID;
2366  DBusMessageIter lDBusMsgIterValue;
2367  char* key = "UUID";
2368  int type = DBUS_TYPE_STRING;
2369  const char* lpServiceUUID = lpstBTRCoreLeGattService->serviceUuid;
2370  BTRCORELOG_DEBUG(" Service UUID is %s\n", lpServiceUUID );
2371 
2372  dbus_message_iter_open_container(&lDBusMsgIterDictArrStr, DBUS_TYPE_DICT_ENTRY, NULL, &lDBusMsgIterDictStrUUID);
2373  dbus_message_iter_append_basic(&lDBusMsgIterDictStrUUID, DBUS_TYPE_STRING, &key);
2374  dbus_message_iter_open_container(&lDBusMsgIterDictStrUUID, DBUS_TYPE_VARIANT, (char *)&type, &lDBusMsgIterValue);
2375  dbus_message_iter_append_basic(&lDBusMsgIterValue, type, &lpServiceUUID);
2376  dbus_message_iter_close_container(&lDBusMsgIterDictStrUUID, &lDBusMsgIterValue);
2377  dbus_message_iter_close_container (&lDBusMsgIterDictArrStr, &lDBusMsgIterDictStrUUID);
2378  }
2379  {
2380  DBusMessageIter lDBusMsgIterDictBoolPri;
2381  DBusMessageIter lDBusMsgIterValue;
2382  char* key = "Primary";
2383  int type = DBUS_TYPE_BOOLEAN;
2384  dbus_bool_t lbBtPrimaryGatt = lpstBTRCoreLeGattService->serviceType;
2385 
2386  dbus_message_iter_open_container(&lDBusMsgIterDictArrStr, DBUS_TYPE_DICT_ENTRY, NULL, &lDBusMsgIterDictBoolPri);
2387  dbus_message_iter_append_basic(&lDBusMsgIterDictBoolPri, DBUS_TYPE_STRING, &key);
2388  dbus_message_iter_open_container(&lDBusMsgIterDictBoolPri, DBUS_TYPE_VARIANT, (char *)&type, &lDBusMsgIterValue);
2389  dbus_message_iter_append_basic(&lDBusMsgIterValue, type, &lbBtPrimaryGatt);
2390  dbus_message_iter_close_container(&lDBusMsgIterDictBoolPri, &lDBusMsgIterValue);
2391  dbus_message_iter_close_container(&lDBusMsgIterDictArrStr, &lDBusMsgIterDictBoolPri);
2392  }
2393  dbus_message_iter_close_container(&lDBusMsgIterDictStrIfce, &lDBusMsgIterDictArrStr);
2394  dbus_message_iter_close_container(&lDBusMsgIterDictArr, &lDBusMsgIterDictStrIfce);
2395  }
2396  dbus_message_iter_close_container(&lDBusMsgIterDictObjPath, &lDBusMsgIterDictArr);
2397  dbus_message_iter_close_container(&lDBusMsgIterDict, &lDBusMsgIterDictObjPath);
2398  }
2399 
2400  // Characteristic
2401  for (int index = 0; index < lpstBTRCoreLeGattService->ui16NumberOfGattChar; index++) {
2402  stBTLeGattChar *lpstBTRCoreLeGattChar = &lpstBTRCoreLeGattService->astBTRGattChar[index];
2403  const char* lpui8ChrGattPath = strdup(lpstBTRCoreLeGattChar->charPath);
2404 
2405  DBusMessageIter lDBusMsgIterDictObjPath, lDBusMsgIterDictArr;
2406  BTRCORELOG_DEBUG(" Char path is %s\n", lpui8ChrGattPath);
2407  /* Register char path */
2408  dbus_error_init(&lDBusErr);
2409  lDBusOp = dbus_connection_try_register_object_path(apDBusConn, lpui8ChrGattPath, &gDBusLeGattSCDVTable, apstlhBtIfce, &lDBusErr);
2410  if (!lDBusOp) {
2411  btrCore_BTHandleDusError(&lDBusErr, __LINE__, __FUNCTION__);
2412  BTRCORELOG_ERROR("Can't Register Le Gatt Object - %s\n", lpui8ChrGattPath);
2413  }
2414 
2415  dbus_message_iter_open_container(&lDBusMsgIterDict, DBUS_TYPE_DICT_ENTRY, NULL, &lDBusMsgIterDictObjPath);
2416  dbus_message_iter_append_basic(&lDBusMsgIterDictObjPath, DBUS_TYPE_OBJECT_PATH, &lpui8ChrGattPath);
2417  dbus_message_iter_open_container(&lDBusMsgIterDictObjPath,
2418  DBUS_TYPE_ARRAY,
2419  DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
2420  DBUS_TYPE_STRING_AS_STRING
2421  DBUS_TYPE_ARRAY_AS_STRING
2422  DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
2423  DBUS_TYPE_STRING_AS_STRING
2424  DBUS_TYPE_VARIANT_AS_STRING
2425  DBUS_DICT_ENTRY_END_CHAR_AS_STRING
2426  DBUS_DICT_ENTRY_END_CHAR_AS_STRING,
2427  &lDBusMsgIterDictArr);
2428  {
2429  DBusMessageIter lDBusMsgIterDictStrIfce, lDBusMsgIterDictArrStr;
2430  char* lpcIfce = BT_DBUS_BLUEZ_GATT_CHAR_PATH;
2431 
2432  dbus_message_iter_open_container(&lDBusMsgIterDictArr, DBUS_TYPE_DICT_ENTRY, NULL, &lDBusMsgIterDictStrIfce);
2433  dbus_message_iter_append_basic(&lDBusMsgIterDictStrIfce, DBUS_TYPE_STRING, &lpcIfce);
2434  dbus_message_iter_open_container(&lDBusMsgIterDictStrIfce,
2435  DBUS_TYPE_ARRAY,
2436  DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
2437  DBUS_TYPE_STRING_AS_STRING
2438  DBUS_TYPE_VARIANT_AS_STRING
2439  DBUS_DICT_ENTRY_END_CHAR_AS_STRING,
2440  &lDBusMsgIterDictArrStr);
2441  {
2442  DBusMessageIter lDBusMsgIterDictStrUUID;
2443  DBusMessageIter lDBusMsgIterValue;
2444  char* key = "UUID";
2445  int type = DBUS_TYPE_STRING;
2446  const char* lpCharUUID = lpstBTRCoreLeGattChar->charUuid;
2447 
2448  dbus_message_iter_open_container(&lDBusMsgIterDictArrStr, DBUS_TYPE_DICT_ENTRY, NULL, &lDBusMsgIterDictStrUUID);
2449  dbus_message_iter_append_basic(&lDBusMsgIterDictStrUUID, DBUS_TYPE_STRING, &key);
2450  dbus_message_iter_open_container(&lDBusMsgIterDictStrUUID, DBUS_TYPE_VARIANT, (char *)&type, &lDBusMsgIterValue);
2451  dbus_message_iter_append_basic(&lDBusMsgIterValue, type, &lpCharUUID);
2452  dbus_message_iter_close_container(&lDBusMsgIterDictStrUUID, &lDBusMsgIterValue);
2453  dbus_message_iter_close_container(&lDBusMsgIterDictArrStr, &lDBusMsgIterDictStrUUID);
2454  }
2455  {
2456  DBusMessageIter lDBusMsgIterDictStrUUID;
2457  DBusMessageIter lDBusMsgIterValue;
2458  char* key = "Service";
2459  int type = DBUS_TYPE_OBJECT_PATH;
2460 
2461  dbus_message_iter_open_container(&lDBusMsgIterDictArrStr, DBUS_TYPE_DICT_ENTRY, NULL, &lDBusMsgIterDictStrUUID);
2462  dbus_message_iter_append_basic(&lDBusMsgIterDictStrUUID, DBUS_TYPE_STRING, &key);
2463  dbus_message_iter_open_container(&lDBusMsgIterDictStrUUID, DBUS_TYPE_VARIANT, (char *)&type, &lDBusMsgIterValue);
2464  dbus_message_iter_append_basic(&lDBusMsgIterValue, type, &lpui8SrvGattPath);
2465  dbus_message_iter_close_container(&lDBusMsgIterDictStrUUID, &lDBusMsgIterValue);
2466  dbus_message_iter_close_container(&lDBusMsgIterDictArrStr, &lDBusMsgIterDictStrUUID);
2467  }
2468  {
2469  DBusMessageIter lDBusMsgIterDictStrUUID;
2470  DBusMessageIter lDBusMsgIterVariant;
2471  DBusMessageIter lDBusMsgIterSubArray;
2472  char* key = "Flags";
2473  int type = DBUS_TYPE_STRING;
2474  int nFlags = 0;
2475  char lppui8Props[BT_MAX_NUM_GATT_CHAR_FLAGS][BT_MAX_UUID_STR_LEN] = { {""} };
2476  char array_type[5] = "a";
2477 
2478  strncat (array_type, (char*)&type, sizeof(array_type) - sizeof(type));
2479 
2480  btrCore_BTGattGetCharFlag(lpstBTRCoreLeGattChar->charFlags, lppui8Props, BT_MAX_NUM_GATT_CHAR_FLAGS, &nFlags);
2481 
2482  dbus_message_iter_open_container(&lDBusMsgIterDictArrStr, DBUS_TYPE_DICT_ENTRY, NULL, &lDBusMsgIterDictStrUUID);
2483  dbus_message_iter_append_basic(&lDBusMsgIterDictStrUUID, DBUS_TYPE_STRING, &key);
2484  dbus_message_iter_open_container(&lDBusMsgIterDictStrUUID, DBUS_TYPE_VARIANT, array_type, &lDBusMsgIterVariant);
2485  dbus_message_iter_open_container(&lDBusMsgIterVariant, DBUS_TYPE_ARRAY, (char *)&type, &lDBusMsgIterSubArray);
2486  for (int index = 0; index < nFlags; index++) {
2487  const char* lpCharFlag = lppui8Props[index];
2488  dbus_message_iter_append_basic(&lDBusMsgIterSubArray, type, &lpCharFlag);
2489  }
2490  dbus_message_iter_close_container (&lDBusMsgIterVariant, &lDBusMsgIterSubArray);
2491  dbus_message_iter_close_container (&lDBusMsgIterDictStrUUID, &lDBusMsgIterVariant);
2492  dbus_message_iter_close_container (&lDBusMsgIterDictArrStr, &lDBusMsgIterDictStrUUID);
2493  }
2494  { /* SM- TODO Check if this is required */
2495  DBusMessageIter lDBusMsgIterDictBoolPri;
2496  DBusMessageIter lDBusMsgIterValue;
2497  char* key = "Notifying";
2498  int type = DBUS_TYPE_BOOLEAN;
2499  dbus_bool_t lbNotify = FALSE;
2500 
2501  BTRCORELOG_WARN("Characteristics flag is - %d\n", lpstBTRCoreLeGattChar->charFlags);
2502  if ((lpstBTRCoreLeGattChar->charFlags & BT_GATT_CHAR_FLAG_NOTIFY) == BT_GATT_CHAR_FLAG_NOTIFY) {
2503  lbNotify = TRUE;
2504  BTRCORELOG_WARN("Notification flag is - %d\n", (int)lbNotify);
2505  }
2506 
2507  dbus_message_iter_open_container(&lDBusMsgIterDictArrStr, DBUS_TYPE_DICT_ENTRY, NULL, &lDBusMsgIterDictBoolPri);
2508  dbus_message_iter_append_basic(&lDBusMsgIterDictBoolPri, DBUS_TYPE_STRING, &key);
2509  dbus_message_iter_open_container(&lDBusMsgIterDictBoolPri, DBUS_TYPE_VARIANT, (char *)&type, &lDBusMsgIterValue);
2510  dbus_message_iter_append_basic(&lDBusMsgIterValue, type, &lbNotify);
2511  dbus_message_iter_close_container(&lDBusMsgIterDictBoolPri, &lDBusMsgIterValue);
2512  dbus_message_iter_close_container(&lDBusMsgIterDictArrStr, &lDBusMsgIterDictBoolPri);
2513  }
2514 
2515  dbus_message_iter_close_container(&lDBusMsgIterDictStrIfce, &lDBusMsgIterDictArrStr);
2516  dbus_message_iter_close_container(&lDBusMsgIterDictArr, &lDBusMsgIterDictStrIfce);
2517  }
2518  dbus_message_iter_close_container(&lDBusMsgIterDictObjPath, &lDBusMsgIterDictArr);
2519  dbus_message_iter_close_container(&lDBusMsgIterDict, &lDBusMsgIterDictObjPath);
2520 
2521  // Descriptor
2522  for (int DescIndex = 0; DescIndex < lpstBTRCoreLeGattChar->ui16NumberOfGattDesc; DescIndex++) {
2523  stBTLeGattDesc *lpstCoreLeGattDesc = &lpstBTRCoreLeGattChar->atBTRGattDesc[DescIndex];
2524  const char* lpui8DescGattPath = strdup(lpstCoreLeGattDesc->descPath);
2525  DBusMessageIter lDBusMsgIterDictObjPath, lDBusMsgIterDictArr;
2526  /* Register char path */
2527  dbus_error_init(&lDBusErr);
2528  lDBusOp = dbus_connection_try_register_object_path(apDBusConn, lpui8DescGattPath, &gDBusLeGattSCDVTable, apstlhBtIfce, &lDBusErr);
2529  if (!lDBusOp) {
2530  btrCore_BTHandleDusError(&lDBusErr, __LINE__, __FUNCTION__);
2531  BTRCORELOG_ERROR("Can't Register Le Gatt Object - %s\n", lpui8DescGattPath);
2532  }
2533 
2534  dbus_message_iter_open_container(&lDBusMsgIterDict, DBUS_TYPE_DICT_ENTRY, NULL, &lDBusMsgIterDictObjPath);
2535  dbus_message_iter_append_basic(&lDBusMsgIterDictObjPath, DBUS_TYPE_OBJECT_PATH, &lpui8DescGattPath);
2536  dbus_message_iter_open_container(&lDBusMsgIterDictObjPath,
2537  DBUS_TYPE_ARRAY,
2538  DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
2539  DBUS_TYPE_STRING_AS_STRING
2540  DBUS_TYPE_ARRAY_AS_STRING
2541  DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
2542  DBUS_TYPE_STRING_AS_STRING
2543  DBUS_TYPE_VARIANT_AS_STRING
2544  DBUS_DICT_ENTRY_END_CHAR_AS_STRING
2545  DBUS_DICT_ENTRY_END_CHAR_AS_STRING,
2546  &lDBusMsgIterDictArr);
2547  {
2548  DBusMessageIter lDBusMsgIterDictStrIfce, lDBusMsgIterDictArrStr;
2549  char* lpcIfce = BT_DBUS_BLUEZ_GATT_DESCRIPTOR_PATH;
2550 
2551  dbus_message_iter_open_container(&lDBusMsgIterDictArr, DBUS_TYPE_DICT_ENTRY, NULL, &lDBusMsgIterDictStrIfce);
2552  dbus_message_iter_append_basic(&lDBusMsgIterDictStrIfce, DBUS_TYPE_STRING, &lpcIfce);
2553  dbus_message_iter_open_container(&lDBusMsgIterDictStrIfce,
2554  DBUS_TYPE_ARRAY,
2555  DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
2556  DBUS_TYPE_STRING_AS_STRING
2557  DBUS_TYPE_VARIANT_AS_STRING
2558  DBUS_DICT_ENTRY_END_CHAR_AS_STRING,
2559  &lDBusMsgIterDictArrStr);
2560  {
2561  DBusMessageIter lDBusMsgIterDictStrUUID;
2562  DBusMessageIter lDBusMsgIterValue;
2563  char* key = "UUID";
2564  int type = DBUS_TYPE_STRING;
2565  const char* lpDescUUID = lpstCoreLeGattDesc->descUuid;
2566 
2567  dbus_message_iter_open_container(&lDBusMsgIterDictArrStr, DBUS_TYPE_DICT_ENTRY, NULL, &lDBusMsgIterDictStrUUID);
2568  dbus_message_iter_append_basic(&lDBusMsgIterDictStrUUID, DBUS_TYPE_STRING, &key);
2569  dbus_message_iter_open_container(&lDBusMsgIterDictStrUUID, DBUS_TYPE_VARIANT, (char *)&type, &lDBusMsgIterValue);
2570  dbus_message_iter_append_basic(&lDBusMsgIterValue, type, &lpDescUUID);
2571  dbus_message_iter_close_container(&lDBusMsgIterDictStrUUID, &lDBusMsgIterValue);
2572  dbus_message_iter_close_container(&lDBusMsgIterDictArrStr, &lDBusMsgIterDictStrUUID);
2573  }
2574  {
2575  DBusMessageIter lDBusMsgIterDictStrUUID;
2576  DBusMessageIter lDBusMsgIterValue;
2577  char* key = "Characteristic";
2578  int type = DBUS_TYPE_OBJECT_PATH;
2579 
2580  dbus_message_iter_open_container(&lDBusMsgIterDictArrStr, DBUS_TYPE_DICT_ENTRY, NULL, &lDBusMsgIterDictStrUUID);
2581  dbus_message_iter_append_basic(&lDBusMsgIterDictStrUUID, DBUS_TYPE_STRING, &key);
2582  dbus_message_iter_open_container(&lDBusMsgIterDictStrUUID, DBUS_TYPE_VARIANT, (char *)&type, &lDBusMsgIterValue);
2583  dbus_message_iter_append_basic(&lDBusMsgIterValue, type, &lpui8ChrGattPath);
2584  dbus_message_iter_close_container(&lDBusMsgIterDictStrUUID, &lDBusMsgIterValue);
2585  dbus_message_iter_close_container(&lDBusMsgIterDictArrStr, &lDBusMsgIterDictStrUUID);
2586  }
2587  {
2588  DBusMessageIter lDBusMsgIterDictStrUUID;
2589  DBusMessageIter lDBusMsgIterVariant;
2590  DBusMessageIter lDBusMsgIterSubArray;
2591  char* key = "Flags";
2592  int type = DBUS_TYPE_STRING;
2593  char lppui8Props[BT_MAX_NUM_GATT_DESC_FLAGS][BT_MAX_UUID_STR_LEN] = { {""} };
2594  int nFlags = 0;
2595  char array_type[5] = "a";
2596  strncat(array_type, (char*)&type, sizeof(array_type) - sizeof(type));
2597 
2598  btrCore_BTGattGetCharFlag(lpstCoreLeGattDesc->descFlags, lppui8Props, BT_MAX_NUM_GATT_DESC_FLAGS, &nFlags);
2599 
2600  dbus_message_iter_open_container(&lDBusMsgIterDictArrStr, DBUS_TYPE_DICT_ENTRY, NULL, &lDBusMsgIterDictStrUUID);
2601  dbus_message_iter_append_basic(&lDBusMsgIterDictStrUUID, DBUS_TYPE_STRING, &key);
2602  dbus_message_iter_open_container(&lDBusMsgIterDictStrUUID, DBUS_TYPE_VARIANT, array_type, &lDBusMsgIterVariant);
2603  dbus_message_iter_open_container(&lDBusMsgIterVariant, DBUS_TYPE_ARRAY, (char *)&type, &lDBusMsgIterSubArray);
2604  for (int index = 0; index < nFlags; index++)
2605  {
2606  const char* lpCharFlag = lppui8Props[index];
2607  dbus_message_iter_append_basic(&lDBusMsgIterSubArray, type, &lpCharFlag);
2608  }
2609  dbus_message_iter_close_container(&lDBusMsgIterVariant, &lDBusMsgIterSubArray);
2610  dbus_message_iter_close_container(&lDBusMsgIterDictStrUUID, &lDBusMsgIterVariant);
2611  dbus_message_iter_close_container(&lDBusMsgIterDictArrStr, &lDBusMsgIterDictStrUUID);
2612  }
2613 
2614 
2615  dbus_message_iter_close_container(&lDBusMsgIterDictStrIfce, &lDBusMsgIterDictArrStr);
2616  dbus_message_iter_close_container(&lDBusMsgIterDictArr, &lDBusMsgIterDictStrIfce);
2617  }
2618  dbus_message_iter_close_container(&lDBusMsgIterDictObjPath, &lDBusMsgIterDictArr);
2619  dbus_message_iter_close_container(&lDBusMsgIterDict, &lDBusMsgIterDictObjPath);
2620 
2621  free((void*)lpui8DescGattPath);
2622  }
2623  free((void*)lpui8ChrGattPath);
2624  }
2625  free((void*)lpui8SrvGattPath);
2626  }
2627  dbus_message_iter_close_container (&lDBusMsgIter, &lDBusMsgIterDict);
2628 
2629  BTRCORELOG_ERROR ("RETURNING - %p\n", lpDBusReply);
2630  return lpDBusReply;
2631 }
2632 
2633 
2634 static int
2635 btrCore_BTUnRegisterGattService (
2636  DBusConnection* apDBusConn,
2637  const char* apui8SCDGattPath
2638 ) {
2639  dbus_bool_t lDBusOp;
2640 
2641  (void)lDBusOp;
2642  BTRCORELOG_TRACE("Inside btrCore_BTUnRegisterGattService\n");
2643 
2644  return 0;
2645 }
2646 
2647 static int
2648 btrCore_BTReleaseLEGattObjPath (
2649  char* apstObjPath,
2650  void* apvUserData
2651 ) {
2652  dbus_bool_t lDBusOp;
2653  stBtIfceHdl* pstlhBtIfce = (stBtIfceHdl*)apvUserData;
2654 
2655  lDBusOp = dbus_connection_unregister_object_path(pstlhBtIfce->pDBusConn, apstObjPath);
2656  if (!lDBusOp) {
2657  BTRCORELOG_ERROR("Can't unregister object path %s for Gatt!\n", apstObjPath);
2658  return -1;
2659  }
2660 
2661  return 0;
2662 }
2663 
2664 /* Function to read/write characteristic/descriptor value to/from Bluez */
2665 static DBusMessage*
2666 btrCore_BTLEGattOps (
2667  DBusMessage* apDBusMsg,
2668  stBtIfceHdl* apstlhBtIfce,
2669  enBTOpIfceType aenIfceType,
2670  enBTLeGattOp aenGattOp
2671 ) {
2672  DBusMessage* lpDBusReply = NULL;
2673  //DBusError lDBusErr;
2674  void* lpLEGattOutput = NULL;
2675  DBusMessageIter lDBusReplyIter, lDBusNextIter;
2676  DBusMessageIter element;
2677  int dbus_type = DBUS_TYPE_INVALID;
2678  char propertyValue[BT_MAX_GATT_OP_DATA_LEN] = {'\0'};
2679  char data = '\0';
2680  int index = 0;
2681  char objectPath[BT_MAX_STR_LEN] = "\0";
2682 
2683  const char *path = dbus_message_get_path(apDBusMsg);
2684 
2685  switch (aenGattOp) {
2686  case enBTLeGattOpWriteValue: {
2687  BTRCORELOG_INFO("enBTLeGattOpWriteValue\n");
2688  /* Read the data from the bus */
2689  dbus_message_iter_init(apDBusMsg, &lDBusReplyIter); // apDBusMsg is pointer to dbus message received
2690  if ((dbus_message_iter_get_arg_type(&lDBusReplyIter)) == DBUS_TYPE_INVALID) {
2691  BTRCORELOG_ERROR("DBUS_TYPE_INVALID\n");
2692  dbus_message_unref(apDBusMsg);
2693  }
2694 
2695  dbus_message_iter_recurse(&lDBusReplyIter, &element); // pointer to first element of the dbus messge received
2696  /* Get the array of bytes */
2697  while ((dbus_type = dbus_message_iter_get_arg_type(&element)) != DBUS_TYPE_INVALID) {
2698  if (dbus_type == DBUS_TYPE_BYTE) {
2699  dbus_message_iter_get_basic(&element, &data);
2700  propertyValue[index++] = data;
2701  }
2702 
2703  if (!dbus_message_iter_next(&element)) {
2704  break;
2705  }
2706  }
2707  propertyValue[index] = '\0';
2708 
2709  dbus_message_iter_recurse(&element, &lDBusNextIter);
2710  if (DBUS_TYPE_DICT_ENTRY == dbus_message_iter_get_arg_type(&lDBusNextIter)) {
2711  DBusMessageIter dictEntryIter;
2712  dbus_message_iter_recurse(&lDBusNextIter, &dictEntryIter);
2713  if (DBUS_TYPE_STRING == dbus_message_iter_get_arg_type(&dictEntryIter)) {
2714  char *dbusObject;
2715 
2716  dbus_message_iter_get_basic(&dictEntryIter, &dbusObject);
2717 
2718  if (0 == strcmp(dbusObject, "device")) {
2719  if (true == dbus_message_iter_next(&dictEntryIter)) {
2720  DBusMessageIter variantArray;
2721  dbus_message_iter_recurse(&dictEntryIter, &variantArray);
2722  dbus_type = dbus_message_iter_get_arg_type(&variantArray);
2723  if (DBUS_TYPE_OBJECT_PATH == dbus_message_iter_get_arg_type(&variantArray)) {
2724  char *path;
2725  dbus_message_iter_get_basic(&variantArray, &path);
2726  strcpy(objectPath, path);
2727  BTRCORELOG_DEBUG("object path is %s\n", objectPath);
2728  }
2729  }
2730  }
2731  }
2732  }
2733 
2734  stBTDeviceInfo lstBTDeviceInfo;
2735  btrCore_BTGetDeviceInfo(apstlhBtIfce->pDBusConn, &lstBTDeviceInfo, objectPath);
2736  BTRCORELOG_DEBUG("device address is %s\n", lstBTDeviceInfo.pcAddress);
2737  BTRCORELOG_DEBUG("Received data is %s with length %lu\n", propertyValue, (unsigned long)strlen(propertyValue));
2738 
2739  /* Update data to the LE layer */
2740  if (apstlhBtIfce->fpcBTLeGattPath) {
2741  apstlhBtIfce->fpcBTLeGattPath(aenIfceType, aenGattOp, path, lstBTDeviceInfo.pcAddress, enBTDevStPropChanged, propertyValue, apstlhBtIfce->pcBLePathUserData);
2742  }
2743  }
2744  break;
2745  case enBTLeGattOpReadValue: {
2746  int lDataLength = 0;
2747  /* Read the options from the dbus message */
2748  dbus_message_iter_init(apDBusMsg, &lDBusReplyIter);
2749  if ((dbus_message_iter_get_arg_type(&lDBusReplyIter)) == DBUS_TYPE_INVALID) {
2750  BTRCORELOG_ERROR("DBUS_TYPE_INVALID\n");
2751  dbus_message_unref(apDBusMsg);
2752  }
2753 
2754  dbus_message_iter_recurse(&lDBusReplyIter, &lDBusNextIter); // pointer to first element of the dbus messge received
2755  if (DBUS_TYPE_DICT_ENTRY == dbus_message_iter_get_arg_type(&lDBusNextIter)) {
2756  DBusMessageIter dictEntryIter;
2757  dbus_message_iter_recurse(&lDBusNextIter, &dictEntryIter);
2758 
2759  if (DBUS_TYPE_STRING == dbus_message_iter_get_arg_type(&dictEntryIter)) {
2760  char *dbusObject;
2761  dbus_message_iter_get_basic(&dictEntryIter, &dbusObject);
2762 
2763  if (0 == strcmp(dbusObject, "device")) {
2764  if (true == dbus_message_iter_next(&dictEntryIter)) {
2765  DBusMessageIter variantArray;
2766  dbus_message_iter_recurse(&dictEntryIter, &variantArray);
2767 
2768  if (DBUS_TYPE_OBJECT_PATH == dbus_message_iter_get_arg_type(&variantArray)) {
2769  char *path;
2770  dbus_message_iter_get_basic(&variantArray, &path);
2771  strcpy(objectPath, path);
2772  BTRCORELOG_DEBUG("object path is %s\n", objectPath);
2773  }
2774  }
2775  }
2776  }
2777  }
2778 
2779  stBTDeviceInfo lstBTDeviceInfo;
2780  btrCore_BTGetDeviceInfo(apstlhBtIfce->pDBusConn, &lstBTDeviceInfo, objectPath);
2781  BTRCORELOG_DEBUG("device address is %s\n", lstBTDeviceInfo.pcAddress);
2782 
2783  /* Get data from LE layer */
2784  if (apstlhBtIfce->fpcBTLeGattPath) {
2785  apstlhBtIfce->fpcBTLeGattPath(aenIfceType, aenGattOp, path, lstBTDeviceInfo.pcAddress, enBTDevStPropChanged, propertyValue, apstlhBtIfce->pcBLePathUserData);
2786  }
2787  BTRCORELOG_INFO("Property value is %s\n", propertyValue);
2788  lDataLength = strlen(propertyValue);
2789  lpLEGattOutput = (void*)propertyValue;
2790 
2791  /* Write the data to the bus */
2792  lpDBusReply = dbus_message_new_method_return(apDBusMsg);
2793  dbus_message_append_args(lpDBusReply, DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, &lpLEGattOutput, lDataLength, DBUS_TYPE_INVALID);
2794  }
2795  break;
2796  default:
2797  break;
2798  }
2799 
2800  return lpDBusReply;
2801 }
2802 
2803 
2804 /* Function to send advertisement data to Bluez */
2805 static int
2806 btrCore_BTRegisterLeAdvGetProp (
2807  DBusConnection* apDBusConn,
2808  DBusMessage* apDBusMsg,
2809  stBtIfceHdl* apstlhBtIfce
2810 ) {
2811  DBusMessage* lpDBusReply = NULL;
2812  DBusMessageIter lDBusMsgIterAdv;
2813  DBusMessageIter lDBusMsgIterDictAdv;
2814  stBTLeCustomAdv* lpstCustomAdv = &apstlhBtIfce->stBTLeCustAdvt;
2815 
2816  lpDBusReply = dbus_message_new_method_return(apDBusMsg);
2817 
2818  dbus_message_iter_init_append(lpDBusReply, &lDBusMsgIterAdv);
2819  dbus_message_iter_open_container(&lDBusMsgIterAdv,
2820  DBUS_TYPE_ARRAY,
2821  DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
2822  DBUS_TYPE_STRING_AS_STRING
2823  DBUS_TYPE_VARIANT_AS_STRING
2824  DBUS_DICT_ENTRY_END_CHAR_AS_STRING,
2825  &lDBusMsgIterDictAdv);
2826  {
2827  /* Get advertisement data */
2828  apstlhBtIfce->fpcBTLeAdvPath(NULL, &lpstCustomAdv, apstlhBtIfce->pcBLeAdvUserData);
2829 
2830  {
2831  DBusMessageIter lDBusMsgIterDictStr, lDBusMsgIterVariant;
2832  char* lpcKey = "Type";
2833  char* lui8Value = "";
2834  int i32DBusType = DBUS_TYPE_STRING;
2835 
2836  /* Get advertisement type */
2837  lui8Value = lpstCustomAdv->AdvertisementType;
2838  BTRCORELOG_INFO("Advertisement type is %s\n", lui8Value);
2839 
2840  dbus_message_iter_open_container(&lDBusMsgIterDictAdv, DBUS_TYPE_DICT_ENTRY, NULL, &lDBusMsgIterDictStr);
2841  dbus_message_iter_append_basic(&lDBusMsgIterDictStr, DBUS_TYPE_STRING, &lpcKey);
2842  dbus_message_iter_open_container(&lDBusMsgIterDictStr, DBUS_TYPE_VARIANT, (char *)&i32DBusType, &lDBusMsgIterVariant);
2843  dbus_message_iter_append_basic(&lDBusMsgIterVariant, i32DBusType, &lui8Value);
2844  dbus_message_iter_close_container(&lDBusMsgIterDictStr, &lDBusMsgIterVariant);
2845  dbus_message_iter_close_container(&lDBusMsgIterDictAdv, &lDBusMsgIterDictStr);
2846  }
2847 
2848  {
2849  if (lpstCustomAdv->numServiceUUID > 0) {
2850  DBusMessageIter lDBusMsgIterDictStr, lDBusMsgIterVariant, lDBusMsgIterSubArray;
2851  char* key = "ServiceUUIDs";
2852  int type = DBUS_TYPE_STRING;
2853 
2854  char array_type[5] = "a";
2855  strncat(array_type, (char*)&type, sizeof(array_type) - sizeof(type));
2856 
2857  dbus_message_iter_open_container(&lDBusMsgIterDictAdv, DBUS_TYPE_DICT_ENTRY, NULL, &lDBusMsgIterDictStr);
2858  dbus_message_iter_append_basic(&lDBusMsgIterDictStr, DBUS_TYPE_STRING, &key);
2859  dbus_message_iter_open_container(&lDBusMsgIterDictStr, DBUS_TYPE_VARIANT, array_type, &lDBusMsgIterVariant);
2860  dbus_message_iter_open_container(&lDBusMsgIterVariant, DBUS_TYPE_ARRAY, (char *)&type, &lDBusMsgIterSubArray);
2861  for (int index = 0; index < lpstCustomAdv->numServiceUUID; index++) {
2862  const char *lppui8Props = lpstCustomAdv->ServiceUUID[index];
2863  BTRCORELOG_INFO("Service UUID is %s\n", lpstCustomAdv->ServiceUUID[index]);
2864  dbus_message_iter_append_basic(&lDBusMsgIterSubArray, type, &lppui8Props);
2865  }
2866  dbus_message_iter_close_container(&lDBusMsgIterVariant, &lDBusMsgIterSubArray);
2867  dbus_message_iter_close_container(&lDBusMsgIterDictStr, &lDBusMsgIterVariant);
2868  dbus_message_iter_close_container(&lDBusMsgIterDictAdv, &lDBusMsgIterDictStr);
2869  }
2870  }
2871 
2872  {
2873  if (lpstCustomAdv->numSolicitUUID > 0) {
2874  DBusMessageIter lDBusMsgIterDictStr, lDBusMsgIterVariant, lDBusMsgIterSubArray;
2875  char* key = "SolicitUUIDs";
2876  int type = DBUS_TYPE_STRING;
2877 
2878  char array_type[5] = "a";
2879  strncat(array_type, (char*)&type, sizeof(array_type) - sizeof(type));
2880 
2881  dbus_message_iter_open_container(&lDBusMsgIterDictAdv, DBUS_TYPE_DICT_ENTRY, NULL, &lDBusMsgIterDictStr);
2882  dbus_message_iter_append_basic(&lDBusMsgIterDictStr, DBUS_TYPE_STRING, &key);
2883  dbus_message_iter_open_container(&lDBusMsgIterDictStr, DBUS_TYPE_VARIANT, array_type, &lDBusMsgIterVariant);
2884  dbus_message_iter_open_container(&lDBusMsgIterVariant, DBUS_TYPE_ARRAY, (char *)&type, &lDBusMsgIterSubArray);
2885  for (int index = 0; index < lpstCustomAdv->numSolicitUUID; index++) {
2886  const char *lppui8Props = lpstCustomAdv->SolicitUUID[index];
2887  BTRCORELOG_INFO("Solicit UUID is %s\n", lpstCustomAdv->SolicitUUID[index]);
2888  dbus_message_iter_append_basic(&lDBusMsgIterSubArray, type, &lppui8Props);
2889  }
2890  dbus_message_iter_close_container(&lDBusMsgIterVariant, &lDBusMsgIterSubArray);
2891  dbus_message_iter_close_container(&lDBusMsgIterDictStr, &lDBusMsgIterVariant);
2892  dbus_message_iter_close_container(&lDBusMsgIterDictAdv, &lDBusMsgIterDictStr);
2893  }
2894  }
2895 
2896  {
2897  DBusMessageIter lDBusMsgIterDictStr, lDBusMsgIterArrStr, lDBusMsgIterDictVar, lDBusMsgIterArrVar, lDBusMsgIterVarDict, lDBusMsgIterSubArrStr;
2898  char* key = "ManufacturerData";
2899  int lManfId = lpstCustomAdv->ManfData.ManfID;
2900  int type = DBUS_TYPE_BYTE;
2901 
2902  dbus_message_iter_open_container(&lDBusMsgIterDictAdv, DBUS_TYPE_DICT_ENTRY, NULL, &lDBusMsgIterDictStr);
2903  dbus_message_iter_append_basic(&lDBusMsgIterDictStr, DBUS_TYPE_STRING, &key);
2904  dbus_message_iter_open_container(&lDBusMsgIterDictStr,
2905  DBUS_TYPE_VARIANT,
2906  DBUS_TYPE_ARRAY_AS_STRING
2907  DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
2908  DBUS_TYPE_UINT16_AS_STRING
2909  DBUS_TYPE_VARIANT_AS_STRING
2910  DBUS_DICT_ENTRY_END_CHAR_AS_STRING,
2911  &lDBusMsgIterDictVar);
2912  dbus_message_iter_open_container(&lDBusMsgIterDictVar,
2913  DBUS_TYPE_ARRAY,
2914  DBUS_TYPE_UINT16_AS_STRING
2915  DBUS_TYPE_VARIANT_AS_STRING,
2916  &lDBusMsgIterArrVar);
2917  dbus_message_iter_open_container(&lDBusMsgIterArrVar, DBUS_TYPE_DICT_ENTRY, NULL, &lDBusMsgIterVarDict);
2918  dbus_message_iter_append_basic(&lDBusMsgIterVarDict, DBUS_TYPE_UINT16, &lManfId);
2919  dbus_message_iter_open_container(&lDBusMsgIterVarDict,
2920  DBUS_TYPE_VARIANT,
2921  DBUS_TYPE_ARRAY_AS_STRING
2922  DBUS_TYPE_BYTE_AS_STRING,
2923  &lDBusMsgIterArrStr);
2924  dbus_message_iter_open_container(&lDBusMsgIterArrStr, DBUS_TYPE_ARRAY, (char*)&type, &lDBusMsgIterSubArrStr);
2925 
2926  for (int index = 0; index < lpstCustomAdv->ManfData.lenManfData; index++) {
2927  dbus_message_iter_append_basic(&lDBusMsgIterSubArrStr, DBUS_TYPE_BYTE, &lpstCustomAdv->ManfData.data[index]);
2928  }
2929  dbus_message_iter_close_container(&lDBusMsgIterArrStr, &lDBusMsgIterSubArrStr);
2930  dbus_message_iter_close_container(&lDBusMsgIterVarDict, &lDBusMsgIterArrStr);
2931  dbus_message_iter_close_container(&lDBusMsgIterArrVar, &lDBusMsgIterVarDict);
2932  dbus_message_iter_close_container(&lDBusMsgIterDictVar, &lDBusMsgIterArrVar);
2933  dbus_message_iter_close_container(&lDBusMsgIterDictStr, &lDBusMsgIterDictVar);
2934  dbus_message_iter_close_container(&lDBusMsgIterDictAdv, &lDBusMsgIterDictStr);
2935  }
2936 
2937  {
2938  DBusMessageIter lDBusMsgIterDictBoolPri;
2939  DBusMessageIter lDBusMsgIterValue;
2940  char* key = "IncludeTxPower";
2941  int type = DBUS_TYPE_BOOLEAN;
2942  dbus_bool_t lbTxPower = lpstCustomAdv->bTxPower;
2943 
2944  dbus_message_iter_open_container(&lDBusMsgIterDictAdv, DBUS_TYPE_DICT_ENTRY, NULL, &lDBusMsgIterDictBoolPri);
2945  dbus_message_iter_append_basic (&lDBusMsgIterDictBoolPri, DBUS_TYPE_STRING, &key);
2946  dbus_message_iter_open_container (&lDBusMsgIterDictBoolPri, DBUS_TYPE_VARIANT, (char *)&type, &lDBusMsgIterValue);
2947  dbus_message_iter_append_basic (&lDBusMsgIterValue, type, &lbTxPower);
2948  dbus_message_iter_close_container (&lDBusMsgIterDictBoolPri, &lDBusMsgIterValue);
2949  dbus_message_iter_close_container (&lDBusMsgIterDictAdv, &lDBusMsgIterDictBoolPri);
2950  }
2951  }
2952 
2953  dbus_message_iter_close_container (&lDBusMsgIterAdv, &lDBusMsgIterDictAdv);
2954 
2955  dbus_connection_send(apDBusConn, lpDBusReply, NULL);
2956  dbus_connection_flush(apDBusConn);
2957 
2958  dbus_message_unref(lpDBusReply);
2959 
2960  return 0;
2961 }
2962 
2963 
2964 
2965 /* Interfaces */
2966 void*
2967 BtrCore_BTInitGetConnection (
2968  void
2969 ) {
2970  DBusError lDBusErr;
2971  DBusConnection* lpDBusConn = NULL;
2972  stBtIfceHdl* pstlhBtIfce= NULL;
2973 
2974  dbus_error_init(&lDBusErr);
2975  lpDBusConn = dbus_bus_get(DBUS_BUS_SYSTEM, &lDBusErr);
2976 
2977  if (lpDBusConn == NULL) {
2978  btrCore_BTHandleDusError(&lDBusErr, __LINE__, __FUNCTION__);
2979  return NULL;
2980  }
2981 
2982 
2983  pstlhBtIfce = (stBtIfceHdl*)malloc(sizeof(stBtIfceHdl));
2984  if (!pstlhBtIfce)
2985  return NULL;
2986 
2987 
2988  pstlhBtIfce->pDBusConn = NULL;
2989 
2990  pstlhBtIfce->pcBTAgentPath = NULL;
2991  pstlhBtIfce->pcBTDAdapterPath = NULL;
2992  pstlhBtIfce->pcBTDAdapterAddr = NULL;
2993  pstlhBtIfce->pcBTAdapterPath = NULL;
2994  pstlhBtIfce->pcDevTransportPath = NULL;
2995 
2996  pstlhBtIfce->pcBTOutPassCode = NULL;
2997 
2998  pstlhBtIfce->i32DoReject = 1;
2999 
3000  pstlhBtIfce->ui32cBConnAuthPassKey = 0;
3001  pstlhBtIfce->ui32DevLost = 0;
3002 
3003  pstlhBtIfce->ui32IsAdapterDiscovering = 0;
3004 
3005  memset(pstlhBtIfce->pcBTVersion, '\0', sizeof(char) * BT_MAX_STR_LEN);
3006  memset(pstlhBtIfce->pcDeviceCurrState, '\0', sizeof(char) * BT_MAX_STR_LEN);
3007  memset(pstlhBtIfce->pcLeDeviceCurrState,'\0', sizeof(char) * BT_MAX_STR_LEN);
3008  memset(pstlhBtIfce->pcLeDeviceAddress, '\0', sizeof(char) * BT_MAX_STR_LEN);
3009  memset(pstlhBtIfce->pcMediaCurrState, '\0', sizeof(char) * BT_MAX_STR_LEN);
3010 
3011  memset(&pstlhBtIfce->lstBTAdapterInfo, 0, sizeof(stBTAdapterInfo));
3012  memset(&pstlhBtIfce->lstBTDeviceInfo, 0, sizeof(stBTDeviceInfo));
3013  memset(&pstlhBtIfce->lstBTMediaInfo, 0, sizeof(stBTMediaInfo));
3014 
3015  memset(&pstlhBtIfce->stBTLeGatt, 0, sizeof(stBTLeGattInfo));
3016  memset(&pstlhBtIfce->stBTLeCustAdvt, 0, sizeof(stBTLeCustomAdv));
3017  memset(pstlhBtIfce->pcBTAdapterGattSrvEpPath, '\0', sizeof(char) * BT_MAX_DEV_PATH_LEN);
3018 
3019  strncpy(pstlhBtIfce->pcDeviceCurrState, "disconnected", BT_MAX_STR_LEN - 1);
3020  strncpy(pstlhBtIfce->pcLeDeviceCurrState, "disconnected", BT_MAX_STR_LEN - 1);
3021  strncpy(pstlhBtIfce->pcLeDeviceAddress, "none", BT_MAX_STR_LEN - 1);
3022  strncpy(pstlhBtIfce->pcMediaCurrState, "none", BT_MAX_STR_LEN - 1);
3023 
3024  pstlhBtIfce->pcBAdapterStatusUserData = NULL;
3025  pstlhBtIfce->pcBDevStatusUserData = NULL;
3026  pstlhBtIfce->pcBMediaStatusUserData = NULL;
3027  pstlhBtIfce->pcBNegMediaUserData = NULL;
3028  pstlhBtIfce->pcBTransPathMediaUserData = NULL;
3029  pstlhBtIfce->pcBMediaPlayerPathUserData = NULL;
3030  pstlhBtIfce->pcBConnIntimUserData = NULL;
3031  pstlhBtIfce->pcBConnAuthUserData = NULL;
3032  pstlhBtIfce->pcBLePathUserData = NULL;
3033 
3034  pstlhBtIfce->fpcBAdapterStatusUpdate = NULL;
3035  pstlhBtIfce->fpcBDevStatusUpdate = NULL;
3036  pstlhBtIfce->fpcBMediaStatusUpdate = NULL;
3037  pstlhBtIfce->fpcBNegotiateMedia = NULL;
3038  pstlhBtIfce->fpcBTransportPathMedia = NULL;
3039  pstlhBtIfce->fpcBTMediaPlayerPath = NULL;
3040  pstlhBtIfce->fpcBConnectionIntimation = NULL;
3041  pstlhBtIfce->fpcBConnectionAuthentication = NULL;
3042  pstlhBtIfce->fpcBTLeGattPath = NULL;
3043 
3044 
3045  BTRCORELOG_INFO ("DBus Debug DBus Connection Name %s\n", dbus_bus_get_unique_name (lpDBusConn));
3046  pstlhBtIfce->pDBusConn = lpDBusConn;
3047 
3048 
3049  dbus_bus_add_match(pstlhBtIfce->pDBusConn, "type='signal',sender='" BT_DBUS_BLUEZ_PATH "',interface='" DBUS_INTERFACE_OBJECT_MANAGER "',member='InterfacesAdded'", NULL);
3050  dbus_bus_add_match(pstlhBtIfce->pDBusConn, "type='signal',sender='" BT_DBUS_BLUEZ_PATH "',interface='" DBUS_INTERFACE_OBJECT_MANAGER "',member='InterfacesRemoved'", NULL);
3051  dbus_bus_add_match(pstlhBtIfce->pDBusConn, "type='signal',sender='" BT_DBUS_BLUEZ_PATH "',interface='" DBUS_INTERFACE_PROPERTIES "',member='PropertiesChanged'"",arg0='" BT_DBUS_BLUEZ_ADAPTER_PATH "'", NULL);
3052  dbus_bus_add_match(pstlhBtIfce->pDBusConn, "type='signal',sender='" BT_DBUS_BLUEZ_PATH "',interface='" DBUS_INTERFACE_PROPERTIES "',member='PropertiesChanged'"",arg0='" BT_DBUS_BLUEZ_DEVICE_PATH "'", NULL);
3053  dbus_bus_add_match(pstlhBtIfce->pDBusConn, "type='signal',sender='" BT_DBUS_BLUEZ_PATH "',interface='" DBUS_INTERFACE_PROPERTIES "',member='PropertiesChanged'"",arg0='" BT_DBUS_BLUEZ_MEDIA_TRANSPORT_PATH "'", NULL);
3054  dbus_bus_add_match(pstlhBtIfce->pDBusConn, "type='signal',sender='" BT_DBUS_BLUEZ_PATH "',interface='" DBUS_INTERFACE_PROPERTIES "',member='PropertiesChanged'"",arg0='" BT_DBUS_BLUEZ_MEDIA_CTRL_PATH "'", NULL);
3055  dbus_bus_add_match(pstlhBtIfce->pDBusConn, "type='signal',sender='" BT_DBUS_BLUEZ_PATH "',interface='" DBUS_INTERFACE_PROPERTIES "',member='PropertiesChanged'"",arg0='" BT_DBUS_BLUEZ_MEDIA_PLAYER_PATH "'", NULL);
3056  dbus_bus_add_match(pstlhBtIfce->pDBusConn, "type='signal',sender='" BT_DBUS_BLUEZ_PATH "',interface='" DBUS_INTERFACE_PROPERTIES "',member='PropertiesChanged'"",arg0='" BT_DBUS_BLUEZ_MEDIA_ITEM_PATH "'", NULL);
3057  dbus_bus_add_match(pstlhBtIfce->pDBusConn, "type='signal',sender='" BT_DBUS_BLUEZ_PATH "',interface='" DBUS_INTERFACE_PROPERTIES "',member='PropertiesChanged'"",arg0='" BT_DBUS_BLUEZ_MEDIA_FOLDER_PATH "'", NULL);
3058  dbus_bus_add_match(pstlhBtIfce->pDBusConn, "type='signal',sender='" BT_DBUS_BLUEZ_PATH "',interface='" DBUS_INTERFACE_PROPERTIES "',member='PropertiesChanged'"",arg0='" BT_DBUS_BLUEZ_LE_ADV_PATH "'", NULL);
3059  dbus_bus_add_match(pstlhBtIfce->pDBusConn, "type='signal',sender='" BT_DBUS_BLUEZ_PATH "',interface='" DBUS_INTERFACE_PROPERTIES "',member='PropertiesChanged'"",arg0='" BT_DBUS_BLUEZ_GATT_SERVICE_PATH"'", NULL);
3060  dbus_bus_add_match(pstlhBtIfce->pDBusConn, "type='signal',sender='" BT_DBUS_BLUEZ_PATH "',interface='" DBUS_INTERFACE_PROPERTIES "',member='PropertiesChanged'"",arg0='" BT_DBUS_BLUEZ_GATT_CHAR_PATH "'", NULL);
3061  dbus_bus_add_match(pstlhBtIfce->pDBusConn, "type='signal',sender='" BT_DBUS_BLUEZ_PATH "',interface='" DBUS_INTERFACE_PROPERTIES "',member='PropertiesChanged'"",arg0='" BT_DBUS_BLUEZ_GATT_DESCRIPTOR_PATH "'", NULL);
3062 
3063 
3064  if (!dbus_connection_add_filter(pstlhBtIfce->pDBusConn, btrCore_BTDBusConnectionFilterCb, pstlhBtIfce, NULL)) {
3065  BTRCORELOG_ERROR ("Can't add signal filter - BtrCore_BTInitGetConnection\n");
3066  BtrCore_BTDeInitReleaseConnection((void*)pstlhBtIfce);
3067  return NULL;
3068  }
3069 
3070  return (void*)pstlhBtIfce;
3071 }
3072 
3073 
3074 int
3075 BtrCore_BTDeInitReleaseConnection (
3076  void* apstBtIfceHdl
3077 ) {
3078  stBtIfceHdl* pstlhBtIfce = (stBtIfceHdl*)apstBtIfceHdl;
3079 
3080  if (!apstBtIfceHdl)
3081  return -1;
3082 
3083  dbus_connection_remove_filter(pstlhBtIfce->pDBusConn, btrCore_BTDBusConnectionFilterCb, pstlhBtIfce);
3084 
3085  dbus_bus_remove_match(pstlhBtIfce->pDBusConn, "type='signal',sender='" BT_DBUS_BLUEZ_PATH "',interface='" DBUS_INTERFACE_PROPERTIES "',member='PropertiesChanged'"",arg0='" BT_DBUS_BLUEZ_GATT_DESCRIPTOR_PATH "'", NULL);
3086  dbus_bus_remove_match(pstlhBtIfce->pDBusConn, "type='signal',sender='" BT_DBUS_BLUEZ_PATH "',interface='" DBUS_INTERFACE_PROPERTIES "',member='PropertiesChanged'"",arg0='" BT_DBUS_BLUEZ_GATT_CHAR_PATH "'", NULL);
3087  dbus_bus_remove_match(pstlhBtIfce->pDBusConn, "type='signal',sender='" BT_DBUS_BLUEZ_PATH "',interface='" DBUS_INTERFACE_PROPERTIES "',member='PropertiesChanged'"",arg0='" BT_DBUS_BLUEZ_GATT_SERVICE_PATH"'", NULL);
3088  dbus_bus_remove_match(pstlhBtIfce->pDBusConn, "type='signal',sender='" BT_DBUS_BLUEZ_PATH "',interface='" DBUS_INTERFACE_PROPERTIES "',member='PropertiesChanged'"",arg0='" BT_DBUS_BLUEZ_LE_ADV_PATH "'", NULL);
3089  dbus_bus_remove_match(pstlhBtIfce->pDBusConn, "type='signal',sender='" BT_DBUS_BLUEZ_PATH "',interface='" DBUS_INTERFACE_PROPERTIES "',member='PropertiesChanged'"",arg0='" BT_DBUS_BLUEZ_MEDIA_FOLDER_PATH "'", NULL);
3090  dbus_bus_remove_match(pstlhBtIfce->pDBusConn, "type='signal',sender='" BT_DBUS_BLUEZ_PATH "',interface='" DBUS_INTERFACE_PROPERTIES "',member='PropertiesChanged'"",arg0='" BT_DBUS_BLUEZ_MEDIA_ITEM_PATH "'", NULL);
3091  dbus_bus_remove_match(pstlhBtIfce->pDBusConn, "type='signal',sender='" BT_DBUS_BLUEZ_PATH "',interface='" DBUS_INTERFACE_PROPERTIES "',member='PropertiesChanged'"",arg0='" BT_DBUS_BLUEZ_MEDIA_PLAYER_PATH "'", NULL);
3092  dbus_bus_remove_match(pstlhBtIfce->pDBusConn, "type='signal',sender='" BT_DBUS_BLUEZ_PATH "',interface='" DBUS_INTERFACE_PROPERTIES "',member='PropertiesChanged'"",arg0='" BT_DBUS_BLUEZ_MEDIA_CTRL_PATH "'", NULL);
3093  dbus_bus_remove_match(pstlhBtIfce->pDBusConn, "type='signal',sender='" BT_DBUS_BLUEZ_PATH "',interface='" DBUS_INTERFACE_PROPERTIES "',member='PropertiesChanged'"",arg0='" BT_DBUS_BLUEZ_MEDIA_TRANSPORT_PATH "'", NULL);
3094  dbus_bus_remove_match(pstlhBtIfce->pDBusConn, "type='signal',sender='" BT_DBUS_BLUEZ_PATH "',interface='" DBUS_INTERFACE_PROPERTIES "',member='PropertiesChanged'"",arg0='" BT_DBUS_BLUEZ_DEVICE_PATH "'", NULL);
3095  dbus_bus_remove_match(pstlhBtIfce->pDBusConn, "type='signal',sender='" BT_DBUS_BLUEZ_PATH "',interface='" DBUS_INTERFACE_PROPERTIES "',member='PropertiesChanged'"",arg0='" BT_DBUS_BLUEZ_ADAPTER_PATH "'", NULL);
3096  dbus_bus_remove_match(pstlhBtIfce->pDBusConn, "type='signal',sender='" BT_DBUS_BLUEZ_PATH "',interface='" DBUS_INTERFACE_OBJECT_MANAGER "',member='InterfacesRemoved'", NULL);
3097  dbus_bus_remove_match(pstlhBtIfce->pDBusConn, "type='signal',sender='" BT_DBUS_BLUEZ_PATH "',interface='" DBUS_INTERFACE_OBJECT_MANAGER "',member='InterfacesAdded'", NULL);
3098 
3099  if (pstlhBtIfce->pcBTAgentPath) {
3100  free(pstlhBtIfce->pcBTAgentPath);
3101  pstlhBtIfce->pcBTAgentPath = NULL;
3102  }
3103 
3104  if (pstlhBtIfce->pcBTDAdapterAddr) {
3105  free(pstlhBtIfce->pcBTDAdapterAddr);
3106  pstlhBtIfce->pcBTDAdapterAddr = NULL;
3107  }
3108 
3109  if (pstlhBtIfce->pcBTDAdapterPath) {
3110  free(pstlhBtIfce->pcBTDAdapterPath);
3111  pstlhBtIfce->pcBTDAdapterPath = NULL;
3112  }
3113 
3114  if (pstlhBtIfce->pcBTAdapterPath) {
3115  free(pstlhBtIfce->pcBTAdapterPath);
3116  pstlhBtIfce->pcBTAdapterPath = NULL;
3117  }
3118 
3119 
3120  pstlhBtIfce->pcBLePathUserData = NULL;
3121  pstlhBtIfce->pcBConnAuthUserData = NULL;
3122  pstlhBtIfce->pcBConnIntimUserData = NULL;
3123  pstlhBtIfce->pcBMediaPlayerPathUserData = NULL;
3124  pstlhBtIfce->pcBTransPathMediaUserData = NULL;
3125  pstlhBtIfce->pcBNegMediaUserData = NULL;
3126  pstlhBtIfce->pcBMediaStatusUserData = NULL;
3127  pstlhBtIfce->pcBDevStatusUserData = NULL;
3128  pstlhBtIfce->pcBAdapterStatusUserData = NULL;
3129 
3130 
3131  pstlhBtIfce->fpcBTLeGattPath = NULL;
3132  pstlhBtIfce->fpcBConnectionAuthentication = NULL;
3133  pstlhBtIfce->fpcBConnectionIntimation = NULL;
3134  pstlhBtIfce->fpcBTMediaPlayerPath = NULL;
3135  pstlhBtIfce->fpcBTransportPathMedia = NULL;
3136  pstlhBtIfce->fpcBNegotiateMedia = NULL;
3137  pstlhBtIfce->fpcBMediaStatusUpdate = NULL;
3138  pstlhBtIfce->fpcBDevStatusUpdate = NULL;
3139  pstlhBtIfce->fpcBAdapterStatusUpdate = NULL;
3140 
3141 
3142  pstlhBtIfce->ui32IsAdapterDiscovering = 0;
3143  pstlhBtIfce->ui32DevLost = 0;
3144  pstlhBtIfce->ui32cBConnAuthPassKey = 0;
3145  pstlhBtIfce->i32DoReject = 0;
3146 
3147 
3148  pstlhBtIfce->pDBusConn = NULL;
3149 
3150  free(pstlhBtIfce);
3151  pstlhBtIfce = NULL;
3152 
3153 
3154  return 0;
3155 }
3156 
3157 
3158 char*
3159 BtrCore_BTGetAgentPath (
3160  void* apstBtIfceHdl
3161 ) {
3162  stBtIfceHdl* pstlhBtIfce = (stBtIfceHdl*)apstBtIfceHdl;
3163  char lDefaultBTPath[BT_MAX_DEV_PATH_LEN] = {'\0'};
3164 
3165  if (!apstBtIfceHdl)
3166  return NULL;
3167 
3168 
3169  snprintf(lDefaultBTPath, sizeof(lDefaultBTPath), "/org/bluez/agent_%d", getpid());
3170 
3171  if (pstlhBtIfce->pcBTAgentPath) {
3172  free(pstlhBtIfce->pcBTAgentPath);
3173  pstlhBtIfce->pcBTAgentPath = NULL;
3174  }
3175 
3176  pstlhBtIfce->pcBTAgentPath = strdup(lDefaultBTPath);
3177  BTRCORELOG_INFO ("Agent Path: %s\n", pstlhBtIfce->pcBTAgentPath);
3178  return pstlhBtIfce->pcBTAgentPath;
3179 }
3180 
3181 
3182 int
3183 BtrCore_BTReleaseAgentPath (
3184  void* apstBtIfceHdl
3185 ) {
3186  stBtIfceHdl* pstlhBtIfce = (stBtIfceHdl*)apstBtIfceHdl;
3187 
3188  if (!apstBtIfceHdl)
3189  return -1;
3190 
3191 
3192  if (pstlhBtIfce->pcBTAgentPath) {
3193  free(pstlhBtIfce->pcBTAgentPath);
3194  pstlhBtIfce->pcBTAgentPath = NULL;
3195  }
3196 
3197  return 0;
3198 }
3199 
3200 
3201 int
3202 BtrCore_BTRegisterAgent (
3203  void* apstBtIfceHdl,
3204  const char* apBtAdapter,
3205  const char* apBtAgentPath,
3206  const char* capabilities
3207 ) {
3208  stBtIfceHdl* pstlhBtIfce = (stBtIfceHdl*)apstBtIfceHdl;
3209  DBusMessage* lpDBusMsg = NULL;
3210  DBusMessage* lpDBusReply = NULL;
3211  DBusError lDBusErr;
3212  dbus_bool_t lDBusOp;
3213 
3214  if (!apstBtIfceHdl)
3215  return -1;
3216 
3217  dbus_error_init(&lDBusErr);
3218  lDBusOp = dbus_connection_try_register_object_path(pstlhBtIfce->pDBusConn, apBtAgentPath, &gDBusAgentVTable, pstlhBtIfce, &lDBusErr);
3219  if (!lDBusOp) {
3220  btrCore_BTHandleDusError(&lDBusErr, __LINE__, __FUNCTION__);
3221  BTRCORELOG_ERROR ("Error registering object path for agent - %s\n", apBtAgentPath);
3222 
3223  if (strcmp(lDBusErr.name, DBUS_ERROR_OBJECT_PATH_IN_USE) != 0)
3224  return -1;
3225  }
3226 
3227  lpDBusMsg = dbus_message_new_method_call(BT_DBUS_BLUEZ_PATH,
3228  "/org/bluez",
3229  BT_DBUS_BLUEZ_AGENT_MGR_PATH,
3230  "RegisterAgent");
3231  if (!lpDBusMsg) {
3232  BTRCORELOG_ERROR ("Error allocating new method call\n");
3233  return -1;
3234  }
3235 
3236  dbus_message_append_args(lpDBusMsg, DBUS_TYPE_OBJECT_PATH, &apBtAgentPath, DBUS_TYPE_STRING, &capabilities, DBUS_TYPE_INVALID);
3237 
3238 
3239  dbus_error_init(&lDBusErr);
3240  lpDBusReply = dbus_connection_send_with_reply_and_block(pstlhBtIfce->pDBusConn, lpDBusMsg, -1, &lDBusErr);
3241  dbus_message_unref(lpDBusMsg);
3242 
3243  if (!lpDBusReply) {
3244  BTRCORELOG_ERROR ("Unable to register agent\n");
3245  btrCore_BTHandleDusError(&lDBusErr, __LINE__, __FUNCTION__);
3246  return -1;
3247  }
3248 
3249  dbus_message_unref(lpDBusReply);
3250 
3251  dbus_connection_flush(pstlhBtIfce->pDBusConn);
3252 
3253  lpDBusMsg = dbus_message_new_method_call(BT_DBUS_BLUEZ_PATH,
3254  "/org/bluez",
3255  BT_DBUS_BLUEZ_AGENT_MGR_PATH,
3256  "RequestDefaultAgent");
3257  if (!lpDBusMsg) {
3258  BTRCORELOG_ERROR ("Can't allocate new method call\n");
3259  return -1;
3260  }
3261 
3262  dbus_message_append_args(lpDBusMsg, DBUS_TYPE_OBJECT_PATH, &apBtAgentPath, DBUS_TYPE_INVALID);
3263 
3264 
3265  dbus_error_init(&lDBusErr);
3266  lpDBusReply = dbus_connection_send_with_reply_and_block(pstlhBtIfce->pDBusConn, lpDBusMsg, -1, &lDBusErr);
3267  dbus_message_unref(lpDBusMsg);
3268 
3269  if (!lpDBusReply) {
3270  BTRCORELOG_ERROR ("Can't unregister agent\n");
3271  btrCore_BTHandleDusError(&lDBusErr, __LINE__, __FUNCTION__);
3272  return -1;//this was an error case
3273  }
3274 
3275  dbus_message_unref(lpDBusReply);
3276 
3277  dbus_connection_flush(pstlhBtIfce->pDBusConn);
3278 
3279  return 0;
3280 }
3281 
3282 
3283 int
3284 BtrCore_BTUnregisterAgent (
3285  void* apstBtIfceHdl,
3286  const char* apBtAdapter,
3287  const char* apBtAgentPath
3288 ) {
3289  stBtIfceHdl* pstlhBtIfce = (stBtIfceHdl*)apstBtIfceHdl;
3290  DBusMessage* lpDBusMsg = NULL;
3291  DBusMessage* lpDBusReply = NULL;
3292  DBusError lDBusErr;
3293 
3294  if (!apstBtIfceHdl)
3295  return -1;
3296 
3297 
3298  lpDBusMsg = dbus_message_new_method_call(BT_DBUS_BLUEZ_PATH,
3299  "/org/bluez",
3300  BT_DBUS_BLUEZ_AGENT_MGR_PATH,
3301  "UnregisterAgent");
3302  if (!lpDBusMsg) {
3303  BTRCORELOG_ERROR ("Can't allocate new method call\n");
3304  return -1;
3305  }
3306 
3307  dbus_message_append_args(lpDBusMsg, DBUS_TYPE_OBJECT_PATH, &apBtAgentPath, DBUS_TYPE_INVALID);
3308 
3309 
3310  dbus_error_init(&lDBusErr);
3311  lpDBusReply = dbus_connection_send_with_reply_and_block(pstlhBtIfce->pDBusConn, lpDBusMsg, -1, &lDBusErr);
3312  dbus_message_unref(lpDBusMsg);
3313 
3314  if (!lpDBusReply) {
3315  BTRCORELOG_ERROR ("Can't unregister agent\n");
3316  btrCore_BTHandleDusError(&lDBusErr, __LINE__, __FUNCTION__);
3317  return -1;//this was an error case
3318  }
3319 
3320  dbus_message_unref(lpDBusReply);
3321 
3322  dbus_connection_flush(pstlhBtIfce->pDBusConn);
3323 
3324  if (!dbus_connection_unregister_object_path(pstlhBtIfce->pDBusConn, apBtAgentPath)) {
3325  BTRCORELOG_ERROR ("Error unregistering object path for agent\n");
3326  return -1;
3327  }
3328 
3329  /* UnregisterAgent in bluez5.54 internal it is setting Pairable false.
3330  * due to this pairing is failing, to avoid this implicitly setting
3331  * Pairable true here */
3332  if (!strncmp(pstlhBtIfce->pcBTVersion, BT_BLUEZ_VERSION_5_54, strlen(BT_BLUEZ_VERSION_5_54)) || !strncmp(pstlhBtIfce->pcBTVersion, BT_BLUEZ_VERSION_5_48, strlen(BT_BLUEZ_VERSION_5_48)) )
3333  {
3334  unBTOpIfceProp lunBtOpAdapProp;
3335  int isPairable = 1;
3336  lunBtOpAdapProp.enBtAdapterProp = enBTAdPropPairable;
3337  if (BtrCore_BTSetProp(apstBtIfceHdl, apBtAdapter, enBTAdapter, lunBtOpAdapProp, &isPairable)) {
3338  BTRCORELOG_ERROR ("Set Adapter Property enBTAdPropPairable - FAILED\n");
3339  return -1;
3340  }
3341  }
3342 
3343  return 0;
3344 }
3345 
3346 
3347 int
3348 BtrCore_BTGetAdapterList (
3349  void* apstBtIfceHdl,
3350  unsigned int* apBtNumAdapters,
3351  char* apcArrBtAdapterPath[BT_MAX_NUM_ADAPTERS]
3352 ) {
3353  stBtIfceHdl* pstlhBtIfce = (stBtIfceHdl*)apstBtIfceHdl;
3354  int c;
3355  int rc = -1;
3356  int a = 0;
3357  int b = 0;
3358  int d = 0;
3359  int num = -1;
3360  int index = 0;
3361  char paths[BT_MAX_NUM_ADAPTERS][BT_MAX_DEV_PATH_LEN] = {'\0'};
3362  //char **paths2 = NULL;
3363 
3364  DBusMessage* lpDBusReply = NULL;
3365  DBusMessageIter rootIter;
3366  bool adapterFound = FALSE;
3367  char* adapter_path;
3368  char* dbusObject2;
3369  char objectPath[BT_MAX_DEV_PATH_LEN] = {'\0'};
3370  char objectData[BT_MAX_DEV_PATH_LEN] = {'\0'};
3371 
3372  if (!apstBtIfceHdl)
3373  return -1;
3374 
3375 
3376  lpDBusReply = btrCore_BTSendMethodCall(pstlhBtIfce->pDBusConn, "/", DBUS_INTERFACE_OBJECT_MANAGER, "GetManagedObjects");
3377  if (!lpDBusReply) {
3378  BTRCORELOG_ERROR ("org.bluez.Manager.ListAdapters returned an error\n");
3379  return rc;
3380  }
3381 
3382 
3383  for (index = 0; index < BT_MAX_NUM_ADAPTERS; index++)
3384  memset (&paths[index], '\0', BT_MAX_DEV_PATH_LEN);
3385 
3386  memset(objectPath, '\0', BT_MAX_DEV_PATH_LEN);
3387  memset(objectData, '\0', BT_MAX_DEV_PATH_LEN);
3388 
3389 
3390  if (dbus_message_iter_init(lpDBusReply, &rootIter) && //point iterator to lpDBusReply message
3391  DBUS_TYPE_ARRAY == dbus_message_iter_get_arg_type(&rootIter)) { //get the type of message that iter points to
3392 
3393  DBusMessageIter arrayElementIter;
3394  dbus_message_iter_recurse(&rootIter, &arrayElementIter); //assign new iterator to first element of array
3395 
3396  while (!adapterFound) {
3397  if (DBUS_TYPE_DICT_ENTRY == dbus_message_iter_get_arg_type(&arrayElementIter)) {
3398 
3399  DBusMessageIter dictEntryIter;
3400  dbus_message_iter_recurse(&arrayElementIter,&dictEntryIter ); //assign new iterator to first element of (get all dict entries of 1st level (all object paths)
3401 
3402  if (DBUS_TYPE_OBJECT_PATH == dbus_message_iter_get_arg_type(&dictEntryIter)) {
3403  dbus_message_iter_get_basic(&dictEntryIter, &adapter_path);
3404  strncpy(objectPath, adapter_path, (strlen(adapter_path) < BT_MAX_DEV_PATH_LEN) ? strlen(adapter_path) : BT_MAX_DEV_PATH_LEN - 1);
3405  ++a;
3406  }
3407 
3408  dbus_message_iter_next(&dictEntryIter);
3409  if (DBUS_TYPE_ARRAY == dbus_message_iter_get_arg_type(&dictEntryIter)) {
3410  DBusMessageIter innerArrayIter;
3411  dbus_message_iter_recurse(&dictEntryIter, &innerArrayIter);
3412 
3413  while (dbus_message_iter_has_next(&innerArrayIter) && (d < BT_MAX_NUM_ADAPTERS)) {
3414  if (DBUS_TYPE_DICT_ENTRY == dbus_message_iter_get_arg_type(&innerArrayIter)) {
3415  DBusMessageIter innerDictEntryIter;
3416  dbus_message_iter_recurse(&innerArrayIter,&innerDictEntryIter ); //assign new iterator to first element of
3417 
3418  if (DBUS_TYPE_STRING == dbus_message_iter_get_arg_type(&innerDictEntryIter)) {
3419  char *dbusObject;
3420  dbus_message_iter_get_basic(&innerDictEntryIter, &dbusObject);
3421 
3422  ////// getting all bluetooth adapters object paths //////
3423 
3424  if (strcmp(dbusObject, BT_DBUS_BLUEZ_ADAPTER_PATH) == 0) {
3425  strncpy(&paths[d][0], adapter_path, (strlen(adapter_path) < BT_MAX_DEV_PATH_LEN) ? strlen(adapter_path) : BT_MAX_DEV_PATH_LEN - 1);
3426  //strcpy(paths2+d,adapter_path);
3427  //paths2[d] = strdup(adapter_path);
3428  //BTRCORELOG_ERROR ("\n\n test");
3429  //(paths2+2) = strdup(adapter_path);
3430  ++d;
3431  }
3432  }
3433 
3434  /////// NEW //////////
3435  dbus_message_iter_next(&innerDictEntryIter);
3436  if (DBUS_TYPE_ARRAY == dbus_message_iter_get_arg_type(&innerDictEntryIter)) {
3437  DBusMessageIter innerArrayIter2;
3438  dbus_message_iter_recurse(&innerDictEntryIter, &innerArrayIter2);
3439 
3440  while (dbus_message_iter_has_next(&innerArrayIter2)) {
3441 
3442  if (DBUS_TYPE_DICT_ENTRY == dbus_message_iter_get_arg_type(&innerArrayIter2)) {
3443  DBusMessageIter innerDictEntryIter2;
3444  dbus_message_iter_recurse(&innerArrayIter2,&innerDictEntryIter2); //assign new iterator to first element of
3445 
3446  if (DBUS_TYPE_STRING == dbus_message_iter_get_arg_type(&innerDictEntryIter2)) {
3447  dbus_message_iter_get_basic(&innerDictEntryIter2, &dbusObject2);
3448  }
3449 
3450  ////////////// NEW 2 ////////////
3451  dbus_message_iter_next(&innerDictEntryIter2);
3452  DBusMessageIter innerDictEntryIter3;
3453  char *dbusObject3;
3454 
3455  dbus_message_iter_recurse(&innerDictEntryIter2,&innerDictEntryIter3);
3456  if (DBUS_TYPE_STRING == dbus_message_iter_get_arg_type(&innerDictEntryIter3)) {
3457  dbus_message_iter_get_basic(&innerDictEntryIter3, &dbusObject3);
3458  memset(objectData, '\0', BT_MAX_DEV_PATH_LEN);
3459  strncpy(objectData, dbusObject3, (strlen(dbusObject3) < BT_MAX_DEV_PATH_LEN) ? strlen(dbusObject3) : BT_MAX_DEV_PATH_LEN - 1);
3460  ++b;
3461  }
3462  else if (DBUS_TYPE_BOOLEAN == dbus_message_iter_get_arg_type(&innerDictEntryIter3)) {
3463  bool *device_prop = FALSE;
3464  dbus_message_iter_get_basic(&innerDictEntryIter3, &device_prop);
3465  }
3466  }
3467 
3468  if (!dbus_message_iter_has_next(&innerArrayIter2)) {
3469  break; //check to see if end of 3rd array
3470  }
3471  else {
3472  dbus_message_iter_next(&innerArrayIter2);
3473  }
3474  }
3475  }
3476  }
3477 
3478  if (!dbus_message_iter_has_next(&innerArrayIter)) {
3479  break; //check to see if end of 2nd array
3480  }
3481  else {
3482  dbus_message_iter_next(&innerArrayIter);
3483  }
3484  }
3485  }
3486 
3487  if (!dbus_message_iter_has_next(&arrayElementIter)) {
3488  break; //check to see if end of 1st array
3489  }
3490  else {
3491  dbus_message_iter_next(&arrayElementIter);
3492  }
3493  } //while loop end --used to traverse array
3494  }
3495  }
3496 
3497  num = d;
3498  if (apBtNumAdapters && apcArrBtAdapterPath) {
3499  *apBtNumAdapters = num;
3500 
3501  for (c = 0; c < num; c++) {
3502  if (apcArrBtAdapterPath[c]) {
3503  if (*(apcArrBtAdapterPath[c]) == '\0') {
3504  BTRCORELOG_DEBUG ("Adapter Path %d is: %s\n", c, &paths[c][0]);
3505  strncpy(apcArrBtAdapterPath[c], &paths[c][0], (strlen(&paths[c][0]) < BT_MAX_DEV_PATH_LEN) ? strlen(&paths[c][0]) : BT_MAX_DEV_PATH_LEN - 1);
3506  rc = 0;
3507  }
3508  else {
3509  BTRCORELOG_DEBUG ("Adapter Path %d is: %s\n", c, &paths[c][0]);
3510  BTRCORELOG_DEBUG ("Existing Adapter Path is: %s\n", apcArrBtAdapterPath[c]);
3511  rc = 0;
3512  }
3513  }
3514  }
3515  }
3516 
3517  dbus_message_unref(lpDBusReply);
3518 
3519  return rc;
3520 }
3521 
3522 
3523 char*
3524 BtrCore_BTGetAdapterPath (
3525  void* apstBtIfceHdl,
3526  const char* apBtAdapter
3527 ) {
3528  stBtIfceHdl* pstlhBtIfce = (stBtIfceHdl*)apstBtIfceHdl;
3529  char* pui8DefAdapterPath = NULL;
3530  char* pui8AdapterPath1 = "/org/bluez/hci0";
3531  char* pui8AdapterPath2 = "/org/bluez/hci1";
3532  char* pui8AdapterPath3 = "/org/bluez/hci2";
3533  char* bt1 = "hci0";
3534  char* bt2 = "hci1";
3535  char* bt3 = "hci2";
3536 
3537  if (!apstBtIfceHdl)
3538  return NULL;
3539 
3540 
3541  if (!apBtAdapter) {
3542  if (!pstlhBtIfce->pcBTAdapterPath && ((pui8DefAdapterPath = btrCore_BTGetDefaultAdapterPath(pstlhBtIfce)) != NULL)) {
3543  BTRCORELOG_WARN ("Got Default Adapter Path is : %s - %p\n", pui8DefAdapterPath, pui8DefAdapterPath);
3544  pstlhBtIfce->pcBTAdapterPath = strndup(pui8DefAdapterPath, strlen(pui8DefAdapterPath));
3545  }
3546  }
3547  else if (strcmp(apBtAdapter, bt1) == 0) {
3548  if (!pstlhBtIfce->pcBTAdapterPath) {
3549  pstlhBtIfce->pcBTAdapterPath = strndup(pui8AdapterPath1, strlen(pui8AdapterPath1));
3550  }
3551  }
3552  else if (strcmp(apBtAdapter, bt2) == 0) {
3553  if (!pstlhBtIfce->pcBTAdapterPath) {
3554  pstlhBtIfce->pcBTAdapterPath = strndup(pui8AdapterPath2, strlen(pui8AdapterPath2));
3555  }
3556  }
3557  else if (strcmp(apBtAdapter, bt3) == 0) {
3558  if (!pstlhBtIfce->pcBTAdapterPath) {
3559  pstlhBtIfce->pcBTAdapterPath = strndup(pui8AdapterPath3, strlen(pui8AdapterPath3));
3560  }
3561  }
3562  else {
3563  if (!pstlhBtIfce->pcBTAdapterPath && ((pui8DefAdapterPath = btrCore_BTGetDefaultAdapterPath(pstlhBtIfce)) != NULL)) {
3564  pstlhBtIfce->pcBTAdapterPath = strndup(pui8DefAdapterPath, strlen(pui8DefAdapterPath));
3565  }
3566  }
3567 
3568 
3569  BTRCORELOG_WARN ("Adapter Path is : %s - %p\n", pstlhBtIfce->pcBTAdapterPath, pstlhBtIfce->pcBTAdapterPath);
3570  return pstlhBtIfce->pcBTAdapterPath;
3571 }
3572 
3573 
3574 int
3575 BtrCore_BTReleaseAdapterPath (
3576  void* apstBtIfceHdl,
3577  const char* apBtAdapter
3578 ) {
3579  stBtIfceHdl* pstlhBtIfce = (stBtIfceHdl*)apstBtIfceHdl;
3580 
3581  if (!apstBtIfceHdl)
3582  return -1;
3583 
3584 
3585  if (!apBtAdapter) {
3586  btrCore_BTReleaseDefaultAdapterPath(pstlhBtIfce);
3587  }
3588 
3589  if (pstlhBtIfce->pcBTAdapterPath) {
3590 
3591  BTRCORELOG_WARN ("Adapter Path is : %s - %p\n", pstlhBtIfce->pcBTAdapterPath, pstlhBtIfce->pcBTAdapterPath);
3592  if (pstlhBtIfce->pcBTAdapterPath != apBtAdapter) {
3593  BTRCORELOG_ERROR ("ERROR: Looks like Adapter path has been changed by User\n");
3594  }
3595 
3596  free(pstlhBtIfce->pcBTAdapterPath);
3597  pstlhBtIfce->pcBTAdapterPath = NULL;
3598  }
3599 
3600  BTRCORELOG_WARN ("Freed Adapter\n");
3601 
3602  return 0;
3603 }
3604 
3605 
3606 int
3607 BtrCore_BTGetIfceNameVersion (
3608  void* apstBtIfceHdl,
3609  char* apBtOutIfceName,
3610  char* apBtOutVersion
3611 ) {
3612  stBtIfceHdl* pstlhBtIfce = (stBtIfceHdl*)apstBtIfceHdl;
3613  FILE* lfpVersion = NULL;
3614  char lcpVersion[BT_MAX_STR_LEN] = {'\0'};
3615 
3616  if (!apstBtIfceHdl || !apBtOutIfceName || !apBtOutVersion)
3617  return -1;
3618 
3619 
3620  (void)pstlhBtIfce;
3621 
3622  /* strncpy() throws format truncation error on gcc 9.x when same length of src string
3623  is given in 3rd argument. Also, strncpy() will fill null terminating characters if
3624  3rd argument length is more than the length of src string
3625  */
3626  lfpVersion = popen("/usr/lib/bluez5/bluetooth/bluetoothd --version", "r");
3627  if ((lfpVersion == NULL)) {
3628  BTRCORELOG_ERROR ("Failed to run Version command\n");
3629  strncpy(lcpVersion, "5.XXX", strlen("5.XXX") + 1);
3630  }
3631  else {
3632  do {
3633  if (fgets(lcpVersion, sizeof(lcpVersion)-1, lfpVersion) == NULL) {
3634  BTRCORELOG_ERROR ("Failed to Valid Version\n");
3635  strncpy(lcpVersion, "5.XXX", sizeof(lcpVersion));
3636  lcpVersion[sizeof(lcpVersion) - 1] = '\0';
3637  }
3638  } while (strstr(lcpVersion, "breakpad") || strstr(lcpVersion, "Breakpad"));
3639 
3640  pclose(lfpVersion);
3641  }
3642 
3643 
3644  strncpy(apBtOutIfceName, "Bluez", strlen("Bluez") + 1);
3645  strncpy(apBtOutVersion, lcpVersion, strlen(lcpVersion) + 1);
3646  strncpy(pstlhBtIfce->pcBTVersion, lcpVersion, strlen(lcpVersion));
3647 
3648  BTRCORELOG_WARN ("Bluez Version - %s\n", apBtOutVersion);
3649 
3650  return 0;
3651 }
3652 
3653 
3654 int
3655 BtrCore_BTGetProp (
3656  void* apstBtIfceHdl,
3657  const char* apcBtOpIfcePath,
3658  enBTOpIfceType aenBtOpIfceType,
3659  unBTOpIfceProp aunBtOpIfceProp,
3660  void* apvVal
3661 ) {
3662  stBtIfceHdl* pstlhBtIfce = (stBtIfceHdl*)apstBtIfceHdl;
3663  int rc = 0;
3664 
3665  DBusMessage* lpDBusMsg = NULL;
3666  DBusMessage* lpDBusReply = NULL;
3667  DBusPendingCall* lpDBusPendC = NULL;
3668  DBusMessageIter arg_i;
3669  DBusMessageIter element_i;
3670  DBusMessageIter variant_i;
3671  DBusError lDBusErr;
3672 
3673  const char* pParsedKey = NULL;
3674  const char* pParsedValueString = NULL;
3675  int parsedValueNumber = 0;
3676  unsigned int parsedValueUnsignedNumber = 0;
3677  unsigned short parsedValueUnsignedShort = 0;
3678 
3679  const char* lDBusKey = NULL;
3680  int lDBusType = DBUS_TYPE_INVALID;
3681  int i32StoreDefAdpAddr = 0;
3682 
3683  const char* pInterface = NULL;
3684  const char* pAdapterInterface = BT_DBUS_BLUEZ_ADAPTER_PATH;
3685  const char* pDeviceInterface = BT_DBUS_BLUEZ_DEVICE_PATH;
3686  const char* pMediaTransInterface = BT_DBUS_BLUEZ_MEDIA_TRANSPORT_PATH;
3687  const char* pGattServiceInterface = BT_DBUS_BLUEZ_GATT_SERVICE_PATH;
3688  const char* pGattCharInterface = BT_DBUS_BLUEZ_GATT_CHAR_PATH;
3689  const char* pGattDescInterface = BT_DBUS_BLUEZ_GATT_DESCRIPTOR_PATH;
3690 
3691  if (!apstBtIfceHdl)
3692  return -1;
3693 
3694 
3695  if ((!apcBtOpIfcePath) || (!apvVal)) {
3696  BTRCORELOG_ERROR ("enBTRCoreInvalidArg - enBTRCoreInitFailure\n");
3697  return -1;
3698  }
3699 
3700 
3701  switch (aenBtOpIfceType) {
3702  case enBTAdapter:
3703  pInterface = pAdapterInterface;
3704  switch (aunBtOpIfceProp.enBtAdapterProp) {
3705  case enBTAdPropName:
3706  lDBusType = DBUS_TYPE_STRING;
3707  lDBusKey = "Alias";
3708  break;
3709  case enBTAdPropAddress:
3710  lDBusType = DBUS_TYPE_STRING;
3711  lDBusKey = "Address";
3712  if (!strncmp(apcBtOpIfcePath, pstlhBtIfce->pcBTDAdapterPath, strlen(pstlhBtIfce->pcBTDAdapterPath))) {
3713  i32StoreDefAdpAddr = 1;
3714  }
3715  break;
3716  case enBTAdPropPowered:
3717  lDBusType = DBUS_TYPE_BOOLEAN;
3718  lDBusKey = "Powered";
3719  break;
3720  case enBTAdPropDiscoverable:
3721  lDBusType = DBUS_TYPE_BOOLEAN;
3722  lDBusKey = "Discoverable";
3723  break;
3724  case enBTAdPropDiscoverableTimeOut:
3725  lDBusType = DBUS_TYPE_UINT32;
3726  lDBusKey = "DiscoverableTimeout";
3727  break;
3728  case enBTAdPropPairable:
3729  lDBusType = DBUS_TYPE_BOOLEAN;
3730  lDBusKey = "Pairable";
3731  break;
3732  case enBTAdPropUnknown:
3733  default:
3734  BTRCORELOG_ERROR ("Invalid Adapter Property\n");
3735  return -1;
3736  }
3737  break;
3738  case enBTDevice:
3739  pInterface = pDeviceInterface;
3740  switch (aunBtOpIfceProp.enBtDeviceProp) {
3741  case enBTDevPropPaired:
3742  lDBusType = DBUS_TYPE_BOOLEAN;
3743  lDBusKey = "Paired";
3744  break;
3745  case enBTDevPropConnected:
3746  lDBusType = DBUS_TYPE_BOOLEAN;
3747  lDBusKey = "Connected";
3748  break;
3749  case enBTDevPropVendor:
3750  lDBusType = DBUS_TYPE_UINT16;
3751  lDBusKey = "Vendor";
3752  break;
3753  case enBTDevPropSrvRslvd:
3754  lDBusType = DBUS_TYPE_BOOLEAN;
3755  lDBusKey = "ServicesResolved";
3756  break;
3757  case enBTDevPropUnknown:
3758  default:
3759  BTRCORELOG_ERROR ("Invalid Device Property\n");
3760  return -1;
3761  }
3762  break;
3763  case enBTMediaTransport:
3764  pInterface = pMediaTransInterface;
3765  switch (aunBtOpIfceProp.enBtMediaTransportProp) {
3766  case enBTMedTPropDelay:
3767  lDBusType = DBUS_TYPE_UINT16;
3768  lDBusKey = "Delay";
3769  break;
3770  case enBTMedTPropVol:
3771  lDBusType = DBUS_TYPE_UINT16;
3772  lDBusKey = "Volume";
3773  break;
3774  case enBTMedTPropState:
3775  lDBusType = DBUS_TYPE_STRING;
3776  lDBusKey = "State";
3777  break;
3778  case enBTMedTPropUnknown:
3779  default:
3780  BTRCORELOG_ERROR ("Invalid MediaTransport Property\n");
3781  return -1;
3782  }
3783  break;
3784  case enBTGattService:
3785  pInterface = pGattServiceInterface;
3786  switch (aunBtOpIfceProp.enBtGattServiceProp) {
3787  case enBTGattSPropUUID:
3788  lDBusType = DBUS_TYPE_STRING;
3789  lDBusKey = "UUID";
3790  break;
3791  case enBTGattSPropPrimary:
3792  lDBusType = DBUS_TYPE_BOOLEAN;
3793  lDBusKey = "Primary";
3794  break;
3795  case enBTGattSPropDevice:
3796  lDBusType = DBUS_TYPE_OBJECT_PATH;
3797  lDBusKey = "Device";
3798  break;
3799  case enBTGattSPropUnknown:
3800  default:
3801  BTRCORELOG_ERROR ("Invalid GattService Property\n");
3802  return -1;
3803  }
3804  break;
3805  case enBTGattCharacteristic:
3806  pInterface = pGattCharInterface;
3807  switch (aunBtOpIfceProp.enBtGattCharProp) {
3808  case enBTGattCPropUUID:
3809  lDBusType = DBUS_TYPE_STRING;
3810  lDBusKey = "UUID";
3811  break;
3812  case enBTGattCPropService:
3813  lDBusType = DBUS_TYPE_OBJECT_PATH;
3814  lDBusKey = "Service";
3815  break;
3816  case enBTGattCPropValue:
3817  lDBusType = DBUS_TYPE_ARRAY;
3818  lDBusKey = "Value";
3819  break;
3820  case enBTGattCPropNotifying:
3821  lDBusType = DBUS_TYPE_BOOLEAN;
3822  lDBusKey = "Notifying";
3823  break;
3824  case enBTGattCPropFlags:
3825  lDBusType = DBUS_TYPE_ARRAY;
3826  lDBusKey = "Flags";
3827  break;
3828  case enBTGattCPropUnknown:
3829  default:
3830  BTRCORELOG_ERROR ("Invalid GattCharacteristic Property\n");
3831  return -1;
3832  }
3833  break;
3834  case enBTGattDescriptor:
3835  pInterface = pGattDescInterface;
3836  switch (aunBtOpIfceProp.enBtGattDescProp) {
3837  case enBTGattDPropUUID:
3838  lDBusType = DBUS_TYPE_STRING;
3839  lDBusKey = "UUID";
3840  break;
3841  case enBTGattDPropCharacteristic:
3842  lDBusType = DBUS_TYPE_OBJECT_PATH;
3843  lDBusKey = "Characteristic";
3844  break;
3845  case enBTGattDPropValue:
3846  lDBusType = DBUS_TYPE_ARRAY;
3847  lDBusKey = "Value";
3848  break;
3849  case enBTGattDPropFlags:
3850  lDBusType = DBUS_TYPE_ARRAY;
3851  lDBusKey = "Flags";
3852  break;
3853  case enBTGattDPropUnknown:
3854  default:
3855  BTRCORELOG_ERROR ("Invalid GattDescriptor Property\n");
3856  return -1;
3857  }
3858  break;
3859  case enBTUnknown:
3860  default:
3861  BTRCORELOG_ERROR ("Invalid Operational Interface\n");
3862  return -1;
3863  }
3864 
3865 
3866  if (!lDBusKey || (lDBusType == DBUS_TYPE_INVALID)) {
3867  BTRCORELOG_ERROR ("Invalid Interface Property\n");
3868  return -1;
3869  }
3870 
3871 
3872  lpDBusMsg = dbus_message_new_method_call(BT_DBUS_BLUEZ_PATH,
3873  apcBtOpIfcePath,
3874  DBUS_INTERFACE_PROPERTIES,
3875  "GetAll");
3876 
3877  dbus_message_append_args(lpDBusMsg, DBUS_TYPE_STRING, &pInterface, DBUS_TYPE_INVALID);
3878 
3879  dbus_error_init(&lDBusErr);
3880  if (!dbus_connection_send_with_reply(pstlhBtIfce->pDBusConn, lpDBusMsg, &lpDBusPendC, -1)) {
3881  BTRCORELOG_ERROR ("failed to send message\n");
3882  }
3883 
3884 
3885  dbus_connection_flush(pstlhBtIfce->pDBusConn);
3886 
3887 
3888  if (!lpDBusPendC) {
3889  BTRCORELOG_ERROR ("%s.GetProperties returned an error\n", pInterface);
3890  rc = -1;
3891  btrCore_BTHandleDusError(&lDBusErr, __LINE__, __FUNCTION__);
3892  dbus_message_unref(lpDBusMsg);
3893  lpDBusMsg = NULL;
3894  }
3895  else {
3896  dbus_pending_call_block(lpDBusPendC);
3897  lpDBusReply = dbus_pending_call_steal_reply(lpDBusPendC);
3898 
3899 
3900  if (!lpDBusReply) {
3901  BTRCORELOG_ERROR ("%s.GetProperties returned an error\n", pInterface);
3902  rc = -1;
3903  btrCore_BTHandleDusError(&lDBusErr, __LINE__, __FUNCTION__);
3904  dbus_pending_call_unref(lpDBusPendC);
3905  dbus_message_unref(lpDBusMsg);
3906  lpDBusPendC = NULL;
3907  lpDBusMsg = NULL;
3908  }
3909  else {
3910  if (!dbus_message_iter_init(lpDBusReply, &arg_i)) {
3911  BTRCORELOG_ERROR ("GetProperties lpDBusReply has no arguments.\n");
3912  rc = -1;
3913  }
3914  else if (dbus_message_iter_get_arg_type(&arg_i) != DBUS_TYPE_ARRAY) {
3915  BTRCORELOG_ERROR ("GetProperties argument is not an array.\n");
3916  rc = -1;
3917  }
3918  else {
3919  dbus_message_iter_recurse(&arg_i, &element_i);
3920  while (dbus_message_iter_get_arg_type(&element_i) != DBUS_TYPE_INVALID) {
3921  if (dbus_message_iter_get_arg_type(&element_i) == DBUS_TYPE_DICT_ENTRY) {
3922  DBusMessageIter dict_i;
3923  dbus_message_iter_recurse(&element_i, &dict_i);
3924  dbus_message_iter_get_basic(&dict_i, &pParsedKey);
3925 
3926  if ((pParsedKey) && (strcmp (pParsedKey, lDBusKey) == 0)) {
3927  dbus_message_iter_next(&dict_i);
3928  dbus_message_iter_recurse(&dict_i, &variant_i);
3929  if (lDBusType == DBUS_TYPE_STRING) {
3930  dbus_message_iter_get_basic(&variant_i, &pParsedValueString);
3931  //BTRCORELOG_ERROR ("Key is %s and the value in string is %s\n", pParsedKey, pParsedValueString);
3932  strncpy (apvVal, pParsedValueString, strlen(pParsedValueString) < BT_MAX_UUID_STR_LEN ? strlen(pParsedValueString) : BT_MAX_UUID_STR_LEN - 1);
3933 
3934  if (i32StoreDefAdpAddr && !pstlhBtIfce->pcBTDAdapterAddr) {
3935  pstlhBtIfce->pcBTDAdapterAddr = strndup(pParsedValueString, strlen(pParsedValueString) < BT_MAX_UUID_STR_LEN ? strlen(pParsedValueString) : BT_MAX_UUID_STR_LEN - 1);
3936  }
3937  }
3938  else if (lDBusType == DBUS_TYPE_UINT16) {
3939  unsigned short* ptr = (unsigned short*) apvVal;
3940  dbus_message_iter_get_basic(&variant_i, &parsedValueUnsignedShort);
3941  //BTRCORELOG_ERROR ("Key is %s and the value is %u\n", pParsedKey, parsedValueUnsignedNumber);
3942  *ptr = parsedValueUnsignedShort;
3943  }
3944  else if (lDBusType == DBUS_TYPE_UINT32) {
3945  unsigned int* ptr = (unsigned int*) apvVal;
3946  dbus_message_iter_get_basic(&variant_i, &parsedValueUnsignedNumber);
3947  //BTRCORELOG_ERROR ("Key is %s and the value is %u\n", pParsedKey, parsedValueUnsignedNumber);
3948  *ptr = parsedValueUnsignedNumber;
3949  }
3950  else if (lDBusType == DBUS_TYPE_OBJECT_PATH) {
3951  dbus_message_iter_get_basic(&variant_i, &pParsedValueString);
3952  //BTRCORELOG_ERROR ("Key is %s and the value in string is %s\n", pParsedKey, pParsedValueString);
3953  strncpy (apvVal, pParsedValueString, strlen(pParsedValueString) < BT_MAX_STR_LEN ? strlen(pParsedValueString) : BT_MAX_STR_LEN - 1);
3954  }
3955  else if (lDBusType == DBUS_TYPE_ARRAY) {
3956  DBusMessageIter variantArray;
3957  dbus_message_iter_recurse(&variant_i, &variantArray);
3958  int lType = dbus_message_iter_get_arg_type(&variantArray);
3959  int lIndex = 0;
3960 
3961  if (lType == DBUS_TYPE_STRING) {
3962  char (*ptr)[BT_MAX_UUID_STR_LEN] = (char (*)[BT_MAX_UUID_STR_LEN])apvVal;
3963 
3964  while (dbus_message_iter_get_arg_type(&variantArray) != DBUS_TYPE_INVALID) {
3965 
3966  dbus_message_iter_get_basic(&variantArray, &pParsedValueString);
3967  strncpy (ptr[lIndex++], pParsedValueString, BT_MAX_UUID_STR_LEN-1);
3968 
3969  if (!dbus_message_iter_next(&variantArray)) {
3970  break;
3971  }
3972  }
3973  } else
3974  if (lType == DBUS_TYPE_BYTE) {
3975  unsigned char chr = '\0';
3976  char hex[] = "0123456789abcdef";
3977  char *byteStream = (char*)apvVal;
3978 
3979  while (dbus_message_iter_get_arg_type(&variantArray) != DBUS_TYPE_INVALID) {
3980 
3981  dbus_message_iter_get_basic(&variantArray, &chr);
3982  byteStream[lIndex++] = hex[chr >> 4];
3983  byteStream[lIndex++] = hex[chr & 0x0F];
3984 
3985  if (!dbus_message_iter_next(&variantArray)) {
3986  break;
3987  }
3988  }
3989  byteStream[lIndex] = '\0';
3990  }
3991  }
3992  else { /* As of now ints and bools are used. This function has to be extended for array if needed */
3993  int* ptr = (int*) apvVal;
3994  dbus_message_iter_get_basic(&variant_i, &parsedValueNumber);
3995  //BTRCORELOG_ERROR ("Key is %s and the value is %d\n", pParsedKey, parsedValueNumber);
3996  *ptr = parsedValueNumber;
3997  }
3998  rc = 0;
3999  break;
4000  }
4001  }
4002 
4003  if (!dbus_message_iter_next(&element_i))
4004  break;
4005  }
4006  }
4007 
4008  btrCore_BTHandleDusError(&lDBusErr, __LINE__, __FUNCTION__);
4009 
4010  dbus_message_unref(lpDBusReply);
4011  dbus_pending_call_unref(lpDBusPendC);
4012  dbus_message_unref(lpDBusMsg);
4013 
4014  lpDBusReply = NULL;
4015  lpDBusPendC = NULL;
4016  lpDBusMsg = NULL;
4017  }
4018  }
4019 
4020  return rc;
4021 }
4022 
4023 
4024 int
4025 BtrCore_BTSetProp (
4026  void* apstBtIfceHdl,
4027  const char* apcBtOpIfcePath,
4028  enBTOpIfceType aenBtOpIfceType,
4029  unBTOpIfceProp aunBtOpIfceProp,
4030  void* apvVal
4031 ) {
4032  stBtIfceHdl* pstlhBtIfce = (stBtIfceHdl*)apstBtIfceHdl;
4033  DBusMessage* lpDBusMsg = NULL;
4034  DBusMessage* lpDBusReply = NULL;
4035  DBusMessageIter lDBusMsgIter;
4036  DBusMessageIter lDBusMsgIterValue;
4037  DBusError lDBusErr;
4038 
4039  const char* lDBusTypeAsString;
4040 
4041  const char* lDBusKey = NULL;
4042  int lDBusType = DBUS_TYPE_INVALID;
4043 
4044  const char* pInterface = NULL;
4045  const char* pAdapterInterface = BT_DBUS_BLUEZ_ADAPTER_PATH;
4046  const char* pDeviceInterface = BT_DBUS_BLUEZ_DEVICE_PATH;
4047  const char* pMediaTransInterface= BT_DBUS_BLUEZ_MEDIA_TRANSPORT_PATH;
4048  const char* pGattCharInterface = BT_DBUS_BLUEZ_GATT_CHAR_PATH;
4049 
4050  if (!apstBtIfceHdl)
4051  return -1;
4052 
4053 
4054  switch (aenBtOpIfceType) {
4055  case enBTAdapter:
4056  pInterface = pAdapterInterface;
4057  switch (aunBtOpIfceProp.enBtAdapterProp) {
4058  case enBTAdPropName:
4059  lDBusType = DBUS_TYPE_STRING;
4060  lDBusKey = "Alias";
4061  break;
4062  case enBTAdPropAddress:
4063  lDBusType = DBUS_TYPE_STRING;
4064  lDBusKey = "Address";
4065  break;
4066  case enBTAdPropPowered:
4067  lDBusType = DBUS_TYPE_BOOLEAN;
4068  lDBusKey = "Powered";
4069  break;
4070  case enBTAdPropDiscoverable:
4071  lDBusType = DBUS_TYPE_BOOLEAN;
4072  lDBusKey = "Discoverable";
4073  break;
4074  case enBTAdPropDiscoverableTimeOut:
4075  lDBusType = DBUS_TYPE_UINT32;
4076  lDBusKey = "DiscoverableTimeout";
4077  break;
4078  case enBTAdPropPairable:
4079  lDBusType = DBUS_TYPE_BOOLEAN;
4080  lDBusKey = "Pairable";
4081  break;
4082  case enBTAdPropUnknown:
4083  default:
4084  BTRCORELOG_ERROR ("Invalid Adapter Property\n");
4085  return -1;
4086  }
4087  break;
4088  case enBTDevice:
4089  pInterface = pDeviceInterface;
4090  switch (aunBtOpIfceProp.enBtDeviceProp) {
4091  case enBTDevPropPaired:
4092  lDBusType = DBUS_TYPE_BOOLEAN;
4093  lDBusKey = "Paired";
4094  break;
4095  case enBTDevPropConnected:
4096  lDBusType = DBUS_TYPE_BOOLEAN;
4097  lDBusKey = "Connected";
4098  break;
4099  case enBTDevPropVendor:
4100  lDBusType = DBUS_TYPE_UINT16;
4101  lDBusKey = "Vendor";
4102  break;
4103  case enBTDevPropUnknown:
4104  default:
4105  BTRCORELOG_ERROR ("Invalid Device Property\n");
4106  return -1;
4107  }
4108  break;
4109  case enBTMediaTransport:
4110  pInterface = pMediaTransInterface;
4111  switch (aunBtOpIfceProp.enBtMediaTransportProp) {
4112  case enBTMedTPropDelay:
4113  lDBusType = DBUS_TYPE_UINT16;
4114  lDBusKey = "Delay";
4115  break;
4116  case enBTMedTPropVol:
4117  lDBusType = DBUS_TYPE_UINT16;
4118  lDBusKey = "Volume";
4119  break;
4120  case enBTMedTPropState:
4121  case enBTMedTPropUnknown:
4122  default:
4123  BTRCORELOG_ERROR ("Invalid MediaTransport Property\n");
4124  return -1;
4125  }
4126  break;
4127  case enBTGattCharacteristic: /* SM: Only enBTGattCPropValue has been tested*/
4128  pInterface = pGattCharInterface;
4129  switch (aunBtOpIfceProp.enBtGattCharProp) {
4130  case enBTGattCPropUUID:
4131  lDBusType = DBUS_TYPE_STRING;
4132  lDBusKey = "UUID";
4133  break;
4134  case enBTGattCPropService:
4135  lDBusType = DBUS_TYPE_OBJECT_PATH;
4136  lDBusKey = "Service";
4137  break;
4138  case enBTGattCPropValue:
4139  lDBusType = DBUS_TYPE_ARRAY;
4140  lDBusKey = "Value";
4141  break;
4142  case enBTGattCPropNotifying:
4143  lDBusType = DBUS_TYPE_BOOLEAN;
4144  BTRCORELOG_INFO("Key is notifying\n");
4145  lDBusKey = "Notifying";
4146  break;
4147  case enBTGattCPropFlags:
4148  lDBusType = DBUS_TYPE_ARRAY;
4149  lDBusKey = "Flags";
4150  break;
4151  case enBTGattCPropUnknown:
4152  default:
4153  BTRCORELOG_ERROR("Invalid GattCharacteristic Property\n");
4154  return -1;
4155  }
4156  break;
4157  case enBTUnknown:
4158  default:
4159  BTRCORELOG_ERROR ("Invalid Operational Interface\n");
4160  return -1;
4161  }
4162 
4163 
4164  if (!lDBusKey || (lDBusType == DBUS_TYPE_INVALID)) {
4165  BTRCORELOG_ERROR ("Invalid Interface Property\n");
4166  return -1;
4167  }
4168 
4169 
4170  switch (lDBusType) {
4171  case DBUS_TYPE_BOOLEAN:
4172  lDBusTypeAsString = DBUS_TYPE_BOOLEAN_AS_STRING;
4173  break;
4174  case DBUS_TYPE_UINT32:
4175  lDBusTypeAsString = DBUS_TYPE_UINT32_AS_STRING;
4176  break;
4177  case DBUS_TYPE_UINT16:
4178  lDBusTypeAsString = DBUS_TYPE_UINT16_AS_STRING;
4179  break;
4180  case DBUS_TYPE_STRING:
4181  lDBusTypeAsString = DBUS_TYPE_STRING_AS_STRING;
4182  break;
4183  case DBUS_TYPE_ARRAY:
4184  lDBusTypeAsString = DBUS_TYPE_ARRAY_AS_STRING;
4185  break;
4186  default:
4187  BTRCORELOG_ERROR ("Invalid DBus Type\n");
4188  return -1;
4189  }
4190 
4191  if(aenBtOpIfceType == enBTGattCharacteristic) {
4192  lpDBusMsg = dbus_message_new_signal(apcBtOpIfcePath,
4193  DBUS_INTERFACE_PROPERTIES,
4194  "PropertiesChanged");
4195  }
4196  else {
4197  lpDBusMsg = dbus_message_new_method_call(BT_DBUS_BLUEZ_PATH,
4198  apcBtOpIfcePath,
4199  DBUS_INTERFACE_PROPERTIES,
4200  "Set");
4201 
4202  if (!lpDBusMsg) {
4203  BTRCORELOG_ERROR ("Can't allocate new method call\n");
4204  return -1;
4205  }
4206  }
4207 
4208  if (aenBtOpIfceType == enBTGattCharacteristic) {
4209  char* pVlaue = (char*)apvVal;
4210  BTRCORELOG_INFO("Notified Value is %s with length %lu\n", pVlaue, (unsigned long)strlen(pVlaue));
4211 
4212  DBusMessageIter lDBusMsgIter, signal_iter;
4213  DBusMessageIter lDBusMsgIterDictStr, lDBusMsgIterSubArray, lDBusMsgIterVariant;
4214  char* Prop = "Value";
4215  int type = DBUS_TYPE_BYTE;
4216 
4217  char array_type[5] = "a";
4218  strncat(array_type, (char*)&type, sizeof(array_type) - sizeof(type));
4219 
4220  dbus_message_iter_init_append(lpDBusMsg, &signal_iter);
4221  dbus_message_iter_append_basic(&signal_iter, DBUS_TYPE_STRING, &pGattCharInterface);
4222  dbus_message_iter_open_container(&signal_iter, DBUS_TYPE_ARRAY, "{sv}", &lDBusMsgIter);
4223  dbus_message_iter_open_container(&lDBusMsgIter, DBUS_TYPE_DICT_ENTRY, NULL, &lDBusMsgIterDictStr);
4224  dbus_message_iter_append_basic(&lDBusMsgIterDictStr, DBUS_TYPE_STRING, &Prop);
4225  dbus_message_iter_open_container(&lDBusMsgIterDictStr, DBUS_TYPE_VARIANT, array_type, &lDBusMsgIterVariant);
4226  dbus_message_iter_open_container(&lDBusMsgIterVariant, DBUS_TYPE_ARRAY, (char *)&type, &lDBusMsgIterSubArray);
4227  for (int i = 0; i < strlen(pVlaue); i++) {
4228  dbus_message_iter_append_basic(&lDBusMsgIterSubArray, DBUS_TYPE_BYTE, &(pVlaue[i]));
4229  }
4230  dbus_message_iter_close_container(&lDBusMsgIterVariant, &lDBusMsgIterSubArray);
4231  dbus_message_iter_close_container(&lDBusMsgIterDictStr, &lDBusMsgIterVariant);
4232  dbus_message_iter_close_container(&lDBusMsgIter, &lDBusMsgIterDictStr);
4233  dbus_message_iter_close_container(&signal_iter, &lDBusMsgIter);
4234  }
4235  else {
4236  dbus_message_iter_init_append(lpDBusMsg, &lDBusMsgIter);
4237  dbus_message_iter_append_basic(&lDBusMsgIter, DBUS_TYPE_STRING, &pInterface);
4238  dbus_message_iter_append_basic(&lDBusMsgIter, DBUS_TYPE_STRING, &lDBusKey);
4239  dbus_message_iter_open_container(&lDBusMsgIter, DBUS_TYPE_VARIANT, lDBusTypeAsString, &lDBusMsgIterValue);
4240  dbus_message_iter_append_basic(&lDBusMsgIterValue, lDBusType, apvVal);
4241  dbus_message_iter_close_container(&lDBusMsgIter, &lDBusMsgIterValue);
4242  //dbus_message_append_args(lpDBusMsg, DBUS_TYPE_STRING, &pInterface, DBUS_TYPE_STRING, &lDBusKey, lDBusType, apvVal, DBUS_TYPE_INVALID);
4243  }
4244 
4245  const char* lsignature = dbus_message_get_signature(lpDBusMsg);
4246  int li32MessageType;
4247  const char* lpcSender;
4248  const char* lpcDestination;
4249  BTRCORELOG_INFO("Signature is %s\n", lsignature);
4250 
4251  li32MessageType = dbus_message_get_type(lpDBusMsg);
4252  lpcSender = dbus_message_get_sender(lpDBusMsg);
4253  lpcDestination = dbus_message_get_destination(lpDBusMsg);
4254 
4255  BTRCORELOG_TRACE ("%s Sender=%s -> Dest=%s Path=%s; Interface=%s; Member=%s\n",
4256  btrCore_DBusType2Name(li32MessageType),
4257  lpcSender ? lpcSender : "Null",
4258  lpcDestination ? lpcDestination : "Null",
4259  dbus_message_get_path(lpDBusMsg),
4260  dbus_message_get_interface(lpDBusMsg),
4261  dbus_message_get_member(lpDBusMsg));
4262  dbus_error_init(&lDBusErr);
4263  lpDBusReply = dbus_connection_send_with_reply_and_block(pstlhBtIfce->pDBusConn, lpDBusMsg, -1, &lDBusErr);
4264  dbus_message_unref(lpDBusMsg);
4265 
4266  if (!lpDBusReply) {
4267  BTRCORELOG_ERROR ("lpDBusReply Null\n");
4268  btrCore_BTHandleDusError(&lDBusErr, __LINE__, __FUNCTION__);
4269  return -1;
4270  }
4271 
4272  dbus_message_unref(lpDBusReply);
4273 
4274  dbus_connection_flush(pstlhBtIfce->pDBusConn);
4275 
4276  return 0;
4277 }
4278 
4279 
4280 int
4281 BtrCore_BTStartDiscovery (
4282  void* apstBtIfceHdl,
4283  const char* apBtAdapter,
4284  const char* apBtAgentPath
4285 ) {
4286  stBtIfceHdl* pstlhBtIfce = (stBtIfceHdl*)apstBtIfceHdl;
4287  DBusMessage* lpDBusMsg = NULL;
4288  dbus_bool_t lDBusOp;
4289 
4290  if (!apstBtIfceHdl)
4291  return -1;
4292 
4293 
4294  lpDBusMsg = dbus_message_new_method_call(BT_DBUS_BLUEZ_PATH,
4295  apBtAdapter,
4296  BT_DBUS_BLUEZ_ADAPTER_PATH,
4297  "StartDiscovery");
4298  if (!lpDBusMsg) {
4299  BTRCORELOG_ERROR ("Can't allocate new method call\n");
4300  return -1;
4301  }
4302 
4303  lDBusOp = dbus_connection_send(pstlhBtIfce->pDBusConn, lpDBusMsg, NULL);
4304  dbus_message_unref(lpDBusMsg);
4305 
4306  if (!lDBusOp) {
4307  BTRCORELOG_ERROR ("Not enough memory for message send\n");
4308  return -1;
4309  }
4310 
4311  dbus_connection_flush(pstlhBtIfce->pDBusConn);
4312 
4313  return 0;
4314 }
4315 
4316 
4317 int
4318 BtrCore_BTStopDiscovery (
4319  void* apstBtIfceHdl,
4320  const char* apBtAdapter,
4321  const char* apBtAgentPath
4322 ) {
4323  stBtIfceHdl* pstlhBtIfce = (stBtIfceHdl*)apstBtIfceHdl;
4324  DBusMessage* lpDBusMsg = NULL;
4325  dbus_bool_t lDBusOp;
4326 
4327  if (!apstBtIfceHdl)
4328  return -1;
4329 
4330 
4331  lpDBusMsg = dbus_message_new_method_call(BT_DBUS_BLUEZ_PATH,
4332  apBtAdapter,
4333  BT_DBUS_BLUEZ_ADAPTER_PATH,
4334  "StopDiscovery");
4335 
4336  if (!lpDBusMsg) {
4337  BTRCORELOG_ERROR ("Can't allocate new method call\n");
4338  return -1;
4339  }
4340 
4341  lDBusOp = dbus_connection_send(pstlhBtIfce->pDBusConn, lpDBusMsg, NULL);
4342  dbus_message_unref(lpDBusMsg);
4343 
4344  if (!lDBusOp) {
4345  BTRCORELOG_ERROR ("Not enough memory for message send\n");
4346  return -1;
4347  }
4348 
4349  dbus_connection_flush(pstlhBtIfce->pDBusConn);
4350  // for now, adding a 1s sleep to prevent stop discovery from being interrupted
4351  // by an LE connect request that immediately follows the stop discovery request
4352  // TODO: avoid sleep. handle correctly by listening for "Discovering" events from Adapter interface
4353  sleep (1);
4354 
4355  return 0;
4356 }
4357 
4358 
4359 int
4360 BtrCore_BTStartLEDiscovery (
4361  void* apstBtIfceHdl,
4362  const char* apBtAdapter,
4363  const char* apBtAgentPath
4364 ) {
4365  stBtIfceHdl* pstlhBtIfce = (stBtIfceHdl*)apstBtIfceHdl;
4366  DBusMessage* lpDBusMsg = NULL;
4367  dbus_bool_t lDBusOp;
4368  DBusMessageIter lDBusMsgIter;
4369  DBusMessageIter lDBusMsgIterDict;
4370 
4371  if (!apstBtIfceHdl)
4372  return -1;
4373 
4374 
4375  lpDBusMsg = dbus_message_new_method_call(BT_DBUS_BLUEZ_PATH,
4376  apBtAdapter,
4377  BT_DBUS_BLUEZ_ADAPTER_PATH,
4378  "SetDiscoveryFilter");
4379  if (!lpDBusMsg) {
4380  BTRCORELOG_ERROR ("Can't allocate new method call\n");
4381  return -1;
4382  }
4383 
4384 
4385  dbus_message_iter_init_append(lpDBusMsg, &lDBusMsgIter);
4386  dbus_message_iter_open_container(&lDBusMsgIter,
4387  DBUS_TYPE_ARRAY,
4388  DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
4389  DBUS_TYPE_STRING_AS_STRING
4390  DBUS_TYPE_VARIANT_AS_STRING
4391  DBUS_DICT_ENTRY_END_CHAR_AS_STRING,
4392  &lDBusMsgIterDict);
4393  {
4394  DBusMessageIter lDBusMsgIterDictStr, lDBusMsgIterVariant;
4395  char* lpcKey = "Transport";
4396  char* lpcValue = "le";
4397  int i32DBusType = DBUS_TYPE_STRING;
4398 
4399  dbus_message_iter_open_container(&lDBusMsgIterDict, DBUS_TYPE_DICT_ENTRY, NULL, &lDBusMsgIterDictStr);
4400  dbus_message_iter_append_basic (&lDBusMsgIterDictStr, DBUS_TYPE_STRING, &lpcKey);
4401  dbus_message_iter_open_container (&lDBusMsgIterDictStr, DBUS_TYPE_VARIANT, (char *)&i32DBusType, &lDBusMsgIterVariant);
4402  dbus_message_iter_append_basic (&lDBusMsgIterVariant, i32DBusType, &lpcValue);
4403  dbus_message_iter_close_container (&lDBusMsgIterDictStr, &lDBusMsgIterVariant);
4404  dbus_message_iter_close_container (&lDBusMsgIterDict, &lDBusMsgIterDictStr);
4405  }
4406  {
4407  DBusMessageIter lDBusMsgIterDictStr, lDBusMsgIterVariant, lDBusMsgIterSubArray;
4408  char* lpcKey = "UUIDs";
4409  int i32DBusType = DBUS_TYPE_STRING;
4410  const char* apcBtSrvUUID1 = BT_UUID_GATT_TILE_1;
4411  const char* apcBtSrvUUID2 = BT_UUID_GATT_TILE_2;
4412  const char* apcBtSrvUUID3 = BT_UUID_GATT_TILE_3;
4413 
4414  char array_type[5] = "a";
4415  strncat (array_type, (char*)&i32DBusType, sizeof(array_type) - sizeof(i32DBusType));
4416 
4417  const char *lppui8Props[] = { apcBtSrvUUID1, apcBtSrvUUID2, apcBtSrvUUID3, NULL };
4418 
4419  dbus_message_iter_open_container(&lDBusMsgIterDict, DBUS_TYPE_DICT_ENTRY, NULL, &lDBusMsgIterDictStr);
4420  dbus_message_iter_append_basic (&lDBusMsgIterDictStr, DBUS_TYPE_STRING, &lpcKey);
4421  dbus_message_iter_open_container (&lDBusMsgIterDictStr, DBUS_TYPE_VARIANT, array_type, &lDBusMsgIterVariant);
4422  dbus_message_iter_open_container (&lDBusMsgIterVariant, DBUS_TYPE_ARRAY, (char *)&i32DBusType, &lDBusMsgIterSubArray);
4423  dbus_message_iter_append_basic (&lDBusMsgIterSubArray, i32DBusType, &lppui8Props);
4424  dbus_message_iter_close_container (&lDBusMsgIterVariant, &lDBusMsgIterSubArray);
4425  dbus_message_iter_close_container (&lDBusMsgIterDictStr, &lDBusMsgIterVariant);
4426  dbus_message_iter_close_container (&lDBusMsgIterDict, &lDBusMsgIterDictStr);
4427  }
4428 #if 0
4429  //TODO: Enable in future when you can eliminate the UUID based filter
4430  // As in my opinion filtering based on RSSI and delta of RSSI change is a better approach as compared to
4431  // Filtering based on UUID as above
4432  {
4433  DBusMessageIter lDBusMsgIterDictStr, lDBusMsgIterVariant;
4434  char* lpcKey = "RSSI";
4435  short lpcValue = -64;
4436  int i32DBusType = DBUS_TYPE_INT16;
4437 
4438  dbus_message_iter_open_container(&lDBusMsgIterDict, DBUS_TYPE_DICT_ENTRY, NULL, &lDBusMsgIterDictStr);
4439  dbus_message_iter_append_basic (&lDBusMsgIterDictStr, DBUS_TYPE_STRING, &lpcKey);
4440  dbus_message_iter_open_container (&lDBusMsgIterDictStr, DBUS_TYPE_VARIANT, (char *)&i32DBusType, &lDBusMsgIterVariant);
4441  dbus_message_iter_append_basic (&lDBusMsgIterVariant, i32DBusType, &lpcValue);
4442  dbus_message_iter_close_container (&lDBusMsgIterDictStr, &lDBusMsgIterVariant);
4443  dbus_message_iter_close_container (&lDBusMsgIterDict, &lDBusMsgIterDictStr);
4444  }
4445 #endif
4446 
4447  dbus_message_iter_close_container (&lDBusMsgIter, &lDBusMsgIterDict);
4448 
4449 
4450  lDBusOp = dbus_connection_send(pstlhBtIfce->pDBusConn, lpDBusMsg, NULL);
4451  dbus_message_unref(lpDBusMsg);
4452 
4453  if (!lDBusOp) {
4454  BTRCORELOG_ERROR ("Not enough memory for message send\n");
4455  return -1;
4456  }
4457 
4458  dbus_connection_flush(pstlhBtIfce->pDBusConn);
4459 
4460  return BtrCore_BTStartDiscovery(pstlhBtIfce, apBtAdapter, apBtAgentPath);
4461 }
4462 
4463 
4464 int
4465 BtrCore_BTStopLEDiscovery (
4466  void* apstBtIfceHdl,
4467  const char* apBtAdapter,
4468  const char* apBtAgentPath
4469 ) {
4470  stBtIfceHdl* pstlhBtIfce = (stBtIfceHdl*)apstBtIfceHdl;
4471  DBusMessage* lpDBusMsg = NULL;
4472  dbus_bool_t lDBusOp;
4473  DBusMessageIter lDBusMsgIter, lDBusMsgIterDict;
4474 
4475  if (!apstBtIfceHdl)
4476  return -1;
4477 
4478 
4479  if (BtrCore_BTStopDiscovery(pstlhBtIfce, apBtAdapter, apBtAgentPath)) {
4480  BTRCORELOG_WARN ("Failed to Stop Discovery\n");
4481  }
4482 
4483 
4484  lpDBusMsg = dbus_message_new_method_call(BT_DBUS_BLUEZ_PATH,
4485  apBtAdapter,
4486  BT_DBUS_BLUEZ_ADAPTER_PATH,
4487  "SetDiscoveryFilter");
4488  if (!lpDBusMsg) {
4489  BTRCORELOG_ERROR ("Can't allocate new method call\n");
4490  return -1;
4491  }
4492 
4493 
4494  dbus_message_iter_init_append(lpDBusMsg, &lDBusMsgIter);
4495  dbus_message_iter_open_container(&lDBusMsgIter,
4496  DBUS_TYPE_ARRAY,
4497  DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
4498  DBUS_TYPE_STRING_AS_STRING
4499  DBUS_TYPE_VARIANT_AS_STRING
4500  DBUS_DICT_ENTRY_END_CHAR_AS_STRING,
4501  &lDBusMsgIterDict);
4502  {
4503  // Empty
4504  }
4505  dbus_message_iter_close_container (&lDBusMsgIter, &lDBusMsgIterDict);
4506 
4507 
4508  lDBusOp = dbus_connection_send(pstlhBtIfce->pDBusConn, lpDBusMsg, NULL);
4509  dbus_message_unref(lpDBusMsg);
4510 
4511  if (!lDBusOp) {
4512  BTRCORELOG_ERROR ("Not enough memory for message send\n");
4513  return -1;
4514  }
4515 
4516  dbus_connection_flush(pstlhBtIfce->pDBusConn);
4517 
4518  return 0;
4519 }
4520 
4521 
4522 int
4523 BtrCore_BTStartClassicDiscovery (
4524  void* apstBtIfceHdl,
4525  const char* apBtAdapter,
4526  const char* apBtAgentPath
4527 ) {
4528  stBtIfceHdl* pstlhBtIfce = (stBtIfceHdl*)apstBtIfceHdl;
4529  DBusMessage* lpDBusMsg = NULL;
4530  dbus_bool_t lDBusOp;
4531  DBusMessageIter lDBusMsgIter;
4532  DBusMessageIter lDBusMsgIterDict;
4533 
4534  if (!apstBtIfceHdl)
4535  return -1;
4536 
4537 
4538  lpDBusMsg = dbus_message_new_method_call(BT_DBUS_BLUEZ_PATH,
4539  apBtAdapter,
4540  BT_DBUS_BLUEZ_ADAPTER_PATH,
4541  "SetDiscoveryFilter");
4542  if (!lpDBusMsg) {
4543  BTRCORELOG_ERROR ("Can't allocate new method call\n");
4544  return -1;
4545  }
4546 
4547 
4548  dbus_message_iter_init_append(lpDBusMsg, &lDBusMsgIter);
4549  dbus_message_iter_open_container(&lDBusMsgIter,
4550  DBUS_TYPE_ARRAY,
4551  DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
4552  DBUS_TYPE_STRING_AS_STRING
4553  DBUS_TYPE_VARIANT_AS_STRING
4554  DBUS_DICT_ENTRY_END_CHAR_AS_STRING,
4555  &lDBusMsgIterDict);
4556  {
4557  DBusMessageIter lDBusMsgIterDictStr, lDBusMsgIterVariant;
4558  char* lpcKey = "Transport";
4559  char* lpcValue = "bredr";
4560  int i32DBusType = DBUS_TYPE_STRING;
4561 
4562  dbus_message_iter_open_container(&lDBusMsgIterDict, DBUS_TYPE_DICT_ENTRY, NULL, &lDBusMsgIterDictStr);
4563  dbus_message_iter_append_basic (&lDBusMsgIterDictStr, DBUS_TYPE_STRING, &lpcKey);
4564  dbus_message_iter_open_container (&lDBusMsgIterDictStr, DBUS_TYPE_VARIANT, (char *)&i32DBusType, &lDBusMsgIterVariant);
4565  dbus_message_iter_append_basic (&lDBusMsgIterVariant, i32DBusType, &lpcValue);
4566  dbus_message_iter_close_container (&lDBusMsgIterDictStr, &lDBusMsgIterVariant);
4567  dbus_message_iter_close_container (&lDBusMsgIterDict, &lDBusMsgIterDictStr);
4568  }
4569  dbus_message_iter_close_container (&lDBusMsgIter, &lDBusMsgIterDict);
4570 
4571 
4572  lDBusOp = dbus_connection_send(pstlhBtIfce->pDBusConn, lpDBusMsg, NULL);
4573  dbus_message_unref(lpDBusMsg);
4574 
4575  if (!lDBusOp) {
4576  BTRCORELOG_ERROR ("Not enough memory for message send\n");
4577  return -1;
4578  }
4579 
4580  dbus_connection_flush(pstlhBtIfce->pDBusConn);
4581 
4582  return BtrCore_BTStartDiscovery(pstlhBtIfce, apBtAdapter, apBtAgentPath);
4583 }
4584 
4585 
4586 int
4587 BtrCore_BTStopClassicDiscovery (
4588  void* apstBtIfceHdl,
4589  const char* apBtAdapter,
4590  const char* apBtAgentPath
4591 ) {
4592  stBtIfceHdl* pstlhBtIfce = (stBtIfceHdl*)apstBtIfceHdl;
4593  DBusMessage* lpDBusMsg = NULL;
4594  dbus_bool_t lDBusOp;
4595  DBusMessageIter lDBusMsgIter, lDBusMsgIterDict;
4596 
4597  if (!apstBtIfceHdl)
4598  return -1;
4599 
4600 
4601  if (BtrCore_BTStopDiscovery(pstlhBtIfce, apBtAdapter, apBtAgentPath)) {
4602  BTRCORELOG_WARN ("Failed to Stop Discovery\n");
4603  }
4604 
4605 
4606  lpDBusMsg = dbus_message_new_method_call(BT_DBUS_BLUEZ_PATH,
4607  apBtAdapter,
4608  BT_DBUS_BLUEZ_ADAPTER_PATH,
4609  "SetDiscoveryFilter");
4610  if (!lpDBusMsg) {
4611  BTRCORELOG_ERROR ("Can't allocate new method call\n");
4612  return -1;
4613  }
4614 
4615 
4616  dbus_message_iter_init_append(lpDBusMsg, &lDBusMsgIter);
4617  dbus_message_iter_open_container(&lDBusMsgIter,
4618  DBUS_TYPE_ARRAY,
4619  DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
4620  DBUS_TYPE_STRING_AS_STRING
4621  DBUS_TYPE_VARIANT_AS_STRING
4622  DBUS_DICT_ENTRY_END_CHAR_AS_STRING,
4623  &lDBusMsgIterDict);
4624  {
4625  // Empty
4626  }
4627  dbus_message_iter_close_container (&lDBusMsgIter, &lDBusMsgIterDict);
4628 
4629 
4630  lDBusOp = dbus_connection_send(pstlhBtIfce->pDBusConn, lpDBusMsg, NULL);
4631  dbus_message_unref(lpDBusMsg);
4632 
4633  if (!lDBusOp) {
4634  BTRCORELOG_ERROR ("Not enough memory for message send\n");
4635  return -1;
4636  }
4637 
4638  dbus_connection_flush(pstlhBtIfce->pDBusConn);
4639 
4640  return 0;
4641 }
4642 
4643 
4644 
4645 int
4646 BtrCore_BTGetPairedDeviceInfo (
4647  void* apstBtIfceHdl,
4648  const char* apBtAdapter,
4649  stBTPairedDeviceInfo* pPairedDeviceInfo
4650 ) {
4651  stBtIfceHdl* pstlhBtIfce = (stBtIfceHdl*)apstBtIfceHdl;
4652  DBusMessage* lpDBusMsg = NULL;
4653  DBusMessage* lpDBusReply = NULL;
4654  DBusMessageIter rootIter;
4655  DBusError lDBusErr;
4656  bool adapterFound = FALSE;
4657 
4658  char* pdeviceInterface = BT_DBUS_BLUEZ_DEVICE_PATH;
4659  char* adapter_path;
4660  char* dbusObject2;
4661  char paths[BT_MAX_NUM_DEVICE][BT_MAX_DEV_PATH_LEN];
4662  char objectPath[BT_MAX_DEV_PATH_LEN] = {'\0'};
4663  char objectData[BT_MAX_DEV_PATH_LEN] = {'\0'};
4664  int i = 0;
4665  int num = 0;
4666  int a = 0;
4667  int b = 0;
4668  int d = 0;
4669 
4670 
4671  if (!apstBtIfceHdl || !apBtAdapter || !pPairedDeviceInfo)
4672  return -1;
4673 
4674 
4675  dbus_error_init(&lDBusErr);
4676  lpDBusReply = btrCore_BTSendMethodCall(pstlhBtIfce->pDBusConn, "/", DBUS_INTERFACE_OBJECT_MANAGER, "GetManagedObjects");
4677  if (!lpDBusReply) {
4678  BTRCORELOG_ERROR ("org.bluez.Manager.ListAdapters returned an error: '%s'\n", lDBusErr.message);
4679  dbus_error_free(&lDBusErr);
4680  return -1;
4681  }
4682 
4683  for ( i = 0; i < BT_MAX_NUM_DEVICE; i++) {
4684  memset(&paths[i][0], '\0', BT_MAX_DEV_PATH_LEN);
4685  }
4686 
4687  if (dbus_message_iter_init(lpDBusReply, &rootIter) && //point iterator to lpDBusReply message
4688  DBUS_TYPE_ARRAY == dbus_message_iter_get_arg_type(&rootIter)) { //get the type of message that iter points to
4689 
4690  DBusMessageIter arrayElementIter;
4691  dbus_message_iter_recurse(&rootIter, &arrayElementIter); //assign new iterator to first element of array
4692 
4693  while(!adapterFound) {
4694  if (DBUS_TYPE_DICT_ENTRY == dbus_message_iter_get_arg_type(&arrayElementIter)) {
4695 
4696  DBusMessageIter dictEntryIter;
4697  dbus_message_iter_recurse(&arrayElementIter,&dictEntryIter ); //assign new iterator to first element of (get all dict entries of 1st level (all object paths)
4698 
4699  if (DBUS_TYPE_OBJECT_PATH == dbus_message_iter_get_arg_type(&dictEntryIter)) {
4700  dbus_message_iter_get_basic(&dictEntryIter, &adapter_path);
4701  strncpy(objectPath, adapter_path, (strlen(adapter_path) < BT_MAX_DEV_PATH_LEN) ? strlen(adapter_path) : BT_MAX_DEV_PATH_LEN - 1);
4702  ++a;
4703  }
4704 
4705  dbus_message_iter_next(&dictEntryIter);
4706  if (DBUS_TYPE_ARRAY == dbus_message_iter_get_arg_type(&dictEntryIter)) {
4707  DBusMessageIter innerArrayIter;
4708  dbus_message_iter_recurse(&dictEntryIter, &innerArrayIter);
4709 
4710  while (dbus_message_iter_has_next(&innerArrayIter)) {
4711  if (DBUS_TYPE_DICT_ENTRY == dbus_message_iter_get_arg_type(&innerArrayIter)) {
4712  DBusMessageIter innerDictEntryIter;
4713  dbus_message_iter_recurse(&innerArrayIter,&innerDictEntryIter ); //assign new iterator to first element of
4714 
4715  if (DBUS_TYPE_STRING == dbus_message_iter_get_arg_type(&innerDictEntryIter)) {
4716  char *dbusObject;
4717  dbus_message_iter_get_basic(&innerDictEntryIter, &dbusObject);
4718  }
4719 
4720 
4721  /////// NEW //////////
4722  dbus_message_iter_next(&innerDictEntryIter);
4723  if (DBUS_TYPE_ARRAY == dbus_message_iter_get_arg_type(&innerDictEntryIter)) {
4724  DBusMessageIter innerArrayIter2;
4725  dbus_message_iter_recurse(&innerDictEntryIter, &innerArrayIter2);
4726 
4727  while (dbus_message_iter_has_next(&innerArrayIter2)) {
4728  if (DBUS_TYPE_DICT_ENTRY == dbus_message_iter_get_arg_type(&innerArrayIter2)) {
4729  DBusMessageIter innerDictEntryIter2;
4730  dbus_message_iter_recurse(&innerArrayIter2,&innerDictEntryIter2); //assign new iterator to first element of
4731 
4732  if (DBUS_TYPE_STRING == dbus_message_iter_get_arg_type(&innerDictEntryIter2)) {
4733  dbus_message_iter_get_basic(&innerDictEntryIter2, &dbusObject2);
4734  }
4735 
4736 
4737  ////////////// NEW 2 ////////////
4738  dbus_message_iter_next(&innerDictEntryIter2);
4739  DBusMessageIter innerDictEntryIter3;
4740  char *dbusObject3;
4741 
4742  dbus_message_iter_recurse(&innerDictEntryIter2,&innerDictEntryIter3);
4743  if (DBUS_TYPE_STRING == dbus_message_iter_get_arg_type(&innerDictEntryIter3)) {
4744  dbus_message_iter_get_basic(&innerDictEntryIter3, &dbusObject3);
4745  memset(objectData, '\0', BT_MAX_DEV_PATH_LEN);
4746  strncpy(objectData, dbusObject3, (strlen(dbusObject3) < BT_MAX_DEV_PATH_LEN) ? strlen(dbusObject3) : BT_MAX_DEV_PATH_LEN - 1);
4747  ++b;
4748  }
4749  else if (DBUS_TYPE_BOOLEAN == dbus_message_iter_get_arg_type(&innerDictEntryIter3)) {
4750  bool *device_prop = FALSE;
4751  dbus_message_iter_get_basic(&innerDictEntryIter3, &device_prop);
4752 
4753  if (strcmp(dbusObject2, "Paired") == 0 && device_prop) {
4754  strncpy(&paths[d][0], adapter_path, (strlen(adapter_path) < BT_MAX_DEV_PATH_LEN) ? strlen(adapter_path) : BT_MAX_DEV_PATH_LEN - 1);
4755  ++d;
4756  }
4757  }
4758  }
4759 
4760  if (!dbus_message_iter_has_next(&innerArrayIter2)) {
4761  break; //check to see if end of 3rd array
4762  }
4763  else {
4764  dbus_message_iter_next(&innerArrayIter2);
4765  }
4766  }
4767  }
4768  }
4769 
4770  if (!dbus_message_iter_has_next(&innerArrayIter)) {
4771  break; //check to see if end of 2nd array
4772  }
4773  else {
4774  dbus_message_iter_next(&innerArrayIter);
4775  }
4776  }
4777  }
4778 
4779  if (!dbus_message_iter_has_next(&arrayElementIter)) {
4780  break; //check to see if end of 1st array
4781  }
4782  else {
4783  dbus_message_iter_next(&arrayElementIter);
4784  }
4785  } //while loop end --used to traverse array
4786  }
4787  }
4788 
4789  num = d;
4790 
4791  /* Update the number of devices */
4792  pPairedDeviceInfo->numberOfDevices = num;
4793 
4794  /* Update the paths of these devices */
4795  for ( i = 0; i < num; i++) {
4796  memset(&pPairedDeviceInfo->devicePath[i][0], '\0', BT_MAX_DEV_PATH_LEN);
4797  strncpy(&pPairedDeviceInfo->devicePath[i][0], &paths[i][0], (strlen(&paths[i][0]) < BT_MAX_DEV_PATH_LEN) ? strlen(&paths[i][0]) : BT_MAX_DEV_PATH_LEN - 1);
4798  }
4799 
4800  dbus_message_unref(lpDBusReply);
4801  lpDBusReply = NULL;
4802 
4803 
4804  for ( i = 0; i < num; i++) {
4805  DBusPendingCall* lpDBusPendC = NULL;
4806 
4807  lpDBusMsg = dbus_message_new_method_call(BT_DBUS_BLUEZ_PATH,
4808  pPairedDeviceInfo->devicePath[i],
4809  DBUS_INTERFACE_PROPERTIES,
4810  "GetAll");
4811  dbus_message_append_args(lpDBusMsg, DBUS_TYPE_STRING, &pdeviceInterface, DBUS_TYPE_INVALID);
4812 
4813  dbus_error_init(&lDBusErr);
4814 
4815  if (!dbus_connection_send_with_reply(pstlhBtIfce->pDBusConn, lpDBusMsg, &lpDBusPendC, -1)) {
4816  BTRCORELOG_ERROR ("failed to send message");
4817  return -1;
4818  }
4819 
4820  dbus_connection_flush(pstlhBtIfce->pDBusConn);
4821  dbus_message_unref(lpDBusMsg);
4822  lpDBusMsg = NULL;
4823 
4824  if (lpDBusPendC != NULL) {
4825  dbus_pending_call_block(lpDBusPendC);
4826  lpDBusReply = dbus_pending_call_steal_reply(lpDBusPendC);
4827  dbus_pending_call_unref(lpDBusPendC);
4828 
4829  if (lpDBusReply != NULL) {
4830  stBTDeviceInfo apstBTDeviceInfo;
4831 
4832  memset (&apstBTDeviceInfo, 0, sizeof(stBTDeviceInfo));
4833  if (0 != btrCore_BTParseDevice(lpDBusReply, &apstBTDeviceInfo)) {
4834  BTRCORELOG_ERROR ("Parsing the device %s failed..\n", pPairedDeviceInfo->devicePath[i]);
4835  dbus_message_unref(lpDBusReply);
4836  return -1;
4837  }
4838  else {
4839  memcpy (&pPairedDeviceInfo->deviceInfo[i], &apstBTDeviceInfo, sizeof(stBTDeviceInfo));
4840  }
4841 
4842  dbus_message_unref(lpDBusReply);
4843  }
4844  }
4845  }
4846 
4847 
4848  BTRCORELOG_TRACE ("Exiting\n");
4849 
4850  return 0;
4851 }
4852 
4853 
4854 int
4855 BtrCore_BTDiscoverDeviceServices (
4856  void* apstBtIfceHdl,
4857  const char* apcDevPath,
4858  stBTDeviceSupportedServiceList* pProfileList
4859 ) {
4860  stBtIfceHdl* pstlhBtIfce = (stBtIfceHdl*)apstBtIfceHdl;
4861  DBusMessage* lpDBusMsg = NULL;
4862  DBusMessage* lpDBusReply = NULL;
4863  DBusError lDBusErr;
4864  DBusMessageIter args;
4865  DBusMessageIter MsgIter;
4866  DBusPendingCall* lpDBusPendC;
4867  int match = 0;
4868  const char* apcSearchString = "UUIDs";
4869  const char* pDeviceInterface= BT_DBUS_BLUEZ_DEVICE_PATH;
4870 
4871  if (!apstBtIfceHdl)
4872  return -1;
4873 
4874 
4875  lpDBusMsg = dbus_message_new_method_call(BT_DBUS_BLUEZ_PATH,
4876  apcDevPath,
4877  DBUS_INTERFACE_PROPERTIES,
4878  "GetAll");
4879 
4880  dbus_message_iter_init_append(lpDBusMsg, &args);
4881  dbus_message_append_args(lpDBusMsg, DBUS_TYPE_STRING, &pDeviceInterface, DBUS_TYPE_INVALID);
4882 
4883  dbus_error_init(&lDBusErr);
4884  if (!dbus_connection_send_with_reply(pstlhBtIfce->pDBusConn, lpDBusMsg, &lpDBusPendC, -1)) {
4885  BTRCORELOG_ERROR ("failed to send message");
4886  return -1;
4887  }
4888 
4889  dbus_connection_flush(pstlhBtIfce->pDBusConn);
4890  dbus_message_unref(lpDBusMsg);
4891  lpDBusMsg = NULL;
4892 
4893  dbus_pending_call_block(lpDBusPendC);
4894  lpDBusReply = dbus_pending_call_steal_reply(lpDBusPendC);
4895  dbus_pending_call_unref(lpDBusPendC);
4896 
4897 
4898  dbus_message_iter_init(lpDBusReply, &MsgIter); //lpDBusMsg is pointer to dbus message received
4899  //dbus_message_iter_recurse(&MsgIter,&element); //pointer to first element of the dbus messge received
4900  /*if (!dbus_message_iter_init(lpDBusReply, &MsgIter))
4901  {
4902  BTRCORELOG_ERROR ("Message has no arguments!\n");
4903  }*/
4904 
4905  if (DBUS_TYPE_ARRAY == dbus_message_iter_get_arg_type(&MsgIter)) {
4906  DBusMessageIter arrayElementIter;
4907  dbus_message_iter_recurse(&MsgIter, &arrayElementIter); //assign new iterator to first element of array
4908  while (dbus_message_iter_has_next(&arrayElementIter)) {
4909  if (DBUS_TYPE_STRING == dbus_message_iter_get_arg_type(&arrayElementIter)) {
4910  char *dbusObject2;
4911  dbus_message_iter_get_basic(&arrayElementIter, &dbusObject2);
4912  if (strcmp(apcSearchString, dbusObject2) == 0) {
4913  match = 1;
4914  }
4915  else {
4916  match = 0;
4917  }
4918  }
4919 
4920  if (!dbus_message_iter_has_next(&arrayElementIter)) {
4921  break; //check to see if end of 3rd array
4922  }
4923  else {
4924  dbus_message_iter_next(&arrayElementIter);
4925  }
4926  }
4927  }
4928 
4929  return match;
4930 }
4931 
4932 
4933 int
4934 BtrCore_BTFindServiceSupported (
4935  void* apstBtIfceHdl,
4936  const char* apcDevPath,
4937  const char* apcSearchString,
4938  char* apcDataString
4939 ) {
4940  stBtIfceHdl* pstlhBtIfce = (stBtIfceHdl*)apstBtIfceHdl;
4941  DBusMessage* lpDBusMsg = NULL;
4942  DBusMessage* lpDBusReply = NULL;
4943  DBusError lDBusErr;
4944  DBusMessageIter arg_i, element_i;
4945  DBusMessageIter dict_i;
4946  int dbus_type;
4947 
4948  int match;
4949  const char* value;
4950  char* ret;
4951 
4952  if (!apstBtIfceHdl || !apcDevPath)
4953  return -1;
4954 
4955 
4956  //BTRCORELOG_ERROR ("%d\t: %s - apcDevPath is %s\n and service UUID is %s", __LINE__, __FUNCTION__, apcDevPath, apcSearchString);
4957  lpDBusMsg = dbus_message_new_method_call(BT_DBUS_BLUEZ_PATH,
4958  apcDevPath,
4959  BT_DBUS_BLUEZ_DEVICE_PATH,
4960  "DiscoverServices");
4961 
4962  if (!lpDBusMsg) {
4963  BTRCORELOG_ERROR ("Can't allocate new method call\n");
4964  return -1;
4965  }
4966 
4967  match = 0; //assume it does not match
4968  dbus_message_append_args(lpDBusMsg, DBUS_TYPE_STRING, &apcSearchString, DBUS_TYPE_INVALID);
4969 
4970  dbus_error_init(&lDBusErr);
4971  lpDBusReply = dbus_connection_send_with_reply_and_block(pstlhBtIfce->pDBusConn, lpDBusMsg, -1, &lDBusErr);
4972  dbus_message_unref(lpDBusMsg);
4973 
4974  if (!lpDBusReply) {
4975  BTRCORELOG_ERROR ("Failure attempting to Discover Services\n");
4976  btrCore_BTHandleDusError(&lDBusErr, __LINE__, __FUNCTION__);
4977  return -1;
4978  }
4979 
4980  if (!dbus_message_iter_init(lpDBusReply, &arg_i)) {
4981  BTRCORELOG_ERROR ("DiscoverServices lpDBusReply has no information.");
4982  return -1;
4983  }
4984 
4985  dbus_type = dbus_message_iter_get_arg_type(&arg_i);
4986  // BTRCORELOG_ERROR ("type is %d\n", dbus_type);
4987 
4988  dbus_message_iter_recurse(&arg_i, &element_i);
4989  dbus_type = dbus_message_iter_get_arg_type(&element_i);
4990  //BTRCORELOG_ERROR ("checking the type, it is %d\n",dbus_type);
4991 
4992  while (dbus_message_iter_get_arg_type(&element_i) != DBUS_TYPE_INVALID) {
4993  dbus_type = dbus_message_iter_get_arg_type(&element_i);
4994  //BTRCORELOG_ERROR ("next element_i type is %d\n",dbus_type);
4995 
4996  if (dbus_message_iter_get_arg_type(&element_i) == DBUS_TYPE_DICT_ENTRY) {
4997 
4998  dbus_message_iter_recurse(&element_i, &dict_i);
4999  dbus_type = dbus_message_iter_get_arg_type(&dict_i);
5000  // BTRCORELOG_ERROR ("checking the dict subtype, it is %d\n",dbus_type);
5001 
5002  dbus_message_iter_next(&dict_i);
5003  dbus_type = dbus_message_iter_get_arg_type(&dict_i);
5004  // BTRCORELOG_ERROR ("interating the dict subtype, it is %d\n",dbus_type);
5005  dbus_message_iter_get_basic(&dict_i, &value);
5006 
5007  // BTRCORELOG_ERROR ("Services: %s\n",value);
5008  if (apcDataString != NULL) {
5009  strcpy(apcDataString, value);
5010  }
5011 
5012  // lets strstr to see if "uuid value="<UUID>" is there
5013  ret = strstr(value, apcSearchString);
5014  if (ret !=NULL) {
5015  match = 1;//assume it does match
5016  // BTRCORELOG_ERROR ("match\n");
5017  }
5018  else {
5019  //BTRCORELOG_ERROR ("NO match\n");
5020  match = 0;//assume it does not match
5021  }
5022  }
5023 
5024  //load the new device into our list of scanned devices
5025  if (!dbus_message_iter_next(&element_i))
5026  break;
5027 
5028  }
5029 
5030  (void)dbus_type;
5031 
5032  return match;
5033 }
5034 
5035 
5036 int
5037 BtrCore_BTPerformAdapterOp (
5038  void* apstBtIfceHdl,
5039  const char* apBtAdapter,
5040  const char* apBtAgentPath,
5041  const char* apcDevPath,
5042  enBTAdapterOp aenBTAdpOp
5043 ) {
5044  stBtIfceHdl* pstlhBtIfce = (stBtIfceHdl*)apstBtIfceHdl;
5045  DBusMessage* lpDBusMsg = NULL;
5046  DBusMessage* lpDBusReply = NULL;
5047  DBusError lDBusErr;
5048  DBusMessageIter rootIter;
5049  bool adapterFound = FALSE;
5050  char* adapter_path = NULL;
5051  char deviceObjectPath[BT_MAX_DEV_PATH_LEN] = {'\0'};
5052  char deviceOpString[BT_MAX_STR_LEN/8] = {'\0'};
5053  char objectPath[BT_MAX_DEV_PATH_LEN] = {'\0'};
5054  char objectData[BT_MAX_DEV_PATH_LEN] = {'\0'};
5055  int rc = 0;
5056  int a = 0;
5057  int b = 0;
5058 
5059  if (!apstBtIfceHdl || !apBtAdapter || !apBtAgentPath || !apcDevPath || (aenBTAdpOp == enBTAdpOpUnknown))
5060  return -1;
5061 
5062 
5063  switch (aenBTAdpOp) {
5064  case enBTAdpOpFindPairedDev:
5065  strcpy(deviceOpString, "FindDevice");
5066  break;
5067  case enBTAdpOpCreatePairedDev:
5068  case enBTAdpOpCreatePairedDevASync:
5069  strcpy(deviceOpString, "Pair");
5070  break;
5071  case enBTAdpOpRemovePairedDev:
5072  strcpy(deviceOpString, "RemoveDevice");
5073  break;
5074  case enBTAdpOpUnknown:
5075  default:
5076  rc = -1;
5077  break;
5078  }
5079 
5080  if (rc == -1)
5081  return rc;
5082 
5083 
5084  if (aenBTAdpOp == enBTAdpOpFindPairedDev) {
5085  lpDBusReply = btrCore_BTSendMethodCall(pstlhBtIfce->pDBusConn, "/", DBUS_INTERFACE_OBJECT_MANAGER, "GetManagedObjects");
5086 
5087  if (lpDBusReply &&
5088  dbus_message_iter_init(lpDBusReply, &rootIter) && //point iterator to lpDBusReply message
5089  DBUS_TYPE_ARRAY == dbus_message_iter_get_arg_type(&rootIter)) { //get the type of message that iter points to
5090 
5091  DBusMessageIter arrayElementIter;
5092  dbus_message_iter_recurse(&rootIter, &arrayElementIter); //assign new iterator to first element of array
5093 
5094  while(!adapterFound) {
5095  if (DBUS_TYPE_DICT_ENTRY == dbus_message_iter_get_arg_type(&arrayElementIter)) {
5096 
5097  DBusMessageIter dictEntryIter;
5098  dbus_message_iter_recurse(&arrayElementIter,&dictEntryIter ); //assign new iterator to first element of (get all dict entries of 1st level (all object paths)
5099 
5100  if (DBUS_TYPE_OBJECT_PATH == dbus_message_iter_get_arg_type(&dictEntryIter)) {
5101  dbus_message_iter_get_basic(&dictEntryIter, &adapter_path);
5102  strncpy(objectPath, adapter_path, (strlen(adapter_path) < BT_MAX_DEV_PATH_LEN) ? strlen(adapter_path) : BT_MAX_DEV_PATH_LEN - 1);
5103  ++a;
5104  }
5105 
5106  dbus_message_iter_next(&dictEntryIter);
5107  if (DBUS_TYPE_ARRAY == dbus_message_iter_get_arg_type(&dictEntryIter)) {
5108  DBusMessageIter innerArrayIter;
5109  dbus_message_iter_recurse(&dictEntryIter, &innerArrayIter);
5110 
5111  while (dbus_message_iter_has_next(&innerArrayIter)) {
5112  if (DBUS_TYPE_DICT_ENTRY == dbus_message_iter_get_arg_type(&innerArrayIter)) {
5113  DBusMessageIter innerDictEntryIter;
5114  dbus_message_iter_recurse(&innerArrayIter,&innerDictEntryIter ); //assign new iterator to first element of
5115 
5116  if (DBUS_TYPE_STRING == dbus_message_iter_get_arg_type(&innerDictEntryIter)) {
5117  char *dbusObject;
5118  dbus_message_iter_get_basic(&innerDictEntryIter, &dbusObject);
5119  ////// getting default adapter path //////
5120  }
5121 
5122 
5123  /////// NEW //////////
5124  dbus_message_iter_next(&innerDictEntryIter);
5125  if (DBUS_TYPE_ARRAY == dbus_message_iter_get_arg_type(&innerDictEntryIter)) {
5126  DBusMessageIter innerArrayIter2;
5127  dbus_message_iter_recurse(&innerDictEntryIter, &innerArrayIter2);
5128 
5129  while (dbus_message_iter_has_next(&innerArrayIter2)) {
5130  if (DBUS_TYPE_DICT_ENTRY == dbus_message_iter_get_arg_type(&innerArrayIter2)) {
5131  DBusMessageIter innerDictEntryIter2;
5132  dbus_message_iter_recurse(&innerArrayIter2,&innerDictEntryIter2); //assign new iterator to first element of
5133  if (DBUS_TYPE_STRING == dbus_message_iter_get_arg_type(&innerDictEntryIter2)) {
5134  char *dbusObject2;
5135  dbus_message_iter_get_basic(&innerDictEntryIter2, &dbusObject2);
5136  }
5137 
5138 
5139  ////////////// NEW 2 ////////////
5140  dbus_message_iter_next(&innerDictEntryIter2);
5141  DBusMessageIter innerDictEntryIter3;
5142  char *dbusObject3;
5143 
5144  dbus_message_iter_recurse(&innerDictEntryIter2,&innerDictEntryIter3);
5145  if (DBUS_TYPE_STRING == dbus_message_iter_get_arg_type(&innerDictEntryIter3)) {
5146  dbus_message_iter_get_basic(&innerDictEntryIter3, &dbusObject3);
5147  memset(objectData, '\0', BT_MAX_DEV_PATH_LEN);
5148  strncpy(objectData, dbusObject3, (strlen(dbusObject3) < BT_MAX_DEV_PATH_LEN) ? strlen(dbusObject3) : BT_MAX_DEV_PATH_LEN - 1);
5149 
5150  if (strcmp(apcDevPath, objectData) == 0) {
5151  ++b;
5152  adapterFound = TRUE;
5153  break;
5154  }
5155  }
5156  else if (DBUS_TYPE_BOOLEAN == dbus_message_iter_get_arg_type(&innerDictEntryIter3)) {
5157  bool *device_prop = FALSE;
5158  dbus_message_iter_get_basic(&innerDictEntryIter3, &device_prop);
5159  }
5160  }
5161 
5162  if (!dbus_message_iter_has_next(&innerArrayIter2)) {
5163  break; //check to see if end of 3rd array
5164  }
5165  else {
5166  dbus_message_iter_next(&innerArrayIter2);
5167  }
5168  }
5169  }
5170  }
5171 
5172  if (!dbus_message_iter_has_next(&innerArrayIter)) {
5173  break; //check to see if end of 2nd array
5174  }
5175  else {
5176  dbus_message_iter_next(&innerArrayIter);
5177  }
5178  }
5179  }
5180 
5181  if (!dbus_message_iter_has_next(&arrayElementIter)) {
5182  break; //check to see if end of 1st array
5183  }
5184  else {
5185  dbus_message_iter_next(&arrayElementIter);
5186  }
5187  } //while loop end --used to traverse arra
5188  }
5189 
5190  dbus_message_unref(lpDBusReply);
5191  }
5192  }
5193 
5194  else if (aenBTAdpOp == enBTAdpOpRemovePairedDev) {
5195  lpDBusMsg = dbus_message_new_method_call(BT_DBUS_BLUEZ_PATH,
5196  apBtAdapter,
5197  BT_DBUS_BLUEZ_ADAPTER_PATH,
5198  deviceOpString);
5199  if (!lpDBusMsg) {
5200  BTRCORELOG_ERROR ("Can't allocate new method call\n");
5201  return -1;
5202  }
5203 
5204  dbus_message_append_args(lpDBusMsg, DBUS_TYPE_OBJECT_PATH, &apcDevPath, DBUS_TYPE_INVALID);
5205 
5206  dbus_error_init(&lDBusErr);
5207  lpDBusReply = dbus_connection_send_with_reply_and_block(pstlhBtIfce->pDBusConn, lpDBusMsg, -1, &lDBusErr);
5208  dbus_message_unref(lpDBusMsg);
5209 
5210  if (!lpDBusReply) {
5211  BTRCORELOG_ERROR ("UnPairing failed...\n");
5212  btrCore_BTHandleDusError(&lDBusErr, __LINE__, __FUNCTION__);
5213  return -1;
5214  }
5215 
5216  dbus_message_unref(lpDBusReply);
5217  }
5218 
5219  else if ((aenBTAdpOp == enBTAdpOpCreatePairedDev) || (aenBTAdpOp == enBTAdpOpCreatePairedDevASync)) {
5220  lpDBusReply = btrCore_BTSendMethodCall(pstlhBtIfce->pDBusConn, "/", DBUS_INTERFACE_OBJECT_MANAGER, "GetManagedObjects");
5221 
5222  if (lpDBusReply &&
5223  dbus_message_iter_init(lpDBusReply, &rootIter) && //point iterator to lpDBusReply message
5224  DBUS_TYPE_ARRAY == dbus_message_iter_get_arg_type(&rootIter)) { //get the type of message that iter points to
5225 
5226  DBusMessageIter arrayElementIter;
5227  dbus_message_iter_recurse(&rootIter, &arrayElementIter); //assign new iterator to first element of array
5228 
5229  while (!adapterFound) {
5230  if (DBUS_TYPE_DICT_ENTRY == dbus_message_iter_get_arg_type(&arrayElementIter)) {
5231 
5232  DBusMessageIter dictEntryIter;
5233  dbus_message_iter_recurse(&arrayElementIter,&dictEntryIter ); //assign new iterator to first element of (get all dict entries of 1st level (all object paths)
5234 
5235  if (DBUS_TYPE_OBJECT_PATH == dbus_message_iter_get_arg_type(&dictEntryIter)) {
5236  dbus_message_iter_get_basic(&dictEntryIter, &adapter_path);
5237  strncpy(objectPath, adapter_path, (strlen(adapter_path) < BT_MAX_DEV_PATH_LEN) ? strlen(adapter_path) : BT_MAX_DEV_PATH_LEN - 1);
5238  ++a;
5239  }
5240 
5241  dbus_message_iter_next(&dictEntryIter);
5242  if (DBUS_TYPE_ARRAY == dbus_message_iter_get_arg_type(&dictEntryIter)) {
5243  DBusMessageIter innerArrayIter;
5244  dbus_message_iter_recurse(&dictEntryIter, &innerArrayIter);
5245 
5246  while (dbus_message_iter_has_next(&innerArrayIter)) {
5247  if (DBUS_TYPE_DICT_ENTRY == dbus_message_iter_get_arg_type(&innerArrayIter)) {
5248  DBusMessageIter innerDictEntryIter;
5249  dbus_message_iter_recurse(&innerArrayIter,&innerDictEntryIter ); //assign new iterator to first element of
5250 
5251  if (DBUS_TYPE_STRING == dbus_message_iter_get_arg_type(&innerDictEntryIter)) {
5252  char *dbusObject;
5253  dbus_message_iter_get_basic(&innerDictEntryIter, &dbusObject);
5254  ////// getting default adapter path //////
5255  }
5256 
5257  /////// NEW //////////
5258  dbus_message_iter_next(&innerDictEntryIter);
5259  if (DBUS_TYPE_ARRAY == dbus_message_iter_get_arg_type(&innerDictEntryIter)) {
5260  DBusMessageIter innerArrayIter2;
5261  dbus_message_iter_recurse(&innerDictEntryIter, &innerArrayIter2);
5262 
5263  while (dbus_message_iter_has_next(&innerArrayIter2)) {
5264  if (DBUS_TYPE_DICT_ENTRY == dbus_message_iter_get_arg_type(&innerArrayIter2)) {
5265  DBusMessageIter innerDictEntryIter2;
5266  dbus_message_iter_recurse(&innerArrayIter2,&innerDictEntryIter2); //assign new iterator to first element of
5267 
5268  if (DBUS_TYPE_STRING == dbus_message_iter_get_arg_type(&innerDictEntryIter2)) {
5269  char *dbusObject2;
5270  dbus_message_iter_get_basic(&innerDictEntryIter2, &dbusObject2);
5271  }
5272 
5273  ////////////// NEW 2 ////////////
5274  dbus_message_iter_next(&innerDictEntryIter2);
5275  DBusMessageIter innerDictEntryIter3;
5276  char *dbusObject3;
5277 
5278  dbus_message_iter_recurse(&innerDictEntryIter2,&innerDictEntryIter3);
5279  if (DBUS_TYPE_STRING == dbus_message_iter_get_arg_type(&innerDictEntryIter3)) {
5280  dbus_message_iter_get_basic(&innerDictEntryIter3, &dbusObject3);
5281  memset(objectData, '\0', BT_MAX_DEV_PATH_LEN);
5282  strncpy(objectData, dbusObject3, (strlen(dbusObject3) < BT_MAX_DEV_PATH_LEN) ? strlen(dbusObject3) : BT_MAX_DEV_PATH_LEN - 1);
5283  if (strcmp(apcDevPath, objectData) == 0) {
5284  ++b;
5285  strcpy(deviceObjectPath,adapter_path);
5286  adapterFound = TRUE;
5287  break;
5288  }
5289  }
5290  else if (DBUS_TYPE_BOOLEAN == dbus_message_iter_get_arg_type(&innerDictEntryIter3)) {
5291  bool *device_prop = FALSE;
5292  dbus_message_iter_get_basic(&innerDictEntryIter3, &device_prop);
5293  }
5294  }
5295 
5296  if (!dbus_message_iter_has_next(&innerArrayIter2)) {
5297  break; //check to see if end of 3rd array
5298  }
5299  else {
5300  dbus_message_iter_next(&innerArrayIter2);
5301  }
5302  }
5303  }
5304  }
5305 
5306  if (!dbus_message_iter_has_next(&innerArrayIter)) {
5307  break; //check to see if end of 2nd array
5308  }
5309  else {
5310  dbus_message_iter_next(&innerArrayIter);
5311  }
5312  }
5313  }
5314 
5315  if (!dbus_message_iter_has_next(&arrayElementIter)) {
5316  break; //check to see if end of 1st array
5317  }
5318  else {
5319  dbus_message_iter_next(&arrayElementIter);
5320  }
5321  } //while loop end --used to traverse arra
5322  }
5323 
5324  dbus_message_unref(lpDBusReply);
5325  }
5326 
5327 
5328 
5329  lpDBusMsg = dbus_message_new_method_call(BT_DBUS_BLUEZ_PATH,
5330  deviceObjectPath,
5331  BT_DBUS_BLUEZ_DEVICE_PATH,
5332  deviceOpString);
5333  if (!lpDBusMsg) {
5334  BTRCORELOG_ERROR ("Can't allocate new method call\n");
5335  return -1;
5336  }
5337  if (enBTAdpOpCreatePairedDev == aenBTAdpOp) {
5338  dbus_error_init(&lDBusErr);
5339  lpDBusReply = dbus_connection_send_with_reply_and_block(pstlhBtIfce->pDBusConn, lpDBusMsg, -1, &lDBusErr);
5340  dbus_message_unref(lpDBusMsg);
5341 
5342  if (!lpDBusReply) {
5343  BTRCORELOG_ERROR ("Pairing failed...\n");
5344  btrCore_BTHandleDusError(&lDBusErr, __LINE__, __FUNCTION__);
5345  return -1;
5346  }
5347 
5348  dbus_message_unref(lpDBusReply);
5349  }
5350  else
5351  {
5352  /* The Device Pairing should not block n wait for success as this action expected to trigger chain of events like PIN sharing.
5353  * So, let us use the device pairing alone to be unblocked and wait for response.
5354  */
5355  DBusPendingCall* lpDBusPendC = NULL;
5356  if (!dbus_connection_send_with_reply(pstlhBtIfce->pDBusConn, lpDBusMsg, &lpDBusPendC, -1)) { //Send and expect lpDBusReply using pending call object
5357  BTRCORELOG_ERROR ("failed to send message!\n");
5358  }
5359  dbus_pending_call_set_notify(lpDBusPendC, btrCore_BTPendingCallCheckReply, NULL, NULL);
5360 
5361  dbus_connection_flush(pstlhBtIfce->pDBusConn);
5362  dbus_message_unref(lpDBusMsg);
5363  }
5364  }
5365 
5366  return 0;
5367 }
5368 
5369 
5370 int
5371 BtrCore_BTIsDeviceConnectable (
5372  void* apstBtIfceHdl,
5373  const char* apcDevPath
5374 ) {
5375  stBtIfceHdl* pstlhBtIfce = (stBtIfceHdl*)apstBtIfceHdl;
5376  FILE* lfpL2Ping = NULL;
5377  int i32OpRet = -1;
5378  char lcpL2PingIp[BT_MAX_STR_LEN/2] = {'\0'};
5379  char lcpL2PingOp[BT_MAX_STR_LEN] = {'\0'};
5380 
5381  if (!apstBtIfceHdl || !apcDevPath)
5382  return -1;
5383 
5384  (void)pstlhBtIfce;
5385 
5386  snprintf(lcpL2PingIp, BT_MAX_STR_LEN/2, "l2ping -i hci0 -c 3 -s 2 -d 2 %s", apcDevPath);
5387  BTRCORELOG_INFO ("lcpL2PingIp: %s\n", lcpL2PingIp);
5388 #ifdef LIBSYSWRAPPER_BUILD
5389  lfpL2Ping = v_secure_popen("r","l2ping -i hci0 -c 3 -s 2 -d 2 %s", apcDevPath);
5390 #else
5391  lfpL2Ping = popen(lcpL2PingIp, "r");
5392 #endif
5393  if ((lfpL2Ping == NULL)) {
5394  BTRCORELOG_ERROR ("Failed to run BTIsDeviceConnectable command\n");
5395  }
5396  else {
5397  if (fgets(lcpL2PingOp, sizeof(lcpL2PingOp)-1, lfpL2Ping) == NULL) {
5398  BTRCORELOG_ERROR ("Failed to Output of l2ping\n");
5399  }
5400  else {
5401  BTRCORELOG_WARN ("Output of l2ping = %s\n", lcpL2PingOp);
5402  if (!strstr(lcpL2PingOp, "Host is down")) {
5403  i32OpRet = 0;
5404  }
5405  }
5406 #ifdef LIBSYSWRAPPER_BUILD
5407  v_secure_pclose(lfpL2Ping);
5408 #else
5409  pclose(lfpL2Ping);
5410 #endif
5411  }
5412 
5413  return i32OpRet;
5414 }
5415 
5416 
5417 int
5418 BtrCore_BTConnectDevice (
5419  void* apstBtIfceHdl,
5420  const char* apDevPath,
5421  enBTDeviceType aenBTDeviceType
5422 ) {
5423  stBtIfceHdl* pstlhBtIfce = (stBtIfceHdl*)apstBtIfceHdl;
5424  DBusMessage* lpDBusMsg = NULL;
5425  dbus_bool_t lDBusOp;
5426 
5427  if (!apstBtIfceHdl || !apDevPath)
5428  return -1;
5429 
5430 
5431  lpDBusMsg = dbus_message_new_method_call(BT_DBUS_BLUEZ_PATH,
5432  apDevPath,
5433  BT_DBUS_BLUEZ_DEVICE_PATH,
5434  "Connect");
5435 
5436  if (!lpDBusMsg) {
5437  BTRCORELOG_ERROR ("Can't allocate new method call\n");
5438  return -1;
5439  }
5440 
5441  lDBusOp = dbus_connection_send(pstlhBtIfce->pDBusConn, lpDBusMsg, NULL);
5442  dbus_message_unref(lpDBusMsg);
5443 
5444  if (!lDBusOp) {
5445  BTRCORELOG_ERROR ("Not enough memory for message send\n");
5446  return -1;
5447  }
5448 
5449  dbus_connection_flush(pstlhBtIfce->pDBusConn);
5450 
5451  return 0;
5452 }
5453 
5454 
5455 int
5456 BtrCore_BTDisconnectDevice (
5457  void* apstBtIfceHdl,
5458  const char* apDevPath,
5459  enBTDeviceType aenBTDeviceType
5460 ) {
5461  stBtIfceHdl* pstlhBtIfce = (stBtIfceHdl*)apstBtIfceHdl;
5462  DBusMessage* lpDBusMsg = NULL;
5463  dbus_bool_t lDBusOp;
5464 
5465  if (!apstBtIfceHdl || !apDevPath)
5466  return -1;
5467 
5468 
5469  lpDBusMsg = dbus_message_new_method_call(BT_DBUS_BLUEZ_PATH,
5470  apDevPath,
5471  BT_DBUS_BLUEZ_DEVICE_PATH,
5472  "Disconnect");
5473 
5474  if (!lpDBusMsg) {
5475  BTRCORELOG_ERROR ("Can't allocate new method call\n");
5476  return -1;
5477  }
5478 
5479  lDBusOp = dbus_connection_send(pstlhBtIfce->pDBusConn, lpDBusMsg, NULL);
5480  dbus_message_unref(lpDBusMsg);
5481 
5482  if (!lDBusOp) {
5483  BTRCORELOG_ERROR ("Not enough memory for message send\n");
5484  return -1;
5485  }
5486 
5487  dbus_connection_flush(pstlhBtIfce->pDBusConn);
5488 
5489  return 0;
5490 }
5491 
5492 
5493 int
5494 BtrCore_BTEnableEnhancedRetransmissionMode (
5495  void* apstBtIfceHdl
5496 ) {
5497  stBtIfceHdl* pstlhBtIfce = (stBtIfceHdl*)apstBtIfceHdl;
5498  FILE* lfpBtErtm = NULL;
5499  int i32OpRet = -1;
5500  char lcpBtErtmIp[BT_MAX_STR_LEN/2] = {'\0'};
5501  char lcpBtErtmOp[BT_MAX_STR_LEN] = {'\0'};
5502 
5503  if (!apstBtIfceHdl || !pstlhBtIfce)
5504  return -1;
5505 
5506 
5507  memset(lcpBtErtmIp, '\0', BT_MAX_STR_LEN/2);
5508  memset(lcpBtErtmOp, '\0', BT_MAX_STR_LEN);
5509 
5510  snprintf(lcpBtErtmIp, BT_MAX_STR_LEN/2, "echo 0 > /sys/module/bluetooth/parameters/disable_ertm");
5511  BTRCORELOG_INFO ("lcpBtErtmIp: %s\n", lcpBtErtmIp);
5512 
5513 #ifdef LIBSYSWRAPPER_BUILD
5514  lfpBtErtm = v_secure_popen("r", lcpBtErtmIp);
5515 #else
5516  lfpBtErtm = popen(lcpBtErtmIp, "r");
5517 #endif
5518  if (lfpBtErtm == NULL) {
5519  BTRCORELOG_ERROR ("Failed to run BTEnableEnhancedRetransmissionMode command\n");
5520  }
5521  else {
5522  if (fgets(lcpBtErtmOp, sizeof(lcpBtErtmOp)-1, lfpBtErtm) == NULL) {
5523  BTRCORELOG_INFO ("Success - Output of BtErtm\n");
5524  i32OpRet = 0;
5525  }
5526  else {
5527  BTRCORELOG_WARN ("Failed Output of BtErtm = %s\n", lcpBtErtmOp);
5528  if (!strstr(lcpBtErtmOp, "Permission denied")) {
5529  BTRCORELOG_WARN ("Check path = %s\n", lcpBtErtmIp);
5530  }
5531  }
5532 #ifdef LIBSYSWRAPPER_BUILD
5533  v_secure_pclose(lfpBtErtm);
5534 #else
5535  pclose(lfpBtErtm);
5536 #endif
5537  }
5538 
5539  return i32OpRet;
5540 }
5541 
5542 
5543 int
5544 BtrCore_BTDisableEnhancedRetransmissionMode (
5545  void* apstBtIfceHdl
5546 ) {
5547  stBtIfceHdl* pstlhBtIfce = (stBtIfceHdl*)apstBtIfceHdl;
5548  FILE* lfpBtErtm = NULL;
5549  int i32OpRet = -1;
5550  char lcpBtErtmIp[BT_MAX_STR_LEN/2] = {'\0'};
5551  char lcpBtErtmOp[BT_MAX_STR_LEN] = {'\0'};
5552 
5553  if (!apstBtIfceHdl || !pstlhBtIfce)
5554  return -1;
5555 
5556 
5557  memset(lcpBtErtmIp, '\0', BT_MAX_STR_LEN/2);
5558  memset(lcpBtErtmOp, '\0', BT_MAX_STR_LEN);
5559 
5560  snprintf(lcpBtErtmIp, BT_MAX_STR_LEN/2, "echo 1 > /sys/module/bluetooth/parameters/disable_ertm");
5561  BTRCORELOG_INFO ("lcpBtErtmIp: %s\n", lcpBtErtmIp);
5562 
5563 #ifdef LIBSYSWRAPPER_BUILD
5564  lfpBtErtm = v_secure_popen("r", lcpBtErtmIp);
5565 #else
5566  lfpBtErtm = popen(lcpBtErtmIp, "r");
5567 #endif
5568  if ((lfpBtErtm == NULL)) {
5569  BTRCORELOG_ERROR ("Failed to run BTDisableEnhancedRetransmissionMode command\n");
5570  }
5571  else {
5572  if (fgets(lcpBtErtmOp, sizeof(lcpBtErtmOp)-1, lfpBtErtm) == NULL) {
5573  BTRCORELOG_INFO ("Success - Output of BtErtm\n");
5574  i32OpRet = 0;
5575  }
5576  else {
5577  BTRCORELOG_WARN ("Failed Output of BtErtm = %s\n", lcpBtErtmOp);
5578  if (!strstr(lcpBtErtmOp, "Permission denied")) {
5579  BTRCORELOG_WARN ("Check path = %s\n", lcpBtErtmIp);
5580  }
5581  }
5582 #ifdef LIBSYSWRAPPER_BUILD
5583  v_secure_pclose(lfpBtErtm);
5584 #else
5585  pclose(lfpBtErtm);
5586 #endif
5587  }
5588 
5589  return i32OpRet;
5590 }
5591 
5592 
5593 int
5594 BtrCore_BTRegisterMedia (
5595  void* apstBtIfceHdl,
5596  const char* apBtAdapter,
5597  enBTDeviceType aenBTDevType,
5598  enBTMediaType aenBTMediaType,
5599  const char* apBtUUID,
5600  void* apBtMediaCapabilities,
5601  int apBtMediaCapabilitiesSize,
5602  int abBtMediaDelayReportEnable
5603 ) {
5604  stBtIfceHdl* pstlhBtIfce = (stBtIfceHdl*)apstBtIfceHdl;
5605  DBusMessage* lpDBusMsg = NULL;
5606  DBusMessage* lpDBusReply = NULL;
5607  DBusError lDBusErr;
5608  DBusMessageIter lDBusMsgIter;
5609  DBusMessageIter lDBusMsgIterArr;
5610  dbus_bool_t lDBusOp;
5611  dbus_bool_t lBtMediaDelayReport = FALSE;
5612 
5613  const char* lpBtMediaEpObjPath;
5614  char lBtMediaCodec;
5615 
5616  if (!apstBtIfceHdl)
5617  return -1;
5618 
5619 
5620  switch (aenBTMediaType) {
5621  case enBTMediaTypePCM:
5622  lBtMediaCodec = BT_MEDIA_CODEC_PCM;
5623  break;
5624  case enBTMediaTypeSBC:
5625  lBtMediaCodec = BT_MEDIA_CODEC_SBC;
5626  break;
5627  case enBTMediaTypeMP3:
5628  lBtMediaCodec = BT_MEDIA_CODEC_MPEG12;
5629  break;
5630  case enBTMediaTypeAAC:
5631  lBtMediaCodec = BT_MEDIA_CODEC_MPEG24;
5632  break;
5633  case enBTMediaTypeUnknown:
5634  default:
5635  lBtMediaCodec = BT_MEDIA_CODEC_SBC;
5636  break;
5637  }
5638 
5639 
5640  switch (aenBTDevType) {
5641  case enBTDevAudioSink:
5642  if (lBtMediaCodec == BT_MEDIA_CODEC_SBC) {
5643  lpBtMediaEpObjPath = BT_MEDIA_SBC_A2DP_SOURCE_ENDPOINT;
5644  }
5645  else if (lBtMediaCodec == BT_MEDIA_CODEC_MPEG12) {
5646  lpBtMediaEpObjPath = BT_MEDIA_MP3_A2DP_SOURCE_ENDPOINT;
5647  }
5648  else if (lBtMediaCodec == BT_MEDIA_CODEC_MPEG24) {
5649  lpBtMediaEpObjPath = BT_MEDIA_AAC_A2DP_SOURCE_ENDPOINT;
5650  }
5651  else {
5652  lpBtMediaEpObjPath = BT_MEDIA_SBC_A2DP_SOURCE_ENDPOINT;
5653  }
5654  break;
5655  case enBTDevAudioSource:
5656  if (lBtMediaCodec == BT_MEDIA_CODEC_SBC) {
5657  lpBtMediaEpObjPath = BT_MEDIA_SBC_A2DP_SINK_ENDPOINT;
5658  }
5659  else if (lBtMediaCodec == BT_MEDIA_CODEC_MPEG12) {
5660  lpBtMediaEpObjPath = BT_MEDIA_MP3_A2DP_SINK_ENDPOINT;
5661  }
5662  else if (lBtMediaCodec == BT_MEDIA_CODEC_MPEG24) {
5663  lpBtMediaEpObjPath = BT_MEDIA_AAC_A2DP_SINK_ENDPOINT;
5664  }
5665  else {
5666  lpBtMediaEpObjPath = BT_MEDIA_SBC_A2DP_SINK_ENDPOINT;
5667  }
5668  break;
5669  case enBTDevHFPHeadset:
5670  if (lBtMediaCodec == BT_MEDIA_CODEC_PCM) {
5671  lpBtMediaEpObjPath = BT_MEDIA_PCM_HFP_AG_ENDPOINT;
5672  }
5673  else if (lBtMediaCodec == BT_MEDIA_CODEC_SBC) {
5674  lpBtMediaEpObjPath = BT_MEDIA_SBC_HFP_AG_ENDPOINT;
5675  }
5676  else {
5677  lpBtMediaEpObjPath = BT_MEDIA_PCM_HFP_AG_ENDPOINT;
5678  }
5679  break;
5680  case enBTDevHFPAudioGateway:
5681  lpBtMediaEpObjPath = BT_MEDIA_PCM_HFP_HS_ENDPOINT;
5682  break;
5683  case enBTDevUnknown:
5684  default:
5685  lpBtMediaEpObjPath = BT_MEDIA_SBC_A2DP_SOURCE_ENDPOINT;
5686  break;
5687  }
5688 
5689  if (abBtMediaDelayReportEnable)
5690  lBtMediaDelayReport = TRUE;
5691 
5692  dbus_error_init(&lDBusErr);
5693  lDBusOp = dbus_connection_try_register_object_path(pstlhBtIfce->pDBusConn, lpBtMediaEpObjPath, &gDBusMediaEndpointVTable, pstlhBtIfce, &lDBusErr);
5694  if (!lDBusOp) {
5695  btrCore_BTHandleDusError(&lDBusErr, __LINE__, __FUNCTION__);
5696  BTRCORELOG_ERROR ("Can't Register Media Object - %s\n", lpBtMediaEpObjPath);
5697 
5698  if (strcmp(lDBusErr.name, DBUS_ERROR_OBJECT_PATH_IN_USE) != 0)
5699  return -1;
5700  }
5701 
5702  lpDBusMsg = dbus_message_new_method_call(BT_DBUS_BLUEZ_PATH,
5703  apBtAdapter,
5704  BT_DBUS_BLUEZ_MEDIA_PATH,
5705  "RegisterEndpoint");
5706  if (!lpDBusMsg) {
5707  BTRCORELOG_ERROR ("Can't allocate new method call\n");
5708  return -1;
5709  }
5710 
5711  dbus_message_iter_init_append (lpDBusMsg, &lDBusMsgIter);
5712  dbus_message_iter_append_basic (&lDBusMsgIter, DBUS_TYPE_OBJECT_PATH, &lpBtMediaEpObjPath);
5713  dbus_message_iter_open_container (&lDBusMsgIter, DBUS_TYPE_ARRAY, "{sv}", &lDBusMsgIterArr);
5714  {
5715  DBusMessageIter lDBusMsgIterDict, lDBusMsgIterVariant;
5716  char* key = "UUID";
5717  int type = DBUS_TYPE_STRING;
5718 
5719  dbus_message_iter_open_container (&lDBusMsgIterArr, DBUS_TYPE_DICT_ENTRY, NULL, &lDBusMsgIterDict);
5720  dbus_message_iter_append_basic (&lDBusMsgIterDict, DBUS_TYPE_STRING, &key);
5721  dbus_message_iter_open_container (&lDBusMsgIterDict, DBUS_TYPE_VARIANT, (char *)&type, &lDBusMsgIterVariant);
5722  dbus_message_iter_append_basic (&lDBusMsgIterVariant, type, &apBtUUID);
5723  dbus_message_iter_close_container (&lDBusMsgIterDict, &lDBusMsgIterVariant);
5724  dbus_message_iter_close_container (&lDBusMsgIterArr, &lDBusMsgIterDict);
5725  }
5726  {
5727  DBusMessageIter lDBusMsgIterDict, lDBusMsgIterVariant;
5728  char* key = "Codec";
5729  int type = DBUS_TYPE_BYTE;
5730 
5731  dbus_message_iter_open_container (&lDBusMsgIterArr, DBUS_TYPE_DICT_ENTRY, NULL, &lDBusMsgIterDict);
5732  dbus_message_iter_append_basic (&lDBusMsgIterDict, DBUS_TYPE_STRING, &key);
5733  dbus_message_iter_open_container (&lDBusMsgIterDict, DBUS_TYPE_VARIANT, (char *)&type, &lDBusMsgIterVariant);
5734  dbus_message_iter_append_basic (&lDBusMsgIterVariant, type, &lBtMediaCodec);
5735  dbus_message_iter_close_container (&lDBusMsgIterDict, &lDBusMsgIterVariant);
5736  dbus_message_iter_close_container (&lDBusMsgIterArr, &lDBusMsgIterDict);
5737  }
5738  {
5739  DBusMessageIter lDBusMsgIterDict, lDBusMsgIterVariant;
5740  char* key = "DelayReporting";
5741  int type = DBUS_TYPE_BOOLEAN;
5742 
5743  dbus_message_iter_open_container (&lDBusMsgIterArr, DBUS_TYPE_DICT_ENTRY, NULL, &lDBusMsgIterDict);
5744  dbus_message_iter_append_basic (&lDBusMsgIterDict, DBUS_TYPE_STRING, &key);
5745  dbus_message_iter_open_container (&lDBusMsgIterDict, DBUS_TYPE_VARIANT, (char *)&type, &lDBusMsgIterVariant);
5746  dbus_message_iter_append_basic (&lDBusMsgIterVariant, type, &lBtMediaDelayReport);
5747  dbus_message_iter_close_container (&lDBusMsgIterDict, &lDBusMsgIterVariant);
5748  dbus_message_iter_close_container (&lDBusMsgIterArr, &lDBusMsgIterDict);
5749  }
5750  {
5751  DBusMessageIter lDBusMsgIterDict, lDBusMsgIterVariant, lDBusMsgIterSubArray;
5752  char* key = "Capabilities";
5753  int type = DBUS_TYPE_BYTE;
5754 
5755  char array_type[5] = "a";
5756  strncat (array_type, (char*)&type, sizeof(array_type) - sizeof(type));
5757 
5758  dbus_message_iter_open_container (&lDBusMsgIterArr, DBUS_TYPE_DICT_ENTRY, NULL, &lDBusMsgIterDict);
5759  dbus_message_iter_append_basic (&lDBusMsgIterDict, DBUS_TYPE_STRING, &key);
5760  dbus_message_iter_open_container (&lDBusMsgIterDict, DBUS_TYPE_VARIANT, array_type, &lDBusMsgIterVariant);
5761  dbus_message_iter_open_container (&lDBusMsgIterVariant, DBUS_TYPE_ARRAY, (char *)&type, &lDBusMsgIterSubArray);
5762  dbus_message_iter_append_fixed_array (&lDBusMsgIterSubArray, type, &apBtMediaCapabilities, apBtMediaCapabilitiesSize);
5763  dbus_message_iter_close_container (&lDBusMsgIterVariant, &lDBusMsgIterSubArray);
5764  dbus_message_iter_close_container (&lDBusMsgIterDict, &lDBusMsgIterVariant);
5765  dbus_message_iter_close_container (&lDBusMsgIterArr, &lDBusMsgIterDict);
5766  }
5767  dbus_message_iter_close_container (&lDBusMsgIter, &lDBusMsgIterArr);
5768 
5769 
5770  dbus_error_init(&lDBusErr);
5771  lpDBusReply = dbus_connection_send_with_reply_and_block (pstlhBtIfce->pDBusConn, lpDBusMsg, -1, &lDBusErr);
5772  dbus_message_unref(lpDBusMsg);
5773 
5774  if (!lpDBusReply) {
5775  BTRCORELOG_ERROR ("lpDBusReply Null\n");
5776  btrCore_BTHandleDusError(&lDBusErr, __LINE__, __FUNCTION__);
5777  return -1;
5778  }
5779 
5780  dbus_message_unref(lpDBusReply);
5781 
5782  dbus_connection_flush(pstlhBtIfce->pDBusConn);
5783 
5784  return 0;
5785 }
5786 
5787 
5788 int
5789 BtrCore_BTUnRegisterMedia (
5790  void* apstBtIfceHdl,
5791  const char* apBtAdapter,
5792  enBTDeviceType aenBTDevType,
5793  enBTMediaType aenBTMediaType
5794 ) {
5795  stBtIfceHdl* pstlhBtIfce = (stBtIfceHdl*)apstBtIfceHdl;
5796  DBusMessage* lpDBusMsg = NULL;
5797  dbus_bool_t lDBusOp;
5798 
5799  const char* lpBtMediaEpObjPath;
5800  int lBtMediaCodec;
5801 
5802  if (!apstBtIfceHdl)
5803  return -1;
5804 
5805 
5806  switch (aenBTMediaType) {
5807  case enBTMediaTypePCM:
5808  lBtMediaCodec = BT_MEDIA_CODEC_PCM;
5809  break;
5810  case enBTMediaTypeSBC:
5811  lBtMediaCodec = BT_MEDIA_CODEC_SBC;
5812  break;
5813  case enBTMediaTypeMP3:
5814  lBtMediaCodec = BT_MEDIA_CODEC_MPEG12;
5815  break;
5816  case enBTMediaTypeAAC:
5817  lBtMediaCodec = BT_MEDIA_CODEC_MPEG24;
5818  break;
5819  case enBTMediaTypeUnknown:
5820  default:
5821  lBtMediaCodec = BT_MEDIA_CODEC_SBC;
5822  break;
5823  }
5824 
5825 
5826  switch (aenBTDevType) {
5827  case enBTDevAudioSink:
5828  if (lBtMediaCodec == BT_MEDIA_CODEC_SBC) {
5829  lpBtMediaEpObjPath = BT_MEDIA_SBC_A2DP_SOURCE_ENDPOINT;
5830  }
5831  else if (lBtMediaCodec == BT_MEDIA_CODEC_MPEG12) {
5832  lpBtMediaEpObjPath = BT_MEDIA_MP3_A2DP_SOURCE_ENDPOINT;
5833  }
5834  else if (lBtMediaCodec == BT_MEDIA_CODEC_MPEG24) {
5835  lpBtMediaEpObjPath = BT_MEDIA_AAC_A2DP_SOURCE_ENDPOINT;
5836  }
5837  else {
5838  lpBtMediaEpObjPath = BT_MEDIA_SBC_A2DP_SOURCE_ENDPOINT;
5839  }
5840  break;
5841  case enBTDevAudioSource:
5842  if (lBtMediaCodec == BT_MEDIA_CODEC_SBC) {
5843  lpBtMediaEpObjPath = BT_MEDIA_SBC_A2DP_SINK_ENDPOINT;
5844  }
5845  else if (lBtMediaCodec == BT_MEDIA_CODEC_MPEG12) {
5846  lpBtMediaEpObjPath = BT_MEDIA_MP3_A2DP_SINK_ENDPOINT;
5847  }
5848  else if (lBtMediaCodec == BT_MEDIA_CODEC_MPEG24) {
5849  lpBtMediaEpObjPath = BT_MEDIA_AAC_A2DP_SINK_ENDPOINT;
5850  }
5851  else {
5852  lpBtMediaEpObjPath = BT_MEDIA_SBC_A2DP_SINK_ENDPOINT;
5853  }
5854  break;
5855  case enBTDevHFPHeadset:
5856  if (lBtMediaCodec == BT_MEDIA_CODEC_PCM) {
5857  lpBtMediaEpObjPath = BT_MEDIA_PCM_HFP_AG_ENDPOINT;
5858  }
5859  else if (lBtMediaCodec == BT_MEDIA_CODEC_SBC) {
5860  lpBtMediaEpObjPath = BT_MEDIA_SBC_HFP_AG_ENDPOINT;
5861  }
5862  else {
5863  lpBtMediaEpObjPath = BT_MEDIA_PCM_HFP_AG_ENDPOINT;
5864  }
5865  break;
5866  case enBTDevHFPAudioGateway:
5867  lpBtMediaEpObjPath = BT_MEDIA_PCM_HFP_HS_ENDPOINT;
5868  break;
5869  case enBTDevUnknown:
5870  default:
5871  lpBtMediaEpObjPath = BT_MEDIA_SBC_A2DP_SOURCE_ENDPOINT;
5872  break;
5873  }
5874 
5875 
5876  lpDBusMsg = dbus_message_new_method_call(BT_DBUS_BLUEZ_PATH,
5877  apBtAdapter,
5878  BT_DBUS_BLUEZ_MEDIA_PATH,
5879  "UnregisterEndpoint");
5880 
5881  if (!lpDBusMsg) {
5882  BTRCORELOG_ERROR ("Can't allocate new method call\n");
5883  return -1;
5884  }
5885 
5886  dbus_message_append_args(lpDBusMsg, DBUS_TYPE_OBJECT_PATH, &lpBtMediaEpObjPath, DBUS_TYPE_INVALID);
5887 
5888  lDBusOp = dbus_connection_send(pstlhBtIfce->pDBusConn, lpDBusMsg, NULL);
5889  dbus_message_unref(lpDBusMsg);
5890 
5891  if (!lDBusOp) {
5892  BTRCORELOG_ERROR ("Not enough memory for message send\n");
5893  return -1;
5894  }
5895 
5896  lDBusOp = dbus_connection_unregister_object_path(pstlhBtIfce->pDBusConn, lpBtMediaEpObjPath);
5897  if (!lDBusOp) {
5898  BTRCORELOG_ERROR ("Can't Register Media Object\n");
5899  return -1;
5900  }
5901 
5902 
5903  dbus_connection_flush(pstlhBtIfce->pDBusConn);
5904 
5905  return 0;
5906 }
5907 
5908 
5909 int
5910 BtrCore_BTAcquireDevDataPath (
5911  void* apstBtIfceHdl,
5912  char* apcDevTransportPath,
5913  int* dataPathFd,
5914  int* dataReadMTU,
5915  int* dataWriteMTU
5916 ) {
5917  stBtIfceHdl* pstlhBtIfce = (stBtIfceHdl*)apstBtIfceHdl;
5918  DBusMessage* lpDBusMsg = NULL;
5919  DBusMessage* lpDBusReply = NULL;
5920  DBusError lDBusErr;
5921  dbus_bool_t lDBusOp;
5922 
5923  if (!apstBtIfceHdl || !apcDevTransportPath)
5924  return -1;
5925 
5926 
5927  lpDBusMsg = dbus_message_new_method_call (BT_DBUS_BLUEZ_PATH,
5928  apcDevTransportPath,
5929  BT_DBUS_BLUEZ_MEDIA_TRANSPORT_PATH,
5930  "Acquire");
5931 
5932  if (!lpDBusMsg) {
5933  BTRCORELOG_ERROR ("Can't allocate new method call\n");
5934  return -1;
5935  }
5936 
5937  dbus_error_init(&lDBusErr);
5938  lpDBusReply = dbus_connection_send_with_reply_and_block (pstlhBtIfce->pDBusConn, lpDBusMsg, -1, &lDBusErr);
5939  dbus_message_unref(lpDBusMsg);
5940 
5941  if (!lpDBusReply) {
5942  BTRCORELOG_ERROR ("lpDBusReply Null\n");
5943  btrCore_BTHandleDusError(&lDBusErr, __LINE__, __FUNCTION__);
5944  return -1;
5945  }
5946 
5947  lDBusOp = dbus_message_get_args(lpDBusReply, &lDBusErr,
5948  DBUS_TYPE_UNIX_FD, dataPathFd,
5949  DBUS_TYPE_UINT16, dataReadMTU,
5950  DBUS_TYPE_UINT16, dataWriteMTU,
5951  DBUS_TYPE_INVALID);
5952  dbus_message_unref(lpDBusReply);
5953 
5954  if (!lDBusOp) {
5955  BTRCORELOG_ERROR ("Can't get lpDBusReply arguments\n");
5956  btrCore_BTHandleDusError(&lDBusErr, __LINE__, __FUNCTION__);
5957  return -1;
5958  }
5959 
5960  dbus_connection_flush(pstlhBtIfce->pDBusConn);
5961 
5962  return 0;
5963 }
5964 
5965 
5966 int
5967 BtrCore_BTReleaseDevDataPath (
5968  void* apstBtIfceHdl,
5969  char* apcDevTransportPath
5970 ) {
5971  stBtIfceHdl* pstlhBtIfce = (stBtIfceHdl*)apstBtIfceHdl;
5972  DBusMessage* lpDBusMsg = NULL;
5973  DBusMessage* lpDBusReply = NULL;
5974  DBusError lDBusErr;
5975 
5976  if (!apstBtIfceHdl || !apcDevTransportPath)
5977  return -1;
5978 
5979 
5980  lpDBusMsg = dbus_message_new_method_call (BT_DBUS_BLUEZ_PATH,
5981  apcDevTransportPath,
5982  BT_DBUS_BLUEZ_MEDIA_TRANSPORT_PATH,
5983  "Release");
5984 
5985  if (!lpDBusMsg) {
5986  BTRCORELOG_ERROR ("Can't allocate new method call\n");
5987  return -1;
5988  }
5989 
5990 
5991  dbus_error_init(&lDBusErr);
5992  lpDBusReply = dbus_connection_send_with_reply_and_block (pstlhBtIfce->pDBusConn, lpDBusMsg, -1, &lDBusErr);
5993  dbus_message_unref(lpDBusMsg);
5994 
5995  if (!lpDBusReply) {
5996  BTRCORELOG_ERROR ("lpDBusReply Null\n");
5997  btrCore_BTHandleDusError(&lDBusErr, __LINE__, __FUNCTION__);
5998  return -1;
5999  }
6000 
6001  dbus_message_unref(lpDBusReply);
6002 
6003  dbus_connection_flush(pstlhBtIfce->pDBusConn);
6004 
6005  return 0;
6006 }
6007 
6008 
6009 int
6010 BtrCore_BTSetDevDataAckTimeout (
6011  void* apstBtIfceHdl,
6012  unsigned int aui32AckTOutms
6013 ) {
6014  stBtIfceHdl* pstlhBtIfce = (stBtIfceHdl*)apstBtIfceHdl;
6015  FILE* lHciDataAck = NULL;
6016  int i32OpRet = -1;
6017  char lcpHciDataWriteAckTOutIp[BT_MAX_STR_LEN/2] = {'\0'};
6018  char lcpHciDataWriteAckTOutOp[BT_MAX_STR_LEN] = {'\0'};
6019 
6020  if (!apstBtIfceHdl)
6021  return -1;
6022 
6023  (void)pstlhBtIfce;
6024 
6025  snprintf(lcpHciDataWriteAckTOutIp, BT_MAX_STR_LEN/2, "hcitool -i hci0 cmd 0x03 0x0028 0x0C 0x00 0x%02x 0x00", aui32AckTOutms);
6026  BTRCORELOG_INFO ("lcpHciDataWriteAckTOutIp: %s\n", lcpHciDataWriteAckTOutIp);
6027 
6028  lHciDataAck = popen(lcpHciDataWriteAckTOutIp, "r");
6029  if ((lHciDataAck == NULL)) {
6030  BTRCORELOG_ERROR ("Failed to run lcpHciDataWriteAckTOutIp command\n");
6031  }
6032  else {
6033  if (fgets(lcpHciDataWriteAckTOutOp, sizeof(lcpHciDataWriteAckTOutOp)-1, lHciDataAck) == NULL) {
6034  BTRCORELOG_ERROR ("Failed to Output of lcpHciDataWriteAckTOutIp\n");
6035  }
6036  else {
6037  BTRCORELOG_WARN ("Output of lcpHciDataWriteAckTOutIp = %s\n", lcpHciDataWriteAckTOutOp);
6038  if (strstr(lcpHciDataWriteAckTOutOp, "HCI Command: ogf 0x03, ocf 0x0028, plen 4")) {
6039  i32OpRet = 0;
6040  }
6041  }
6042 
6043  pclose(lHciDataAck);
6044  }
6045 
6046  return i32OpRet;
6047 }
6048 
6049 
6050 ///////////////////////////////////////////////////// AVRCP Functions ////////////////////////////////////////////////////
6051 /* Get Player Object Path on Remote BT Device*/
6052 char*
6053 BtrCore_BTGetMediaPlayerPath (
6054  void* apstBtIfceHdl,
6055  const char* apBtDevPath
6056 ) {
6057  stBtIfceHdl* pstlhBtIfce = (stBtIfceHdl*)apstBtIfceHdl;
6058  char* playerObjectPath = NULL;
6059  bool isConnected = FALSE;
6060 
6061  if (!apstBtIfceHdl || !apBtDevPath) {
6062  BTRCORELOG_ERROR ("Invalid args!!!");
6063  return NULL;
6064  }
6065 
6066 
6067  if (btrCore_BTGetMediaIfceProperty(pstlhBtIfce->pDBusConn, apBtDevPath, BT_DBUS_BLUEZ_MEDIA_CTRL_PATH, "Connected", (void*)&isConnected)) {
6068  BTRCORELOG_ERROR ("Failed to get %s property : Connected!!!", BT_DBUS_BLUEZ_MEDIA_CTRL_PATH);
6069  return NULL;
6070  }
6071 
6072  if (FALSE == isConnected) {
6073  BTRCORELOG_WARN ("%s is not connected", BT_DBUS_BLUEZ_MEDIA_CTRL_PATH);
6074  return NULL;
6075  }
6076 
6077  if (btrCore_BTGetMediaIfceProperty(pstlhBtIfce->pDBusConn, apBtDevPath, BT_DBUS_BLUEZ_MEDIA_CTRL_PATH, "Player", (void*)&playerObjectPath)) {
6078  BTRCORELOG_ERROR ("Failed to get %s property : Player!!!", BT_DBUS_BLUEZ_MEDIA_CTRL_PATH);
6079  return NULL;
6080  }
6081 
6082  return playerObjectPath;
6083 }
6084 
6085 
6086 
6087 /* Control Media on Remote BT Device*/
6088 int
6089 BtrCore_BTDevMediaControl (
6090  void* apstBtIfceHdl,
6091  const char* apMediaPlayerPath,
6092  enBTMediaControlCmd aenBTMediaOper
6093 ) {
6094  stBtIfceHdl* pstlhBtIfce = (stBtIfceHdl*)apstBtIfceHdl;
6095  dbus_bool_t lDBusOp;
6096  DBusMessage* lpDBusMsg = NULL;
6097  char mediaOper[16] = "\0";
6098  char* mediaProp = NULL;
6099  char* propValue = NULL;
6100 
6101  if (!apstBtIfceHdl || !apMediaPlayerPath) {
6102  BTRCORELOG_ERROR ("Invalid args!!!");
6103  return -1;
6104  }
6105 
6106 
6107  switch (aenBTMediaOper) {
6108  case enBTMediaCtrlPlay:
6109  strcpy(mediaOper, "Play");
6110  break;
6111  case enBTMediaCtrlPause:
6112  strcpy(mediaOper, "Pause");
6113  break;
6114  case enBTMediaCtrlStop:
6115  strcpy(mediaOper, "Stop");
6116  break;
6117  case enBTMediaCtrlNext:
6118  strcpy(mediaOper, "Next");
6119  break;
6120  case enBTMediaCtrlPrevious:
6121  strcpy(mediaOper, "Previous");
6122  break;
6123  case enBTMediaCtrlFastForward:
6124  strcpy(mediaOper, "FastForward");
6125  break;
6126  case enBTMediaCtrlRewind:
6127  strcpy(mediaOper, "Rewind");
6128  break;
6129  case enBTMediaCtrlVolumeUp:
6130  strcpy(mediaOper, "VolumeUp");
6131  break;
6132  case enBTMediaCtrlVolumeDown:
6133  strcpy(mediaOper, "VolumeDown");
6134  break;
6135  case enBTMediaCtrlEqlzrOff:
6136  mediaProp = "Equalizer";
6137  propValue = "off";
6138  break;
6139  case enBTMediaCtrlEqlzrOn:
6140  mediaProp = "Equalizer";
6141  propValue = "on";
6142  break;
6143  case enBTMediaCtrlShflOff:
6144  mediaProp = "Shuffle";
6145  propValue = "off";
6146  break;
6147  case enBTMediaCtrlShflAllTracks:
6148  mediaProp = "Shuffle";
6149  propValue = "alltracks";
6150  break;
6151  case enBTMediaCtrlShflGroup:
6152  mediaProp = "Shuffle";
6153  propValue = "group";
6154  break;
6155  case enBTMediaCtrlRptOff:
6156  mediaProp = "Repeat";
6157  propValue = "off";
6158  break;
6159  case enBTMediaCtrlRptSingleTrack:
6160  mediaProp = "Repeat";
6161  propValue = "singletrack";
6162  break;
6163  case enBTMediaCtrlRptAllTracks:
6164  mediaProp = "Repeat";
6165  propValue = "alltracks";
6166  break;
6167  case enBTMediaCtrlRptGroup:
6168  mediaProp = "Repeat";
6169  propValue = "group";
6170  break;
6171  default:
6172  break;
6173  }
6174 
6175 
6176  if (mediaOper[0]) {
6177  lpDBusMsg = dbus_message_new_method_call(BT_DBUS_BLUEZ_PATH,
6178  apMediaPlayerPath,
6179  BT_DBUS_BLUEZ_MEDIA_PLAYER_PATH,
6180  mediaOper);
6181  }
6182  else
6183  if (mediaProp[0]) {
6184  lpDBusMsg = dbus_message_new_method_call(BT_DBUS_BLUEZ_PATH,
6185  apMediaPlayerPath,
6186  DBUS_INTERFACE_PROPERTIES,
6187  "Set");
6188  {
6189  DBusMessageIter lDBusMsgIter;
6190  DBusMessageIter lDBusMsgIterValue;
6191  const char* mediaPlayerIfce = BT_DBUS_BLUEZ_MEDIA_PLAYER_PATH;
6192  const char* lDBusTypeAsString = DBUS_TYPE_STRING_AS_STRING;
6193 
6194  dbus_message_iter_init_append(lpDBusMsg, &lDBusMsgIter);
6195  dbus_message_iter_append_basic(&lDBusMsgIter, DBUS_TYPE_STRING, &mediaPlayerIfce);
6196  dbus_message_iter_append_basic(&lDBusMsgIter, DBUS_TYPE_STRING, &mediaProp);
6197  dbus_message_iter_open_container(&lDBusMsgIter, DBUS_TYPE_VARIANT, lDBusTypeAsString, &lDBusMsgIterValue);
6198  dbus_message_iter_append_basic(&lDBusMsgIterValue, DBUS_TYPE_STRING, &propValue);
6199  dbus_message_iter_close_container(&lDBusMsgIter, &lDBusMsgIterValue);
6200  }
6201  }
6202  else {
6203  BTRCORELOG_ERROR ("Unknown Media Control Command!\n");
6204  return -1;
6205  }
6206 
6207  if (lpDBusMsg == NULL) {
6208  BTRCORELOG_ERROR ("Can't allocate new method call\n");
6209  return -1;
6210  }
6211 
6212  lDBusOp = dbus_connection_send(pstlhBtIfce->pDBusConn, lpDBusMsg, NULL);
6213  dbus_message_unref(lpDBusMsg);
6214 
6215  if (!lDBusOp) {
6216  BTRCORELOG_ERROR ("Not enough memory for message send\n");
6217  return -1;
6218  }
6219 
6220  dbus_connection_flush(pstlhBtIfce->pDBusConn);
6221 
6222  return 0;
6223 }
6224 
6225 int
6226 BtrCore_BTGetTransportState (
6227  void* apstBtIfceHdl,
6228  const char* apBtDataPath,
6229  void* pState
6230 ) {
6231  stBtIfceHdl* pstlhBtIfce = NULL;
6232 
6233  if (!apstBtIfceHdl) {
6234  BTRCORELOG_ERROR ("Inavalid args - BtIfceHdl : %p\n", apstBtIfceHdl);
6235  return -1;
6236  }
6237 
6238  pstlhBtIfce = (stBtIfceHdl*)apstBtIfceHdl;
6239 
6240  /* switch() */
6241  return btrCore_BTGetMediaIfceProperty(pstlhBtIfce->pDBusConn, apBtDataPath, BT_DBUS_BLUEZ_MEDIA_TRANSPORT_PATH, "State", pState);
6242 }
6243 
6244 /* Get Media Player Property on Remote BT Device*/
6245 int
6246 BtrCore_BTGetMediaPlayerProperty (
6247  void* apstBtIfceHdl,
6248  const char* apBtMediaPlayerPath,
6249  const char* mediaProperty,
6250  void* mediaPropertyValue
6251 ) {
6252  stBtIfceHdl* pstlhBtIfce = NULL;
6253 
6254  if (!apstBtIfceHdl) {
6255  BTRCORELOG_ERROR ("Inavalid args - BtIfceHdl : %p\n", apstBtIfceHdl);
6256  return -1;
6257  }
6258 
6259  pstlhBtIfce = (stBtIfceHdl*)apstBtIfceHdl;
6260 
6261  /* switch() */
6262  return btrCore_BTGetMediaIfceProperty(pstlhBtIfce->pDBusConn, apBtMediaPlayerPath, BT_DBUS_BLUEZ_MEDIA_PLAYER_PATH, mediaProperty, mediaPropertyValue);
6263 }
6264 
6265 
6266 int
6267 BtrCore_BTGetMediaFolderNumberOfItems (
6268  void* apstBtIfceHdl,
6269  const char* apBtMediaPlayerPath,
6270  unsigned int* aui32NumberOfItems
6271 ) {
6272  stBtIfceHdl* pstlhBtIfce = NULL;
6273 
6274  if (!apstBtIfceHdl) {
6275  BTRCORELOG_ERROR ("Inavalid args - BtIfceHdl : %p\n", apstBtIfceHdl);
6276  return -1;
6277  }
6278 
6279  pstlhBtIfce = (stBtIfceHdl*)apstBtIfceHdl;
6280 
6281  return btrCore_BTGetMediaIfceProperty (pstlhBtIfce->pDBusConn, apBtMediaPlayerPath, BT_DBUS_BLUEZ_MEDIA_FOLDER_PATH, "NumberOfItems", (void*)aui32NumberOfItems);
6282 }
6283 
6284 
6285 /* Set Media Property on Remote BT Device (Equalizer, Repeat, Shuffle, Scan, Status)*/
6286 int
6287 BtrCore_BTSetMediaProperty (
6288  void* apstBtIfceHdl,
6289  const char* apBtAdapterPath,
6290  char* mediaProperty,
6291  char* pValue
6292 ) {
6293  stBtIfceHdl* pstlhBtIfce = (stBtIfceHdl*)apstBtIfceHdl;
6294  DBusMessage* lpDBusMsg = NULL;
6295  DBusMessage* lpDBusReply = NULL;
6296  DBusError lDBusErr;
6297  DBusMessageIter lDBusMsgIter;
6298  DBusMessageIter lDBusMsgIterValue;
6299  const char* mediaPlayerPath = BT_DBUS_BLUEZ_MEDIA_PLAYER_PATH;
6300  const char* lDBusTypeAsString = DBUS_TYPE_STRING_AS_STRING;
6301 
6302  char* mediaPlayerObjectPath = NULL;
6303 
6304  if (!apstBtIfceHdl || !pValue || !apBtAdapterPath)
6305  return -1;
6306 
6307 
6308  mediaPlayerObjectPath = BtrCore_BTGetMediaPlayerPath (pstlhBtIfce, apBtAdapterPath);
6309 
6310  if (mediaPlayerObjectPath == NULL) {
6311  return -1;
6312  }
6313 
6314 
6315  lpDBusMsg = dbus_message_new_method_call(BT_DBUS_BLUEZ_PATH,
6316  mediaPlayerObjectPath,
6317  DBUS_INTERFACE_PROPERTIES,
6318  "Set");
6319 
6320  if (!lpDBusMsg) {
6321  BTRCORELOG_ERROR ("Can't allocate new method call\n");
6322  return -1;
6323  }
6324 
6325  dbus_message_iter_init_append(lpDBusMsg, &lDBusMsgIter);
6326  dbus_message_iter_append_basic(&lDBusMsgIter, DBUS_TYPE_STRING, &mediaPlayerPath);
6327  dbus_message_iter_append_basic(&lDBusMsgIter, DBUS_TYPE_STRING, &mediaProperty);
6328  dbus_message_iter_open_container(&lDBusMsgIter, DBUS_TYPE_VARIANT, lDBusTypeAsString, &lDBusMsgIterValue);
6329  dbus_message_iter_append_basic(&lDBusMsgIterValue, DBUS_TYPE_STRING, pValue);
6330  dbus_message_iter_close_container(&lDBusMsgIter, &lDBusMsgIterValue);
6331 
6332  dbus_error_init(&lDBusErr);
6333  lpDBusReply = dbus_connection_send_with_reply_and_block(pstlhBtIfce->pDBusConn, lpDBusMsg, -1, &lDBusErr);
6334  dbus_message_unref(lpDBusMsg);
6335 
6336  if (!lpDBusReply) {
6337  BTRCORELOG_ERROR ("lpDBusReply Null\n");
6338  btrCore_BTHandleDusError(&lDBusErr, __LINE__, __FUNCTION__);
6339  return -1;
6340  }
6341 
6342  dbus_message_unref(lpDBusReply);
6343 
6344  dbus_connection_flush(pstlhBtIfce->pDBusConn);
6345 
6346  return 0;
6347 }
6348 
6349 /* Get Track information and place them in an array (Title, Artists, Album, number of tracks, tracknumber, duration, Genre)*/
6350 // TODO : write a api that gets any properties irrespective of the objects' interfaces
6351 int
6352 BtrCore_BTGetTrackInformation (
6353  void* apstBtIfceHdl,
6354  const char* apBtmediaObjectPath,
6355  stBTMediaTrackInfo* apstBTMediaTrackInfo
6356 ) {
6357  stBtIfceHdl* pstlhBtIfce = (stBtIfceHdl*)apstBtIfceHdl;
6358  char* pcProperty = "Track";
6359  DBusMessage* lpDBusMsg = NULL;
6360  DBusMessage* lpDBusReply = NULL;
6361  DBusMessageIter lDBusMsgIter;
6362  DBusError lDBusErr;
6363  char* mediaInterfacePath = BT_DBUS_BLUEZ_MEDIA_PLAYER_PATH;
6364 
6365 
6366  if (!apstBtIfceHdl || !apBtmediaObjectPath) {
6367  BTRCORELOG_ERROR ("Media Object Path is NULL!!!");
6368  return -1;
6369  }
6370 
6371  if (strstr(apBtmediaObjectPath, "item")) {
6372  mediaInterfacePath = BT_DBUS_BLUEZ_MEDIA_ITEM_PATH;
6373  pcProperty = "Metadata";
6374  }
6375 
6376  BTRCORELOG_ERROR("[#####TESTING]Calling with : %s | %s | %s\n", mediaInterfacePath, pcProperty, apBtmediaObjectPath);
6377  //if (!strcmp (pcProperty, "Metadata")) { return 0; }
6378 
6379  lpDBusMsg = dbus_message_new_method_call(BT_DBUS_BLUEZ_PATH,
6380  apBtmediaObjectPath,
6381  DBUS_INTERFACE_PROPERTIES,
6382  "Get");
6383 
6384  if (!lpDBusMsg) {
6385  BTRCORELOG_ERROR ("Can't allocate new method call\n");
6386  return -1;
6387  }
6388 
6389  dbus_message_iter_init_append(lpDBusMsg, &lDBusMsgIter);
6390 
6391  dbus_message_iter_append_basic(&lDBusMsgIter, DBUS_TYPE_STRING, &mediaInterfacePath);
6392  dbus_message_iter_append_basic(&lDBusMsgIter, DBUS_TYPE_STRING, &pcProperty);
6393 
6394 
6395  dbus_error_init(&lDBusErr);
6396  lpDBusReply = dbus_connection_send_with_reply_and_block(pstlhBtIfce->pDBusConn, lpDBusMsg, -1, &lDBusErr);
6397  dbus_message_unref(lpDBusMsg);
6398 
6399  dbus_connection_flush(pstlhBtIfce->pDBusConn);
6400 
6401  if (lpDBusReply) {
6402  if (btrCore_BTParseMediaTrackMetadata(lpDBusReply, apstBTMediaTrackInfo)) {
6403  BTRCORELOG_ERROR ("Failed to parse MetaData !\n");
6404  dbus_message_unref (lpDBusReply);
6405  return -1;
6406  }
6407  }
6408  else {
6409  BTRCORELOG_ERROR ("lpDBusReply NULL\n");
6410  btrCore_BTHandleDusError(&lDBusErr, __LINE__, __FUNCTION__);
6411  return -1;
6412  }
6413 
6414  dbus_message_unref (lpDBusReply);
6415  return 0;
6416 }
6417 
6418 tBTMediaItemId
6419 BtrCore_BTGetCommonParentMediaItemId (
6420  tBTMediaItemId aBTcurrMediaItemId,
6421  tBTMediaItemId aBTdestMediaItemId
6422 ) {
6423  tBTMediaItemId currItemId = 0;
6424  tBTMediaItemId destItemId = 0;
6425  tBTMediaItemId comnItemId = 0;
6426  short powerIdx = 1;
6427 
6428  /* logic to reverse the digits. Ex: n=1234, val=4321 */
6429  while (destItemId = destItemId*10 + aBTdestMediaItemId/powerIdx%10, aBTdestMediaItemId/(powerIdx*=10));
6430  powerIdx = 1;
6431  /* logic to reverse the digits. Ex: n=1234, val=4321 */
6432  while (currItemId = currItemId*10 + aBTcurrMediaItemId/powerIdx%10, aBTcurrMediaItemId/(powerIdx*=10));
6433  powerIdx = 1;
6434  /* logic to find mediaID portion in common between 2 IDs. Ex: ID_1 - 1345, ID_2 - 132, common ID - 13 (parent ID) */
6435  while (comnItemId = comnItemId*10 + currItemId*10/powerIdx%10, powerIdx*=10, (currItemId*10/powerIdx || destItemId*10/powerIdx) && destItemId%powerIdx == currItemId%powerIdx);
6436 
6437  return comnItemId;
6438 }
6439 
6440 int
6441 BtrCore_BTChangeMediaFolder (
6442  void* apstBtIfceHdl,
6443  const char* apBtmediaPlayerObjectPath,
6444  const char* apBtdestMediaFolderPath
6445 ) {
6446  stBtIfceHdl* pstlhBtIfce = (stBtIfceHdl*)apstBtIfceHdl;
6447  DBusMessage* lpDBusMsg = NULL;
6448  DBusMessage* lpDBusReply = NULL;
6449  DBusError lDBusErr;
6450 
6451  if (!apstBtIfceHdl || !apBtmediaPlayerObjectPath || !apBtdestMediaFolderPath) {
6452  BTRCORELOG_ERROR ("Invalid Args!!!\n");
6453  return -1;
6454  }
6455 
6456 
6457  lpDBusMsg = dbus_message_new_method_call(BT_DBUS_BLUEZ_PATH,
6458  apBtmediaPlayerObjectPath,
6459  BT_DBUS_BLUEZ_MEDIA_FOLDER_PATH,
6460  "ChangeFolder");
6461  if (!lpDBusMsg) {
6462  BTRCORELOG_ERROR ("Can't allocate new method call\n");
6463  return -1;
6464  }
6465 
6466  dbus_message_append_args(lpDBusMsg, DBUS_TYPE_OBJECT_PATH, &apBtdestMediaFolderPath, DBUS_TYPE_INVALID);
6467 
6468  dbus_error_init(&lDBusErr);
6469 
6470  lpDBusReply = dbus_connection_send_with_reply_and_block (pstlhBtIfce->pDBusConn, lpDBusMsg, -1, &lDBusErr);
6471 
6472  dbus_message_unref(lpDBusMsg);
6473 
6474  dbus_connection_flush(pstlhBtIfce->pDBusConn);
6475 
6476  if (lpDBusReply) {
6477  dbus_message_unref (lpDBusReply);
6478  }
6479 
6480  return 0;
6481 }
6482 
6483 
6484 int
6485 BtrCore_BTSelectMediaFolderItems (
6486  void* apstBtIfceHdl,
6487  const char* apBtMediaPlayerObjectPath,
6488  // to change the diff filter args into a single filterList
6489  unsigned int apBtMediaFolderStartIndex,
6490  unsigned int apBtMediaFolderEndIndex,
6491  const char* apBtMediaFilter,
6492  int apBtMediaFilterSize
6493 ) {
6494  stBtIfceHdl* pstlhBtIfce = (stBtIfceHdl*)apstBtIfceHdl;
6495  DBusMessage* lpDBusMsg = NULL;
6496  DBusMessage* lpDBusReply = NULL;
6497  DBusError lDBusErr;
6498  DBusMessageIter lDBusMsgIter;
6499  DBusMessageIter lDBusMsgIterArr;
6500 
6501 
6502  if (!apstBtIfceHdl || !apBtMediaPlayerObjectPath) {
6503  BTRCORELOG_ERROR ("Invalid Args!!!\n");
6504  return -1;
6505  }
6506 
6507  lpDBusMsg = dbus_message_new_method_call(BT_DBUS_BLUEZ_PATH,
6508  apBtMediaPlayerObjectPath,
6509  BT_DBUS_BLUEZ_MEDIA_FOLDER_PATH,
6510  "ListItems");
6511  if (!lpDBusMsg) {
6512  BTRCORELOG_ERROR ("Can't allocate new method call\n");
6513  return -1;
6514  }
6515 
6516  dbus_message_iter_init_append (lpDBusMsg, &lDBusMsgIter);
6517  dbus_message_iter_open_container (&lDBusMsgIter,
6518  DBUS_TYPE_ARRAY,
6519  DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
6520  DBUS_TYPE_STRING_AS_STRING
6521  DBUS_TYPE_VARIANT_AS_STRING
6522  DBUS_DICT_ENTRY_END_CHAR_AS_STRING,
6523  &lDBusMsgIterArr);
6524  if (apBtMediaFolderEndIndex) {
6525  {
6526  DBusMessageIter lDBusMsgIterDict, lDBusMsgIterVariant;
6527  char* key = "Start";
6528  int type = DBUS_TYPE_UINT32;
6529 
6530  dbus_message_iter_open_container (&lDBusMsgIterArr, DBUS_TYPE_DICT_ENTRY, NULL, &lDBusMsgIterDict);
6531  dbus_message_iter_append_basic (&lDBusMsgIterDict, DBUS_TYPE_STRING, &key);
6532  dbus_message_iter_open_container (&lDBusMsgIterDict, DBUS_TYPE_VARIANT, (char *)&type, &lDBusMsgIterVariant);
6533  dbus_message_iter_append_basic (&lDBusMsgIterVariant, type, &apBtMediaFolderStartIndex);
6534  dbus_message_iter_close_container (&lDBusMsgIterDict, &lDBusMsgIterVariant);
6535  dbus_message_iter_close_container (&lDBusMsgIterArr, &lDBusMsgIterDict);
6536  }
6537  {
6538  DBusMessageIter lDBusMsgIterDict, lDBusMsgIterVariant;
6539  char* key = "End";
6540  int type = DBUS_TYPE_UINT32;
6541 
6542  dbus_message_iter_open_container (&lDBusMsgIterArr, DBUS_TYPE_DICT_ENTRY, NULL, &lDBusMsgIterDict);
6543  dbus_message_iter_append_basic (&lDBusMsgIterDict, DBUS_TYPE_STRING, &key);
6544  dbus_message_iter_open_container (&lDBusMsgIterDict, DBUS_TYPE_VARIANT, (char *)&type, &lDBusMsgIterVariant);
6545  dbus_message_iter_append_basic (&lDBusMsgIterVariant, type, &apBtMediaFolderEndIndex);
6546  dbus_message_iter_close_container (&lDBusMsgIterDict, &lDBusMsgIterVariant);
6547  dbus_message_iter_close_container (&lDBusMsgIterArr, &lDBusMsgIterDict);
6548  }
6549  }
6550 /* {
6551  DBusMessageIter lDBusMsgIterDict, lDBusMsgIterVariant, lDBusMsgIterSubArray;
6552  char* key = "Attributes";
6553  int type = DBUS_TYPE_STRING;
6554 
6555  char array_type[5] = "a";
6556  strncat (array_type, (char*)&type, sizeof(array_type) - sizeof(type));
6557 
6558  dbus_message_iter_open_container (&lDBusMsgIterArr, DBUS_TYPE_DICT_ENTRY, NULL, &lDBusMsgIterDict);
6559  dbus_message_iter_append_basic (&lDBusMsgIterDict, DBUS_TYPE_STRING, &key);
6560  dbus_message_iter_open_container (&lDBusMsgIterDict, DBUS_TYPE_VARIANT, array_type, &lDBusMsgIterVariant);
6561  dbus_message_iter_open_container (&lDBusMsgIterVariant, DBUS_TYPE_ARRAY, (char *)&type, &lDBusMsgIterSubArray);
6562  dbus_message_iter_append_fixed_array (&lDBusMsgIterSubArray, type, &apBtMediaFilter, apBtMediaFilterSize);
6563  dbus_message_iter_close_container (&lDBusMsgIterVariant, &lDBusMsgIterSubArray);
6564  dbus_message_iter_close_container (&lDBusMsgIterDict, &lDBusMsgIterVariant);
6565  dbus_message_iter_close_container (&lDBusMsgIterArr, &lDBusMsgIterDict);
6566  }
6567 */
6568  dbus_message_iter_close_container (&lDBusMsgIter, &lDBusMsgIterArr);
6569 
6570  dbus_error_init(&lDBusErr);
6571  lpDBusReply = dbus_connection_send_with_reply_and_block (pstlhBtIfce->pDBusConn, lpDBusMsg, DBUS_TIMEOUT_INFINITE, &lDBusErr);
6572  dbus_message_unref(lpDBusMsg);
6573 
6574  if (!lpDBusReply) {
6575  BTRCORELOG_ERROR ("lpDBusReply Null\n");
6576  btrCore_BTHandleDusError(&lDBusErr, __LINE__, __FUNCTION__);
6577  return -1;
6578  }
6579 
6580  dbus_connection_flush(pstlhBtIfce->pDBusConn);
6581  {
6582 #if 0
6583  DBusMessageIter lDBusReplyIter;
6584  DBusMessageIter dictMsgIter, subDictMsgIter;
6585  DBusMessageIter element, subElementMgsIter, subVarElementMsgIter;
6586  char* pcKey = 0;
6587  char* pcValue = 0;
6588  unsigned int ui32Value = 0;
6589  int dbus_type = DBUS_TYPE_INVALID;
6590 
6591  dbus_message_iter_init(lpDBusReply, &lDBusReplyIter); // lpDBusMsg is pointer to dbus message received
6592 
6593  if ((dbus_message_iter_get_arg_type (&lDBusReplyIter)) == DBUS_TYPE_INVALID) {
6594  BTRCORELOG_ERROR ("lDBusReplyIter - DBUS_TYPE_INVALID\n");
6595  dbus_message_unref(lpDBusReply);
6596  return -1;
6597  }
6598 
6599  dbus_message_iter_recurse(&lDBusReplyIter, &dictMsgIter); // pointer to first element DICTIONARY of the dbus messge received
6600 
6601  while ((dbus_type = dbus_message_iter_get_arg_type(&dictMsgIter)) != DBUS_TYPE_INVALID) {
6602  if (DBUS_TYPE_DICT_ENTRY == dbus_type) {
6603  dbus_message_iter_recurse(&dictMsgIter, &element); // pointer to element Object of the dbus messge received
6604 
6605  if (DBUS_TYPE_OBJECT_PATH == dbus_message_iter_get_arg_type(&element)) {
6606  dbus_message_iter_get_basic(&element, &pcKey);
6607 
6608  dbus_message_iter_next(&element); // pointer to element Array of the dbus messge received
6609 
6610 
6611  dbus_message_iter_recurse(&element, &subDictMsgIter); // pointer to element Dictionary of the dbus messge received
6612 
6613  btrCore_BTParseMediaTrackMetadata ();
6614  }
6615  }
6616  if (!dbus_message_iter_has_next(&dictMsgIter)) {
6617  break;
6618  }
6619  else {
6620  dbus_message_iter_next(&dictMsgIter);
6621  }
6622  }
6623 #endif
6624  }
6625  dbus_message_unref(lpDBusReply);
6626 
6627  return 0;
6628 }
6629 
6630 
6631 int
6632 BtrCore_BTPlayMediaTrackItem (
6633  void* apstBtIfceHdl,
6634  const char* apBtMediaItemObjectPath
6635 ) {
6636  stBtIfceHdl* pstlhBtIfce = (stBtIfceHdl*)apstBtIfceHdl;
6637  DBusMessage* lpDBusMsg = NULL;
6638  dbus_bool_t lDBusOp;
6639 
6640  if (!apstBtIfceHdl || !apBtMediaItemObjectPath) {
6641  BTRCORELOG_ERROR ("Invalid Args!!!\n");
6642  return -1;
6643  }
6644 
6645 
6646  lpDBusMsg = dbus_message_new_method_call(BT_DBUS_BLUEZ_PATH,
6647  apBtMediaItemObjectPath,
6648  BT_DBUS_BLUEZ_MEDIA_ITEM_PATH,
6649  "Play");
6650  if (!lpDBusMsg) {
6651  BTRCORELOG_ERROR ("Can't allocate new method call\n");
6652  return -1;
6653  }
6654 
6655  lDBusOp = dbus_connection_send(pstlhBtIfce->pDBusConn, lpDBusMsg, NULL);
6656 
6657  dbus_message_unref(lpDBusMsg);
6658 
6659  if (!lDBusOp) {
6660  BTRCORELOG_ERROR ("Not enough memory for message send\n");
6661  return -1;
6662  }
6663 
6664  dbus_connection_flush(pstlhBtIfce->pDBusConn);
6665 
6666  return 0;
6667 }
6668 
6669 #if 0
6670 int
6671 BtrCore_BTAddTrackItemToPlayList (
6672  void* apstBtIfceHdl,
6673  const char* apBtMediaItemObjectPath
6674 ) {
6675  stBtIfceHdl* pstlhBtIfce = (stBtIfceHdl*)apstBtIfceHdl;
6676  DBusMessage* lpDBusMsg = NULL;
6677  dbus_bool_t lDBusOp;
6678 
6679  if (!apstBtIfceHdl || !apBtMediaItemObjectPath) {
6680  BTRCORELOG_ERROR ("Invalid Args!!!\n");
6681  return -1;
6682  }
6683 
6684 
6685  lpDBusMsg = dbus_message_new_method_call(BT_DBUS_BLUEZ_PATH,
6686  apBtMediaItemObjectPath,
6687  BT_DBUS_BLUEZ_MEDIA_ITEM_PATH,
6688  "AddtoNowPlaying");
6689  if (!lpDBusMsg) {
6690  BTRCORELOG_ERROR ("Can't allocate new method call\n");
6691  return -1;
6692  }
6693 
6694  lDBusOp = dbus_connection_send(pstlhBtIfce->pDBusConn, lpDBusMsg, NULL);
6695 
6696  dbus_message_unref(lpDBusMsg);
6697 
6698  if (!lDBusOp) {
6699  BTRCORELOG_ERROR ("Not enough memory for message send\n");
6700  return -1;
6701  }
6702 
6703  dbus_connection_flush(pstlhBtIfce->pDBusConn);
6704 
6705  return 0;
6706 }
6707 #endif
6708 
6709 int
6710 BtrCore_BTRegisterLeAdvertisement (
6711  void* apstBtIfceHdl,
6712  const char* apBtAdapter
6713 ) {
6714  stBtIfceHdl* pstlhBtIfce = NULL;
6715  DBusMessage* lpDBusMsg = NULL;
6716  DBusPendingCall* lpDBusPendCAdv = NULL;
6717  DBusMessageIter lDBusMsgIterAdv;
6718  DBusMessageIter lDBusMsgIterDictAdv;
6719  const char* lpBtLeGattAdvEpPath;
6720 
6721  if ((NULL == apstBtIfceHdl) || (NULL == apBtAdapter)) {
6722  return -1;
6723  }
6724 
6725  pstlhBtIfce = (stBtIfceHdl*)apstBtIfceHdl;
6726  BTRCORELOG_INFO("Registering advertisement\n");
6727 
6728  memset(pstlhBtIfce->stBTLeCustAdvt.pui8AdvertPath, '\0', BT_MAX_STR_LEN);
6729  strncpy(pstlhBtIfce->stBTLeCustAdvt.pui8AdvertPath, apBtAdapter, strlen(apBtAdapter));
6730  strncat(pstlhBtIfce->stBTLeCustAdvt.pui8AdvertPath, BT_LE_GATT_SERVER_ADVERTISEMENT, (sizeof(pstlhBtIfce->stBTLeCustAdvt.pui8AdvertPath) - strlen(pstlhBtIfce->stBTLeCustAdvt.pui8AdvertPath) -1));
6731 
6732  lpDBusMsg = dbus_message_new_method_call(BT_DBUS_BLUEZ_PATH,
6733  apBtAdapter,
6734  BT_DBUS_BLUEZ_LE_ADV_MGR_PATH,
6735  "RegisterAdvertisement");
6736  if (!lpDBusMsg) {
6737  BTRCORELOG_ERROR("Can't allocate new method call\n");
6738  return -1;
6739  }
6740 
6741  lpBtLeGattAdvEpPath = pstlhBtIfce->stBTLeCustAdvt.pui8AdvertPath;
6742  dbus_message_iter_init_append(lpDBusMsg, &lDBusMsgIterAdv);
6743  dbus_message_iter_append_basic(&lDBusMsgIterAdv, DBUS_TYPE_OBJECT_PATH, &lpBtLeGattAdvEpPath);
6744 
6745  dbus_message_iter_open_container(&lDBusMsgIterAdv,
6746  DBUS_TYPE_ARRAY,
6747  DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
6748  DBUS_TYPE_STRING_AS_STRING
6749  DBUS_TYPE_VARIANT_AS_STRING
6750  DBUS_DICT_ENTRY_END_CHAR_AS_STRING,
6751  &lDBusMsgIterDictAdv);
6752 
6753  dbus_message_iter_close_container(&lDBusMsgIterAdv, &lDBusMsgIterDictAdv);
6754 
6755 
6756  if (!dbus_connection_send_with_reply(pstlhBtIfce->pDBusConn, lpDBusMsg, &lpDBusPendCAdv, -1)) {
6757  //Send, expect lpDBusReply using pending call object
6758  BTRCORELOG_ERROR("failed to send message!\n");
6759  }
6760 
6761  dbus_pending_call_set_notify(lpDBusPendCAdv, btrCore_BTPendingCallCheckReply, NULL, NULL);
6762 
6763  dbus_connection_flush(pstlhBtIfce->pDBusConn);
6764  dbus_message_unref(lpDBusMsg);
6765 
6766  BTRCORELOG_ERROR("Exiting!!!!\n");
6767  return 0;
6768 }
6769 
6770 int
6771 BtrCore_BTRegisterLeGatt (
6772  void* apstBtIfceHdl,
6773  const char* apBtAdapter
6774 ) {
6775  stBtIfceHdl* pstlhBtIfce = (stBtIfceHdl*)apstBtIfceHdl;
6776  DBusMessage* lpDBusMsg = NULL;
6777  DBusPendingCall* lpDBusPendC = NULL;
6778 
6779  DBusError lDBusErr;
6780  DBusMessageIter lDBusMsgIter;
6781  DBusMessageIter lDBusMsgIterDict;
6782  dbus_bool_t lDBusOp;
6783 
6784  const char* lpBtLeGattSrvEpPath = BT_LE_GATT_SERVER_ENDPOINT;
6785 
6786  if (!apstBtIfceHdl || !apBtAdapter)
6787  return -1;
6788 
6789  if (!strncmp(apBtAdapter, pstlhBtIfce->pcBTDAdapterPath, strlen(pstlhBtIfce->pcBTDAdapterPath))) {
6790 
6791  char lCurAdapterAddress[BT_MAX_DEV_PATH_LEN] = "\0";
6792 
6793  if (!pstlhBtIfce->pcBTDAdapterAddr) {
6794  unBTOpIfceProp lunBtOpAdapProp;
6795  lunBtOpAdapProp.enBtAdapterProp = enBTAdPropAddress;
6796 
6797  /* Get current device address */
6798  if (BtrCore_BTGetProp(pstlhBtIfce,
6799  (BtrCore_BTGetAdapterPath(pstlhBtIfce, NULL)),
6800  enBTAdapter,
6801  lunBtOpAdapProp,
6802  lCurAdapterAddress)) {
6803  return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
6804  }
6805  }
6806  else {
6807  //CID:156558-Copy into fixed size buffer
6808  strncpy(lCurAdapterAddress, pstlhBtIfce->pcBTDAdapterAddr, (strlen(pstlhBtIfce->pcBTDAdapterAddr) < BT_MAX_DEV_PATH_LEN) ? strlen(pstlhBtIfce->pcBTDAdapterAddr) : BT_MAX_DEV_PATH_LEN - 1);
6809  }
6810 
6811  char *current_pos = strchr(lCurAdapterAddress, ':');
6812  while (current_pos){
6813  *current_pos = '_';
6814  current_pos = strchr(current_pos, ':');
6815  }
6816 
6817  memset(pstlhBtIfce->pcBTAdapterGattSrvEpPath, '\0', sizeof(char) * BT_MAX_DEV_PATH_LEN);
6818  //CID:156558-Copy into fixed size buffer
6819  strncpy(pstlhBtIfce->pcBTAdapterGattSrvEpPath, pstlhBtIfce->pcBTDAdapterPath, (strlen(pstlhBtIfce->pcBTDAdapterPath) < BT_MAX_DEV_PATH_LEN) ? strlen(pstlhBtIfce->pcBTDAdapterPath) : BT_MAX_DEV_PATH_LEN-1);
6820  strncat(pstlhBtIfce->pcBTAdapterGattSrvEpPath, "/dev_", (sizeof(pstlhBtIfce->pcBTAdapterGattSrvEpPath) - strlen(pstlhBtIfce->pcBTAdapterGattSrvEpPath) -1));
6821  strncat(pstlhBtIfce->pcBTAdapterGattSrvEpPath, lCurAdapterAddress, strlen(lCurAdapterAddress));
6822 
6823  lpBtLeGattSrvEpPath = pstlhBtIfce->pcBTAdapterGattSrvEpPath;
6824  }
6825  else {
6826  lpBtLeGattSrvEpPath = BT_LE_GATT_SERVER_ENDPOINT;
6827  }
6828 
6829  dbus_error_init(&lDBusErr);
6830  lDBusOp = dbus_connection_try_register_object_path(pstlhBtIfce->pDBusConn, lpBtLeGattSrvEpPath, &gDBusLeGattEndpointVTable, pstlhBtIfce, &lDBusErr);
6831  if (!lDBusOp) {
6832  btrCore_BTHandleDusError(&lDBusErr, __LINE__, __FUNCTION__);
6833  BTRCORELOG_ERROR ("Can't Register Le Gatt Object - %s\n", lpBtLeGattSrvEpPath);
6834 
6835  if (strcmp(lDBusErr.name, DBUS_ERROR_OBJECT_PATH_IN_USE) != 0)
6836  return -1;
6837  }
6838 
6839 
6840  lpDBusMsg = dbus_message_new_method_call(BT_DBUS_BLUEZ_PATH,
6841  apBtAdapter,
6842  BT_DBUS_BLUEZ_GATT_MGR_PATH,
6843  "RegisterApplication");
6844  if (!lpDBusMsg) {
6845  BTRCORELOG_ERROR ("Can't allocate new method call\n");
6846  return -1;
6847  }
6848 
6849  dbus_message_iter_init_append (lpDBusMsg, &lDBusMsgIter);
6850  dbus_message_iter_append_basic (&lDBusMsgIter, DBUS_TYPE_OBJECT_PATH, &lpBtLeGattSrvEpPath);
6851 
6852  dbus_message_iter_open_container(&lDBusMsgIter,
6853  DBUS_TYPE_ARRAY,
6854  DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
6855  DBUS_TYPE_STRING_AS_STRING
6856  DBUS_TYPE_VARIANT_AS_STRING
6857  DBUS_DICT_ENTRY_END_CHAR_AS_STRING,
6858  &lDBusMsgIterDict);
6859  {
6860  // Empty
6861  }
6862  dbus_message_iter_close_container (&lDBusMsgIter, &lDBusMsgIterDict);
6863 
6864 
6865  if (!dbus_connection_send_with_reply(pstlhBtIfce->pDBusConn, lpDBusMsg, &lpDBusPendC, -1)) { //Send and expect lpDBusReply using pending call object
6866  BTRCORELOG_ERROR ("failed to send message!\n");
6867  }
6868 
6869 
6870  dbus_pending_call_set_notify(lpDBusPendC, btrCore_BTPendingCallCheckReply, NULL, NULL);
6871 
6872  dbus_connection_flush(pstlhBtIfce->pDBusConn);
6873  dbus_message_unref(lpDBusMsg);
6874 
6875  return 0;
6876 }
6877 
6878 
6879 int
6880 BtrCore_BTUnRegisterLeGatt (
6881  void* apstBtIfceHdl,
6882  const char* apBtAdapter
6883 ) {
6884  stBtIfceHdl* pstlhBtIfce = (stBtIfceHdl*)apstBtIfceHdl;
6885  DBusMessage* lpDBusMsg = NULL;
6886  dbus_bool_t lDBusOp;
6887  const char* lpBtLeGattSrvEpPath;
6888  const char* lpBtLeGattAdvEpPath;
6889 
6890  if (!apstBtIfceHdl || !apBtAdapter)
6891  return -1;
6892 
6893  lpDBusMsg = dbus_message_new_method_call(BT_DBUS_BLUEZ_PATH,
6894  apBtAdapter,
6895  BT_DBUS_BLUEZ_LE_ADV_MGR_PATH,
6896  "UnregisterAdvertisement");
6897  if (!lpDBusMsg) {
6898  BTRCORELOG_ERROR ("Can't allocate new method call\n");
6899  return -1;
6900  }
6901 
6902  lpBtLeGattAdvEpPath = pstlhBtIfce->stBTLeCustAdvt.pui8AdvertPath;
6903  dbus_message_append_args(lpDBusMsg, DBUS_TYPE_OBJECT_PATH, &lpBtLeGattAdvEpPath, DBUS_TYPE_INVALID);
6904 
6905  lDBusOp = dbus_connection_send(pstlhBtIfce->pDBusConn, lpDBusMsg, NULL);
6906  dbus_message_unref(lpDBusMsg);
6907 
6908  if (!lDBusOp) {
6909  BTRCORELOG_ERROR ("Not enough memory for message send\n");
6910  return -1;
6911  }
6912 
6913 
6914  lpDBusMsg = dbus_message_new_method_call(BT_DBUS_BLUEZ_PATH,
6915  apBtAdapter,
6916  BT_DBUS_BLUEZ_GATT_MGR_PATH,
6917  "UnregisterApplication");
6918  if (!lpDBusMsg) {
6919  BTRCORELOG_ERROR ("Can't allocate new method call\n");
6920  return -1;
6921  }
6922 
6923  lpBtLeGattSrvEpPath = (pstlhBtIfce->pcBTAdapterGattSrvEpPath[0] == '\0') ? BT_LE_GATT_SERVER_ENDPOINT : pstlhBtIfce->pcBTAdapterGattSrvEpPath;
6924  dbus_message_append_args(lpDBusMsg, DBUS_TYPE_OBJECT_PATH, &lpBtLeGattSrvEpPath, DBUS_TYPE_INVALID);
6925 
6926  lDBusOp = dbus_connection_send(pstlhBtIfce->pDBusConn, lpDBusMsg, NULL);
6927  dbus_message_unref(lpDBusMsg);
6928 
6929  if (!lDBusOp) {
6930  BTRCORELOG_ERROR ("Not enough memory for message send\n");
6931  return -1;
6932  }
6933 
6934  /* Get object paths */
6935  stBTLeGattInfo* lpstBTLeGattInfo = &pstlhBtIfce->stBTLeGatt;
6936  char lCurAdapterAddress[BT_MAX_DEV_PATH_LEN] = "\0";
6937 
6938 
6939  if (!pstlhBtIfce->pcBTDAdapterAddr) {
6940  unBTOpIfceProp lunBtOpAdapProp;
6941  lunBtOpAdapProp.enBtAdapterProp = enBTAdPropAddress;
6942 
6943  /* Get current device address */
6944  if (BtrCore_BTGetProp(pstlhBtIfce,
6945  (BtrCore_BTGetAdapterPath(pstlhBtIfce, NULL)),
6946  enBTAdapter,
6947  lunBtOpAdapProp,
6948  lCurAdapterAddress)) {
6949  return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
6950  }
6951  }
6952  else {
6953  //CID: 156557 Copy into fixed size buffer
6954  strncpy(lCurAdapterAddress, pstlhBtIfce->pcBTDAdapterAddr, (strlen(pstlhBtIfce->pcBTDAdapterAddr) < BT_MAX_DEV_PATH_LEN) ? strlen(pstlhBtIfce->pcBTDAdapterAddr) : BT_MAX_DEV_PATH_LEN - 1);
6955  }
6956 
6957  //pstlhBtIfce->fpcBTLeLocalGattPath(NULL, lCurAdapterAddress, &lpstBTLeGattSrv, &lNumGattServices, pstlhBtIfce->pcBLePathUserData);
6958  if (pstlhBtIfce->fpcBTLeGattPath) {
6959  pstlhBtIfce->fpcBTLeGattPath(enBTAdvertisement, enBTLeGattOpUnknown, NULL, lCurAdapterAddress, enBTDevStUnknown, (void*)lpstBTLeGattInfo, pstlhBtIfce->pcBLePathUserData);
6960  }
6961 
6962  for (int serviceIndex = 0; serviceIndex < lpstBTLeGattInfo->nNumGattServices; serviceIndex++) {
6963  stBTLeGattService *lpstBTLeGattService = &lpstBTLeGattInfo->astBTRGattService[serviceIndex];
6964  btrCore_BTReleaseLEGattObjPath(lpstBTLeGattService->servicePath, (void*)pstlhBtIfce);
6965 
6966  for (int index = 0; index < lpstBTLeGattService->ui16NumberOfGattChar; index++) {
6967  stBTLeGattChar *lpstBTLeGattChar = &lpstBTLeGattService->astBTRGattChar[index];
6968  btrCore_BTReleaseLEGattObjPath(lpstBTLeGattChar->charPath, (void*)pstlhBtIfce);
6969 
6970  for (int DescIndex = 0; DescIndex < lpstBTLeGattChar->ui16NumberOfGattDesc; DescIndex++) {
6971  stBTLeGattDesc *lpstBTLeGattDesc = &lpstBTLeGattChar->atBTRGattDesc[DescIndex];
6972  btrCore_BTReleaseLEGattObjPath(lpstBTLeGattDesc->descPath, (void*)pstlhBtIfce);
6973  }
6974  }
6975  }
6976 
6977  lDBusOp = dbus_connection_unregister_object_path(pstlhBtIfce->pDBusConn, lpBtLeGattSrvEpPath);
6978  if (!lDBusOp) {
6979  BTRCORELOG_ERROR ("Can't Unregister Object\n");
6980  return -1;
6981  }
6982 
6983 
6984  dbus_connection_flush(pstlhBtIfce->pDBusConn);
6985 
6986  btrCore_BTUnRegisterGattService((void*)pstlhBtIfce, NULL);
6987 
6988  memset(pstlhBtIfce->stBTLeCustAdvt.pui8AdvertPath, '\0', BT_MAX_STR_LEN);
6989 
6990  return 0;
6991 }
6992 
6993 
6994 int
6995 BtrCore_BTPerformLeGattOp (
6996  void* apstBtIfceHdl,
6997  const char* apBtGattPath,
6998  enBTOpIfceType aenBTOpIfceType,
6999  enBTLeGattOp aenBTLeGattOp,
7000  char* apLeGatOparg1,
7001  char* apLeGatOparg2,
7002  char* rpLeOpRes
7003 ) {
7004  stBtIfceHdl* pstlhBtIfce = (stBtIfceHdl*)apstBtIfceHdl;
7005  DBusMessage* lpDBusMsg = NULL;
7006  DBusMessage* lpDBusReply = NULL;
7007  DBusError lDBusErr;
7008  char lcBtGattOpString[64] = "\0";
7009  char* lpBtGattInterface = NULL;
7010  int rc = 0;
7011 
7012  if (!apstBtIfceHdl || !apBtGattPath) {
7013  BTRCORELOG_ERROR ("LE Gatt Path is NULL!!!");
7014  return -1;
7015  }
7016 
7017 
7018  if (aenBTOpIfceType == enBTGattCharacteristic) {
7019  lpBtGattInterface = BT_DBUS_BLUEZ_GATT_CHAR_PATH;
7020  }
7021  else if (aenBTOpIfceType == enBTGattDescriptor) {
7022  lpBtGattInterface = BT_DBUS_BLUEZ_GATT_DESCRIPTOR_PATH;
7023  }
7024 
7025  switch (aenBTLeGattOp) {
7026  case enBTLeGattOpReadValue:
7027  strcpy(lcBtGattOpString, "ReadValue");
7028  break;
7029  case enBTLeGattOpWriteValue:
7030  strcpy(lcBtGattOpString, "WriteValue");
7031  break;
7032  case enBTLeGattOpStartNotify:
7033  strcpy(lcBtGattOpString, "StartNotify");
7034  break;
7035  case enBTLeGattOpStopNotify:
7036  strcpy(lcBtGattOpString, "StopNotify");
7037  break;
7038  case enBTLeGattOpUnknown:
7039  default:
7040  rc = -1;
7041  break;
7042  }
7043 
7044  if (rc == -1){
7045  BTRCORELOG_ERROR ("Invalid enBTLeGattOp Option %d !!!", aenBTLeGattOp);
7046  return rc;
7047  }
7048 
7049  lpDBusMsg = dbus_message_new_method_call(BT_DBUS_BLUEZ_PATH,
7050  apBtGattPath,
7051  lpBtGattInterface,
7052  lcBtGattOpString);
7053  if (!lpDBusMsg) {
7054  BTRCORELOG_ERROR ("Can't allocate new method call\n");
7055  return -1;
7056  }
7057 
7058  if (aenBTLeGattOp == enBTLeGattOpWriteValue && apLeGatOparg2) {
7059 
7060  BTRCORELOG_TRACE ("apLeGatOparg2 : %s \n", apLeGatOparg2);
7061  unsigned char lpcLeWriteByteData[BT_MAX_STR_LEN];
7062  int lWriteByteDataLen = 0;
7063  unsigned short u16idx = 0;
7064  unsigned char u8val = 0;
7065  unsigned char *laptr = (unsigned char*)apLeGatOparg2;
7066 
7067  memset (lpcLeWriteByteData, 0, BT_MAX_STR_LEN);
7068 
7069  while (*laptr) {
7070  // Below logic is to map literals in a string to Hex values. Ex: hexOf_a = 'a' - 87 | hexOf_B = 'B' - 55 | hexOf_0 = '0' - 48
7071  // TODO : May be we should check apLeGatOparg2 in upper layer, if it has only [a..f] | [A..F] | [0..9]
7072  u8val = *laptr - ((*laptr <= 'f' && *laptr >= 'a')? ('a'-10) : (*laptr <= 'F' && *laptr >= 'A')? ('A'-10) : '0');
7073 
7074  if (u16idx % 2) {
7075  lpcLeWriteByteData[u16idx++/2] |= u8val;
7076  }
7077  else {
7078  lpcLeWriteByteData[u16idx++/2] = u8val << 4;
7079  }
7080 
7081  laptr++;
7082  }
7083 
7084  lpcLeWriteByteData[u16idx] = '\0';
7085  lWriteByteDataLen = u16idx/2;
7086 
7087  for(int i = 0; i <= lWriteByteDataLen; i++ ) {
7088  BTRCORELOG_TRACE ("lpcLeWriteByteData[%d] : %02x\n", i, lpcLeWriteByteData[i]);
7089  }
7090 
7091  const unsigned char* lpcLeWriteByteDataC = ((unsigned char*)lpcLeWriteByteData);
7092 
7093  dbus_message_append_args (lpDBusMsg, DBUS_TYPE_ARRAY, DBUS_TYPE_BYTE, &lpcLeWriteByteDataC, lWriteByteDataLen, DBUS_TYPE_INVALID);
7094 
7095  {
7096  DBusMessageIter lDBusMsgIter, lDBusMsgIterDict;
7097  dbus_message_iter_init_append(lpDBusMsg, &lDBusMsgIter);
7098  dbus_message_iter_open_container(&lDBusMsgIter,
7099  DBUS_TYPE_ARRAY,
7100  DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
7101  DBUS_TYPE_STRING_AS_STRING
7102  DBUS_TYPE_VARIANT_AS_STRING
7103  DBUS_DICT_ENTRY_END_CHAR_AS_STRING,
7104  &lDBusMsgIterDict);
7105  {
7106  DBusMessageIter lDBusMsgIterDictStr, lDBusMsgIterVariant;
7107  char* lpcKey = "offset";
7108  unsigned short lus16Value = 0;
7109  int i32DBusType = DBUS_TYPE_UINT16;
7110 
7111  dbus_message_iter_open_container(&lDBusMsgIterDict, DBUS_TYPE_DICT_ENTRY, NULL, &lDBusMsgIterDictStr);
7112  dbus_message_iter_append_basic (&lDBusMsgIterDictStr, DBUS_TYPE_STRING, &lpcKey);
7113  dbus_message_iter_open_container (&lDBusMsgIterDictStr, DBUS_TYPE_VARIANT, (char *)&i32DBusType, &lDBusMsgIterVariant);
7114  dbus_message_iter_append_basic (&lDBusMsgIterVariant, i32DBusType, &lus16Value);
7115  dbus_message_iter_close_container (&lDBusMsgIterDictStr, &lDBusMsgIterVariant);
7116  dbus_message_iter_close_container (&lDBusMsgIterDict, &lDBusMsgIterDictStr);
7117  }
7118 #if 0
7119  {
7120  DBusMessageIter lDBusMsgIterDictStr, lDBusMsgIterVariant;
7121  char* lpcKey = "device";
7122  char* lpcValue = apLeGatOparg1;
7123  int i32DBusType = DBUS_TYPE_OBJECT_PATH;
7124 
7125  dbus_message_iter_open_container(&lDBusMsgIterDict, DBUS_TYPE_DICT_ENTRY, NULL, &lDBusMsgIterDictStr);
7126  dbus_message_iter_append_basic (&lDBusMsgIterDictStr, DBUS_TYPE_STRING, &lpcKey);
7127  dbus_message_iter_open_container (&lDBusMsgIterDictStr, DBUS_TYPE_VARIANT, (char *)&i32DBusType, &lDBusMsgIterVariant);
7128  dbus_message_iter_append_basic (&lDBusMsgIterVariant, i32DBusType, &lpcValue);
7129  dbus_message_iter_close_container (&lDBusMsgIterDictStr, &lDBusMsgIterVariant);
7130  dbus_message_iter_close_container (&lDBusMsgIterDict, &lDBusMsgIterDictStr);
7131  }
7132 #endif
7133  dbus_message_iter_close_container (&lDBusMsgIter, &lDBusMsgIterDict);
7134  }
7135  }
7136  else if (aenBTLeGattOp == enBTLeGattOpReadValue) {
7137 
7138  DBusMessageIter lDBusMsgIter, lDBusMsgIterDict;
7139  dbus_message_iter_init_append(lpDBusMsg, &lDBusMsgIter);
7140  dbus_message_iter_open_container(&lDBusMsgIter,
7141  DBUS_TYPE_ARRAY,
7142  DBUS_DICT_ENTRY_BEGIN_CHAR_AS_STRING
7143  DBUS_TYPE_STRING_AS_STRING
7144  DBUS_TYPE_VARIANT_AS_STRING
7145  DBUS_DICT_ENTRY_END_CHAR_AS_STRING,
7146  &lDBusMsgIterDict);
7147  {
7148  DBusMessageIter lDBusMsgIterDictStr, lDBusMsgIterVariant;
7149  char* lpcKey = "offset";
7150  unsigned short lus16Value = 0;
7151  int i32DBusType = DBUS_TYPE_UINT16;
7152 
7153  dbus_message_iter_open_container(&lDBusMsgIterDict, DBUS_TYPE_DICT_ENTRY, NULL, &lDBusMsgIterDictStr);
7154  dbus_message_iter_append_basic (&lDBusMsgIterDictStr, DBUS_TYPE_STRING, &lpcKey);
7155  dbus_message_iter_open_container (&lDBusMsgIterDictStr, DBUS_TYPE_VARIANT, (char *)&i32DBusType, &lDBusMsgIterVariant);
7156  dbus_message_iter_append_basic (&lDBusMsgIterVariant, i32DBusType, &lus16Value);
7157  dbus_message_iter_close_container (&lDBusMsgIterDictStr, &lDBusMsgIterVariant);
7158  dbus_message_iter_close_container (&lDBusMsgIterDict, &lDBusMsgIterDictStr);
7159  }
7160  {
7161  DBusMessageIter lDBusMsgIterDictStr, lDBusMsgIterVariant;
7162  char* lpcKey = "device";
7163  char* lpcValue = apLeGatOparg1; // "/org/bluez/hci0/dev_D3_DE_82_9A_7F_1E";
7164  int i32DBusType = DBUS_TYPE_OBJECT_PATH;
7165 
7166  dbus_message_iter_open_container(&lDBusMsgIterDict, DBUS_TYPE_DICT_ENTRY, NULL, &lDBusMsgIterDictStr);
7167  dbus_message_iter_append_basic (&lDBusMsgIterDictStr, DBUS_TYPE_STRING, &lpcKey);
7168  dbus_message_iter_open_container (&lDBusMsgIterDictStr, DBUS_TYPE_VARIANT, (char *)&i32DBusType, &lDBusMsgIterVariant);
7169  dbus_message_iter_append_basic (&lDBusMsgIterVariant, i32DBusType, &lpcValue);
7170  dbus_message_iter_close_container (&lDBusMsgIterDictStr, &lDBusMsgIterVariant);
7171  dbus_message_iter_close_container (&lDBusMsgIterDict, &lDBusMsgIterDictStr);
7172  }
7173  dbus_message_iter_close_container (&lDBusMsgIter, &lDBusMsgIterDict);
7174  }
7175 
7176  if (aenBTLeGattOp == enBTLeGattOpReadValue) {
7177 
7178  dbus_error_init(&lDBusErr);
7179  lpDBusReply = dbus_connection_send_with_reply_and_block(pstlhBtIfce->pDBusConn, lpDBusMsg, -1, &lDBusErr);
7180  dbus_message_unref(lpDBusMsg);
7181 
7182  if (!lpDBusReply) {
7183  BTRCORELOG_ERROR ("Send Reply Block Method Failed!!!\n");
7184  btrCore_BTHandleDusError(&lDBusErr, __LINE__, __FUNCTION__);
7185  return -1;
7186  }
7187 
7188  DBusMessageIter arg_i, element_i;
7189  if (!dbus_message_iter_init(lpDBusReply, &arg_i)) {
7190  BTRCORELOG_ERROR ("lpDBusReply has no information.");
7191  return -1;
7192  }
7193 
7194  int dbus_type = DBUS_TYPE_INVALID;
7195  char byteValue[BT_MAX_STR_LEN] = "\0";
7196  char hexValue[] = "0123456789abcdef";
7197  unsigned short u16idx = 0;
7198  char ch = '\0';
7199 
7200  memset (byteValue, 0, sizeof(byteValue));
7201 
7202  dbus_message_iter_recurse(&arg_i, &element_i);
7203 
7204  while ((dbus_type = dbus_message_iter_get_arg_type(&element_i)) != DBUS_TYPE_INVALID) {
7205 
7206  if (dbus_type == DBUS_TYPE_BYTE) {
7207  dbus_message_iter_get_basic(&element_i, &ch);
7208  byteValue[u16idx++] = hexValue[ch >> 4];
7209  byteValue[u16idx++] = hexValue[ch & 0x0F];
7210  }
7211  if (!dbus_message_iter_next(&element_i)) {
7212  break;
7213  }
7214  }
7215  byteValue[u16idx] = '\0';
7216  strncpy (rpLeOpRes, byteValue, BT_MAX_STR_LEN-1);
7217  BTRCORELOG_DEBUG ("rpLeOpRes : %s\n", rpLeOpRes);
7218  dbus_message_unref(lpDBusReply);
7219 
7220  } else {
7221  dbus_bool_t lDBusOp;
7222 
7223  lDBusOp = dbus_connection_send(pstlhBtIfce->pDBusConn, lpDBusMsg, NULL);
7224  dbus_message_unref(lpDBusMsg);
7225 
7226  if (!lDBusOp) {
7227  BTRCORELOG_ERROR ("Not enough memory for message send\n");
7228  return -1;
7229  }
7230 
7231  dbus_connection_flush(pstlhBtIfce->pDBusConn);
7232  }
7233 
7234  return 0;
7235 }
7236 
7237 
7238 int
7239 BtrCore_BTSendReceiveMessages (
7240  void* apstBtIfceHdl
7241 ) {
7242  stBtIfceHdl* pstlhBtIfce = (stBtIfceHdl*)apstBtIfceHdl;
7243 
7244  if (!apstBtIfceHdl)
7245  return -1;
7246 
7247 
7248  if(dbus_connection_read_write_dispatch(pstlhBtIfce->pDBusConn, 25) != TRUE) {
7249  return -1;
7250  }
7251 
7252  return 0;
7253 }
7254 
7255 
7256 // Outgoing callbacks Registration Interfaces
7257 int
7258 BtrCore_BTRegisterAdapterStatusUpdateCb (
7259  void* apstBtIfceHdl,
7260  fPtr_BtrCore_BTAdapterStatusUpdateCb afpcBAdapterStatusUpdate,
7261  void* apUserData
7262 ) {
7263  stBtIfceHdl* pstlhBtIfce = (stBtIfceHdl*)apstBtIfceHdl;
7264 
7265  if (!apstBtIfceHdl || !afpcBAdapterStatusUpdate)
7266  return -1;
7267 
7268 
7269  pstlhBtIfce->fpcBAdapterStatusUpdate = afpcBAdapterStatusUpdate;
7270  pstlhBtIfce->pcBAdapterStatusUserData = apUserData;
7271 
7272  return 0;
7273 }
7274 
7275 
7276 int
7277 BtrCore_BTRegisterDevStatusUpdateCb (
7278  void* apstBtIfceHdl,
7279  fPtr_BtrCore_BTDevStatusUpdateCb afpcBDevStatusUpdate,
7280  void* apUserData
7281 ) {
7282  stBtIfceHdl* pstlhBtIfce = (stBtIfceHdl*)apstBtIfceHdl;
7283 
7284  if (!apstBtIfceHdl || !afpcBDevStatusUpdate)
7285  return -1;
7286 
7287 
7288  pstlhBtIfce->fpcBDevStatusUpdate = afpcBDevStatusUpdate;
7289  pstlhBtIfce->pcBDevStatusUserData = apUserData;
7290 
7291  return 0;
7292 }
7293 
7294 
7295 int
7296 BtrCore_BTRegisterMediaStatusUpdateCb (
7297  void* apstBtIfceHdl,
7298  fPtr_BtrCore_BTMediaStatusUpdateCb afpcBMediaStatusUpdate,
7299  void* apUserData
7300 ) {
7301  stBtIfceHdl* pstlhBtIfce = (stBtIfceHdl*)apstBtIfceHdl;
7302 
7303  if (!apstBtIfceHdl || !afpcBMediaStatusUpdate)
7304  return -1;
7305 
7306 
7307  pstlhBtIfce->fpcBMediaStatusUpdate = afpcBMediaStatusUpdate;
7308  pstlhBtIfce->pcBMediaStatusUserData = apUserData;
7309 
7310  return 0;
7311 }
7312 
7313 int
7314 BtrCore_BTRegisterConnIntimationCb (
7315  void* apstBtIfceHdl,
7316  fPtr_BtrCore_BTConnIntimCb afpcBConnIntim,
7317  void* apUserData
7318 ) {
7319  stBtIfceHdl* pstlhBtIfce = (stBtIfceHdl*)apstBtIfceHdl;
7320 
7321  if (!apstBtIfceHdl || !afpcBConnIntim)
7322  return -1;
7323 
7324 
7325  pstlhBtIfce->fpcBConnectionIntimation = afpcBConnIntim;
7326  pstlhBtIfce->pcBConnIntimUserData = apUserData;
7327 
7328  return 0;
7329 }
7330 
7331 
7332 int
7333 BtrCore_BTRegisterConnAuthCb (
7334  void* apstBtIfceHdl,
7335  fPtr_BtrCore_BTConnAuthCb afpcBConnAuth,
7336  void* apUserData
7337 ) {
7338  stBtIfceHdl* pstlhBtIfce = (stBtIfceHdl*)apstBtIfceHdl;
7339 
7340  if (!apstBtIfceHdl || !afpcBConnAuth)
7341  return -1;
7342 
7343 
7344  pstlhBtIfce->fpcBConnectionAuthentication = afpcBConnAuth;
7345  pstlhBtIfce->pcBConnAuthUserData = apUserData;
7346 
7347  return 0;
7348 }
7349 
7350 
7351 int
7352 BtrCore_BTRegisterNegotiateMediaCb (
7353  void* apstBtIfceHdl,
7354  const char* apBtAdapter,
7355  fPtr_BtrCore_BTNegotiateMediaCb afpcBNegotiateMedia,
7356  void* apUserData
7357 ) {
7358  stBtIfceHdl* pstlhBtIfce = (stBtIfceHdl*)apstBtIfceHdl;
7359 
7360  if (!apstBtIfceHdl || !apBtAdapter || !afpcBNegotiateMedia)
7361  return -1;
7362 
7363 
7364  pstlhBtIfce->fpcBNegotiateMedia = afpcBNegotiateMedia;
7365  pstlhBtIfce->pcBNegMediaUserData = apUserData;
7366 
7367  return 0;
7368 }
7369 
7370 
7371 int
7372 BtrCore_BTRegisterTransportPathMediaCb (
7373  void* apstBtIfceHdl,
7374  const char* apBtAdapter,
7375  fPtr_BtrCore_BTTransportPathMediaCb afpcBTransportPathMedia,
7376  void* apUserData
7377 ) {
7378  stBtIfceHdl* pstlhBtIfce = (stBtIfceHdl*)apstBtIfceHdl;
7379 
7380  if (!apstBtIfceHdl || !apBtAdapter || !afpcBTransportPathMedia)
7381  return -1;
7382 
7383 
7384  pstlhBtIfce->fpcBTransportPathMedia = afpcBTransportPathMedia;
7385  pstlhBtIfce->pcBTransPathMediaUserData = apUserData;
7386 
7387  return 0;
7388 }
7389 
7390 
7391 int
7392 BtrCore_BTRegisterMediaPlayerPathCb (
7393  void* apstBtIfceHdl,
7394  const char* apBtAdapter,
7395  fPtr_BtrCore_BTMediaPlayerPathCb afpcBTMediaPlayerPath,
7396  void* apUserData
7397 ) {
7398  stBtIfceHdl* pstlhBtIfce = (stBtIfceHdl*)apstBtIfceHdl;
7399 
7400  if (!apstBtIfceHdl || !apBtAdapter || !afpcBTMediaPlayerPath)
7401  return -1;
7402 
7403 
7404  pstlhBtIfce->fpcBTMediaPlayerPath = afpcBTMediaPlayerPath;
7405  pstlhBtIfce->pcBMediaPlayerPathUserData = apUserData;
7406 
7407  return 0;
7408 }
7409 
7410 
7411 int
7412 BtrCore_BTRegisterMediaBrowserUpdateCb (
7413  void* apstBtIfceHdl,
7414  fPtr_BtrCore_BTMediaBrowserPathCb afpcBTMediaBrowserPath,
7415  void* apUserData
7416 ) {
7417  stBtIfceHdl* pstlhBtIfce = (stBtIfceHdl*)apstBtIfceHdl;
7418 
7419  if (!apstBtIfceHdl || !afpcBTMediaBrowserPath)
7420  return -1;
7421 
7422 
7423  pstlhBtIfce->fpcBTMediaBrowserPath = afpcBTMediaBrowserPath;
7424  pstlhBtIfce->pcBMediaBrowserPathUserData = apUserData;
7425 
7426  return 0;
7427 }
7428 
7429 
7430 int
7431 BtrCore_BTRegisterLEGattInfoCb (
7432  void* apstBtIfceHdl,
7433  const char* apBtAdapter,
7434  fPtr_BtrCore_BTLeGattPathCb afpcBtLeGattPath,
7435  void* apUserData
7436 ) {
7437  stBtIfceHdl* pstlhBtIfce = (stBtIfceHdl*)apstBtIfceHdl;
7438 
7439  if (!apstBtIfceHdl || !apBtAdapter || !afpcBtLeGattPath)
7440  return -1;
7441 
7442 
7443  pstlhBtIfce->fpcBTLeGattPath = afpcBtLeGattPath;
7444  pstlhBtIfce->pcBLePathUserData = apUserData;
7445 
7446  return 0;
7447 }
7448 
7449 
7450 int
7451 BtrCore_BTRegisterLEAdvInfoCb (
7452  void* apstBtIfceHdl,
7453  const char* apBtAdapter,
7454  fPtr_BtrCore_BTLeAdvertisementCb afpcBtLeAdvPath,
7455  void* apUserData
7456 ) {
7457  stBtIfceHdl* pstlhBtIfce = NULL;
7458 
7459  if (!apstBtIfceHdl || !apBtAdapter || !afpcBtLeAdvPath) {
7460  return -1;
7461  }
7462 
7463  pstlhBtIfce = (stBtIfceHdl*)apstBtIfceHdl;
7464 
7465  pstlhBtIfce->fpcBTLeAdvPath = afpcBtLeAdvPath;
7466  pstlhBtIfce->pcBLeAdvUserData = apUserData;
7467 
7468  return 0;
7469 }
7470 
7471 //TODO: Add BtrCore_BTRegisterLEGattInfocB which can be used to register function pointer
7472 //which can be called back when the following interfaces gets added or removed or the properties
7473 //changes on the following Interfaces
7474 // BT_DBUS_BLUEZ_GATT_SERVICE_PATH
7475 // BT_DBUS_BLUEZ_GATT_CHAR_PATH
7476 // BT_DBUS_BLUEZ_GATT_DESCRIPTOR_PATH
7477 
7478 
7479 /* Incoming Callbacks */
7480 static DBusHandlerResult
7481 btrCore_BTDBusConnectionFilterCb (
7482  DBusConnection* apDBusConn,
7483  DBusMessage* apDBusMsg,
7484  void* apvUserData
7485 ) {
7486  int i32OpRet = -1;
7487  int li32MessageType;
7488  stBTAdapterInfo* pstBTAdapterInfo = NULL;
7489  stBTDeviceInfo* pstBTDeviceInfo = NULL;
7490  stBTMediaInfo* pstBTMediaInfo = NULL;
7491  const char* lpcSender = NULL;
7492  const char* lpcDestination = NULL;
7493  stBtIfceHdl* pstlhBtIfce = (stBtIfceHdl*)apvUserData;
7494 
7495  BTRCORELOG_DEBUG ("Connection Filter Activated....\n");
7496 
7497  if (!apDBusConn || !apDBusMsg || !apvUserData) {
7498  return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
7499  }
7500 
7501 
7502  pstBTAdapterInfo = &pstlhBtIfce->lstBTAdapterInfo;
7503  pstBTDeviceInfo = &pstlhBtIfce->lstBTDeviceInfo;
7504  pstBTMediaInfo = &pstlhBtIfce->lstBTMediaInfo;
7505 
7506  memset(pstBTAdapterInfo, 0, sizeof(stBTAdapterInfo));
7507  memset(pstBTDeviceInfo, 0, sizeof(stBTDeviceInfo));
7508  memset(pstBTMediaInfo, 0, sizeof(stBTMediaInfo));
7509  pstBTDeviceInfo->i32RSSI = INT_MIN;
7510 
7511  li32MessageType = dbus_message_get_type(apDBusMsg);
7512  lpcSender = dbus_message_get_sender(apDBusMsg);
7513  lpcDestination = dbus_message_get_destination(apDBusMsg);
7514 
7515  BTRCORELOG_INFO ("%s Sender=%s -> Dest=%s Path=%s; Interface=%s; Member=%s\n",
7516  btrCore_DBusType2Name(li32MessageType),
7517  lpcSender ? lpcSender : "Null",
7518  lpcDestination ? lpcDestination : "Null",
7519  dbus_message_get_path(apDBusMsg),
7520  dbus_message_get_interface(apDBusMsg),
7521  dbus_message_get_member(apDBusMsg));
7522  const char* lSignature = dbus_message_get_signature(apDBusMsg);
7523  BTRCORELOG_TRACE("Signature is %s\n", lSignature);
7524 
7525  if (li32MessageType == DBUS_MESSAGE_TYPE_ERROR) {
7526  const char* lpcError = dbus_message_get_error_name(apDBusMsg);
7527  BTRCORELOG_ERROR ("Error = %s\n", lpcError ? lpcError : NULL);
7528  }
7529  else if (dbus_message_is_signal(apDBusMsg, DBUS_INTERFACE_PROPERTIES, "PropertiesChanged")) {
7530  BTRCORELOG_DEBUG ("Property Changed!\n");
7531 
7532  DBusMessageIter lDBusMsgIter;
7533  const char* lpcDBusIface = NULL;
7534 
7535  dbus_message_iter_init(apDBusMsg, &lDBusMsgIter);
7536  dbus_message_iter_get_basic(&lDBusMsgIter, &lpcDBusIface);
7537  dbus_message_iter_next(&lDBusMsgIter);
7538 
7539  if (dbus_message_iter_get_arg_type(&lDBusMsgIter) == DBUS_TYPE_ARRAY) {
7540  if (lpcDBusIface) {
7541  if (!strcmp(lpcDBusIface, BT_DBUS_BLUEZ_ADAPTER_PATH)) {
7542  BTRCORELOG_INFO ("Property Changed! : %s\n", BT_DBUS_BLUEZ_ADAPTER_PATH);
7543 
7544  {
7545  DBusMessageIter lDBusMsgIterDict, lDBusMsgIter1;
7546  dbus_message_iter_recurse(&lDBusMsgIter, &lDBusMsgIterDict);
7547 
7548  while (dbus_message_iter_get_arg_type(&lDBusMsgIterDict) == DBUS_TYPE_DICT_ENTRY) {
7549  dbus_message_iter_recurse (&lDBusMsgIterDict, &lDBusMsgIter1);
7550 
7551  if (dbus_message_iter_get_arg_type(&lDBusMsgIter1) == DBUS_TYPE_STRING) {
7552  char *str="\0";
7553 
7554  dbus_message_iter_get_basic(&lDBusMsgIter1, &str);
7555  BTRCORELOG_DEBUG ("%s received event <%s>\n", BT_DBUS_BLUEZ_ADAPTER_PATH, str);
7556 
7557  /* Can listen on below events if required
7558  Discovering
7559  Name
7560  Alias
7561  Class
7562  Powered
7563  UUIDs
7564  Discoverable
7565  Pairable
7566  Connectable
7567  DiscoverableTimeout
7568  PairableTimeout
7569  */
7570  }
7571  dbus_message_iter_next(&lDBusMsgIterDict);
7572  }
7573  }
7574 
7575  const char* adapter_path = dbus_message_get_path(apDBusMsg);
7576  strncpy (pstBTAdapterInfo->pcPath, adapter_path, strlen(adapter_path) < BT_MAX_DEV_PATH_LEN ? strlen(adapter_path) : BT_MAX_DEV_PATH_LEN - 1);
7577  i32OpRet = btrCore_BTParseAdapter(&lDBusMsgIter, pstBTAdapterInfo);
7578 
7579  pstlhBtIfce->ui32IsAdapterDiscovering = pstBTAdapterInfo->bDiscovering;
7580  if (pstBTAdapterInfo->bDiscovering) {
7581  BTRCORELOG_INFO ("Adapter Started Discovering | %d\n", pstlhBtIfce->ui32IsAdapterDiscovering);
7582  }
7583  else {
7584  BTRCORELOG_INFO ("Adapter Stopped Discovering | %d\n", pstlhBtIfce->ui32IsAdapterDiscovering);
7585  }
7586 
7587  if (!i32OpRet) {
7588  if (pstlhBtIfce->fpcBAdapterStatusUpdate) {
7589  if(pstlhBtIfce->fpcBAdapterStatusUpdate(enBTAdPropDiscoveryStatus, pstBTAdapterInfo, pstlhBtIfce->pcBAdapterStatusUserData)) {
7590  }
7591  }
7592  }
7593  }
7594  else if (!strcmp(lpcDBusIface, BT_DBUS_BLUEZ_DEVICE_PATH)) {
7595  BTRCORELOG_INFO ("Property Changed! : %s\n", BT_DBUS_BLUEZ_DEVICE_PATH);
7596  DBusMessageIter lDBusMsgIterDict;
7597  const char* pui8DevPath = dbus_message_get_path(apDBusMsg);
7598  int settingRSSItoZero = 0;
7599  int bPairingEvent = 0;
7600  int bPaired = 0;
7601  int bSrvResolvedEvent = 0; //TODO: Bad way to do this. Live with it for now
7602  int bSrvResolved = 0;
7603  int bConnectEvent = 0; //TODO: Bad way to do this. Live with it for now
7604  int bConnected = 0;
7605  int bRssiEvent = 0; //TODO: Bad way to do this. Live with it for now
7606  short i16RSSI = 0;
7607 
7608  i32OpRet = btrCore_BTGetDeviceInfo(apDBusConn, pstBTDeviceInfo, pui8DevPath);
7609 
7610  dbus_message_iter_recurse(&lDBusMsgIter, &lDBusMsgIterDict);
7611 
7612  if (dbus_message_iter_get_arg_type(&lDBusMsgIterDict) == DBUS_TYPE_INVALID) {
7613  settingRSSItoZero = 1;
7614  BTRCORELOG_INFO ("Setting Dev %s RSSI to 0...\n", pstBTDeviceInfo->pcAddress);
7615  }
7616  else {
7617  DBusMessageIter lDBusMsgParse;
7618 
7619  while (dbus_message_iter_get_arg_type(&lDBusMsgIterDict) == DBUS_TYPE_DICT_ENTRY) {
7620  dbus_message_iter_recurse (&lDBusMsgIterDict, &lDBusMsgParse);
7621 
7622  if (dbus_message_iter_get_arg_type(&lDBusMsgParse) == DBUS_TYPE_STRING) {
7623  DBusMessageIter lDBusMsgPropertyValue;
7624  const char *pNameOfProperty = NULL;
7625 
7626  dbus_message_iter_get_basic(&lDBusMsgParse, &pNameOfProperty);
7627  BTRCORELOG_DEBUG ("%s received event <%s>\n", BT_DBUS_BLUEZ_DEVICE_PATH, pNameOfProperty);
7628 
7629  if (strcmp (pNameOfProperty, "Paired") == 0) {
7630  dbus_message_iter_next(&lDBusMsgParse);
7631  dbus_message_iter_recurse(&lDBusMsgParse, &lDBusMsgPropertyValue);
7632  dbus_message_iter_get_basic(&lDBusMsgPropertyValue, &bPaired);
7633  pstBTDeviceInfo->bPaired = bPaired;
7634  bPairingEvent = 1;
7635  BTRCORELOG_DEBUG ("bPaired = %d\n", bPaired);
7636  }
7637  else if (strcmp (pNameOfProperty, "Connected") == 0) {
7638  dbus_message_iter_next(&lDBusMsgParse);
7639  dbus_message_iter_recurse(&lDBusMsgParse, &lDBusMsgPropertyValue);
7640  dbus_message_iter_get_basic(&lDBusMsgPropertyValue, &bConnected);
7641  bConnectEvent = 1;
7642  BTRCORELOG_DEBUG ("bConnected = %d\n", bConnected);
7643  }
7644  else if (strcmp (pNameOfProperty, "ServicesResolved") == 0) {
7645  dbus_message_iter_next(&lDBusMsgParse);
7646  dbus_message_iter_recurse(&lDBusMsgParse, &lDBusMsgPropertyValue);
7647  dbus_message_iter_get_basic(&lDBusMsgPropertyValue, &bSrvResolved);
7648  bSrvResolvedEvent = 1;
7649  BTRCORELOG_DEBUG ("bServicesResolved = %d\n", bSrvResolved);
7650  }
7651  else if (strcmp (pNameOfProperty, "RSSI") == 0) {
7652  dbus_message_iter_next(&lDBusMsgParse);
7653  dbus_message_iter_recurse(&lDBusMsgParse, &lDBusMsgPropertyValue);
7654  dbus_message_iter_get_basic(&lDBusMsgPropertyValue, &i16RSSI);
7655  pstBTDeviceInfo->i32RSSI = i16RSSI;
7656  bRssiEvent = 1;
7657  BTRCORELOG_DEBUG ("Event - bi32Rssi = %d\n", pstBTDeviceInfo->i32RSSI);
7658  }
7659  else if (strcmp (pNameOfProperty, "UUIDs") == 0) {
7660  DBusMessageIter variant_i;
7661  int dbus_type;
7662 
7663  dbus_message_iter_next(&lDBusMsgParse);
7664  dbus_message_iter_recurse(&lDBusMsgParse, &variant_i);
7665 
7666  dbus_type = dbus_message_iter_get_arg_type (&variant_i);
7667  if (dbus_type == DBUS_TYPE_ARRAY) {
7668  int count = 0;
7669  DBusMessageIter variant_j;
7670  dbus_message_iter_recurse(&variant_i, &variant_j);
7671 
7672  while ((dbus_type = dbus_message_iter_get_arg_type (&variant_j)) != DBUS_TYPE_INVALID) {
7673  if ((dbus_type == DBUS_TYPE_STRING) && (count < BT_MAX_DEVICE_PROFILE)) {
7674  char *pVal = NULL;
7675  dbus_message_iter_get_basic (&variant_j, &pVal);
7676  BTRCORELOG_TRACE ("UUID value is %s\n", pVal);
7677  strncpy(pstBTDeviceInfo->aUUIDs[count], pVal, (BT_MAX_UUID_STR_LEN - 1));
7678  count++;
7679  }
7680  dbus_message_iter_next (&variant_j);
7681  }
7682  }
7683  else {
7684  BTRCORELOG_ERROR ("Services; Not an Array\n");
7685  }
7686  }
7687 
7688  /* Can listen on below events if required
7689  Name
7690  Alias
7691  Class
7692  Address
7693  Appearance
7694  Icon
7695  Trusted
7696  Paired
7697  Connected
7698  ServicesResolved
7699  ServiceData
7700  ManufacturerData
7701  RSSI
7702  TxPower
7703  Modalias
7704  Blocked
7705  LegacyPairing
7706  */
7707  }
7708  dbus_message_iter_next(&lDBusMsgIterDict);
7709  }
7710  }
7711 
7712  if (!i32OpRet) {
7713  enBTDeviceState lenBtDevState = enBTDevStUnknown;
7714  enBTDeviceType lenBTDevType = btrCore_BTMapDevClasstoDevType(pstBTDeviceInfo->ui32Class);
7715 
7716  if (bPairingEvent) {
7717  const char* value = NULL;
7718  BTRCORELOG_INFO ("Parsing Property Changed event figured that its pairing change..\n");
7719  if (bPaired) {
7720  value = "paired";
7721  }
7722  else {
7723  value = "unpaired";
7724  }
7725  strncpy(pstBTDeviceInfo->pcDevicePrevState, pstlhBtIfce->pcDeviceCurrState, BT_MAX_STR_LEN - 1);
7726  strncpy(pstBTDeviceInfo->pcDeviceCurrState, value, BT_MAX_STR_LEN - 1);
7727  strncpy(pstlhBtIfce->pcDeviceCurrState, value, BT_MAX_STR_LEN - 1);
7728 
7729  lenBtDevState = enBTDevStPropChanged;
7730  if (pstlhBtIfce->fpcBDevStatusUpdate) {
7731  if(pstlhBtIfce->fpcBDevStatusUpdate(lenBTDevType, lenBtDevState, pstBTDeviceInfo, pstlhBtIfce->pcBDevStatusUserData)) {
7732  }
7733  }
7734  }
7735  else if (pstBTDeviceInfo->bPaired) {
7736  if (settingRSSItoZero || bRssiEvent) {
7737  if (pstlhBtIfce->ui32IsAdapterDiscovering || pstBTDeviceInfo->bConnected) {
7738  lenBtDevState = enBTDevStRSSIUpdate;
7739  }
7740  }
7741  else {
7742  if (pstBTDeviceInfo->bConnected) {
7743  const char* value = "connected";
7744 
7745  strncpy(pstBTDeviceInfo->pcDevicePrevState, pstlhBtIfce->pcDeviceCurrState, BT_MAX_STR_LEN - 1);
7746  strncpy(pstBTDeviceInfo->pcDeviceCurrState, value, BT_MAX_STR_LEN - 1);
7747  strncpy(pstlhBtIfce->pcDeviceCurrState, value, BT_MAX_STR_LEN - 1);
7748 
7749  lenBtDevState = enBTDevStPropChanged;
7750  }
7751  else if (!pstBTDeviceInfo->bConnected) {
7752  const char* value = "disconnected";
7753 
7754  strncpy(pstBTDeviceInfo->pcDevicePrevState, pstlhBtIfce->pcDeviceCurrState, BT_MAX_STR_LEN - 1);
7755  strncpy(pstBTDeviceInfo->pcDeviceCurrState, value, BT_MAX_STR_LEN - 1);
7756  strncpy(pstlhBtIfce->pcDeviceCurrState, value, BT_MAX_STR_LEN - 1);
7757 
7758  lenBtDevState = enBTDevStPropChanged;
7759 
7760  if (enBTDevAudioSink == lenBTDevType && pstlhBtIfce->ui32DevLost) {
7761  lenBtDevState = enBTDevStLost;
7762  }
7763  }
7764  pstlhBtIfce->ui32DevLost = 0;
7765  }
7766 
7767  if (enBTDevAudioSource != lenBTDevType || strcmp(pstlhBtIfce->pcDeviceCurrState, "connected")) {
7768  if (pstlhBtIfce->fpcBDevStatusUpdate) {
7769  if(pstlhBtIfce->fpcBDevStatusUpdate(lenBTDevType, lenBtDevState, pstBTDeviceInfo, pstlhBtIfce->pcBDevStatusUserData)) {
7770  }
7771  }
7772  }
7773  else if ((enBTDevAudioSource == lenBTDevType) && bSrvResolvedEvent && !strcmp(pstBTDeviceInfo->pcDevicePrevState, "connected") && !strcmp(pstBTDeviceInfo->pcDeviceCurrState, "connected")) {
7774  if (pstlhBtIfce->fpcBDevStatusUpdate) {
7775  if(pstlhBtIfce->fpcBDevStatusUpdate(lenBTDevType, lenBtDevState, pstBTDeviceInfo, pstlhBtIfce->pcBDevStatusUserData)) {
7776  }
7777  }
7778  }
7779  }
7780  else if (!pstBTDeviceInfo->bPaired && !pstBTDeviceInfo->bConnected &&
7781  strncmp(pstlhBtIfce->pcLeDeviceAddress, pstBTDeviceInfo->pcAddress,
7782  ((BT_MAX_STR_LEN > strlen(pstBTDeviceInfo->pcAddress))?strlen(pstBTDeviceInfo->pcAddress):BT_MAX_STR_LEN))) {
7783 
7784  if (pstlhBtIfce->ui32IsAdapterDiscovering && settingRSSItoZero) {
7785  lenBtDevState = enBTDevStRSSIUpdate;
7786  }
7787  else {
7788  lenBtDevState = enBTDevStFound;
7789  }
7790 
7791  if (pstlhBtIfce->fpcBDevStatusUpdate) {
7792  if(pstlhBtIfce->fpcBDevStatusUpdate(lenBTDevType, lenBtDevState, pstBTDeviceInfo, pstlhBtIfce->pcBDevStatusUserData)) {
7793  }
7794  }
7795  }
7796  else if (lenBTDevType == enBTDevUnknown) { //TODO: Have to figure out a way to identify it as a LE device
7797 
7798  if (bConnectEvent) {
7799  if (pstBTDeviceInfo->bConnected) {
7800  const char* value = "connected";
7801 
7802  strncpy(pstBTDeviceInfo->pcDevicePrevState, pstlhBtIfce->pcLeDeviceCurrState, BT_MAX_STR_LEN - 1);
7803  strncpy(pstBTDeviceInfo->pcDeviceCurrState, value, BT_MAX_STR_LEN - 1);
7804  strncpy(pstlhBtIfce->pcLeDeviceCurrState, value, BT_MAX_STR_LEN - 1);
7805  strncpy(pstlhBtIfce->pcLeDeviceAddress, pstBTDeviceInfo->pcAddress, BT_MAX_STR_LEN - 1);
7806  }
7807  else if (!pstBTDeviceInfo->bConnected) {
7808  const char* value = "disconnected";
7809 
7810  strncpy(pstBTDeviceInfo->pcDevicePrevState, pstlhBtIfce->pcLeDeviceCurrState, BT_MAX_STR_LEN - 1);
7811  strncpy(pstBTDeviceInfo->pcDeviceCurrState, value, BT_MAX_STR_LEN - 1);
7812  strncpy(pstlhBtIfce->pcLeDeviceCurrState, value, BT_MAX_STR_LEN - 1);
7813  strncpy(pstlhBtIfce->pcLeDeviceAddress, "none", BT_MAX_STR_LEN - 1);
7814  }
7815 
7816  lenBTDevType = enBTDevLE;
7817  lenBtDevState = enBTDevStPropChanged;
7818 
7819  if (pstlhBtIfce->fpcBDevStatusUpdate) {
7820  if(pstlhBtIfce->fpcBDevStatusUpdate(lenBTDevType, lenBtDevState, pstBTDeviceInfo, pstlhBtIfce->pcBDevStatusUserData)) {
7821  }
7822  }
7823  }
7824 
7825  if (bSrvResolvedEvent) {
7826  if (pstlhBtIfce->fpcBTLeGattPath) {
7827  pstlhBtIfce->fpcBTLeGattPath(enBTDevice, enBTLeGattOpUnknown, pui8DevPath, pstBTDeviceInfo->pcAddress, enBTDevStPropChanged, NULL, pstlhBtIfce->pcBLePathUserData);
7828  }
7829  }
7830  else if (!bConnectEvent) {
7831  lenBTDevType = enBTDevLE;
7832  lenBtDevState = enBTDevStPropChanged;
7833 
7834  if (pstlhBtIfce->fpcBDevStatusUpdate) {
7835  if(pstlhBtIfce->fpcBDevStatusUpdate(lenBTDevType, lenBtDevState, pstBTDeviceInfo, pstlhBtIfce->pcBDevStatusUserData)) {
7836  }
7837  }
7838  }
7839  }
7840  else if ((lenBTDevType == enBTDevHID)) {
7841  if (bConnectEvent) {
7842  if (pstBTDeviceInfo->bConnected) {
7843  const char* value = "connected";
7844 
7845  strncpy(pstBTDeviceInfo->pcDevicePrevState, pstBTDeviceInfo->pcDeviceCurrState, BT_MAX_STR_LEN - 1);
7846  strncpy(pstBTDeviceInfo->pcDeviceCurrState, value, BT_MAX_STR_LEN - 1);
7847  }
7848  else if (!pstBTDeviceInfo->bConnected) {
7849  const char* value = "disconnected";
7850 
7851  strncpy(pstBTDeviceInfo->pcDevicePrevState, pstlhBtIfce->pcDeviceCurrState, BT_MAX_STR_LEN - 1);
7852  strncpy(pstBTDeviceInfo->pcDeviceCurrState, value, BT_MAX_STR_LEN - 1);
7853  }
7854 
7855  lenBtDevState = enBTDevStPropChanged;
7856  if (pstlhBtIfce->fpcBDevStatusUpdate) {
7857  if(pstlhBtIfce->fpcBDevStatusUpdate(lenBTDevType, lenBtDevState, pstBTDeviceInfo, pstlhBtIfce->pcBDevStatusUserData)) {
7858  }
7859  }
7860  }
7861  }
7862  }
7863  }
7864  else if (!strcmp(lpcDBusIface, BT_DBUS_BLUEZ_MEDIA_TRANSPORT_PATH)) {
7865  const char* apcMediaTransIface = dbus_message_get_path(apDBusMsg);
7866  char apcDeviceIfce[BT_MAX_STR_LEN] = {'\0'};
7867  unsigned int ui32DeviceIfceLen = strstr(apcMediaTransIface, "/fd") - apcMediaTransIface;
7868  enBTDeviceType lenBTDevType = enBTDevUnknown;
7869  char* apcDevAddr = NULL;
7870  enBTMediaTransportProp lenBTMedTransProp = enBTMedTPropUnknown;
7871  unsigned short lVolume = 0;
7872  unsigned short lDelay = 0xFFFFu;
7873  char* pcState = NULL;
7874 
7875  if (!strncmp(pstlhBtIfce->pcBTVersion, BT_BLUEZ_VERSION_5_54, strlen(BT_BLUEZ_VERSION_5_54))) {
7876  ui32DeviceIfceLen = strstr(apcMediaTransIface, "/sep") - apcMediaTransIface;
7877  }
7878 
7879  BTRCORELOG_INFO ("Property Changed! : %s\n", BT_DBUS_BLUEZ_MEDIA_TRANSPORT_PATH);
7880  {
7881  DBusMessageIter lDBusMsgIterDict, lDBusMsgIter1, lDBusMsgIterVal;
7882  dbus_message_iter_recurse(&lDBusMsgIter, &lDBusMsgIterDict);
7883 
7884  while (dbus_message_iter_get_arg_type(&lDBusMsgIterDict) == DBUS_TYPE_DICT_ENTRY) {
7885  dbus_message_iter_recurse (&lDBusMsgIterDict, &lDBusMsgIter1);
7886 
7887  if (dbus_message_iter_get_arg_type(&lDBusMsgIter1) == DBUS_TYPE_STRING) {
7888  char *str="\0";
7889 
7890  dbus_message_iter_get_basic(&lDBusMsgIter1, &str);
7891  BTRCORELOG_DEBUG ("%s received event <%s>\n", BT_DBUS_BLUEZ_MEDIA_TRANSPORT_PATH, str);
7892 
7893  /* Can listen on below events if required
7894  State
7895  Volume
7896  Delay
7897  */
7898  if (!strncmp(str, "State", strlen("State"))) {
7899  lenBTMedTransProp = enBTMedTPropState;
7900  dbus_message_iter_next(&lDBusMsgIter1);
7901  dbus_message_iter_recurse(&lDBusMsgIter1, &lDBusMsgIterVal);
7902  dbus_message_iter_get_basic(&lDBusMsgIterVal, &pcState);
7903  }
7904  else if (!strncmp(str, "Volume", strlen("Volume"))) {
7905  lenBTMedTransProp = enBTMedTPropVol;
7906  dbus_message_iter_next(&lDBusMsgIter1);
7907  dbus_message_iter_recurse(&lDBusMsgIter1, &lDBusMsgIterVal);
7908  dbus_message_iter_get_basic(&lDBusMsgIterVal, &lVolume);
7909  }
7910  else if (!strncmp(str, "Delay", strlen("Delay"))) {
7911  lenBTMedTransProp = enBTMedTPropDelay;
7912  dbus_message_iter_next(&lDBusMsgIter1);
7913  dbus_message_iter_recurse(&lDBusMsgIter1, &lDBusMsgIterVal);
7914  dbus_message_iter_get_basic(&lDBusMsgIterVal, &lDelay);
7915  }
7916  else {
7917  lenBTMedTransProp = enBTMedTPropUnknown;
7918  }
7919  }
7920  dbus_message_iter_next(&lDBusMsgIterDict);
7921  }
7922  }
7923 
7924  /* We will eventually try not to call bluez api in its own context? */
7925  i32OpRet = btrCore_BTGetMediaInfo(apDBusConn, pstBTMediaInfo, apcMediaTransIface);
7926 
7927  if ((ui32DeviceIfceLen > 0) && (ui32DeviceIfceLen < (BT_MAX_STR_LEN - 1))) {
7928  strncpy(apcDeviceIfce, apcMediaTransIface, ui32DeviceIfceLen);
7929  i32OpRet = btrCore_BTGetDeviceInfo(apDBusConn, pstBTDeviceInfo, apcDeviceIfce);
7930  if (!i32OpRet) {
7931  lenBTDevType = btrCore_BTMapDevClasstoDevType(pstBTDeviceInfo->ui32Class);
7932  apcDevAddr = pstBTDeviceInfo->pcAddress;
7933  }
7934  }
7935 
7936  switch (lenBTMedTransProp) {
7937  case enBTMedTPropState:
7938  if ((!strcmp(pstlhBtIfce->pcMediaCurrState, "none")) && (!strcmp(pcState, "pending"))) {
7939  strcpy(pstlhBtIfce->pcMediaCurrState, pcState);
7940 
7941  if (!i32OpRet && pstBTDeviceInfo->bConnected) {
7942  const char* value = "playing";
7943  enBTDeviceState lenBtDevState = enBTDevStPropChanged;
7944 
7945  strncpy(pstBTDeviceInfo->pcDevicePrevState, pstlhBtIfce->pcDeviceCurrState, BT_MAX_STR_LEN - 1);
7946  strncpy(pstBTDeviceInfo->pcDeviceCurrState, value, BT_MAX_STR_LEN - 1);
7947  strncpy(pstlhBtIfce->pcDeviceCurrState, value, BT_MAX_STR_LEN - 1);
7948 
7949  if (pstlhBtIfce->fpcBDevStatusUpdate) {
7950  if(pstlhBtIfce->fpcBDevStatusUpdate(lenBTDevType, lenBtDevState, pstBTDeviceInfo, pstlhBtIfce->pcBDevStatusUserData)) {
7951  }
7952  }
7953  //if () {} t avmedia wiht device address info. from which id can be computed
7954  }
7955  }
7956  else if (lenBTDevType == enBTDevAudioSource) { //Lets handle AudioIn case for media events for now
7957  char* apcDevTransportPath = (char*)apcMediaTransIface;
7958 
7959  // TODO: Obtain this data path reAcquire call from BTRCore - do as part of next commit
7960  if (strcmp(pstlhBtIfce->pcMediaCurrState, "none") && !strcmp(pcState, "pending")) {
7961  int dataPathFd = 0;
7962  int dataReadMTU = 0;
7963  int dataWriteMTU = 0;
7964 
7965  if (BtrCore_BTAcquireDevDataPath (pstlhBtIfce, apcDevTransportPath, &dataPathFd, &dataReadMTU, &dataWriteMTU)) {
7966  BTRCORELOG_ERROR ("Failed to ReAcquire transport path %s\n", apcMediaTransIface);
7967  }
7968  else {
7969  BTRCORELOG_INFO ("Successfully ReAcquired transport path %s\n", apcMediaTransIface);
7970  }
7971  }
7972 
7973  enBTMediaTransportState lenBtMedTransportSt = enBTMedTransportStNone;
7974  stBTMediaStatusUpdate mediaStatusUpdate;
7975 
7976  if (!strcmp(pcState, "idle")) {
7977  lenBtMedTransportSt = enBTMedTransportStIdle;
7978  strncpy(pstlhBtIfce->pcMediaCurrState, "connected", BT_MAX_STR_LEN - 1);
7979  }
7980  else if (!strcmp(pcState, "pending")) {
7981  lenBtMedTransportSt = enBTMedTransportStPending;
7982  strncpy(pstlhBtIfce->pcMediaCurrState, pcState, strlen(pcState));
7983  }
7984  else if (!strcmp(pcState, "active")) {
7985  lenBtMedTransportSt = enBTMedTransportStActive;
7986  strncpy(pstlhBtIfce->pcMediaCurrState, "playing", BT_MAX_STR_LEN - 1);
7987  }
7988 
7989  mediaStatusUpdate.aenBtOpIfceType = enBTMediaTransport;
7990  mediaStatusUpdate.aunBtOpIfceProp.enBtMediaTransportProp = lenBTMedTransProp;
7991  mediaStatusUpdate.m_mediaTransportState = lenBtMedTransportSt;
7992 
7993  if (pstlhBtIfce->fpcBMediaStatusUpdate) {
7994  if(pstlhBtIfce->fpcBMediaStatusUpdate(lenBTDevType, &mediaStatusUpdate, apcDevAddr, pstlhBtIfce->pcBMediaStatusUserData)) {
7995  }
7996  }
7997  }
7998  else if (lenBTDevType == enBTDevAudioSink) { // Lets handle AudioOut case for media events for a Paired device which connects at Pairing
7999  if (!i32OpRet && pstBTDeviceInfo->bConnected && pstBTDeviceInfo->bPaired) {
8000  if ((!strcmp(pstlhBtIfce->pcMediaCurrState, "none")) && (!strcmp(pcState, "idle"))) {
8001  const char* value = "connected";
8002  enBTDeviceState lenBtDevState = enBTDevStPropChanged;
8003 
8004  strncpy(pstBTDeviceInfo->pcDevicePrevState, pstlhBtIfce->pcDeviceCurrState, BT_MAX_STR_LEN - 1);
8005  strncpy(pstBTDeviceInfo->pcDeviceCurrState, value, BT_MAX_STR_LEN - 1);
8006  strncpy(pstlhBtIfce->pcDeviceCurrState, value, BT_MAX_STR_LEN - 1);
8007 
8008  if (pstlhBtIfce->fpcBDevStatusUpdate) {
8009  if (pstlhBtIfce->fpcBDevStatusUpdate(lenBTDevType, lenBtDevState, pstBTDeviceInfo, pstlhBtIfce->pcBDevStatusUserData)) {
8010  }
8011  }
8012  }
8013  else {
8014  strncpy(pstlhBtIfce->pcMediaCurrState, pcState, strlen(pcState));
8015  }
8016  }
8017  }
8018  break;
8019  case enBTMedTPropDelay:
8020  BTRCORELOG_DEBUG ("MediaTransport Property - Delay\n");
8021  break;
8022  case enBTMedTPropVol:
8023  {
8024  stBTMediaStatusUpdate mediaStatusUpdate;
8025  BTRCORELOG_DEBUG ("MediaTransport Property - Volume\n");
8026 
8027  mediaStatusUpdate.aenBtOpIfceType = enBTMediaTransport;
8028  mediaStatusUpdate.aunBtOpIfceProp.enBtMediaTransportProp = lenBTMedTransProp;
8029  mediaStatusUpdate.m_mediaTransportVolume = (unsigned char)((lVolume == 127) ? 255 : lVolume * 2);
8030 
8031  if (pstlhBtIfce->fpcBMediaStatusUpdate) {
8032  if(pstlhBtIfce->fpcBMediaStatusUpdate(lenBTDevType, &mediaStatusUpdate, apcDevAddr, pstlhBtIfce->pcBMediaStatusUserData)) {
8033  }
8034  }
8035  }
8036  break;
8037  case enBTMedTPropUnknown:
8038  default:
8039  BTRCORELOG_ERROR ("MediaTransport Property - Unknown\n");
8040  break;
8041  }
8042  }
8043  else if (!strcmp(lpcDBusIface, BT_DBUS_BLUEZ_MEDIA_CTRL_PATH)) {
8044  enBTDeviceType lenBTDevType = enBTDevUnknown;
8045  char* apcDevAddr = NULL;
8046  stBTMediaStatusUpdate mediaStatusUpdate;
8047 
8048  BTRCORELOG_ERROR ("Property Changed! : %s\n", BT_DBUS_BLUEZ_MEDIA_CTRL_PATH);
8049 
8050  i32OpRet = btrCore_BTGetDeviceInfo(apDBusConn, pstBTDeviceInfo, dbus_message_get_path(apDBusMsg));
8051  if (!i32OpRet) {
8052  lenBTDevType = btrCore_BTMapDevClasstoDevType(pstBTDeviceInfo->ui32Class);
8053  apcDevAddr = pstBTDeviceInfo->pcAddress;
8054  }
8055 
8056  {
8057  DBusMessageIter lDBusMsgIterDict, lDBusMsgIter1, lDBusMsgIterVal;
8058  dbus_message_iter_recurse(&lDBusMsgIter, &lDBusMsgIterDict);
8059 
8060  while (dbus_message_iter_get_arg_type(&lDBusMsgIterDict) == DBUS_TYPE_DICT_ENTRY) {
8061  dbus_message_iter_recurse (&lDBusMsgIterDict, &lDBusMsgIter1);
8062 
8063  if (dbus_message_iter_get_arg_type(&lDBusMsgIter1) == DBUS_TYPE_STRING) {
8064  char *str="\0";
8065  mediaStatusUpdate.aenBtOpIfceType = enBTMediaControl;
8066 
8067  dbus_message_iter_get_basic(&lDBusMsgIter1, &str);
8068  BTRCORELOG_DEBUG ("%s received event <%s>\n", BT_DBUS_BLUEZ_MEDIA_CTRL_PATH, str);
8069 
8070  /* Can listen on below events if required
8071  Connected
8072  Player
8073  */
8074  if (!strncmp(str, "Connected", strlen("Connected"))) {
8075  unsigned char ui8var = 0;
8076  dbus_message_iter_next(&lDBusMsgIter1);
8077  dbus_message_iter_recurse(&lDBusMsgIter1, &lDBusMsgIterVal);
8078  dbus_message_iter_get_basic(&lDBusMsgIterVal, &ui8var);
8079 
8080  mediaStatusUpdate.aunBtOpIfceProp.enBtMediaPlayerProp = enBTMedControlPropConnected;
8081  mediaStatusUpdate.m_mediaPlayerConnected = ui8var;
8082  }
8083  else if (!strncmp(str, "Player", strlen("Player"))) {
8084  char* lpcPath = 0;
8085  dbus_message_iter_next(&lDBusMsgIter1);
8086  dbus_message_iter_recurse(&lDBusMsgIter1, &lDBusMsgIterVal);
8087  dbus_message_iter_get_basic(&lDBusMsgIterVal, &lpcPath);
8088 
8089  mediaStatusUpdate.aunBtOpIfceProp.enBtMediaPlayerProp = enBTMedControlPropPath;
8090  memset (mediaStatusUpdate.m_mediaPlayerPath, 0, BT_MAX_STR_LEN);
8091  strncpy(mediaStatusUpdate.m_mediaPlayerPath, lpcPath, BT_MAX_STR_LEN - 1);
8092  }
8093  }
8094  if (pstlhBtIfce->fpcBMediaStatusUpdate) {
8095  if(pstlhBtIfce->fpcBMediaStatusUpdate(lenBTDevType, &mediaStatusUpdate, apcDevAddr, pstlhBtIfce->pcBMediaStatusUserData)) {
8096  }
8097  }
8098  dbus_message_iter_next(&lDBusMsgIterDict);
8099  }
8100  }
8101 
8102 
8103  if ((enBTDevAudioSource == lenBTDevType) && pstBTDeviceInfo->bConnected && mediaStatusUpdate.m_mediaPlayerConnected) {
8104  const char* value = "connected";
8105  enBTDeviceState lenBtDevState = enBTDevStPropChanged;
8106 
8107  strncpy(pstBTDeviceInfo->pcDevicePrevState, pstlhBtIfce->pcDeviceCurrState, BT_MAX_STR_LEN - 1);
8108  strncpy(pstBTDeviceInfo->pcDeviceCurrState, value, BT_MAX_STR_LEN - 1);
8109  strncpy(pstlhBtIfce->pcDeviceCurrState, value, BT_MAX_STR_LEN - 1);
8110 
8111  if (pstlhBtIfce->fpcBDevStatusUpdate) {
8112  if(pstlhBtIfce->fpcBDevStatusUpdate(lenBTDevType, lenBtDevState, pstBTDeviceInfo, pstlhBtIfce->pcBDevStatusUserData)) {
8113  }
8114  }
8115  }
8116 
8117  }
8118  else if (!strcmp(lpcDBusIface, BT_DBUS_BLUEZ_MEDIA_PLAYER_PATH)) {
8119  const char* apcMediaPlayerIface = dbus_message_get_path(apDBusMsg);
8120  char apcDeviceIfce[BT_MAX_STR_LEN] = {'\0'};
8121  unsigned int ui32DeviceIfceLen = strstr(apcMediaPlayerIface, "/player") - apcMediaPlayerIface;
8122  enBTDeviceType lenBTDevType = enBTDevUnknown;
8123  char* apcDevAddr = NULL;
8124  stBTMediaStatusUpdate mediaStatusUpdate;
8125 
8126  BTRCORELOG_ERROR ("Property Changed! : %s\n", BT_DBUS_BLUEZ_MEDIA_PLAYER_PATH);
8127 
8128  strncpy(apcDeviceIfce, apcMediaPlayerIface, ui32DeviceIfceLen);
8129  i32OpRet = btrCore_BTGetDeviceInfo(apDBusConn, pstBTDeviceInfo, apcDeviceIfce);
8130  if (!i32OpRet) {
8131  lenBTDevType = btrCore_BTMapDevClasstoDevType(pstBTDeviceInfo->ui32Class);
8132  apcDevAddr = pstBTDeviceInfo->pcAddress;
8133  }
8134  memset (&mediaStatusUpdate, 0, sizeof(stBTMediaStatusUpdate));
8135 
8136  {
8137  DBusMessageIter lDBusMsgIterDict, lDBusMsgIter1, lDBusMsgIterVal;
8138  dbus_message_iter_recurse(&lDBusMsgIter, &lDBusMsgIterDict);
8139 
8140  while (dbus_message_iter_get_arg_type(&lDBusMsgIterDict) == DBUS_TYPE_DICT_ENTRY) {
8141  dbus_message_iter_recurse (&lDBusMsgIterDict, &lDBusMsgIter1);
8142 
8143  if (dbus_message_iter_get_arg_type(&lDBusMsgIter1) == DBUS_TYPE_STRING) {
8144  char *str="\0";
8145  mediaStatusUpdate.aenBtOpIfceType = enBTMediaPlayer;
8146 
8147  dbus_message_iter_get_basic(&lDBusMsgIter1, &str);
8148  BTRCORELOG_DEBUG ("%s received event <%s>\n", BT_DBUS_BLUEZ_MEDIA_PLAYER_PATH, str);
8149  /* Can listen on below events if required
8150  Name
8151  Type
8152  Subtype
8153  Status
8154  Position
8155  Track
8156  Browsable
8157  Searchable
8158  Playlist
8159  Equalizer
8160  Repeat
8161  Shuffle
8162  Scan
8163  */
8164  if (!strncmp(str, "Name", strlen("Name"))) {
8165  char* pcName = 0;
8166  dbus_message_iter_next(&lDBusMsgIter1);
8167  dbus_message_iter_recurse(&lDBusMsgIter1, &lDBusMsgIterVal);
8168  dbus_message_iter_get_basic(&lDBusMsgIterVal, &pcName);
8169  mediaStatusUpdate.aunBtOpIfceProp.enBtMediaPlayerProp = enBTMedPlayerPropName;
8170  strncpy (mediaStatusUpdate.m_mediaPlayerName, pcName, BT_MAX_STR_LEN - 1);
8171  }
8172  else if (!strncmp(str, "Type", strlen("Type"))) {
8173  char* pcType = 0;
8174  dbus_message_iter_next(&lDBusMsgIter1);
8175  dbus_message_iter_recurse(&lDBusMsgIter1, &lDBusMsgIterVal);
8176  dbus_message_iter_get_basic(&lDBusMsgIterVal, &pcType);
8177  mediaStatusUpdate.aunBtOpIfceProp.enBtMediaPlayerProp = enBTMedPlayerPropType;
8178 
8179  if (!strncmp ("Audio", pcType, strlen("Audio"))) {
8180  mediaStatusUpdate.enMediaPlayerType = enBTMedPlayerTypAudio;
8181  }
8182  else if (!strncmp ("Video", pcType, strlen("Video"))) {
8183  mediaStatusUpdate.enMediaPlayerType = enBTMedPlayerTypVideo;
8184  }
8185  else if (!strncmp ("Audio Broadcasting", pcType, strlen("Audio Broadcasting"))) {
8186  mediaStatusUpdate.enMediaPlayerType = enBTMedPlayerTypAudioBroadcasting;
8187  }
8188  else if (!strncmp ("Video Broadcasting", pcType, strlen("Video Broadcasting"))) {
8189  mediaStatusUpdate.enMediaPlayerType = enBTMedPlayerTypVideoBroadcasting;
8190  }
8191  }
8192  else if (!strncmp(str, "Subtype", strlen("Subtype"))) {
8193  char* pcSubtype = 0;
8194  dbus_message_iter_next(&lDBusMsgIter1);
8195  dbus_message_iter_recurse(&lDBusMsgIter1, &lDBusMsgIterVal);
8196  dbus_message_iter_get_basic(&lDBusMsgIterVal, &pcSubtype);
8197  mediaStatusUpdate.aunBtOpIfceProp.enBtMediaPlayerProp = enBTMedPlayerPropSubtype;
8198 
8199  if (!strncmp ("Audio Book", pcSubtype, strlen("Audio Book"))) {
8200  mediaStatusUpdate.enMediaPlayerSubtype = enBTMedPlayerSbTypAudioBook;
8201  }
8202  else if (!strncmp ("Podcast", pcSubtype, strlen("Podcast"))) {
8203  mediaStatusUpdate.enMediaPlayerSubtype = enBTMedPlayerSbTypPodcast;
8204  }
8205  }
8206  else if (!strncmp(str, "Status", strlen("Status"))) {
8207  char* pcStatus = 0;
8208  dbus_message_iter_next(&lDBusMsgIter1);
8209  dbus_message_iter_recurse(&lDBusMsgIter1, &lDBusMsgIterVal);
8210  dbus_message_iter_get_basic(&lDBusMsgIterVal, &pcStatus);
8211  mediaStatusUpdate.aunBtOpIfceProp.enBtMediaPlayerProp = enBTMedPlayerPropStatus;
8212 
8213  if (!strncmp("playing", pcStatus, strlen("playing"))) {
8214  mediaStatusUpdate.enMediaPlayerStatus = enBTMedPlayerStPlaying;
8215  }
8216  else if (!strncmp("paused", pcStatus, strlen("paused"))) {
8217  mediaStatusUpdate.enMediaPlayerStatus = enBTMedPlayerStPaused;
8218  }
8219  else if (!strncmp("forward-seek", pcStatus, strlen("forward-seek"))) {
8220  mediaStatusUpdate.enMediaPlayerStatus = enBTMedPlayerStForwardSeek;
8221  }
8222  else if (!strncmp("reverse-seek", pcStatus, strlen("reverse-seek"))) {
8223  mediaStatusUpdate.enMediaPlayerStatus = enBTMedPlayerStReverseSeek;
8224  }
8225  else if (!strncmp("stopped", pcStatus, strlen("stopped"))) {
8226  mediaStatusUpdate.enMediaPlayerStatus = enBTMedPlayerStStopped;
8227  }
8228  else if (!strncmp("error", pcStatus, strlen("error"))) {
8229  mediaStatusUpdate.enMediaPlayerStatus = enBTMedPlayerStError;
8230  }
8231  }
8232  else if (!strncmp(str, "Position", strlen("Position"))) {
8233  unsigned int ui32Position = 0;
8234  dbus_message_iter_next(&lDBusMsgIter1);
8235  dbus_message_iter_recurse(&lDBusMsgIter1, &lDBusMsgIterVal);
8236  dbus_message_iter_get_basic(&lDBusMsgIterVal, &ui32Position);
8237  mediaStatusUpdate.aunBtOpIfceProp.enBtMediaPlayerProp = enBTMedPlayerPropPosition;
8238  mediaStatusUpdate.m_mediaPlayerPosition = ui32Position;
8239  }
8240  else if (!strncmp(str, "Track", strlen("Track"))) {
8241  stBTMediaTrackInfo mediaTrackInfo;
8242  memset (&mediaTrackInfo, 0, sizeof(stBTMediaTrackInfo));
8243 
8244  if (!BtrCore_BTGetTrackInformation (pstlhBtIfce, apcMediaPlayerIface, &mediaTrackInfo)) {
8245  mediaStatusUpdate.aunBtOpIfceProp.enBtMediaPlayerProp = enBTMedPlayerPropTrack;
8246  memcpy(&mediaStatusUpdate.m_mediaTrackInfo, &mediaTrackInfo, sizeof(stBTMediaTrackInfo));
8247  }
8248  }
8249  else if (!strncmp(str, "Browsable", strlen("Browsable"))) {
8250  bool bIsBrowsable = 0;
8251  dbus_message_iter_next(&lDBusMsgIter1);
8252  dbus_message_iter_recurse(&lDBusMsgIter1, &lDBusMsgIterVal);
8253  dbus_message_iter_get_basic(&lDBusMsgIterVal, &bIsBrowsable);
8254  mediaStatusUpdate.aunBtOpIfceProp.enBtMediaPlayerProp = enBTMedPlayerPropBrowsable;
8255  mediaStatusUpdate.m_mediaPlayerBrowsable = bIsBrowsable;
8256  }
8257  else if (!strncmp(str, "Searchable", strlen("Searchable"))) {
8258  bool bIsSearchable = 0;
8259  dbus_message_iter_next(&lDBusMsgIter1);
8260  dbus_message_iter_recurse(&lDBusMsgIter1, &lDBusMsgIterVal);
8261  dbus_message_iter_get_basic(&lDBusMsgIterVal, &bIsSearchable);
8262  mediaStatusUpdate.aunBtOpIfceProp.enBtMediaPlayerProp = enBTMedPlayerPropSearchable;
8263  mediaStatusUpdate.m_mediaPlayerBrowsable = bIsSearchable;
8264  }
8265 
8266  else if (!strncmp(str, "Playlist", strlen("Playlist"))) {
8267  mediaStatusUpdate.aunBtOpIfceProp.enBtMediaPlayerProp = enBTMedPlayerPropPlaylist;
8268  }
8269 
8270  else if (!strncmp(str, "Equalizer", strlen("Equalizer"))) {
8271  char* pcEqualizer = 0;
8272  dbus_message_iter_next(&lDBusMsgIter1);
8273  dbus_message_iter_recurse(&lDBusMsgIter1, &lDBusMsgIterVal);
8274  dbus_message_iter_get_basic(&lDBusMsgIterVal, &pcEqualizer);
8275  mediaStatusUpdate.aunBtOpIfceProp.enBtMediaPlayerProp = enBTMedPlayerPropEqualizer;
8276 
8277  if (!strncmp("on", pcEqualizer, strlen("on"))) {
8278  mediaStatusUpdate.enMediaPlayerEqualizer = enBTMedPlayerEqualizerOn;
8279  }
8280  else if (!strncmp("off", pcEqualizer, strlen("off"))) {
8281  mediaStatusUpdate.enMediaPlayerEqualizer = enBTMedPlayerEqualizerOff;
8282  }
8283  }
8284  else if (!strncmp(str, "Repeat", strlen("Repeat"))) {
8285  char* pcRepeat = 0;
8286  dbus_message_iter_next(&lDBusMsgIter1);
8287  dbus_message_iter_recurse(&lDBusMsgIter1, &lDBusMsgIterVal);
8288  dbus_message_iter_get_basic(&lDBusMsgIterVal, &pcRepeat);
8289  mediaStatusUpdate.aunBtOpIfceProp.enBtMediaPlayerProp = enBTMedPlayerPropRepeat;
8290 
8291  if (!strncmp("off", pcRepeat, strlen("off"))) {
8292  mediaStatusUpdate.enMediaPlayerRepeat = enBTMedPlayerRpOff;
8293  }
8294  else if (!strncmp("singletrack", pcRepeat, strlen("singletrack"))) {
8295  mediaStatusUpdate.enMediaPlayerRepeat = enBTMedPlayerRpSingleTrack;
8296  }
8297  else if (!strncmp("alltracks", pcRepeat, strlen("alltracks"))) {
8298  mediaStatusUpdate.enMediaPlayerRepeat = enBTMedPlayerRpAllTracks;
8299  }
8300  else if (!strncmp("group", pcRepeat, strlen("group"))) {
8301  mediaStatusUpdate.enMediaPlayerRepeat = enBTMedPlayerRpGroup;
8302  }
8303  }
8304  else if (!strncmp(str, "Shuffle", strlen("Shuffle"))) {
8305  char* pcShuffle = 0;
8306  dbus_message_iter_next(&lDBusMsgIter1);
8307  dbus_message_iter_recurse(&lDBusMsgIter1, &lDBusMsgIterVal);
8308  dbus_message_iter_get_basic(&lDBusMsgIterVal, &pcShuffle);
8309  mediaStatusUpdate.aunBtOpIfceProp.enBtMediaPlayerProp = enBTMedPlayerPropShuffle;
8310 
8311  if (!strncmp("off", pcShuffle, strlen("off"))) {
8312  mediaStatusUpdate.enMediaPlayerShuffle = enBTMedPlayerShuffleOff;
8313  }
8314  else if (!strncmp("alltracks", pcShuffle, strlen("alltracks"))) {
8315  mediaStatusUpdate.enMediaPlayerShuffle = enBTMedPlayerShuffleAllTracks;
8316  }
8317  else if (!strncmp("group", pcShuffle, strlen("group"))) {
8318  mediaStatusUpdate.enMediaPlayerShuffle = enBTMedPlayerShuffleGroup;
8319  }
8320  }
8321  else if (!strncmp(str, "Scan", strlen("Scan"))) {
8322  char* pcScan = 0;
8323  dbus_message_iter_next(&lDBusMsgIter1);
8324  dbus_message_iter_recurse(&lDBusMsgIter1, &lDBusMsgIterVal);
8325  dbus_message_iter_get_basic(&lDBusMsgIterVal, &pcScan);
8326  mediaStatusUpdate.aunBtOpIfceProp.enBtMediaPlayerProp = enBTMedPlayerPropScan;
8327 
8328  if (!strncmp("off", pcScan, strlen("off"))) {
8329  mediaStatusUpdate.enMediaPlayerScan = enBTMedPlayerScanOff;
8330  }
8331  else if (!strncmp("alltracks", pcScan, strlen("alltracks"))) {
8332  mediaStatusUpdate.enMediaPlayerScan = enBTMedPlayerScanAllTracks;
8333  }
8334  else if (!strncmp("group", pcScan, strlen("group"))) {
8335  mediaStatusUpdate.enMediaPlayerScan = enBTMedPlayerScanGroup;
8336  }
8337  }
8338  }
8339 
8340  if (pstlhBtIfce->fpcBMediaStatusUpdate) {
8341  if(pstlhBtIfce->fpcBMediaStatusUpdate(lenBTDevType, &mediaStatusUpdate, apcDevAddr, pstlhBtIfce->pcBMediaStatusUserData)) {
8342  }
8343  }
8344  dbus_message_iter_next(&lDBusMsgIterDict);
8345  }
8346  }
8347  }
8348  else if (!strcmp(lpcDBusIface, BT_DBUS_BLUEZ_MEDIA_ITEM_PATH)) {
8349  const char* apcMediaItemIface = dbus_message_get_path(apDBusMsg);
8350  char apcDeviceIfce[BT_MAX_STR_LEN] = {'\0'};
8351  unsigned int ui32DeviceIfceLen = strstr(apcMediaItemIface, "/player") - apcMediaItemIface;
8352  enBTDeviceType lenBTDevType = enBTDevUnknown;
8353  char* apcDevAddr = NULL;
8354  stBTMediaStatusUpdate mediaStatusUpdate;
8355 
8356  BTRCORELOG_ERROR ("Property Changed! : %s\n", BT_DBUS_BLUEZ_MEDIA_ITEM_PATH);
8357 
8358  strncpy(apcDeviceIfce, apcMediaItemIface, ui32DeviceIfceLen);
8359  i32OpRet = btrCore_BTGetDeviceInfo(apDBusConn, pstBTDeviceInfo, apcDeviceIfce);
8360  if (!i32OpRet) {
8361  lenBTDevType = btrCore_BTMapDevClasstoDevType(pstBTDeviceInfo->ui32Class);
8362  apcDevAddr = pstBTDeviceInfo->pcAddress;
8363  }
8364 
8365  {
8366  DBusMessageIter lDBusMsgIterDict, lDBusMsgIter1;
8367  dbus_message_iter_recurse(&lDBusMsgIter, &lDBusMsgIterDict);
8368 
8369  while (dbus_message_iter_get_arg_type(&lDBusMsgIterDict) == DBUS_TYPE_DICT_ENTRY) {
8370  dbus_message_iter_recurse (&lDBusMsgIterDict, &lDBusMsgIter1);
8371 
8372  if (dbus_message_iter_get_arg_type(&lDBusMsgIter1) == DBUS_TYPE_STRING) {
8373  char *str="\0";
8374 
8375  dbus_message_iter_get_basic(&lDBusMsgIter1, &str);
8376  BTRCORELOG_DEBUG ("%s received event <%s>\n", BT_DBUS_BLUEZ_MEDIA_ITEM_PATH, str);
8377 
8378  /* Can listen on below events if required
8379  Playable
8380  Metadata
8381  */
8382  if (!strncmp(str, "Playable", strlen("Playable"))) {
8383  }
8384  else if (!strncmp(str, "Metadata", strlen("Metadata"))) {
8385  char mediaPlayerIface[BT_MAX_STR_LEN];
8386  stBTMediaTrackInfo mediaTrackInfo;
8387  memset (mediaPlayerIface, 0, BT_MAX_STR_LEN);
8388  memset (&mediaTrackInfo, 0, sizeof(stBTMediaTrackInfo));
8389 
8390 #if 1
8391  /* Eliminate querying for TrackInfo, rather read it from the incoming DBusMsg */
8392  if (strstr(apcMediaItemIface, "/NowPlaying")) {
8393  strncpy(mediaPlayerIface, apcMediaItemIface, (unsigned int)(strstr(apcMediaItemIface, "/NowPlaying") - apcMediaItemIface));
8394  }
8395  else if (strstr(apcMediaItemIface, "/Filesystem")) {
8396  strncpy(mediaPlayerIface, apcMediaItemIface, (unsigned int)(strstr(apcMediaItemIface, "/Filesystem") - apcMediaItemIface));
8397  }
8398 #else
8399  dbus_message_iter_next(&lDBusMsgIter1);
8400  dbus_message_iter_recurse(&lDBusMsgIter1, &lDBusMsgIterVal);
8401 
8402  if (dbus_message_iter_get_arg_type(&lDBusMsgIterVal) == DBUS_TYPE_DICT_ENTRY) {
8403  BTRCORELOG_DEBUG ("DBUS_TYPE_DICT_ENTRY\n");
8404  }
8405 
8406  btrCore_BTParseMediaTrackMetadata(&lDBusMsgIterVal, &mediaTrackInfo);
8407 #endif
8408  mediaStatusUpdate.aenBtOpIfceType = enBTMediaPlayer;
8409  mediaStatusUpdate.aunBtOpIfceProp.enBtMediaPlayerProp = enBTMedPlayerPropTrack;
8410 
8411  if (!BtrCore_BTGetTrackInformation (pstlhBtIfce, mediaPlayerIface, &mediaTrackInfo)) {
8412  memcpy(&mediaStatusUpdate.m_mediaTrackInfo, &mediaTrackInfo, sizeof(stBTMediaTrackInfo));
8413  }
8414  else {
8415  BTRCORELOG_ERROR ("FAILED BtrCore_BTGetTrackInformation !!!!\n");
8416  }
8417  }
8418  }
8419  if (pstlhBtIfce->fpcBMediaStatusUpdate) {
8420  if(pstlhBtIfce->fpcBMediaStatusUpdate(lenBTDevType, &mediaStatusUpdate, apcDevAddr, pstlhBtIfce->pcBMediaStatusUserData)) {
8421  }
8422  }
8423  dbus_message_iter_next(&lDBusMsgIterDict);
8424  }
8425  }
8426  }
8427  else if (!strcmp(lpcDBusIface, BT_DBUS_BLUEZ_MEDIA_FOLDER_PATH)){
8428  const char* apcMediaItemIface = dbus_message_get_path(apDBusMsg);
8429  char apcDeviceIfce[BT_MAX_STR_LEN] = {'\0'};
8430  unsigned int ui32DeviceIfceLen = strstr(apcMediaItemIface, "/player") - apcMediaItemIface;
8431  enBTDeviceType lenBTDevType = enBTDevUnknown;
8432  char* apcDevAddr = NULL;
8433  stBTMediaStatusUpdate mediaStatusUpdate;
8434 
8435  BTRCORELOG_ERROR ("Property Changed! : %s\n", BT_DBUS_BLUEZ_MEDIA_FOLDER_PATH);
8436 
8437  strncpy(apcDeviceIfce, apcMediaItemIface, ui32DeviceIfceLen);
8438  i32OpRet = btrCore_BTGetDeviceInfo(apDBusConn, pstBTDeviceInfo, apcDeviceIfce);
8439  if (!i32OpRet) {
8440  lenBTDevType = btrCore_BTMapDevClasstoDevType(pstBTDeviceInfo->ui32Class);
8441  apcDevAddr = pstBTDeviceInfo->pcAddress;
8442  }
8443 
8444  {
8445  DBusMessageIter lDBusMsgIterDict, lDBusMsgIter1, lDBusMsgIterVal;
8446  dbus_message_iter_recurse(&lDBusMsgIter, &lDBusMsgIterDict);
8447 
8448  while (dbus_message_iter_get_arg_type(&lDBusMsgIterDict) == DBUS_TYPE_DICT_ENTRY) {
8449  dbus_message_iter_recurse (&lDBusMsgIterDict, &lDBusMsgIter1);
8450 
8451  if (dbus_message_iter_get_arg_type(&lDBusMsgIter1) == DBUS_TYPE_STRING) {
8452  char *str="\0";
8453 
8454  mediaStatusUpdate.aenBtOpIfceType = enBTMediaFolder;
8455  dbus_message_iter_get_basic(&lDBusMsgIter1, &str);
8456  BTRCORELOG_DEBUG ("%s received event <%s>\n", BT_DBUS_BLUEZ_MEDIA_FOLDER_PATH, str);
8457 
8458  /* Can listen on below events if required
8459  NumberOfItems
8460  Name
8461  */
8462  if (!strncmp(str, "Name", strlen("Name"))) {
8463  char* pcName = 0;
8464  dbus_message_iter_next(&lDBusMsgIter1);
8465  dbus_message_iter_recurse(&lDBusMsgIter1, &lDBusMsgIterVal);
8466  dbus_message_iter_get_basic(&lDBusMsgIterVal, &pcName);
8467  mediaStatusUpdate.aunBtOpIfceProp.enBtMediaFolderProp = enBTMedFolderPropName;
8468  strncpy (mediaStatusUpdate.m_mediaFolderName, btrCore_BTGetMediaItemAbsoluteName (pcName), BT_MAX_STR_LEN -1);
8469  }
8470  else if (!strncmp(str, "NumberOfItems", strlen("NumberOfItems"))) {
8471  unsigned int ui32NumberOfItems = 0;
8472  dbus_message_iter_next(&lDBusMsgIter1);
8473  dbus_message_iter_recurse(&lDBusMsgIter1, &lDBusMsgIterVal);
8474  dbus_message_iter_get_basic(&lDBusMsgIterVal, &ui32NumberOfItems);
8475  mediaStatusUpdate.aunBtOpIfceProp.enBtMediaFolderProp = enBTMedFolderPropNumberOfItems;
8476  mediaStatusUpdate.m_mediaFolderNumberOfItems = ui32NumberOfItems;
8477  }
8478  }
8479 
8480  if (pstlhBtIfce->fpcBMediaStatusUpdate) {
8481  if(pstlhBtIfce->fpcBMediaStatusUpdate(lenBTDevType, &mediaStatusUpdate, apcDevAddr, pstlhBtIfce->pcBMediaStatusUserData)) {
8482  }
8483  }
8484  dbus_message_iter_next(&lDBusMsgIterDict);
8485  }
8486  }
8487  }
8488  /* Added propert change for GATT */
8489  else if (!strcmp(lpcDBusIface, BT_DBUS_BLUEZ_GATT_SERVICE_PATH)) {
8490  BTRCORELOG_INFO ("Property Changed! : %s\n", BT_DBUS_BLUEZ_GATT_SERVICE_PATH);
8491  }
8492  else if (!strcmp(lpcDBusIface, BT_DBUS_BLUEZ_GATT_CHAR_PATH )) {
8493  BTRCORELOG_INFO ("Property Changed! : %s\n", BT_DBUS_BLUEZ_GATT_CHAR_PATH);
8494  const char* pCharIface = dbus_message_get_path(apDBusMsg);
8495  unsigned int ui32DeviceIfceLen = strstr(pCharIface, "/service") - pCharIface;
8496  char apcDeviceIfce[BT_MAX_STR_LEN] = {'\0'};
8497 
8498  if ((ui32DeviceIfceLen > 0) && (ui32DeviceIfceLen < (BT_MAX_STR_LEN - 1))) {
8499  strncpy(apcDeviceIfce, pCharIface, ui32DeviceIfceLen);
8500 
8501  i32OpRet = btrCore_BTGetDeviceInfo(apDBusConn, pstBTDeviceInfo, apcDeviceIfce);
8502  if (!i32OpRet) {
8503  if (pstlhBtIfce->fpcBTLeGattPath) {
8504  pstlhBtIfce->fpcBTLeGattPath(enBTGattCharacteristic, enBTLeGattOpUnknown, pCharIface, pstBTDeviceInfo->pcAddress, enBTDevStPropChanged, NULL, pstlhBtIfce->pcBLePathUserData);
8505  }
8506  }
8507  }
8508  }
8509  else if (!strcmp(lpcDBusIface, BT_DBUS_BLUEZ_GATT_DESCRIPTOR_PATH )) {
8510  BTRCORELOG_INFO ("Property Changed! : %s\n", BT_DBUS_BLUEZ_GATT_DESCRIPTOR_PATH);
8511  }
8512  else {
8513  BTRCORELOG_INFO ("Property Changed! : %s\n", lpcDBusIface);
8514  }
8515  }
8516  }
8517  }
8518  else if (dbus_message_is_method_call(apDBusMsg, DBUS_INTERFACE_OBJECT_MANAGER, "GetManagedObjects")) {
8519  BTRCORELOG_INFO ("%s - GetManagedObjects\n", DBUS_INTERFACE_OBJECT_MANAGER);
8520  }
8521  else if (dbus_message_is_method_call(apDBusMsg, DBUS_INTERFACE_PROPERTIES, "GetAll")) {
8522  BTRCORELOG_INFO ("%s - GetAll\n", DBUS_INTERFACE_PROPERTIES);
8523  if (!strcmp(pstlhBtIfce->stBTLeCustAdvt.pui8AdvertPath, dbus_message_get_path(apDBusMsg))) {
8524  btrCore_BTRegisterLeAdvGetProp(apDBusConn, apDBusMsg, pstlhBtIfce);
8525  BTRCORELOG_INFO ("btrCore_BTRegisterLeAdvGetProp - GetAll\n");
8526  i32OpRet = 0;
8527  }
8528  }
8529  else if (dbus_message_is_signal(apDBusMsg, DBUS_INTERFACE_OBJECT_MANAGER, "InterfacesAdded")) {
8530  DBusMessageIter lDBusMsgIter;
8531  DBusMessageIter lDBusMsgIterDict;
8532  const char* lpcDBusIface = NULL;
8533 
8534  dbus_message_iter_init(apDBusMsg, &lDBusMsgIter);
8535  if (dbus_message_iter_get_arg_type(&lDBusMsgIter) == DBUS_TYPE_OBJECT_PATH) {
8536  dbus_message_iter_get_basic(&lDBusMsgIter, &lpcDBusIface);
8537  dbus_message_iter_next(&lDBusMsgIter);
8538 
8539  if (dbus_message_iter_get_arg_type(&lDBusMsgIter) == DBUS_TYPE_ARRAY) {
8540  BTRCORELOG_INFO ("InterfacesAdded : Interface %s\n", lpcDBusIface ? lpcDBusIface : NULL);
8541 
8542 
8543  dbus_message_iter_recurse(&lDBusMsgIter, &lDBusMsgIterDict);
8544 
8545  while (dbus_message_iter_get_arg_type(&lDBusMsgIterDict) == DBUS_TYPE_DICT_ENTRY) {
8546  DBusMessageIter lDBusMsgIterStrnArr;
8547  const char* lpcDBusIfaceInternal = NULL;
8548 
8549  dbus_message_iter_recurse(&lDBusMsgIterDict, &lDBusMsgIterStrnArr);
8550 
8551  if (dbus_message_iter_get_arg_type(&lDBusMsgIterStrnArr) == DBUS_TYPE_STRING) {
8552  dbus_message_iter_get_basic(&lDBusMsgIterStrnArr, &lpcDBusIfaceInternal);
8553 
8554  dbus_message_iter_next(&lDBusMsgIterStrnArr);
8555  if (dbus_message_iter_get_arg_type(&lDBusMsgIterStrnArr) == DBUS_TYPE_ARRAY) {
8556  if (lpcDBusIfaceInternal) {
8557  if (!strcmp(lpcDBusIfaceInternal, BT_DBUS_BLUEZ_ADAPTER_PATH)) {
8558  BTRCORELOG_INFO ("InterfacesAdded : %s\n", BT_DBUS_BLUEZ_ADAPTER_PATH);
8559  }
8560  else if (!strcmp(lpcDBusIfaceInternal, BT_DBUS_BLUEZ_DEVICE_PATH)) {
8561  BTRCORELOG_INFO ("InterfacesAdded : %s\n", BT_DBUS_BLUEZ_DEVICE_PATH);
8562 
8563  if (lpcDBusIface) {
8564  i32OpRet = btrCore_BTGetDeviceInfo(apDBusConn, pstBTDeviceInfo, lpcDBusIface);
8565  if (!i32OpRet) {
8566  enBTDeviceState lenBtDevState = enBTDevStUnknown;
8567  enBTDeviceType lenBTDevType = btrCore_BTMapDevClasstoDevType(pstBTDeviceInfo->ui32Class);
8568 
8569  if ((!pstBTDeviceInfo->bPaired && !pstBTDeviceInfo->bConnected) ||
8570  ((enBTDevUnknown == lenBTDevType) && (TRUE == pstBTDeviceInfo->bConnected)) ) {
8571  lenBtDevState = enBTDevStFound;
8572 
8573  if (pstlhBtIfce->fpcBDevStatusUpdate) {
8574  if(pstlhBtIfce->fpcBDevStatusUpdate(lenBTDevType, lenBtDevState, pstBTDeviceInfo, pstlhBtIfce->pcBDevStatusUserData)) {
8575  }
8576  }
8577  }
8578  }
8579  }
8580  }
8581  else if (!strcmp(lpcDBusIfaceInternal, BT_DBUS_BLUEZ_MEDIA_TRANSPORT_PATH)) {
8582  BTRCORELOG_INFO ("InterfacesAdded : %s\n", BT_DBUS_BLUEZ_MEDIA_TRANSPORT_PATH);
8583  }
8584  else if (!strcmp(lpcDBusIfaceInternal, BT_DBUS_BLUEZ_MEDIA_CTRL_PATH)) {
8585  BTRCORELOG_INFO ("InterfacesAdded : %s\n", BT_DBUS_BLUEZ_MEDIA_CTRL_PATH);
8586  }
8587  else if (!strcmp(lpcDBusIfaceInternal, BT_DBUS_BLUEZ_MEDIA_PLAYER_PATH)) {
8588  BTRCORELOG_INFO ("InterfacesAdded : %s\n", BT_DBUS_BLUEZ_MEDIA_PLAYER_PATH);
8589 
8590  if (lpcDBusIface && pstlhBtIfce->fpcBTMediaPlayerPath) {
8591  if (pstlhBtIfce->fpcBTMediaPlayerPath(lpcDBusIface, pstlhBtIfce->pcBMediaPlayerPathUserData)) {
8592  BTRCORELOG_ERROR ("Media Player Path callBack Failed!!!\n");
8593  }
8594  }
8595  }
8596  else if (!strcmp(lpcDBusIfaceInternal, BT_DBUS_BLUEZ_MEDIA_ITEM_PATH)) {
8597  BTRCORELOG_INFO ("InterfacesAdded : %s\n", BT_DBUS_BLUEZ_MEDIA_ITEM_PATH);
8598  char apcDeviceIfce[BT_MAX_STR_LEN] = {'\0'};
8599  unsigned int ui32DeviceIfceLen = strstr(lpcDBusIface, "/player") - lpcDBusIface;
8600  enBTDeviceType lenBTDevType = enBTDevUnknown;
8601  char* apcDevAddr = 0;
8602 
8603  if ((ui32DeviceIfceLen > 0) && (ui32DeviceIfceLen < (BT_MAX_STR_LEN - 1))) {
8604  strncpy(apcDeviceIfce, lpcDBusIface, ui32DeviceIfceLen);
8605  i32OpRet = btrCore_BTGetDeviceInfo(apDBusConn, pstBTDeviceInfo, apcDeviceIfce);
8606  if (!i32OpRet) {
8607  lenBTDevType = btrCore_BTMapDevClasstoDevType(pstBTDeviceInfo->ui32Class);
8608  apcDevAddr = pstBTDeviceInfo->pcAddress;
8609  }
8610  }
8611 
8612  if (strstr(lpcDBusIface, "NowPlaying")) {
8613  stBTMediaBrowserUpdate mediaBrowserUpdate;
8614  memset (&mediaBrowserUpdate, 0, sizeof(stBTMediaBrowserUpdate)); //CID:163772 - Uninitialized scalar variable
8615  BTRCORELOG_INFO ("MediaItem InterfacesAdded : %s\n", strstr(lpcDBusIface, "/NowPlaying"));
8616 
8617  if (strstr(lpcDBusIface, "item")) {
8618 
8619  stBTMediaStatusUpdate mediaStatusUpdate;
8620  stBTMediaTrackInfo mediaTrackInfo;
8621  char apcMediaIfce[BT_MAX_STR_LEN] = {'\0'};
8622  unsigned int ui32MediaIfceLen = strstr(lpcDBusIface, "/NowPlaying") - lpcDBusIface;
8623  char* itemName = 0;
8624  char name[BT_MAX_STR_LEN] = "\0";
8625 
8626  if ((ui32MediaIfceLen > 0) && (ui32MediaIfceLen < (BT_MAX_STR_LEN - 1))) {
8627  strncpy(apcMediaIfce, lpcDBusIface, ui32MediaIfceLen);
8628  }
8629 
8630  memset (&mediaTrackInfo, 0, sizeof(stBTMediaTrackInfo));
8631 
8632  i32OpRet = btrCore_BTGetMediaIfceProperty (apDBusConn, lpcDBusIface, BT_DBUS_BLUEZ_MEDIA_ITEM_PATH, "Name", (void*)&itemName);
8633 
8634  if (itemName) {
8635  strncpy(name, itemName, BT_MAX_STR_LEN -1);
8636  }
8637 
8638  if (/*!i32OpRet &&*/ !(i32OpRet = BtrCore_BTGetTrackInformation (pstlhBtIfce, apcMediaIfce, &mediaTrackInfo))) {
8639  /* Should look for a better reliable identification logic */
8640  if (!strncmp(mediaTrackInfo.pcTitle, name, (strlen(mediaTrackInfo.pcTitle) < strlen(name))?
8641  strlen(name) : strlen(mediaTrackInfo.pcTitle))) {
8642 
8643  mediaStatusUpdate.aenBtOpIfceType = enBTMediaPlayer;
8644  mediaStatusUpdate.aunBtOpIfceProp.enBtMediaPlayerProp = enBTMedPlayerPropTrack;
8645  memcpy(&mediaStatusUpdate.m_mediaTrackInfo, &mediaTrackInfo, sizeof(stBTMediaTrackInfo));
8646  /* Media Status Cb */
8647  if (pstlhBtIfce->fpcBMediaStatusUpdate) {
8648  if(pstlhBtIfce->fpcBMediaStatusUpdate(lenBTDevType, &mediaStatusUpdate, apcDevAddr, pstlhBtIfce->pcBMediaStatusUserData)) {
8649  }
8650  }
8651  memcpy (&mediaBrowserUpdate.mediaTrackInfo, &mediaTrackInfo, sizeof(stBTMediaTrackInfo));
8652  }
8653  /*else {
8654  if (BtrCore_BTGetTrackInformation (pstlhBtIfce, lpcDBusIface, &mediaBrowserUpdate.mediaTrackInfo)) {
8655  strncpy(mediaBrowserUpdate.mediaTrackInfo.pcTitle, itemName, BT_MAX_STR_LEN -1);
8656  }
8657  }*/
8658 
8659  {
8660  strncpy(mediaBrowserUpdate.pcMediaItemPath, lpcDBusIface, BT_MAX_STR_LEN -1);
8661  mediaBrowserUpdate.eMediaItemType = enBTMediaItemTypAudio;
8662  mediaBrowserUpdate.ui32BTMediaItemId = btrCore_BTGetMediaItemIdFromMediaPath (lpcDBusIface);
8663  if (name[0]) {
8664  strncpy(mediaBrowserUpdate.mediaTrackInfo.pcTitle, name, BT_MAX_STR_LEN -1);
8665  }
8666  else {
8667  memcpy (&mediaBrowserUpdate.mediaTrackInfo, &mediaTrackInfo, sizeof(stBTMediaTrackInfo));
8668  }
8669  strncpy(mediaBrowserUpdate.pcMediaItemName, mediaBrowserUpdate.mediaTrackInfo.pcTitle, BT_MAX_STR_LEN -1);
8670  BTRCORELOG_DEBUG ("PlayList Audio Item : %s [ID: %llu]\n", mediaBrowserUpdate.mediaTrackInfo.pcTitle, mediaBrowserUpdate.ui32BTMediaItemId);
8671  }
8672  }
8673  else {
8674  BTRCORELOG_ERROR ("Failed to get MediaTrackInfo\n");
8675  }
8676  }
8677  else {
8678  strncpy(mediaBrowserUpdate.pcMediaItemName, "NowPlaying", BT_MAX_STR_LEN -1);
8679  strncpy(mediaBrowserUpdate.pcMediaItemPath, lpcDBusIface, BT_MAX_STR_LEN -1);
8680  mediaBrowserUpdate.ui32BTMediaItemId = btrCore_BTGetMediaItemIdFromMediaPath (lpcDBusIface);
8681  mediaBrowserUpdate.eMediaItemType = enBTMediaItemTypFolder;
8682  BTRCORELOG_DEBUG ("PlayList root : %s [ID: %llu]\n", mediaBrowserUpdate.pcMediaItemName
8683  , mediaBrowserUpdate.ui32BTMediaItemId);
8684  }
8685 
8686  /* Media Browser Cb */
8687  if (/*!i32OpRet &&*/ pstlhBtIfce->fpcBTMediaBrowserPath && 0xFFFFFFFFFFFFFFFF != mediaBrowserUpdate.ui32BTMediaItemId) {
8688  if (pstlhBtIfce->fpcBTMediaBrowserPath(&mediaBrowserUpdate, 1, apcDevAddr, pstlhBtIfce->pcBMediaBrowserPathUserData)) {
8689  }
8690  }
8691  }
8692  else if (strstr(lpcDBusIface, "Filesystem")) {
8693  stBTMediaBrowserUpdate mediaBrowserUpdate;
8694  char apcMediaPlayerIfce[BT_MAX_STR_LEN] = {'\0'};
8695  unsigned int ui32MediaIfceLen = strstr(lpcDBusIface, "/Filesystem") - lpcDBusIface;
8696 
8697  BTRCORELOG_INFO ("MediaItem InterfacesAdded : %s\n", strstr(lpcDBusIface, "/Filesystem"));
8698  memset (&mediaBrowserUpdate, 0, sizeof(stBTMediaBrowserUpdate));
8699 
8700  if ((ui32MediaIfceLen > 0) && (ui32MediaIfceLen < (BT_MAX_STR_LEN - 1))) {
8701  strncpy(apcMediaPlayerIfce, lpcDBusIface, ui32MediaIfceLen);
8702  }
8703 
8704  if (strstr(lpcDBusIface, "item")) {
8705  char* itemType = 0;
8706  char* itemName = 0;
8707 
8708  btrCore_BTGetMediaIfceProperty (apDBusConn, lpcDBusIface, BT_DBUS_BLUEZ_MEDIA_ITEM_PATH, "Name", (void*)&itemName);
8709  if (itemName) {
8710  strncpy(mediaBrowserUpdate.pcMediaItemName, btrCore_BTGetMediaItemAbsoluteName(itemName), BT_MAX_STR_LEN - 1);
8711  }
8712  btrCore_BTGetMediaIfceProperty (apDBusConn, lpcDBusIface, BT_DBUS_BLUEZ_MEDIA_ITEM_PATH, "Type", (void*)&itemType);
8713  strncpy(mediaBrowserUpdate.pcMediaItemPath, lpcDBusIface, BT_MAX_STR_LEN - 1);
8714 
8715  itemName = mediaBrowserUpdate.pcMediaItemName;
8716  if (itemType != NULL) {
8717 
8718  if (!strncmp(itemType, "audio", strlen("audio"))) {
8719 
8720  /*if (BtrCore_BTGetTrackInformation(apDBusConn, lpcDBusIface, &mediaBrowserUpdate.mediaTrackInfo)) {
8721  BTRCORELOG_ERROR ("Failed to get Metadata Info for %s\n", lpcDBusIface);
8722  i32OpRet = -1;
8723  }*/
8724  strncpy(mediaBrowserUpdate.mediaTrackInfo.pcTitle, itemName, BT_MAX_STR_LEN -1);
8725  mediaBrowserUpdate.eMediaItemType = enBTMediaItemTypAudio;
8726  mediaBrowserUpdate.ui32BTMediaItemId = btrCore_BTGetMediaItemIdFromMediaPath (lpcDBusIface);
8727  mediaBrowserUpdate.eMediaFolderType = enBTMediaFldTypTrack;
8728  BTRCORELOG_DEBUG ("MediaBrowser Audio Item : %s [ID: %llu]\n", itemName, mediaBrowserUpdate.ui32BTMediaItemId);
8729  }
8730  else if (!strncmp(itemType, "folder", strlen("folder"))) {
8731  char* folderType = 0;
8732 
8733  btrCore_BTGetMediaIfceProperty (apDBusConn, lpcDBusIface, BT_DBUS_BLUEZ_MEDIA_ITEM_PATH, "FolderType", (void*)&folderType);
8734 
8735  mediaBrowserUpdate.eMediaItemType = enBTMediaItemTypFolder;
8736  mediaBrowserUpdate.ui32BTMediaItemId = btrCore_BTGetMediaItemIdFromMediaPath (lpcDBusIface);
8737  mediaBrowserUpdate.eMediaFolderType = btrCore_BTGetMediaFolderType (folderType);
8738 
8739  BTRCORELOG_DEBUG ("MediaBrowser - Folder Item(%s) : %s [ID: %llu]\n", folderType, itemName, mediaBrowserUpdate.ui32BTMediaItemId);
8740  }
8741  else if (!strncmp(itemType, "video", strlen("video"))) {
8742  BTRCORELOG_DEBUG ("Its a video Item : %s\n", itemName);
8743  mediaBrowserUpdate.eMediaItemType = enBTMediaItemTypVideo;
8744  }
8745  else {
8746  BTRCORELOG_ERROR ("Unknown item type : %s !\n", itemType);
8747  mediaBrowserUpdate.eMediaItemType = enBTMediaItemTypUnknown;
8748  i32OpRet = -1;
8749  }
8750  }
8751  else {
8752  BTRCORELOG_ERROR (" item type is NULL ");
8753  mediaBrowserUpdate.eMediaItemType = enBTMediaItemTypUnknown;
8754  i32OpRet = -1;
8755  }
8756  }
8757  else {
8758  //btrCore_BTGetMediaIfceProperty (apDBusConn, apcMediaPlayerIfce, BT_DBUS_BLUEZ_MEDIA_FOLDER_PATH, "Name", (void*)&folderName);
8759  strncpy(mediaBrowserUpdate.pcMediaItemName, "Filesystem", BT_MAX_STR_LEN -1);
8760  strncpy(mediaBrowserUpdate.pcMediaItemPath, lpcDBusIface, BT_MAX_STR_LEN -1);
8761  mediaBrowserUpdate.ui32BTMediaItemId = btrCore_BTGetMediaItemIdFromMediaPath (lpcDBusIface);
8762  mediaBrowserUpdate.eMediaItemType = enBTMediaItemTypFolder;
8763  BTRCORELOG_DEBUG ("MediaBrowser root : %s [ID: %llu]\n", mediaBrowserUpdate.pcMediaItemName, mediaBrowserUpdate.ui32BTMediaItemId);
8764  }
8765 
8766  if (!i32OpRet && pstlhBtIfce->fpcBTMediaBrowserPath) {
8767  pstlhBtIfce->fpcBTMediaBrowserPath(&mediaBrowserUpdate, 1, apcDevAddr, pstlhBtIfce->pcBMediaBrowserPathUserData);
8768  }
8769  }
8770  }
8771  else if (!strcmp(lpcDBusIfaceInternal, BT_DBUS_BLUEZ_MEDIA_FOLDER_PATH)) {
8772  BTRCORELOG_INFO ("InterfacesAdded : %s\n", BT_DBUS_BLUEZ_MEDIA_FOLDER_PATH);
8773  }
8774  /* Add Interfaces for GATT */
8775  else if (!strcmp(lpcDBusIfaceInternal, BT_DBUS_BLUEZ_GATT_SERVICE_PATH)) {
8776  BTRCORELOG_INFO ("InterfacesAdded : %s\n", BT_DBUS_BLUEZ_GATT_SERVICE_PATH);
8777  char apcDeviceIfce[BT_MAX_STR_LEN] = {'\0'};
8778  unsigned int ui32DeviceIfceLen = strstr(lpcDBusIface, "/service") - lpcDBusIface;
8779 
8780  if ((ui32DeviceIfceLen > 0) && (ui32DeviceIfceLen < (BT_MAX_STR_LEN - 1))) {
8781  strncpy(apcDeviceIfce, lpcDBusIface, ui32DeviceIfceLen);
8782 
8783  i32OpRet = btrCore_BTGetDeviceInfo(apDBusConn, pstBTDeviceInfo, apcDeviceIfce);
8784  if (!i32OpRet) {
8785  if (pstlhBtIfce->fpcBTLeGattPath) {
8786  pstlhBtIfce->fpcBTLeGattPath(enBTGattService, enBTLeGattOpUnknown, lpcDBusIface, pstBTDeviceInfo->pcAddress, enBTDevStFound, NULL, pstlhBtIfce->pcBLePathUserData);
8787  }
8788  }
8789  }
8790  }
8791  else if (!strcmp(lpcDBusIfaceInternal, BT_DBUS_BLUEZ_GATT_CHAR_PATH)) {
8792  BTRCORELOG_INFO ("InterfacesAdded : %s\n", BT_DBUS_BLUEZ_GATT_CHAR_PATH);
8793  char apcDeviceIfce[BT_MAX_STR_LEN] = {'\0'};
8794  unsigned int ui32DeviceIfceLen = strstr(lpcDBusIface, "/service") - lpcDBusIface;
8795 
8796  if ((ui32DeviceIfceLen > 0) && (ui32DeviceIfceLen < (BT_MAX_STR_LEN - 1))) {
8797  strncpy(apcDeviceIfce, lpcDBusIface, ui32DeviceIfceLen);
8798 
8799  i32OpRet = btrCore_BTGetDeviceInfo(apDBusConn, pstBTDeviceInfo, apcDeviceIfce);
8800  if (!i32OpRet) {
8801  if (pstlhBtIfce->fpcBTLeGattPath) {
8802  pstlhBtIfce->fpcBTLeGattPath(enBTGattCharacteristic, enBTLeGattOpUnknown, lpcDBusIface, pstBTDeviceInfo->pcAddress, enBTDevStFound, NULL, pstlhBtIfce->pcBLePathUserData);
8803  }
8804  }
8805  }
8806  }
8807  else if (!strcmp(lpcDBusIfaceInternal, BT_DBUS_BLUEZ_GATT_DESCRIPTOR_PATH)) {
8808  BTRCORELOG_INFO ("InterfacesAdded : %s\n", BT_DBUS_BLUEZ_GATT_DESCRIPTOR_PATH);
8809  char apcDeviceIfce[BT_MAX_STR_LEN] = {'\0'};
8810  unsigned int ui32DeviceIfceLen = strstr(lpcDBusIface, "/service") - lpcDBusIface;
8811 
8812  if ((ui32DeviceIfceLen > 0) && (ui32DeviceIfceLen < (BT_MAX_STR_LEN - 1))) {
8813  strncpy(apcDeviceIfce, lpcDBusIface, ui32DeviceIfceLen);
8814 
8815  i32OpRet = btrCore_BTGetDeviceInfo(apDBusConn, pstBTDeviceInfo, apcDeviceIfce);
8816  if (!i32OpRet) {
8817  if (pstlhBtIfce->fpcBTLeGattPath) {
8818  pstlhBtIfce->fpcBTLeGattPath(enBTGattDescriptor, enBTLeGattOpUnknown, lpcDBusIface, pstBTDeviceInfo->pcAddress, enBTDevStFound, NULL, pstlhBtIfce->pcBLePathUserData);
8819  }
8820  }
8821  }
8822  }
8823  else {
8824  BTRCORELOG_INFO ("InterfacesAdded : %s\n", lpcDBusIfaceInternal);
8825  }
8826  }
8827  }
8828  }
8829 
8830  dbus_message_iter_next(&lDBusMsgIterDict);
8831  }
8832  }
8833  }
8834  }
8835  else if (dbus_message_is_signal(apDBusMsg, DBUS_INTERFACE_OBJECT_MANAGER, "InterfacesRemoved")) {
8836  BTRCORELOG_WARN ("Device Lost!\n");
8837 
8838  DBusMessageIter lDBusMsgIterStr;
8839  DBusMessageIter lDBusMsgIter;
8840  const char* lpcDBusIface = NULL;
8841 
8842  dbus_message_iter_init(apDBusMsg, &lDBusMsgIter);
8843  dbus_message_iter_get_basic(&lDBusMsgIter, &lpcDBusIface);
8844  dbus_message_iter_next(&lDBusMsgIter);
8845 
8846  if (dbus_message_iter_get_arg_type(&lDBusMsgIter) == DBUS_TYPE_ARRAY) {
8847  BTRCORELOG_INFO ("InterfacesRemoved : Interface %s\n", lpcDBusIface ? lpcDBusIface : NULL);
8848 
8849  dbus_message_iter_recurse(&lDBusMsgIter, &lDBusMsgIterStr);
8850 
8851  while (dbus_message_iter_get_arg_type(&lDBusMsgIterStr) == DBUS_TYPE_STRING) {
8852  const char* lpcDBusIfaceInternal = NULL;
8853 
8854  dbus_message_iter_get_basic(&lDBusMsgIterStr, &lpcDBusIfaceInternal);
8855 
8856  if (lpcDBusIfaceInternal) {
8857  if (!strcmp(lpcDBusIfaceInternal, BT_DBUS_BLUEZ_ADAPTER_PATH)) {
8858  BTRCORELOG_INFO ("InterfacesRemoved : %s\n", BT_DBUS_BLUEZ_ADAPTER_PATH);
8859  }
8860  else if (!strcmp(lpcDBusIfaceInternal, BT_DBUS_BLUEZ_DEVICE_PATH)) {
8861  BTRCORELOG_INFO ("InterfacesRemoved : %s\n", BT_DBUS_BLUEZ_DEVICE_PATH);
8862 
8863  if (lpcDBusIface) {
8864  enBTDeviceType lenBTDevType = enBTDevUnknown;
8865  /* On InterfacesRemoved signal of BT_DBUS_BLUEZ_DEVICE_PATH, query to get DevInfo is invalid
8866  i32OpRet = btrCore_BTGetDeviceInfo(apDBusConn, pstBTDeviceInfo, lpcDBusIface);
8867  if (!i32OpRet) {
8868  lenBTDevType = btrCore_BTMapDevClasstoDevType(pstBTDeviceInfo->ui32Class);
8869 
8870  }*/
8871  if (pstlhBtIfce->fpcBDevStatusUpdate) {
8872  btrCore_BTGetDevAddressFromDevPath(lpcDBusIface, pstBTDeviceInfo->pcAddress);
8873  if(pstlhBtIfce->fpcBDevStatusUpdate(lenBTDevType, enBTDevStLost, pstBTDeviceInfo, pstlhBtIfce->pcBDevStatusUserData)) {
8874  }
8875  }
8876  }
8877  }
8878  else if (!strcmp(lpcDBusIfaceInternal, BT_DBUS_BLUEZ_MEDIA_TRANSPORT_PATH)) {
8879  BTRCORELOG_INFO ("InterfacesRemoved : %s\n", BT_DBUS_BLUEZ_MEDIA_TRANSPORT_PATH);
8880  // For Device Lost or Out Of Range cases
8881  pstlhBtIfce->ui32DevLost = 1;
8882 
8883  //TODO: What if some other devices transport interface gets removed with delay ?
8884  strncpy(pstlhBtIfce->pcMediaCurrState, "none", BT_MAX_STR_LEN - 1);
8885  }
8886  else if (!strcmp(lpcDBusIfaceInternal, BT_DBUS_BLUEZ_MEDIA_CTRL_PATH)) {
8887  BTRCORELOG_INFO ("InterfacesRemoved : %s\n", BT_DBUS_BLUEZ_MEDIA_CTRL_PATH);
8888  }
8889  else if (!strcmp(lpcDBusIfaceInternal, BT_DBUS_BLUEZ_MEDIA_PLAYER_PATH)) {
8890  BTRCORELOG_INFO ("InterfacesRemoved : %s\n", BT_DBUS_BLUEZ_MEDIA_PLAYER_PATH);
8891 
8892  if (lpcDBusIface && pstlhBtIfce->fpcBTMediaPlayerPath) {
8893  //if (pstlhBtIfce->fpcBTMediaPlayerPath(lpcDBusIface, pstlhBtIfce->pcBMediaPlayerPathUserData)) {
8894  // BTRCORELOG_ERROR ("Media Player Path callBack Failed!!!\n");
8895  //}
8896  }
8897  }
8898  else if (!strcmp(lpcDBusIfaceInternal, BT_DBUS_BLUEZ_MEDIA_ITEM_PATH)) {
8899  BTRCORELOG_INFO ("InterfacesRemoved : %s\n", BT_DBUS_BLUEZ_MEDIA_ITEM_PATH);
8900  char apcDeviceIfce[BT_MAX_STR_LEN] = {'\0'};
8901  unsigned int ui32DeviceIfceLen = strstr(lpcDBusIface, "/player") - lpcDBusIface;
8902  char* apcDevAddr = 0;
8903  stBTMediaBrowserUpdate mediaBrowserUpdate;
8904 
8905  if ((ui32DeviceIfceLen > 0) && (ui32DeviceIfceLen < (BT_MAX_STR_LEN - 1))) {
8906  strncpy(apcDeviceIfce, lpcDBusIface, ui32DeviceIfceLen);
8907  i32OpRet = btrCore_BTGetDeviceInfo(apDBusConn, pstBTDeviceInfo, apcDeviceIfce);
8908  if (!i32OpRet) {
8909  apcDevAddr = pstBTDeviceInfo->pcAddress;
8910  }
8911  else {
8912  btrCore_BTGetDevAddressFromDevPath(lpcDBusIface, pstBTDeviceInfo->pcAddress);
8913  i32OpRet = 0;
8914  }
8915  }
8916 
8917  if (strstr(lpcDBusIface, "/NowPlaying")) {
8918  BTRCORELOG_INFO ("MediaItem InterfacesRemoved : %s\n", strstr(lpcDBusIface, "/NowPlaying"));
8919  }
8920  else if (strstr(lpcDBusIface, "/Filesystem")) {
8921  BTRCORELOG_INFO ("MediaItem InterfacesRemoved : %s\n", strstr(lpcDBusIface, "/Filesystem"));
8922  }
8923 
8924  mediaBrowserUpdate.ui32BTMediaItemId = btrCore_BTGetMediaItemIdFromMediaPath (lpcDBusIface);
8925  strncpy(mediaBrowserUpdate.pcMediaItemPath, lpcDBusIface, BT_MAX_STR_LEN - 1);
8926 
8927  if (!i32OpRet && pstlhBtIfce->fpcBTMediaBrowserPath) {
8928  pstlhBtIfce->fpcBTMediaBrowserPath(&mediaBrowserUpdate, 0, apcDevAddr, pstlhBtIfce->pcBMediaBrowserPathUserData);
8929  }
8930  }
8931  else if (!strcmp(lpcDBusIfaceInternal, BT_DBUS_BLUEZ_MEDIA_FOLDER_PATH)) {
8932  BTRCORELOG_INFO ("InterfacesRemoved : %s\n", BT_DBUS_BLUEZ_MEDIA_FOLDER_PATH);
8933  }
8934  /* Add Interfaces removed for GATT profile */
8935  else if (!strcmp(lpcDBusIfaceInternal, BT_DBUS_BLUEZ_GATT_SERVICE_PATH)) {
8936  BTRCORELOG_INFO ("InterfacesRemoved : %s\n", BT_DBUS_BLUEZ_GATT_SERVICE_PATH);
8937  char apcDeviceIfce[BT_MAX_STR_LEN] = {'\0'};
8938  unsigned int ui32DeviceIfceLen = strstr(lpcDBusIface, "/service") - lpcDBusIface;
8939 
8940  if ((ui32DeviceIfceLen > 0) && (ui32DeviceIfceLen < (BT_MAX_STR_LEN - 1))) {
8941  strncpy(apcDeviceIfce, lpcDBusIface, ui32DeviceIfceLen);
8942 
8943  i32OpRet = btrCore_BTGetDeviceInfo(apDBusConn, pstBTDeviceInfo, apcDeviceIfce);
8944  if (!i32OpRet) {
8945  if (pstlhBtIfce->fpcBTLeGattPath) {
8946  pstlhBtIfce->fpcBTLeGattPath(enBTGattService, enBTLeGattOpUnknown, lpcDBusIface, pstBTDeviceInfo->pcAddress, enBTDevStLost, NULL, pstlhBtIfce->pcBLePathUserData);
8947  }
8948  }
8949  }
8950  }
8951  else if (!strcmp(lpcDBusIfaceInternal, BT_DBUS_BLUEZ_GATT_CHAR_PATH )) {
8952  BTRCORELOG_INFO ("InterfacesRemoved : %s\n", BT_DBUS_BLUEZ_GATT_CHAR_PATH);
8953  char apcDeviceIfce[BT_MAX_STR_LEN] = {'\0'};
8954  unsigned int ui32DeviceIfceLen = strstr(lpcDBusIface, "/service") - lpcDBusIface;
8955 
8956  if ((ui32DeviceIfceLen > 0) && (ui32DeviceIfceLen < (BT_MAX_STR_LEN - 1))) {
8957  strncpy(apcDeviceIfce, lpcDBusIface, ui32DeviceIfceLen);
8958 
8959  i32OpRet = btrCore_BTGetDeviceInfo(apDBusConn, pstBTDeviceInfo, apcDeviceIfce);
8960  if (!i32OpRet) {
8961  if (pstlhBtIfce->fpcBTLeGattPath) {
8962  pstlhBtIfce->fpcBTLeGattPath(enBTGattCharacteristic, enBTLeGattOpUnknown, lpcDBusIface, pstBTDeviceInfo->pcAddress, enBTDevStLost, NULL, pstlhBtIfce->pcBLePathUserData);
8963  }
8964  }
8965  }
8966  }
8967  else if (!strcmp(lpcDBusIfaceInternal, BT_DBUS_BLUEZ_GATT_DESCRIPTOR_PATH)) {
8968  BTRCORELOG_INFO ("InterfacesRemoved : %s\n", BT_DBUS_BLUEZ_GATT_DESCRIPTOR_PATH);
8969  char apcDeviceIfce[BT_MAX_STR_LEN] = {'\0'};
8970  unsigned int ui32DeviceIfceLen = strstr(lpcDBusIface, "/service") - lpcDBusIface;
8971 
8972  if ((ui32DeviceIfceLen > 0) && (ui32DeviceIfceLen < (BT_MAX_STR_LEN - 1))) {
8973  strncpy(apcDeviceIfce, lpcDBusIface, ui32DeviceIfceLen);
8974 
8975  i32OpRet = btrCore_BTGetDeviceInfo(apDBusConn, pstBTDeviceInfo, apcDeviceIfce);
8976  if (!i32OpRet) {
8977  if (pstlhBtIfce->fpcBTLeGattPath) {
8978  pstlhBtIfce->fpcBTLeGattPath(enBTGattDescriptor, enBTLeGattOpUnknown, lpcDBusIface, pstBTDeviceInfo->pcAddress, enBTDevStLost, NULL, pstlhBtIfce->pcBLePathUserData);
8979  }
8980  }
8981  }
8982  }
8983  else {
8984  BTRCORELOG_INFO ("InterfacesRemoved : %s\n", lpcDBusIfaceInternal);
8985  }
8986  }
8987 
8988  dbus_message_iter_next(&lDBusMsgIterStr);
8989  }
8990  }
8991  }
8992 
8993  if (!i32OpRet)
8994  return DBUS_HANDLER_RESULT_HANDLED;
8995  else
8996  return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
8997 }
8998 
8999 
9000 static DBusHandlerResult
9001 btrCore_BTMediaEndpointHandlerCb (
9002  DBusConnection* apDBusConn,
9003  DBusMessage* apDBusMsg,
9004  void* apvUserData
9005 ) {
9006  DBusMessage* lpDBusReply = NULL;
9007  const char* lpcPath = NULL;
9008  enBTDeviceType lenBTDeviceType = enBTDevUnknown;
9009  enBTMediaType lenBTMediaType = enBTMediaTypeUnknown;
9010 
9011  lpcPath = dbus_message_get_path(apDBusMsg);
9012  if (!lpcPath)
9013  return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
9014 
9015 
9016  BTRCORELOG_INFO ("endpoint_handler: MediaEndpoint1 - %s\n", lpcPath);
9017 
9018  if (!strcmp(lpcPath, BT_MEDIA_SBC_A2DP_SOURCE_ENDPOINT)) {
9019  lenBTDeviceType = enBTDevAudioSink;
9020  lenBTMediaType = enBTMediaTypeSBC;
9021  }
9022  else if (!strcmp(lpcPath, BT_MEDIA_SBC_A2DP_SINK_ENDPOINT)) {
9023  lenBTDeviceType = enBTDevAudioSource;
9024  lenBTMediaType = enBTMediaTypeSBC;
9025  }
9026  else if (!strcmp(lpcPath, BT_MEDIA_PCM_HFP_AG_ENDPOINT)) {
9027  lenBTDeviceType = enBTDevHFPHeadset;
9028  lenBTMediaType = enBTMediaTypePCM;
9029  }
9030  else if (!strcmp(lpcPath, BT_MEDIA_AAC_A2DP_SOURCE_ENDPOINT)) {
9031  lenBTDeviceType = enBTDevAudioSink;
9032  lenBTMediaType = enBTMediaTypeAAC;
9033  }
9034  else if (!strcmp(lpcPath, BT_MEDIA_AAC_A2DP_SINK_ENDPOINT)) {
9035  lenBTDeviceType = enBTDevAudioSource;
9036  lenBTMediaType = enBTMediaTypeAAC;
9037  }
9038  else if (!strcmp(lpcPath, BT_MEDIA_MP3_A2DP_SOURCE_ENDPOINT)) {
9039  lenBTDeviceType = enBTDevAudioSink;
9040  lenBTMediaType = enBTMediaTypeMP3;
9041  }
9042  else if (!strcmp(lpcPath, BT_MEDIA_MP3_A2DP_SINK_ENDPOINT)) {
9043  lenBTDeviceType = enBTDevAudioSource;
9044  lenBTMediaType = enBTMediaTypeMP3;
9045  }
9046  else if (!strcmp(lpcPath, BT_MEDIA_SBC_HFP_AG_ENDPOINT)) {
9047  lenBTDeviceType = enBTDevHFPHeadset;
9048  lenBTMediaType = enBTMediaTypeSBC;
9049  }
9050  else if (!strcmp(lpcPath, BT_MEDIA_PCM_HFP_HS_ENDPOINT)) {
9051  lenBTDeviceType = enBTDevHFPAudioGateway;
9052  lenBTMediaType = enBTMediaTypePCM;
9053  }
9054 
9055 
9056  if (dbus_message_is_method_call(apDBusMsg, BT_DBUS_BLUEZ_MEDIA_ENDPOINT_PATH, "SelectConfiguration")) {
9057  BTRCORELOG_INFO ("endpoint_handler: MediaEndpoint1-SelectConfiguration\n");
9058  lpDBusReply = btrCore_BTMediaEndpointSelectConfiguration(apDBusMsg, lenBTDeviceType, lenBTMediaType, apvUserData);
9059  }
9060  else if (dbus_message_is_method_call(apDBusMsg, BT_DBUS_BLUEZ_MEDIA_ENDPOINT_PATH, "SetConfiguration")) {
9061  BTRCORELOG_INFO ("endpoint_handler: MediaEndpoint1-SetConfiguration\n");
9062  lpDBusReply = btrCore_BTMediaEndpointSetConfiguration(apDBusMsg, lenBTDeviceType, lenBTMediaType, apvUserData);
9063  }
9064  else if (dbus_message_is_method_call(apDBusMsg, BT_DBUS_BLUEZ_MEDIA_ENDPOINT_PATH, "ClearConfiguration")) {
9065  BTRCORELOG_INFO ("endpoint_handler: MediaEndpoint1-ClearConfiguration\n");
9066  lpDBusReply = btrCore_BTMediaEndpointClearConfiguration(apDBusMsg, lenBTDeviceType, lenBTMediaType, apvUserData);
9067  }
9068  else {
9069  return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
9070  }
9071 
9072  if (lpDBusReply) {
9073  dbus_connection_send(apDBusConn, lpDBusReply, NULL);
9074  dbus_message_unref(lpDBusReply);
9075  }
9076 
9077  return DBUS_HANDLER_RESULT_HANDLED;
9078 }
9079 
9080 
9081 static DBusHandlerResult
9082 btrCore_BTAgentMessageHandlerCb (
9083  DBusConnection* apDBusConn,
9084  DBusMessage* apDBusMsg,
9085  void* apvUserData
9086 ) {
9087 
9088  BTRCORELOG_INFO ("btrCore_BTAgentMessageHandlerCb\n");
9089 
9090  if (!apDBusConn || !apDBusMsg || !apvUserData)
9091  return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
9092 
9093 
9094  if (dbus_message_is_method_call(apDBusMsg, BT_DBUS_BLUEZ_AGENT_PATH, "Release"))
9095  return btrCore_BTAgentRelease (apDBusConn, apDBusMsg, apvUserData);
9096 
9097  if (dbus_message_is_method_call(apDBusMsg, BT_DBUS_BLUEZ_AGENT_PATH, "RequestPinCode"))
9098  return btrCore_BTAgentRequestPincode(apDBusConn, apDBusMsg, apvUserData);
9099 
9100  if (dbus_message_is_method_call(apDBusMsg, BT_DBUS_BLUEZ_AGENT_PATH, "RequestPasskey"))
9101  return btrCore_BTAgentRequestPasskey(apDBusConn, apDBusMsg, apvUserData);
9102 
9103  if (dbus_message_is_method_call(apDBusMsg, BT_DBUS_BLUEZ_AGENT_PATH, "RequestConfirmation"))
9104  return btrCore_BTAgentRequestConfirmation(apDBusConn, apDBusMsg, apvUserData);
9105 
9106  if (dbus_message_is_method_call(apDBusMsg, BT_DBUS_BLUEZ_AGENT_PATH, "AuthorizeService"))
9107  return btrCore_BTAgentAuthorize(apDBusConn, apDBusMsg, apvUserData);
9108 
9109  if (dbus_message_is_method_call(apDBusMsg, BT_DBUS_BLUEZ_AGENT_PATH, "Cancel"))
9110  return btrCore_BTAgentCancelMessage(apDBusConn, apDBusMsg, apvUserData);
9111 
9112  if (dbus_message_is_method_call(apDBusMsg, BT_DBUS_BLUEZ_AGENT_PATH, "DisplayPinCode"))
9113  return btrCore_BTAgentDisplayPinCodePassKey(apDBusConn, apDBusMsg, TRUE, apvUserData);
9114 
9115  if (dbus_message_is_method_call(apDBusMsg, BT_DBUS_BLUEZ_AGENT_PATH, "DisplayPasskey")) {
9116  BTRCORELOG_INFO ("btrCore_BTAgentMessageHandlerCb:: DisplayPasskey\n");
9117  return btrCore_BTAgentDisplayPinCodePassKey(apDBusConn, apDBusMsg, FALSE, apvUserData);
9118  }
9119 
9120  if (dbus_message_is_method_call(apDBusMsg, BT_DBUS_BLUEZ_AGENT_PATH, "RequestAuthorization")) {
9121  BTRCORELOG_INFO ("btrCore_BTAgentMessageHandlerCb:: RequestAuthorization\n");
9122  }
9123 
9124  return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
9125 }
9126 
9127 
9128 static DBusHandlerResult
9129 btrCore_BTLeGattEndpointHandlerCb (
9130  DBusConnection* apDBusConn,
9131  DBusMessage* apDBusMsg,
9132  void* apvUserData
9133 ) {
9134  DBusMessage* lpDBusReply = NULL;
9135  const char* lpcPath = NULL;
9136 
9137  int li32MessageType;
9138  const char* lpcSender;
9139  const char* lpcDestination;
9140  stBtIfceHdl* pstlhBtIfce = (stBtIfceHdl*)apvUserData;
9141 
9142 
9143  if (!apDBusConn || !apDBusMsg || !apvUserData)
9144  return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
9145 
9146 
9147  li32MessageType = dbus_message_get_type(apDBusMsg);
9148  lpcSender = dbus_message_get_sender(apDBusMsg);
9149  lpcDestination = dbus_message_get_destination(apDBusMsg);
9150 
9151  BTRCORELOG_INFO ("%s Sender=%s -> Dest=%s Path=%s; Interface=%s; Member=%s\n",
9152  btrCore_DBusType2Name(li32MessageType),
9153  lpcSender ? lpcSender : "Null",
9154  lpcDestination ? lpcDestination : "Null",
9155  dbus_message_get_path(apDBusMsg),
9156  dbus_message_get_interface(apDBusMsg),
9157  dbus_message_get_member(apDBusMsg));
9158 
9159  lpcPath = dbus_message_get_path(apDBusMsg);
9160  if (!lpcPath)
9161  return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
9162 
9163 
9164  BTRCORELOG_INFO ("leGatt: /LeEndpoint/Gatt - %s\n", lpcPath);
9165 
9166  //TODO: Find the right way to store this and deallocate this memory when not needed anymore
9167  stBTLeGattInfo* lpstBTLeGattInfo = &pstlhBtIfce->stBTLeGatt;
9168  char lCurAdapterAddress[BT_MAX_DEV_PATH_LEN] = "\0";
9169 
9170  if (!pstlhBtIfce->pcBTDAdapterAddr) {
9171  unBTOpIfceProp lunBtOpAdapProp;
9172 
9173  lunBtOpAdapProp.enBtAdapterProp = enBTAdPropAddress;
9174  /* Get current device address */
9175  if (BtrCore_BTGetProp(pstlhBtIfce,
9176  (BtrCore_BTGetAdapterPath(pstlhBtIfce, NULL)),
9177  enBTAdapter,
9178  lunBtOpAdapProp,
9179  lCurAdapterAddress)) {
9180  return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
9181  }
9182  }
9183  else {
9184  //CID: 156556 Copy into fixed size buffer
9185  strncpy(lCurAdapterAddress, pstlhBtIfce->pcBTDAdapterAddr, (strlen(pstlhBtIfce->pcBTDAdapterAddr)< BT_MAX_DEV_PATH_LEN) ? strlen(pstlhBtIfce->pcBTDAdapterAddr) : BT_MAX_DEV_PATH_LEN - 1);
9186  }
9187 
9188  BTRCORELOG_TRACE("Current adapter address is : %s\n", lCurAdapterAddress);
9189  pstlhBtIfce->fpcBTLeGattPath(enBTAdvertisement, enBTLeGattOpUnknown, lpcPath, lCurAdapterAddress, enBTDevStUnknown, (void*)lpstBTLeGattInfo, pstlhBtIfce->pcBLePathUserData);
9190  if (dbus_message_is_method_call(apDBusMsg, DBUS_INTERFACE_OBJECT_MANAGER, "GetManagedObjects")) {
9191 
9192  BTRCORELOG_INFO ("leGatt: /LeEndpoint/Gatt - %s GetManagedObjects\n", lpcPath);
9193  BTRCORELOG_INFO("Number of gatt services%d\n", lpstBTLeGattInfo->nNumGattServices);
9194  if (!strcmp(lpcPath, BT_LE_GATT_SERVER_ENDPOINT)) {
9195  lpDBusReply = btrCore_BTRegisterGattService(apDBusConn, apDBusMsg, pstlhBtIfce, lpstBTLeGattInfo->astBTRGattService, lpstBTLeGattInfo->nNumGattServices);
9196  if (!lpDBusReply) {
9197  BTRCORELOG_ERROR ("Can't Register Le Gatt Object Paths\n");
9198  }
9199  }
9200 
9201  BTRCORELOG_INFO ("leGatt: /LeEndpoint/GattServer-GetManagedObjects\n");
9202  }
9203  else {
9204  return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
9205  }
9206 
9207 
9208  if (!lpDBusReply) {
9209  return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
9210  }
9211 
9212 
9213  dbus_connection_send(apDBusConn, lpDBusReply, NULL);
9214  dbus_connection_flush(apDBusConn);
9215 
9216  dbus_message_unref(lpDBusReply);
9217 
9218 
9219  return DBUS_HANDLER_RESULT_HANDLED;
9220 }
9221 
9222 
9223 static DBusHandlerResult
9224 btrCore_BTLeGattMessageHandlerCb (
9225  DBusConnection* apDBusConn,
9226  DBusMessage* apDBusMsg,
9227  void* apvUserData
9228 ) {
9229  DBusMessage* lpDBusReply = NULL;
9230  const char* lpcPath = NULL;
9231  stBtIfceHdl* pstlhBtIfce = (stBtIfceHdl*)apvUserData;
9232 
9233  lpcPath = dbus_message_get_path(apDBusMsg);
9234  if (!lpcPath)
9235  return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
9236 
9237  BTRCORELOG_INFO ("leGatt: /LeEndpoint/GattServer - %s\n", lpcPath);
9238 
9239  if (dbus_message_is_method_call(apDBusMsg, BT_DBUS_BLUEZ_GATT_CHAR_PATH, "ReadValue")) {
9240  BTRCORELOG_INFO ("leGatt: LeEndpoint/GattServer-Characteristic-ReadValue\n");
9241 
9242  lpDBusReply = btrCore_BTLEGattOps(apDBusMsg, pstlhBtIfce, enBTGattCharacteristic, enBTLeGattOpReadValue);
9243  }
9244  else if (dbus_message_is_method_call(apDBusMsg, BT_DBUS_BLUEZ_GATT_CHAR_PATH, "WriteValue")) {
9245  BTRCORELOG_INFO ("leGatt: LeEndpoint/GattServer-Characteristic-WriteValue\n");
9246 
9247  btrCore_BTLEGattOps(apDBusMsg, pstlhBtIfce, enBTGattCharacteristic, enBTLeGattOpWriteValue);
9248  }
9249  else if (dbus_message_is_method_call(apDBusMsg, BT_DBUS_BLUEZ_GATT_CHAR_PATH, "StartNotify")) {
9250  BTRCORELOG_INFO ("leGatt: LeEndpoint/GattServer-Characteristic-StartNotify\n");
9251  }
9252  else if (dbus_message_is_method_call(apDBusMsg, BT_DBUS_BLUEZ_GATT_CHAR_PATH, "StopNotify")) {
9253  BTRCORELOG_INFO ("leGatt: LeEndpoint/GattServer-Characteristic-StopNotify\n");
9254  }
9255  else if (dbus_message_is_method_call(apDBusMsg, BT_DBUS_BLUEZ_GATT_DESCRIPTOR_PATH, "ReadValue")) {
9256  BTRCORELOG_INFO ("leGatt: LeEndpoint/GattServer-Descriptor-ReadValue\n");
9257 
9258  lpDBusReply = btrCore_BTLEGattOps(apDBusMsg, pstlhBtIfce, enBTGattDescriptor, enBTLeGattOpReadValue);
9259  }
9260  else if (dbus_message_is_method_call(apDBusMsg, BT_DBUS_BLUEZ_GATT_DESCRIPTOR_PATH, "WriteValue")) {
9261  BTRCORELOG_INFO ("leGatt: LeEndpoint/GattServer-Descriptor-WriteValue\n");
9262 
9263  btrCore_BTLEGattOps(apDBusMsg, pstlhBtIfce, enBTGattDescriptor, enBTLeGattOpWriteValue);
9264  }
9265  else {
9266  return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
9267  }
9268 
9269  if (!lpDBusReply) {
9270  return DBUS_HANDLER_RESULT_NOT_YET_HANDLED;
9271  }
9272 
9273  dbus_connection_send(apDBusConn, lpDBusReply, NULL);
9274  dbus_connection_flush(apDBusConn);
9275 
9276  dbus_message_unref(lpDBusReply);
9277 
9278  return DBUS_HANDLER_RESULT_HANDLED;
9279 }
BtrCore_BTStopDiscovery
int BtrCore_BTStopDiscovery(void *apstBtIfceHdl, const char *apBtAdapter, const char *apBtAgentPath)
This API is used to stop discovering Bluetooth adapter.
Definition: btrCore_dbus_bluez5.c:4318
_stBTLeGattService
Definition: btrCore_bt_ifce.h:756
_stBTMediaStatusUpdate
Definition: btrCore_bt_ifce.h:700
_stBTDeviceSupportedServiceList
Definition: btrCore_bt_ifce.h:684
BtrCore_BTDevMediaControl
int BtrCore_BTDevMediaControl(void *apstBtIfceHdl, const char *apMediaPlayerPath, enBTMediaControlCmd aenBTMediaOper)
This API is used to control the media device.
Definition: btrCore_dbus_bluez5.c:6089
BtrCore_BTEnableEnhancedRetransmissionMode
int BtrCore_BTEnableEnhancedRetransmissionMode(void *apstBtIfceHdl)
This API is used to Enable Enhanced Retransmission on all BT adapter.
Definition: btrCore_dbus_bluez5.c:5494
_stBTMediaTrackInfo
Definition: btrCore_bt_ifce.h:689
BtrCore_BTUnregisterAgent
int BtrCore_BTUnregisterAgent(void *apstBtIfceHdl, const char *apBtAdapter, const char *apBtAgentPath)
Using this API, DBus object path is unregistered with bluetooth agent path and current adapter's path...
Definition: btrCore_dbus_bluez5.c:3284
_stBTAdapterInfo
Definition: btrCore_bt_ifce.h:625
BtrCore_BTRegisterLeGatt
int BtrCore_BTRegisterLeGatt(void *apstBtIfceHdl, const char *apBtAdapter)
This API is used to invoke the bluez API gatt service method call RegisterApplication.
Definition: btrCore_dbus_bluez5.c:6771
BtrCore_BTGetPairedDeviceInfo
int BtrCore_BTGetPairedDeviceInfo(void *apstBtIfceHdl, const char *apBtAdapter, stBTPairedDeviceInfo *pPairedDeviceInfo)
This API fetches all BT paired devices' device information.
Definition: btrCore_dbus_bluez5.c:4646
BT_MAX_NUM_ADAPTERS
#define BT_MAX_NUM_ADAPTERS
Bluetooth max number of bluetooth adapters that can be connected over USB/UART.
Definition: btrCore_bt_ifce.h:69
BtrCore_BTReleaseAdapterPath
int BtrCore_BTReleaseAdapterPath(void *apstBtIfceHdl, const char *apBtAdapter)
Using this API the path assigned to the current Bluetooth Adapter is released.
Definition: btrCore_dbus_bluez5.c:3575
BtrCore_BTPlayMediaTrackItem
int BtrCore_BTPlayMediaTrackItem(void *apstBtIfceHdl, const char *apBtMediaItemObjectPath)
This API is used to Play the mentioned media track.
Definition: btrCore_dbus_bluez5.c:6632
BtrCore_BTRegisterMedia
int BtrCore_BTRegisterMedia(void *apstBtIfceHdl, const char *apBtAdapter, enBTDeviceType aenBTDevType, enBTMediaType aenBTMediaType, const char *apBtUUID, void *apBtMediaCapabilities, int apBtMediaCapabilitiesSize, int abBtMediaDelayReportEnable)
This API is used to register a media device.
Definition: btrCore_dbus_bluez5.c:5594
enBTMediaType
enum _enBTMediaType enBTMediaType
Bluetooth Media types.
BtrCore_BTSetDevDataAckTimeout
int BtrCore_BTSetDevDataAckTimeout(void *apstBtIfceHdl, unsigned int aui32AckTOutms)
This API is used to release the acquired device data path.
Definition: btrCore_dbus_bluez5.c:6010
BtrCore_BTDisableEnhancedRetransmissionMode
int BtrCore_BTDisableEnhancedRetransmissionMode(void *apstBtIfceHdl)
This API is used to Disable Enhanced Retransmission on all BT adapter.
Definition: btrCore_dbus_bluez5.c:5544
_stBTMediaBrowserUpdate
Definition: btrCore_bt_ifce.h:726
BtrCore_BTSetProp
int BtrCore_BTSetProp(void *apstBtIfceHdl, const char *apcBtOpIfcePath, enBTOpIfceType aenBtOpIfceType, unBTOpIfceProp aunBtOpIfceProp, void *apvVal)
This API sets different properties of different BT devices and services.
Definition: btrCore_dbus_bluez5.c:4025
_stBTLeCustomAdv
Definition: btrCore_bt_ifce.h:781
_stBTPairedDeviceInfo
Definition: btrCore_bt_ifce.h:673
BtrCore_BTConnectDevice
int BtrCore_BTConnectDevice(void *apstBtIfceHdl, const char *apDevPath, enBTDeviceType aenBTDeviceType)
This API is used to establish the connection with a BT device.
Definition: btrCore_dbus_bluez5.c:5418
BT_UUID_GATT_TILE_3
#define BT_UUID_GATT_TILE_3
Bluetooth LE Tile 2 UUID.
Definition: btrCore_bt_ifce.h:100
BtrCore_BTGetAdapterPath
char * BtrCore_BTGetAdapterPath(void *apstBtIfceHdl, const char *apBtAdapter)
Using this API adapter path is fetched from Dbus object path.
Definition: btrCore_dbus_bluez5.c:3524
BtrCore_BTRegisterLeAdvertisement
int BtrCore_BTRegisterLeAdvertisement(void *apstBtIfceHdl, const char *apBtAdapter)
This API is used to invoke the bluez API advertisement method call RegisterAdvertisment.
Definition: btrCore_dbus_bluez5.c:6710
enBTDeviceType
enum _enBTDeviceType enBTDeviceType
Bluetooth device types.
BtrCore_BTStopLEDiscovery
int BtrCore_BTStopLEDiscovery(void *apstBtIfceHdl, const char *apBtAdapter, const char *apBtAgentPath)
This API is used to stop discovering low energy Bluetooth adapter.
Definition: btrCore_dbus_bluez5.c:4465
BtrCore_BTInitGetConnection
void * BtrCore_BTInitGetConnection(void)
This API Initializes the Bluetooth core and fetches DBus connection and returns a handle to the insta...
Definition: btrCore_dbus_bluez5.c:2967
BtrCore_BTGetAgentPath
char * BtrCore_BTGetAgentPath(void *apstBtIfceHdl)
Using this API, a default Path is assigned to the Bluetooth Agent.
Definition: btrCore_dbus_bluez5.c:3159
BtrCore_BTPerformAdapterOp
int BtrCore_BTPerformAdapterOp(void *apstBtIfceHdl, const char *apBtAdapter, const char *apBtAgentPath, const char *apcDevPath, enBTAdapterOp aenBTAdpOp)
This API is used to perform BT adapter operations.
Definition: btrCore_dbus_bluez5.c:5037
BT_MEDIA_CODEC_PCM
#define BT_MEDIA_CODEC_PCM
Bluetooth Media Codec PCM - Must be same as the Ifce.
Definition: btrCore_bt_ifce.h:140
BtrCore_BTGetCommonParentMediaItemId
tBTMediaItemId BtrCore_BTGetCommonParentMediaItemId(tBTMediaItemId aBTcurrMediaItemId, tBTMediaItemId aBTdestMediaItemId)
This API is used to get the mediaItemID of the node which is the immediate common parent of the src a...
Definition: btrCore_dbus_bluez5.c:6419
BtrCore_BTGetIfceNameVersion
int BtrCore_BTGetIfceNameVersion(void *apstBtIfceHdl, char *apBtOutIfceName, char *apBtOutVersion)
using this API, Bluetooth interface version is obtained from bluetooth daemon of the kernel and defau...
Definition: btrCore_dbus_bluez5.c:3607
_unBTOpIfceProp
Definition: btrCore_bt_ifce.h:609
BtrCore_BTReleaseDevDataPath
int BtrCore_BTReleaseDevDataPath(void *apstBtIfceHdl, char *apcDevTransportPath)
This API is used to release the acquired device data path.
Definition: btrCore_dbus_bluez5.c:5967
BtrCore_BTStartLEDiscovery
int BtrCore_BTStartLEDiscovery(void *apstBtIfceHdl, const char *apBtAdapter, const char *apBtAgentPath)
This API is used to discover the low energy Bluetooth adapter.
Definition: btrCore_dbus_bluez5.c:4360
BtrCore_BTGetMediaFolderNumberOfItems
int BtrCore_BTGetMediaFolderNumberOfItems(void *apstBtIfceHdl, const char *apBtMediaPlayerPath, unsigned int *aui32NumberOfItems)
This API is used to get the number of items in the current media folder.
Definition: btrCore_dbus_bluez5.c:6267
BT_UUID_GATT_TILE_2
#define BT_UUID_GATT_TILE_2
Bluetooth LE Tile 2 UUID.
Definition: btrCore_bt_ifce.h:95
enBTMediaControlCmd
enum _enBTMediaControlCmd enBTMediaControlCmd
Bluetooth Media Controls.
BT_MEDIA_CODEC_MPEG12
#define BT_MEDIA_CODEC_MPEG12
Bluetooth Media Codec MPEG12 - Must be same as the Ifce.
Definition: btrCore_bt_ifce.h:121
BtrCore_BTAcquireDevDataPath
int BtrCore_BTAcquireDevDataPath(void *apstBtIfceHdl, char *apcDevTransportPath, int *dataPathFd, int *dataReadMTU, int *dataWriteMTU)
This API is used to acquire device data path.
Definition: btrCore_dbus_bluez5.c:5910
enBTDeviceState
enum _enBTDeviceState enBTDeviceState
Bluetooth device state.
BtrCore_BTStopClassicDiscovery
int BtrCore_BTStopClassicDiscovery(void *apstBtIfceHdl, const char *apBtAdapter, const char *apBtAgentPath)
This API is used to stop discovering Classic Bluetooth Devices.
Definition: btrCore_dbus_bluez5.c:4587
enBTMediaTransportState
enum _enBTMediaTransportState enBTMediaTransportState
Bluetooth Media transport states.
BT_MEDIA_CODEC_SBC
#define BT_MEDIA_CODEC_SBC
Bluetooth Media Codec SBC - Must be same as the Ifce.
Definition: btrCore_bt_ifce.h:116
BT_MAX_UUID_STR_LEN
#define BT_MAX_UUID_STR_LEN
Bluetooth max uuid length.
Definition: btrCore_bt_ifce.h:52
BT_MAX_NUM_DEVICE
#define BT_MAX_NUM_DEVICE
Bluetooth max number of devices that can be connected.
Definition: btrCore_bt_ifce.h:57
BtrCore_BTRegisterAgent
int BtrCore_BTRegisterAgent(void *apstBtIfceHdl, const char *apBtAdapter, const char *apBtAgentPath, const char *capabilities)
using this API, DBus object path is registered with bluetooth agent path and current adapter's path.
Definition: btrCore_dbus_bluez5.c:3202
BtrCore_BTPerformLeGattOp
int BtrCore_BTPerformLeGattOp(void *apstBtIfceHdl, const char *apBtGattPath, enBTOpIfceType aenBTOpIfceType, enBTLeGattOp aenBTLeGattOp, char *apLeGatOparg1, char *apLeGatOparg2, char *rpLeOpRes)
This API is used to perform gatt services of the BT device .
Definition: btrCore_dbus_bluez5.c:6995
BtrCore_BTGetProp
int BtrCore_BTGetProp(void *apstBtIfceHdl, const char *apcBtOpIfcePath, enBTOpIfceType aenBtOpIfceType, unBTOpIfceProp aunBtOpIfceProp, void *apvVal)
This API gets different properties of different BT devices and services.
Definition: btrCore_dbus_bluez5.c:3655
_stBTLeGattDesc
Definition: btrCore_bt_ifce.h:738
BtrCore_BTUnRegisterMedia
int BtrCore_BTUnRegisterMedia(void *apstBtIfceHdl, const char *apBtAdapter, enBTDeviceType aenBTDevType, enBTMediaType aenBTMediaType)
This API is used to unregister the media device.
Definition: btrCore_dbus_bluez5.c:5789
_stBTMediaInfo
Definition: btrCore_dbus_bluez5.c:91
BtrCore_BTGetMediaPlayerProperty
int BtrCore_BTGetMediaPlayerProperty(void *apstBtIfceHdl, const char *apBtMediaPlayerPath, const char *mediaProperty, void *mediaPropertyValue)
This API is used to get media player property value using the object path of BT device and media prop...
Definition: btrCore_dbus_bluez5.c:6246
BtrCore_BTChangeMediaFolder
int BtrCore_BTChangeMediaFolder(void *apstBtIfceHdl, const char *apBtmediaPlayerObjectPath, const char *apBtdestMediaFolderPath)
This API is used to change from the current media folder path to another path.
Definition: btrCore_dbus_bluez5.c:6441
BtrCore_BTStartClassicDiscovery
int BtrCore_BTStartClassicDiscovery(void *apstBtIfceHdl, const char *apBtAdapter, const char *apBtAgentPath)
This API is used to discover the Classic Bluetooth Devices.
Definition: btrCore_dbus_bluez5.c:4523
BT_MAX_SERVICE_DATA_LEN
#define BT_MAX_SERVICE_DATA_LEN
Bluetooth Advertising Service Data max length.
Definition: btrCore_bt_ifce.h:74
BtrCore_BTGetAdapterList
int BtrCore_BTGetAdapterList(void *apBtConn, unsigned int *apBtNumAdapters, char *apcArrBtAdapterPath[4])
This API obtains adapter list from Dbus object path.
BtrCore_BTUnRegisterLeGatt
int BtrCore_BTUnRegisterLeGatt(void *apstBtIfceHdl, const char *apBtAdapter)
This API is used to invoke the bluez API gatt service method call UnRegisterApplication.
Definition: btrCore_dbus_bluez5.c:6880
enBTAdapterOp
enum _enBTAdapterOp enBTAdapterOp
Bluetooth Adapter operations.
BtrCore_BTStartDiscovery
int BtrCore_BTStartDiscovery(void *apstBtIfceHdl, const char *apBtAdapter, const char *apBtAgentPath)
This API is used to discover the Bluetooth adapter.
Definition: btrCore_dbus_bluez5.c:4281
BtrCore_BTGetTransportState
int BtrCore_BTGetTransportState(void *apstBtIfceHdl, const char *apBtDataPath, void *pState)
This API is used to get the state of the BT device .
Definition: btrCore_dbus_bluez5.c:6226
BtrCore_BTIsDeviceConnectable
int BtrCore_BTIsDeviceConnectable(void *apstBtIfceHdl, const char *apcDevPath)
This API is used to run device connectable command.
Definition: btrCore_dbus_bluez5.c:5371
BtrCore_BTDeInitReleaseConnection
int BtrCore_BTDeInitReleaseConnection(void *apstBtIfceHdl)
This API DeInitializes the Bluetooth core and releases the DBus connection.
Definition: btrCore_dbus_bluez5.c:3075
BtrCore_BTSetMediaProperty
int BtrCore_BTSetMediaProperty(void *apstBtIfceHdl, const char *apBtAdapterPath, char *mediaProperty, char *pValue)
This API is used to set the media property of the BT device .
Definition: btrCore_dbus_bluez5.c:6287
BtrCore_BTGetTrackInformation
int BtrCore_BTGetTrackInformation(void *apstBtIfceHdl, const char *apBtmediaObjectPath, stBTMediaTrackInfo *apstBTMediaTrackInfo)
This API is used to retrieve the information about the track that is being played on BT media device.
Definition: btrCore_dbus_bluez5.c:6352
BtrCore_BTDisconnectDevice
int BtrCore_BTDisconnectDevice(void *apstBtIfceHdl, const char *apDevPath, enBTDeviceType aenBTDeviceType)
This API is used to diconnect a BT device.
Definition: btrCore_dbus_bluez5.c:5456
enBTMediaTransportProp
enum _enBTMediaTransportProp enBTMediaTransportProp
Bluetooth Media transport properties.
_stBTLeGattInfo
Definition: btrCore_bt_ifce.h:764
BT_MAX_STR_LEN
#define BT_MAX_STR_LEN
Bluetooth max string length.
Definition: btrCore_bt_ifce.h:38
_stBTDeviceInfo
Definition: btrCore_bt_ifce.h:647
enBTOpIfceType
enum _enBTOpType enBTOpIfceType
Bluetooth device operation types.
BtrCore_BTReleaseAgentPath
int BtrCore_BTReleaseAgentPath(void *apstBtIfceHdl)
Using this API the path assigned to the Bluetooth Agent is released.
Definition: btrCore_dbus_bluez5.c:3183
BT_UUID_GATT_TILE_1
#define BT_UUID_GATT_TILE_1
Bluetooth LE Tile 1 UUID.
Definition: btrCore_bt_ifce.h:90
_stBtIfceHdl
Definition: btrCore_dbus_bluez5.c:100
BT_MAX_DEV_PATH_LEN
#define BT_MAX_DEV_PATH_LEN
Bluetooth max device path length.
Definition: btrCore_bt_ifce.h:44
_stBTLeGattChar
Definition: btrCore_bt_ifce.h:746
BT_MEDIA_CODEC_MPEG24
#define BT_MEDIA_CODEC_MPEG24
Bluetooth Media Codec MPEG24 - Must be same as the Ifce.
Definition: btrCore_bt_ifce.h:126
BtrCore_BTGetMediaPlayerPath
char * BtrCore_BTGetMediaPlayerPath(void *apstBtIfceHdl, const char *apBtDevPath)
A Path is assigned to Media player using Bluetooth device path.
Definition: btrCore_dbus_bluez5.c:6053
TRUE
#define TRUE
Defines for TRUE/FALSE/ENABLE flags.
Definition: wifi_common_hal.h:199
BtrCore_BTFindServiceSupported
int BtrCore_BTFindServiceSupported(void *apstBtIfceHdl, const char *apcDevPath, const char *apcSearchString, char *apcDataString)
This API is used to find all supported services and fetch the profiles of all those devices.
Definition: btrCore_dbus_bluez5.c:4934
enBTLeGattOp
enum _enBTLeGattOp enBTLeGattOp
Bluetooth Gatt operations.
BT_MAX_DEVICE_PROFILE
#define BT_MAX_DEVICE_PROFILE
Bluetooth max number of device profiles that are allowed. Device Profiles are definitions of possible...
Definition: btrCore_bt_ifce.h:64
BtrCore_BTSelectMediaFolderItems
int BtrCore_BTSelectMediaFolderItems(void *apstBtIfceHdl, const char *apBtMediaPlayerObjectPath, unsigned int apBtMediaFolderStartIndex, unsigned int apBtMediaFolderEndIndex, const char *apBtMediaFilter, int apBtMediaFilterSize)
This API is used to list the media items in the current folder.
Definition: btrCore_dbus_bluez5.c:6485
BtrCore_BTDiscoverDeviceServices
int BtrCore_BTDiscoverDeviceServices(void *apstBtIfceHdl, const char *apcDevPath, stBTDeviceSupportedServiceList *pProfileList)
This API is used to discover the supported services and fetch the profiles of all those devices.
Definition: btrCore_dbus_bluez5.c:4855
BtrCore_BTSendReceiveMessages
int BtrCore_BTSendReceiveMessages(void *apstBtIfceHdl)
This API is used to read, write and dispatch BT device information.
Definition: btrCore_dbus_bluez5.c:7239