RDK Documentation (Open Sourced RDK Components)
btrMgr.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 #ifdef HAVE_CONFIG_H
20 #include <config.h>
21 #endif
22 
23 /* System Headers */
24 #include <stdio.h>
25 #include <unistd.h>
26 #include <stdlib.h>
27 #include <string.h>
28 #include <glib.h>
29 
30 #include "btrCore.h"
31 
32 #include "btmgr.h"
33 #include "btrMgr_logger.h"
34 
35 #ifndef BUILD_FOR_PI
36 #include "rfcapi.h"
37 #endif
38 
39 #include "btrMgr_Types.h"
40 #include "btrMgr_mediaTypes.h"
41 #include "btrMgr_streamOut.h"
42 #include "btrMgr_audioCap.h"
43 #include "btrMgr_streamIn.h"
44 #include "btrMgr_persistIface.h"
45 #include "btrMgr_SysDiag.h"
46 #include "btrMgr_Columbo.h"
47 #include "btrMgr_LEOnboarding.h"
48 
49 /* Private Macro definitions */
50 #define BTRMGR_SIGNAL_POOR (-90)
51 #define BTRMGR_SIGNAL_FAIR (-70)
52 #define BTRMGR_SIGNAL_GOOD (-60)
53 
54 #define BTRMGR_CONNECT_RETRY_ATTEMPTS 2
55 #define BTRMGR_DEVCONN_CHECK_RETRY_ATTEMPTS 3
56 #define BTRMGR_DEVCONN_PWRST_CHANGE_TIME 3
57 
58 #define BTRMGR_DISCOVERY_HOLD_OFF_TIME 120
59 #define BTRTEST_LE_ONBRDG_ENABLE 1
60 
61 
62 // Move to private header ?
63 typedef struct _stBTRMgrStreamingInfo {
64  tBTRMgrAcHdl hBTRMgrAcHdl;
65  tBTRMgrSoHdl hBTRMgrSoHdl;
66  tBTRMgrSoHdl hBTRMgrSiHdl;
67  BTRMGR_StreamOut_Type_t tBTRMgrSoType;
68  unsigned long bytesWritten;
69  unsigned samplerate;
70  unsigned channels;
71  unsigned bitsPerSample;
72  int i32BytesToEncode;
73 } stBTRMgrStreamingInfo;
74 
75 typedef enum _BTRMGR_DiscoveryState_t {
76  BTRMGR_DISCOVERY_ST_UNKNOWN,
77  BTRMGR_DISCOVERY_ST_STARTED,
78  BTRMGR_DISCOVERY_ST_PAUSED,
79  BTRMGR_DISCOVERY_ST_RESUMED,
80  BTRMGR_DISCOVERY_ST_STOPPED,
81 } BTRMGR_DiscoveryState_t;
82 
83 typedef enum _enBTRMGRStartupAudio {
84  BTRMGR_STARTUP_AUD_INPROGRESS,
85  BTRMGR_STARTUP_AUD_SKIPPED,
86  BTRMGR_STARTUP_AUD_COMPLETED,
87  BTRMGR_STARTUP_AUD_UNKNOWN,
88 } enBTRMGRStartupAudio;
89 
90 typedef struct _BTRMGR_DiscoveryHandle_t {
91  BTRMGR_DeviceOperationType_t m_devOpType;
92  BTRMGR_DiscoveryState_t m_disStatus;
93  BTRMGR_DiscoveryFilterHandle_t m_disFilter;
94 } BTRMGR_DiscoveryHandle_t;
95 
96 //TODO: Move to a local handle. Mutex protect all
97 static tBTRCoreHandle ghBTRCoreHdl = NULL;
98 static tBTRMgrPIHdl ghBTRMgrPiHdl = NULL;
99 static tBTRMgrSDHdl ghBTRMgrSdHdl = NULL;
100 static BTRMgrDeviceHandle ghBTRMgrDevHdlLastConnected = 0;
101 static BTRMgrDeviceHandle ghBTRMgrDevHdlCurStreaming = 0;
102 static BTRMGR_DiscoveryHandle_t ghBTRMgrDiscoveryHdl;
103 static BTRMGR_DiscoveryHandle_t ghBTRMgrBgDiscoveryHdl;
104 
105 static stBTRCoreAdapter gDefaultAdapterContext;
106 static stBTRCoreListAdapters gListOfAdapters;
107 static stBTRCoreDevMediaInfo gstBtrCoreDevMediaInfo;
108 static BTRMGR_DiscoveredDevicesList_t gListOfDiscoveredDevices;
109 static BTRMGR_PairedDevicesList_t gListOfPairedDevices;
110 static stBTRMgrStreamingInfo gstBTRMgrStreamingInfo;
111 
112 static unsigned char gui8IsSoDevAvrcpSupported = 0;
113 static unsigned char gIsLeDeviceConnected = 0;
114 static unsigned char gIsAgentActivated = 0;
115 static unsigned char gEventRespReceived = 0;
116 static unsigned char gAcceptConnection = 0;
117 static unsigned char gIsUserInitiated = 0;
118 static unsigned char gDiscHoldOffTimeOutCbData = 0;
119 static unsigned char gConnPwrStChTimeOutCbData = 0;
120 static unsigned char gIsAudioInEnabled = 0;
121 static unsigned char gIsHidGamePadEnabled = 0;
122 static volatile guint gTimeOutRef = 0;
123 static volatile guint gConnPwrStChangeTimeOutRef = 0;
124 static volatile unsigned int gIsAdapterDiscovering = 0;
125 
126 static BTRMGR_DeviceOperationType_t gBgDiscoveryType = BTRMGR_DEVICE_OP_TYPE_UNKNOWN;
127 static BTRMGR_Events_t gMediaPlaybackStPrev = BTRMGR_EVENT_MAX;
128 static enBTRMGRStartupAudio gIsAudOutStartupInProgress = BTRMGR_STARTUP_AUD_UNKNOWN;
129 
130 static void* gpvMainLoop = NULL;
131 static void* gpvMainLoopThread = NULL;
132 
133 static BTRMGR_EventCallback gfpcBBTRMgrEventOut = NULL;
134 static char gLeReadOpResponse[BTRMGR_MAX_DEV_OP_DATA_LEN] = "\0";
135 static BOOLEAN gIsAdvertisementSet = FALSE;
136 static BOOLEAN gIsDeviceAdvertising = FALSE;
137 static BOOLEAN gIsDiscoveryOpInternal = FALSE;
138 
139 BTRMGR_LeCustomAdvertisement_t stCoreCustomAdv =
140 {
141  0x02 ,
142  0x01 ,
143  0x06 ,
144  0x05 ,
145  0x03 ,
146  0x0A ,
147  0x18 ,
148  0xB9 ,
149  0xFD ,
150  0x0B ,
151  0xFF ,
152  0xA3 ,
153  0x07 ,
154  0x0101,
155  {
156  0xC8,
157  0xB3,
158  0x73,
159  0x32,
160  0xEA,
161  0x3D
162  }
163 };
164 
165 #ifdef RDK_LOGGER_ENABLED
166 int b_rdk_logger_enabled = 0;
167 #endif
168 
169 
170 
171 /* Static Function Prototypes */
172 static inline unsigned char btrMgr_GetAdapterCnt (void);
173 static const char* btrMgr_GetAdapterPath (unsigned char aui8AdapterIdx);
174 
175 static inline void btrMgr_SetAgentActivated (unsigned char aui8AgentActivated);
176 static inline unsigned char btrMgr_GetAgentActivated (void);
177 static void btrMgr_CheckAudioInServiceAvailability (void);
178 static void btrMgr_CheckHidGamePadServiceAvailability (void);
179 
180 static const char* btrMgr_GetDiscoveryDeviceTypeAsString (BTRMGR_DeviceOperationType_t adevOpType);
181 //static const char* btrMgr_GetDiscoveryFilterAsString (BTRMGR_ScanFilter_t ascanFlt);
182 static const char* btrMgr_GetDiscoveryStateAsString (BTRMGR_DiscoveryState_t aScanStatus);
183 
184 static inline void btrMgr_SetDiscoveryHandle (BTRMGR_DeviceOperationType_t adevOpType, BTRMGR_DiscoveryState_t aScanStatus);
185 static inline void btrMgr_SetBgDiscoveryType (BTRMGR_DeviceOperationType_t adevOpType);
186 static inline void btrMgr_SetDiscoveryState (BTRMGR_DiscoveryHandle_t* ahdiscoveryHdl, BTRMGR_DiscoveryState_t aScanStatus);
187 static inline void btrMgr_SetDiscoveryDeviceType (BTRMGR_DiscoveryHandle_t* ahdiscoveryHdl, BTRMGR_DeviceOperationType_t aeDevOpType);
188 
189 static inline BTRMGR_DeviceOperationType_t btrMgr_GetBgDiscoveryType (void);
190 static inline BTRMGR_DiscoveryState_t btrMgr_GetDiscoveryState (BTRMGR_DiscoveryHandle_t* ahdiscoveryHdl);
191 static inline BTRMGR_DeviceOperationType_t btrMgr_GetDiscoveryDeviceType (BTRMGR_DiscoveryHandle_t* ahdiscoveryHdl);
192 //static inline BTRMGR_DiscoveryFilterHandle_t* btrMgr_GetDiscoveryFilter (BTRMGR_DiscoveryHandle_t* ahdiscoveryHdl);
193 
194 static inline gboolean btrMgr_isTimeOutSet (void);
195 static inline void btrMgr_ClearDiscoveryHoldOffTimer(void);
196 static inline void btrMgr_SetDiscoveryHoldOffTimer(unsigned char aui8AdapterIdx);
197 
198 //static eBTRMgrRet btrMgr_SetDiscoveryFilter (BTRMGR_DiscoveryHandle_t* ahdiscoveryHdl, BTRMGR_ScanFilter_t aeScanFilterType, void* aFilterValue);
199 //static eBTRMgrRet btrMgr_ClearDiscoveryFilter (BTRMGR_DiscoveryHandle_t* ahdiscoveryHdl);
200 
201 static BTRMGR_DiscoveryHandle_t* btrMgr_GetDiscoveryInProgress (void);
202 
203 static BTRMGR_Result_t BTRMGR_StartDeviceDiscovery_Internal (unsigned char aui8AdapterIdx, BTRMGR_DeviceOperationType_t aenBTRMgrDevOpT);
204 static BTRMGR_Result_t BTRMGR_StopDeviceDiscovery_Internal (unsigned char aui8AdapterIdx, BTRMGR_DeviceOperationType_t aenBTRMgrDevOpT);
205 static BTRMGR_Result_t BTRMGR_GetDiscoveredDevices_Internal (unsigned char aui8AdapterIdx, BTRMGR_DiscoveredDevicesList_t* pDiscoveredDevices);
206 
207 static eBTRMgrRet btrMgr_PauseDeviceDiscovery (unsigned char aui8AdapterIdx, BTRMGR_DiscoveryHandle_t* ahdiscoveryHdl);
208 static eBTRMgrRet btrMgr_ResumeDeviceDiscovery (unsigned char aui8AdapterIdx, BTRMGR_DiscoveryHandle_t* ahdiscoveryHdl);
209 static eBTRMgrRet btrMgr_StopDeviceDiscovery (unsigned char aui8AdapterIdx, BTRMGR_DiscoveryHandle_t* ahdiscoveryHdl);
210 
211 static eBTRMgrRet btrMgr_PreCheckDiscoveryStatus (unsigned char aui8AdapterIdx, BTRMGR_DeviceOperationType_t aDevOpType);
212 static eBTRMgrRet btrMgr_PostCheckDiscoveryStatus (unsigned char aui8AdapterIdx, BTRMGR_DeviceOperationType_t aDevOpType);
213 
214 static void btrMgr_GetPairedDevInfo (BTRMgrDeviceHandle ahBTRMgrDevHdl, BTRMGR_PairedDevices_t* apBtMgrPairedDevInfo);
215 static void btrMgr_GetDiscoveredDevInfo (BTRMgrDeviceHandle ahBTRMgrDevHdl, BTRMGR_DiscoveredDevices_t* apBtMgrDiscoveredDevInfo);
216 
217 static unsigned char btrMgr_GetDevPaired (BTRMgrDeviceHandle ahBTRMgrDevHdl);
218 
219 static void btrMgr_SetDevConnected (BTRMgrDeviceHandle ahBTRMgrDevHdl, unsigned char aui8isDeviceConnected);
220 static unsigned char btrMgr_IsDevConnected (BTRMgrDeviceHandle ahBTRMgrDevHdl);
221 
222 static unsigned char btrMgr_IsDevNameSameAsAddress (char* apcDeviceName, char* apcDeviceAddress, unsigned int ui32StrLen);
223 static unsigned char btrMgr_CheckIfDevicePrevDetected (BTRMgrDeviceHandle ahBTRMgrDevHdl);
224 
225 static BTRMGR_DeviceType_t btrMgr_MapDeviceTypeFromCore (enBTRCoreDeviceClass device_type);
226 static BTRMGR_DeviceOperationType_t btrMgr_MapDeviceOpFromDeviceType (BTRMGR_DeviceType_t device_type);
227 static BTRMGR_RSSIValue_t btrMgr_MapSignalStrengthToRSSI (int signalStrength);
228 static eBTRMgrRet btrMgr_MapDevstatusInfoToEventInfo (void* p_StatusCB, BTRMGR_EventMessage_t* apstEventMessage, BTRMGR_Events_t type);
229 
230 static eBTRMgrRet btrMgr_StartCastingAudio (int outFileFd, int outMTUSize, unsigned int outDevDelay, eBTRCoreDevMediaType aenBtrCoreDevOutMType, void* apstBtrCoreDevOutMCodecInfo);
231 static eBTRMgrRet btrMgr_StopCastingAudio (void);
232 static eBTRMgrRet btrMgr_SwitchCastingAudio_AC (BTRMGR_StreamOut_Type_t aenCurrentSoType);
233 static eBTRMgrRet btrMgr_StartReceivingAudio (int inFileFd, int inMTUSize, unsigned int inDevDelay, eBTRCoreDevMediaType aenBtrCoreDevInMType, void* apstBtrCoreDevInMCodecInfo);
234 static eBTRMgrRet btrMgr_StopReceivingAudio (void);
235 
236 static eBTRMgrRet btrMgr_ConnectToDevice (unsigned char aui8AdapterIdx, BTRMgrDeviceHandle ahBTRMgrDevHdl, BTRMGR_DeviceOperationType_t connectAs, unsigned int aui32ConnectRetryIdx, unsigned int aui32ConfirmIdx);
237 
238 static eBTRMgrRet btrMgr_StartAudioStreamingOut (unsigned char aui8AdapterIdx, BTRMgrDeviceHandle ahBTRMgrDevHdl, BTRMGR_DeviceOperationType_t streamOutPref, unsigned int aui32ConnectRetryIdx, unsigned int aui32ConfirmIdx, unsigned int aui32SleepIdx);
239 
240 static eBTRMgrRet btrMgr_AddPersistentEntry(unsigned char aui8AdapterIdx, BTRMgrDeviceHandle ahBTRMgrDevHdl, const char* apui8ProfileStr, int ai32DevConnected);
241 static eBTRMgrRet btrMgr_RemovePersistentEntry(unsigned char aui8AdapterIdx, BTRMgrDeviceHandle ahBTRMgrDevHdl, const char* apui8ProfileStr);
242 static eBTRMgrRet btrMgr_MediaControl(unsigned char aui8AdapterIdx, BTRMgrDeviceHandle ahBTRMgrDevHdl, BTRMGR_MediaDeviceStatus_t* apstMediaDeviceStatus, enBTRCoreDeviceType aenBtrCoreDevTy, enBTRCoreDeviceClass aenBtrCoreDevCl, stBTRCoreMediaCtData *apstBtrCoreMediaCData);
243 
244 #if 0
245 static void btrMgr_AddStandardAdvGattInfo(void);
246 
247 static void btrMgr_AddColumboGATTInfo(void);
248 #endif
249 
250 static BTRMGR_SysDiagChar_t btrMgr_MapUUIDtoDiagElement(char *aUUID);
251 
252 /* Local Op Threads Prototypes */
253 static gpointer btrMgr_g_main_loop_Task (gpointer appvMainLoop);
254 
255 
256 /* Incoming Callbacks Prototypes */
257 static gboolean btrMgr_DiscoveryHoldOffTimerCb (gpointer gptr);
258 static gboolean btrMgr_ConnPwrStChangeTimerCb (gpointer gptr);
259 
260 static eBTRMgrRet btrMgr_ACDataReadyCb (void* apvAcDataBuf, unsigned int aui32AcDataLen, void* apvUserData);
261 static eBTRMgrRet btrMgr_ACStatusCb (stBTRMgrMediaStatus* apstBtrMgrAcStatus, void* apvUserData);
262 static eBTRMgrRet btrMgr_SOStatusCb (stBTRMgrMediaStatus* apstBtrMgrSoStatus, void* apvUserData);
263 static eBTRMgrRet btrMgr_SIStatusCb (stBTRMgrMediaStatus* apstBtrMgrSiStatus, void* apvUserData);
264 static eBTRMgrRet btrMgr_SDStatusCb (stBTRMgrSysDiagStatus* apstBtrMgrSdStatus, void* apvUserData);
265 
266 static enBTRCoreRet btrMgr_DeviceStatusCb (stBTRCoreDevStatusCBInfo* p_StatusCB, void* apvUserData);
267 static enBTRCoreRet btrMgr_DeviceDiscoveryCb (stBTRCoreDiscoveryCBInfo* astBTRCoreDiscoveryCbInfo, void* apvUserData);
268 static enBTRCoreRet btrMgr_ConnectionInIntimationCb (stBTRCoreConnCBInfo* apstConnCbInfo, int* api32ConnInIntimResp, void* apvUserData);
269 static enBTRCoreRet btrMgr_ConnectionInAuthenticationCb (stBTRCoreConnCBInfo* apstConnCbInfo, int* api32ConnInAuthResp, void* apvUserData);
270 static enBTRCoreRet btrMgr_MediaStatusCb (stBTRCoreMediaStatusCBInfo* mediaStatusCB, void* apvUserData);
271 
272 #ifdef RDKTV_PERSIST_VOLUME_SKY
273 static eBTRMgrRet btrMgr_SetLastVolume(unsigned char aui8AdapterIdx, unsigned char ui8Volume);
274 static eBTRMgrRet btrMgr_GetLastVolume(unsigned char aui8AdapterIdx, unsigned char *pVolume);
275 static eBTRMgrRet btrMgr_SetLastMuteState(unsigned char aui8AdapterIdx, gboolean Mute);
276 static eBTRMgrRet btrMgr_GetLastMuteState(unsigned char aui8AdapterIdx, gboolean *pMute);
277 #endif
278 
279 /* Static Function Definitions */
280 static inline unsigned char
281 btrMgr_GetAdapterCnt (
282  void
283 ) {
284  return gListOfAdapters.number_of_adapters;
285 }
286 
287 static const char*
288 btrMgr_GetAdapterPath (
289  unsigned char aui8AdapterIdx
290 ) {
291  const char* pReturn = NULL;
292 
293  if (gListOfAdapters.number_of_adapters) {
294  if ((aui8AdapterIdx < gListOfAdapters.number_of_adapters) && (aui8AdapterIdx < BTRCORE_MAX_NUM_BT_ADAPTERS)) {
295  pReturn = gListOfAdapters.adapter_path[aui8AdapterIdx];
296  }
297  }
298 
299  return pReturn;
300 }
301 
302 static inline void
303 btrMgr_SetAgentActivated (
304  unsigned char aui8AgentActivated
305 ) {
306  gIsAgentActivated = aui8AgentActivated;
307 }
308 
309 static inline unsigned char
310 btrMgr_GetAgentActivated (
311  void
312 ) {
313  return gIsAgentActivated;
314 }
315 
316 
317 static void
318 btrMgr_CheckAudioInServiceAvailability (
319  void
320 ) {
321 #ifdef BUILD_FOR_PI
322  //Since RFC is not enabled for PI devices, enabling by default
323  gIsAudioInEnabled = 1;
324  BTRMGRLOG_INFO ("Enabling BTR AudioIn Service for raspberry pi devices.\n");
325 #else
326  RFC_ParamData_t param = {0};
327  /* We shall make this api generic and macro defined tr181 params as we start to enable diff services based on RFC */
328  WDMP_STATUS status = getRFCParameter("BTRMGR", "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.BTR.AudioIn.Enable", &param);
329 
330  if (status == WDMP_SUCCESS) {
331  BTRMGRLOG_DEBUG ("name = %s, type = %d, value = %s\n", param.name, param.type, param.value);
332 
333  if (!strncmp(param.value, "true", strlen("true"))) {
334  gIsAudioInEnabled = 1;
335  BTRMGRLOG_INFO ("BTR AudioIn Serivce will be available.\n");
336  }
337  else {
338  BTRMGRLOG_INFO ("BTR AudioIn Serivce will not be available.\n");
339  }
340  }
341  else {
342  BTRMGRLOG_ERROR ("getRFCParameter Failed : %s\n", getRFCErrorString(status));
343  }
344 #endif
345 }
346 
347 static void
348 btrMgr_CheckHidGamePadServiceAvailability (
349  void
350 ) {
351 #ifdef BUILD_FOR_PI
352  //Since RFC is not enabled for PI devices, enabling by default
353  gIsHidGamePadEnabled = 1;
354  BTRMGRLOG_INFO ("Enabling BTR HidGamePad Service for raspberry pi devices.\n");
355 #else
356  RFC_ParamData_t param = {0};
357  /* We shall make this api generic and macro defined tr181 params as we start to enable diff services based on RFC */
358  WDMP_STATUS status = getRFCParameter("BTRMGR", "Device.DeviceInfo.X_RDKCENTRAL-COM_RFC.Feature.BTR.GamePad.Enable", &param);
359 
360  if (status == WDMP_SUCCESS) {
361  BTRMGRLOG_DEBUG ("name = %s, type = %d, value = %s\n", param.name, param.type, param.value);
362 
363  if (!strncmp(param.value, "true", strlen("true"))) {
364  gIsHidGamePadEnabled = 1;
365  BTRMGRLOG_INFO ("BTR HidGamePad Serivce will be available.\n");
366  }
367  else {
368  BTRMGRLOG_INFO ("BTR HidGamePad Serivce will not be available.\n");
369  }
370  }
371  else {
372  BTRMGRLOG_ERROR ("getRFCParameter Failed : %s\n", getRFCErrorString(status));
373  }
374 #endif
375 }
376 
377 static const char*
378 btrMgr_GetDiscoveryDeviceTypeAsString (
379  BTRMGR_DeviceOperationType_t adevOpType
380 ) {
381  char* opType = NULL;
382 
383  switch (adevOpType) {
384  case BTRMGR_DEVICE_OP_TYPE_AUDIO_OUTPUT:
385  opType = "AUDIO_OUT";
386  break;
387  case BTRMGR_DEVICE_OP_TYPE_AUDIO_INPUT:
388  opType = "AUDIO_IN";
389  break;
390  case BTRMGR_DEVICE_OP_TYPE_LE:
391  opType = "LE";
392  break;
393  case BTRMGR_DEVICE_OP_TYPE_HID:
394  opType = "HID";
395  break;
396  case BTRMGR_DEVICE_OP_TYPE_UNKNOWN:
397  opType = "UNKNOWN";
398  }
399 
400  return opType;
401 }
402 
403 #if 0
404 static const char*
405 btrMgr_GetDiscoveryFilterAsString (
406  BTRMGR_ScanFilter_t ascanFlt
407 ) {
408  char* filter = NULL;
409 
410  switch (ascanFlt) {
411  case BTRMGR_DISCOVERY_FILTER_UUID:
412  filter = "UUID";
413  break;
414  case BTRMGR_DISCOVERY_FILTER_RSSI:
415  filter = "RSSI";
416  break;
417  case BTRMGR_DISCOVERY_FILTER_PATH_LOSS:
418  filter = "PATH_LOSS";
419  break;
420  case BTRMGR_DISCOVERY_FILTER_SCAN_TYPE:
421  filter = "SCAN_TYPE";
422  }
423 
424  return filter;
425 }
426 #endif
427 
428 static const char*
429 btrMgr_GetDiscoveryStateAsString (
430  BTRMGR_DiscoveryState_t aScanStatus
431 ) {
432  char* state = NULL;
433 
434  switch (aScanStatus) {
435  case BTRMGR_DISCOVERY_ST_STARTED:
436  state = "ST_STARTED";
437  break;
438  case BTRMGR_DISCOVERY_ST_PAUSED:
439  state = "ST_PAUSED";
440  break;
441  case BTRMGR_DISCOVERY_ST_RESUMED:
442  state = "ST_RESUMED";
443  break;
444  case BTRMGR_DISCOVERY_ST_STOPPED:
445  state = "ST_STOPPED";
446  break;
447  case BTRMGR_DISCOVERY_ST_UNKNOWN:
448  default:
449  state = "ST_UNKNOWN";
450  }
451 
452  return state;
453 }
454 
455 static inline void
456 btrMgr_SetBgDiscoveryType (
457  BTRMGR_DeviceOperationType_t adevOpType
458 ) {
459  gBgDiscoveryType = adevOpType;
460 }
461 
462 static inline void
463 btrMgr_SetDiscoveryState (
464  BTRMGR_DiscoveryHandle_t* ahdiscoveryHdl,
465  BTRMGR_DiscoveryState_t aScanStatus
466 ) {
467  ahdiscoveryHdl->m_disStatus = aScanStatus;
468 }
469 
470 static inline void
471 btrMgr_SetDiscoveryDeviceType (
472  BTRMGR_DiscoveryHandle_t* ahdiscoveryHdl,
473  BTRMGR_DeviceOperationType_t aeDevOpType
474 ) {
475  ahdiscoveryHdl->m_devOpType = aeDevOpType;
476 }
477 
478 static inline BTRMGR_DeviceOperationType_t
479 btrMgr_GetBgDiscoveryType (
480  void
481 ) {
482  return gBgDiscoveryType;
483 }
484 
485 static inline BTRMGR_DiscoveryState_t
486 btrMgr_GetDiscoveryState (
487  BTRMGR_DiscoveryHandle_t* ahdiscoveryHdl
488 ) {
489  return ahdiscoveryHdl->m_disStatus;
490 }
491 
492 static inline BTRMGR_DeviceOperationType_t
493 btrMgr_GetDiscoveryDeviceType (
494  BTRMGR_DiscoveryHandle_t* ahdiscoveryHdl
495 ) {
496  return ahdiscoveryHdl->m_devOpType;
497 }
498 
499 static inline void
500 btrMgr_SetDiscoveryHandle (
501  BTRMGR_DeviceOperationType_t aDevOpType,
502  BTRMGR_DiscoveryState_t aScanStatus
503 ) {
504  BTRMGR_DiscoveryHandle_t* ldiscoveryHdl = NULL;
505 
506  if (aDevOpType == btrMgr_GetBgDiscoveryType()) {
507  ldiscoveryHdl = &ghBTRMgrBgDiscoveryHdl;
508  }
509  else {
510  ldiscoveryHdl = &ghBTRMgrDiscoveryHdl;
511  }
512 
513 
514  if (btrMgr_GetDiscoveryState(ldiscoveryHdl) != BTRMGR_DISCOVERY_ST_PAUSED) {
515  btrMgr_SetDiscoveryDeviceType (ldiscoveryHdl, aDevOpType);
516  btrMgr_SetDiscoveryState (ldiscoveryHdl, aScanStatus);
517  // set Filter in the handle from the global Filter
518  }
519 }
520 
521 #if 0
522 static inline BTRMGR_DiscoveryFilterHandle_t*
523 btrMgr_GetDiscoveryFilter (
524  BTRMGR_DiscoveryHandle_t* ahdiscoveryHdl
525 ) {
526  return &ahdiscoveryHdl->m_disFilter;
527 }
528 #endif
529 
530 static inline gboolean
531 btrMgr_isTimeOutSet (
532  void
533 ) {
534  return (gTimeOutRef > 0) ? TRUE : FALSE;
535 }
536 
537 static inline void
538 btrMgr_ClearDiscoveryHoldOffTimer (
539  void
540 ) {
541  if (gTimeOutRef) {
542  BTRMGRLOG_DEBUG ("Cancelling previous Discovery hold off TimeOut Session : %u\n", gTimeOutRef);
543  g_source_remove (gTimeOutRef);
544  gTimeOutRef = 0;
545  }
546 }
547 
548 static inline void
549 btrMgr_SetDiscoveryHoldOffTimer (
550  unsigned char aui8AdapterIdx
551 ) {
552  gDiscHoldOffTimeOutCbData = aui8AdapterIdx;
553  gTimeOutRef = g_timeout_add_seconds (BTRMGR_DISCOVERY_HOLD_OFF_TIME, btrMgr_DiscoveryHoldOffTimerCb, (gpointer)&gDiscHoldOffTimeOutCbData);
554  BTRMGRLOG_ERROR ("DiscoveryHoldOffTimeOut set to +%u seconds || TimeOutReference : %u\n", BTRMGR_DISCOVERY_HOLD_OFF_TIME, gTimeOutRef);
555 }
556 
557 #if 0
558 static eBTRMgrRet
559 btrMgr_SetDiscoveryFilter (
560  BTRMGR_DiscoveryHandle_t* ahdiscoveryHdl,
561  BTRMGR_ScanFilter_t aeScanFilterType,
562  void* aFilterValue
563 ) {
564  BTRMGR_DiscoveryFilterHandle_t* ldisFilter = btrMgr_GetDiscoveryFilter(ahdiscoveryHdl);
565 
566  if (btrMgr_GetDiscoveryState(ahdiscoveryHdl) != BTRMGR_DISCOVERY_ST_INITIALIZING){
567  BTRMGRLOG_ERROR ("Not in Initializing state !!!. Current state is %s\n"
568  , btrMgr_GetDiscoveryStateAsString (btrMgr_GetDiscoveryState(ahdiscoveryHdl)));
569  return eBTRMgrFailure;
570  }
571 
572  switch (aeScanFilterType) {
573  case BTRMGR_DISCOVERY_FILTER_UUID:
574  ldisFilter->m_btuuid.m_uuid = (char**) realloc (ldisFilter->m_btuuid.m_uuid, (sizeof(char*) * (++ldisFilter->m_btuuid.m_uuidCount)));
575  ldisFilter->m_btuuid.m_uuid[ldisFilter->m_btuuid.m_uuidCount] = (char*) malloc (BTRMGR_NAME_LEN_MAX);
576  strncpy (ldisFilter->m_btuuid.m_uuid[ldisFilter->m_btuuid.m_uuidCount-1], (char*)aFilterValue, BTRMGR_NAME_LEN_MAX-1);
577  break;
578  case BTRMGR_DISCOVERY_FILTER_RSSI:
579  ldisFilter->m_rssi = *(short*)aFilterValue;
580  break;
581  case BTRMGR_DISCOVERY_FILTER_PATH_LOSS:
582  ldisFilter->m_pathloss = *(short*)aFilterValue;
583  break;
584  case BTRMGR_DISCOVERY_FILTER_SCAN_TYPE:
585  ldisFilter->m_scanType = *(BTRMGR_DeviceScanType_t*)aFilterValue;
586  }
587 
588  BTRMGRLOG_DEBUG ("Discovery Filter is set successfully with the given %s...\n"
589  , btrMgr_GetDiscoveryFilterAsString(aeScanFilterType));
590 
591  return eBTRMgrSuccess;
592 }
593 
594 static eBTRMgrRet
595 btrMgr_ClearDiscoveryFilter (
596  BTRMGR_DiscoveryHandle_t* ahdiscoveryHdl
597 ) {
598  BTRMGR_DiscoveryFilterHandle_t* ldisFilter = btrMgr_GetDiscoveryFilter(ahdiscoveryHdl);
599 
600  if (btrMgr_GetDiscoveryState(ahdiscoveryHdl) == BTRMGR_DISCOVERY_ST_INITIALIZED ||
601  btrMgr_GetDiscoveryState(ahdiscoveryHdl) == BTRMGR_DISCOVERY_ST_STARTED ||
602  btrMgr_GetDiscoveryState(ahdiscoveryHdl) == BTRMGR_DISCOVERY_ST_RESUMED ||
603  btrMgr_GetDiscoveryState(ahdiscoveryHdl) == BTRMGR_DISCOVERY_ST_PAUSED ){
604  BTRMGRLOG_WARN ("Cannot clear Discovery Filter when Discovery is in %s\n"
605  , btrMgr_GetDiscoveryStateAsString(btrMgr_GetDiscoveryState(ahdiscoveryHdl)));
606  return eBTRMgrFailure;
607  }
608 
609  if (ldisFilter->m_btuuid.m_uuidCount) {
610  while (ldisFilter->m_btuuid.m_uuidCount) {
611  free (ldisFilter->m_btuuid.m_uuid[ldisFilter->m_btuuid.m_uuidCount-1]);
612  ldisFilter->m_btuuid.m_uuid[ldisFilter->m_btuuid.m_uuidCount-1] = NULL;
613  ldisFilter->m_btuuid.m_uuidCount--;
614  }
615  free (ldisFilter->m_btuuid.m_uuid);
616  }
617 
618  ldisFilter->m_btuuid.m_uuid = NULL;
619  ldisFilter->m_rssi = 0;
620  ldisFilter->m_pathloss = 0;
621  ldisFilter->m_scanType = BTRMGR_DEVICE_SCAN_TYPE_AUTO;
622 
623  return eBTRMgrSuccess;
624 }
625 #endif
626 
627 static BTRMGR_DiscoveryHandle_t*
628 btrMgr_GetDiscoveryInProgress (
629  void
630 ) {
631  BTRMGR_DiscoveryHandle_t* ldiscoveryHdl = NULL;
632 
633  if (btrMgr_GetDiscoveryState(&ghBTRMgrDiscoveryHdl) == BTRMGR_DISCOVERY_ST_STARTED ||
634  btrMgr_GetDiscoveryState(&ghBTRMgrDiscoveryHdl) == BTRMGR_DISCOVERY_ST_RESUMED ){
635  ldiscoveryHdl = &ghBTRMgrDiscoveryHdl;
636  }
637  else if (btrMgr_GetDiscoveryState(&ghBTRMgrBgDiscoveryHdl) == BTRMGR_DISCOVERY_ST_STARTED ||
638  btrMgr_GetDiscoveryState(&ghBTRMgrBgDiscoveryHdl) == BTRMGR_DISCOVERY_ST_RESUMED ){
639  ldiscoveryHdl = &ghBTRMgrBgDiscoveryHdl;
640  }
641 
642  if (ldiscoveryHdl) {
643  BTRMGRLOG_DEBUG ("[%s] Scan in Progress...\n"
644  , btrMgr_GetDiscoveryDeviceTypeAsString (btrMgr_GetDiscoveryDeviceType(ldiscoveryHdl)));
645  }
646 
647  return ldiscoveryHdl;
648 }
649 
650 static eBTRMgrRet
651 btrMgr_PauseDeviceDiscovery (
652  unsigned char aui8AdapterIdx,
653  BTRMGR_DiscoveryHandle_t* ahdiscoveryHdl
654 ) {
655  eBTRMgrRet lenBtrMgrRet = eBTRMgrSuccess;
656 
657  if (btrMgr_GetDiscoveryState(ahdiscoveryHdl) == BTRMGR_DISCOVERY_ST_STARTED ||
658  btrMgr_GetDiscoveryState(ahdiscoveryHdl) == BTRMGR_DISCOVERY_ST_RESUMED ){
659 
660  if (BTRMGR_RESULT_SUCCESS == BTRMGR_StopDeviceDiscovery_Internal (aui8AdapterIdx, btrMgr_GetDiscoveryDeviceType(ahdiscoveryHdl))) {
661 
662  btrMgr_SetDiscoveryState (ahdiscoveryHdl, BTRMGR_DISCOVERY_ST_PAUSED);
663  BTRMGRLOG_DEBUG ("[%s] Successfully Paused Scan\n"
664  , btrMgr_GetDiscoveryDeviceTypeAsString (btrMgr_GetDiscoveryDeviceType(ahdiscoveryHdl)));
665  }
666  else {
667  BTRMGRLOG_ERROR ("[%s] Failed to Pause Scan\n"
668  , btrMgr_GetDiscoveryDeviceTypeAsString (btrMgr_GetDiscoveryDeviceType(ahdiscoveryHdl)));
669  lenBtrMgrRet = eBTRMgrFailure;
670  }
671  }
672  return lenBtrMgrRet;
673 }
674 
675 static eBTRMgrRet
676 btrMgr_ResumeDeviceDiscovery (
677  unsigned char aui8AdapterIdx,
678  BTRMGR_DiscoveryHandle_t* ahdiscoveryHdl
679 ) {
680  eBTRMgrRet lenBtrMgrRet = eBTRMgrSuccess;
681 
682  if (btrMgr_GetDiscoveryState(ahdiscoveryHdl) != BTRMGR_DISCOVERY_ST_PAUSED) {
683  BTRMGRLOG_WARN ("\n[%s] Device Discovery Resume is requested, but current state is %s !!!\n"
684  , btrMgr_GetDiscoveryDeviceTypeAsString (btrMgr_GetDiscoveryDeviceType(ahdiscoveryHdl))
685  , btrMgr_GetDiscoveryStateAsString (btrMgr_GetDiscoveryState(ahdiscoveryHdl)));
686  BTRMGRLOG_WARN ("\n Still continuing to Resume Discovery\n");
687  }
688 #if 0
689  if (enBTRCoreSuccess != BTRCore_ApplyDiscoveryFilter (btrMgr_GetDiscoveryFilter(ahdiscoveryHdl))) {
690  BTRMGRLOG_ERROR ("[%s] Failed to set Discovery Filter!!!"
691  , btrMgr_GetDiscoveryDeviceTypeAsString (btrMgr_GetDiscoveryDeviceType(ahdiscoveryHdl)));
692  lenBtrMgrRet = eBTRMgrFailure;
693  }
694  else {
695 #endif
696  if (BTRMGR_RESULT_SUCCESS == BTRMGR_StartDeviceDiscovery_Internal (aui8AdapterIdx, btrMgr_GetDiscoveryDeviceType(ahdiscoveryHdl))) {
697 
698  //TODO: Move before you make the call to StartDeviceDiscovery, store the previous state and restore the previous state in case of Failure
699  btrMgr_SetDiscoveryState (ahdiscoveryHdl, BTRMGR_DISCOVERY_ST_RESUMED);
700  BTRMGRLOG_DEBUG ("[%s] Successfully Resumed Scan\n"
701  , btrMgr_GetDiscoveryDeviceTypeAsString (btrMgr_GetDiscoveryDeviceType(ahdiscoveryHdl)));
702  } else {
703  BTRMGRLOG_ERROR ("[%s] Failed Resume Scan!!!\n"
704  , btrMgr_GetDiscoveryDeviceTypeAsString (btrMgr_GetDiscoveryDeviceType(ahdiscoveryHdl)));
705  lenBtrMgrRet = eBTRMgrFailure;
706  }
707 #if 0
708  }
709 #endif
710 
711  return lenBtrMgrRet;
712 }
713 
714 static eBTRMgrRet
715 btrMgr_StopDeviceDiscovery (
716  unsigned char aui8AdapterIdx,
717  BTRMGR_DiscoveryHandle_t* ahdiscoveryHdl
718 ) {
719  eBTRMgrRet lenBtrMgrRet = eBTRMgrSuccess;
720 
721  if (btrMgr_GetDiscoveryState(ahdiscoveryHdl) == BTRMGR_DISCOVERY_ST_STARTED ||
722  btrMgr_GetDiscoveryState(ahdiscoveryHdl) == BTRMGR_DISCOVERY_ST_RESUMED ){
723 
724  if (BTRMGR_RESULT_SUCCESS == BTRMGR_StopDeviceDiscovery_Internal (aui8AdapterIdx, btrMgr_GetDiscoveryDeviceType(ahdiscoveryHdl))) {
725 
726  BTRMGRLOG_DEBUG ("[%s] Successfully Stopped scan\n"
727  , btrMgr_GetDiscoveryDeviceTypeAsString (btrMgr_GetDiscoveryDeviceType(ahdiscoveryHdl)));
728  }
729  else {
730  BTRMGRLOG_ERROR ("[%s] Failed to Stop scan\n"
731  , btrMgr_GetDiscoveryDeviceTypeAsString (btrMgr_GetDiscoveryDeviceType(ahdiscoveryHdl)));
732  lenBtrMgrRet = eBTRMgrFailure;
733  }
734  }
735  return lenBtrMgrRet;
736 }
737 
738 static eBTRMgrRet
739 btrMgr_PreCheckDiscoveryStatus (
740  unsigned char aui8AdapterIdx,
741  BTRMGR_DeviceOperationType_t aDevOpType
742 ) {
743  eBTRMgrRet lenBtrMgrRet = eBTRMgrSuccess;
744  BTRMGR_DiscoveryHandle_t* ldiscoveryHdl = NULL;
745 
746  if ((ldiscoveryHdl = btrMgr_GetDiscoveryInProgress())) {
747 
748  if ( btrMgr_GetDiscoveryDeviceType(ldiscoveryHdl) == btrMgr_GetBgDiscoveryType()) {
749  BTRMGRLOG_WARN ("Calling btrMgr_PauseDeviceDiscovery\n");
750  lenBtrMgrRet = btrMgr_PauseDeviceDiscovery (aui8AdapterIdx, ldiscoveryHdl);
751  }
752  else if (aDevOpType != btrMgr_GetBgDiscoveryType()) {
753  BTRMGRLOG_WARN ("Calling btrMgr_StopDeviceDiscovery\n");
754  lenBtrMgrRet = btrMgr_StopDeviceDiscovery (aui8AdapterIdx, ldiscoveryHdl);
755  }
756  else {
757  BTRMGRLOG_WARN ("[%s] Scan in Progress.. Request for %s operation is rejected...\n"
758  , btrMgr_GetDiscoveryDeviceTypeAsString (btrMgr_GetDiscoveryDeviceType(ldiscoveryHdl))
759  , btrMgr_GetDiscoveryDeviceTypeAsString (aDevOpType));
760  lenBtrMgrRet = eBTRMgrFailure;
761  }
762  }
763  else if (btrMgr_isTimeOutSet()) {
764  if (aDevOpType == btrMgr_GetBgDiscoveryType()) {
765  BTRMGRLOG_WARN ("[NON-%s] Operation in Progress.. Request for %s operation is rejected...\n"
766  , btrMgr_GetDiscoveryDeviceTypeAsString (aDevOpType)
767  , btrMgr_GetDiscoveryDeviceTypeAsString (aDevOpType));
768  lenBtrMgrRet = eBTRMgrFailure;
769  }
770  }
771 
772  if (aDevOpType != btrMgr_GetBgDiscoveryType()) {
773  btrMgr_ClearDiscoveryHoldOffTimer();
774  }
775 
776  return lenBtrMgrRet;
777 }
778 
779 static eBTRMgrRet
780 btrMgr_PostCheckDiscoveryStatus (
781  unsigned char aui8AdapterIdx,
782  BTRMGR_DeviceOperationType_t aDevOpType
783 ) {
784  eBTRMgrRet lenBtrMgrRet = eBTRMgrSuccess;
785 
786  if (!btrMgr_isTimeOutSet()) {
787  if (aDevOpType == BTRMGR_DEVICE_OP_TYPE_UNKNOWN) {
788  if (btrMgr_GetDiscoveryState(&ghBTRMgrBgDiscoveryHdl) == BTRMGR_DISCOVERY_ST_PAUSED) {
789  BTRMGRLOG_WARN ("Calling btrMgr_ResumeDeviceDiscovery\n");
790  lenBtrMgrRet = btrMgr_ResumeDeviceDiscovery (aui8AdapterIdx, &ghBTRMgrBgDiscoveryHdl);
791  }
792  }
793  else
794  if (aDevOpType != btrMgr_GetBgDiscoveryType()) {
795  if (btrMgr_GetDiscoveryState(&ghBTRMgrBgDiscoveryHdl) == BTRMGR_DISCOVERY_ST_PAUSED) {
796  btrMgr_SetDiscoveryHoldOffTimer(aui8AdapterIdx);
797  }
798  }
799  }
800 
801  return lenBtrMgrRet;
802 }
803 
804 
805 static void
806 btrMgr_GetDiscoveredDevInfo (
807  BTRMgrDeviceHandle ahBTRMgrDevHdl,
808  BTRMGR_DiscoveredDevices_t* apBtMgrDiscDevInfo
809 ) {
810  int j = 0;
811 
812  for (j = 0; j < gListOfDiscoveredDevices.m_numOfDevices; j++) {
813  if (ahBTRMgrDevHdl == gListOfDiscoveredDevices.m_deviceProperty[j].m_deviceHandle) {
814  memcpy(apBtMgrDiscDevInfo, &gListOfDiscoveredDevices.m_deviceProperty[j], sizeof(BTRMGR_DiscoveredDevices_t));;
815  }
816  }
817 }
818 
819 
820 static void
821 btrMgr_GetPairedDevInfo (
822  BTRMgrDeviceHandle ahBTRMgrDevHdl,
823  BTRMGR_PairedDevices_t* apBtMgrPairedDevInfo
824 ) {
825  int j = 0;
826 
827  for (j = 0; j < gListOfPairedDevices.m_numOfDevices; j++) {
828  if (ahBTRMgrDevHdl == gListOfPairedDevices.m_deviceProperty[j].m_deviceHandle) {
829  memcpy(apBtMgrPairedDevInfo, &gListOfPairedDevices.m_deviceProperty[j], sizeof(BTRMGR_PairedDevices_t));
830  break;
831  }
832  }
833 }
834 
835 
836 static unsigned char
837 btrMgr_GetDevPaired (
838  BTRMgrDeviceHandle ahBTRMgrDevHdl
839 ) {
840  int j = 0;
841 
842  for (j = 0; j < gListOfPairedDevices.m_numOfDevices; j++) {
843  if (ahBTRMgrDevHdl == gListOfPairedDevices.m_deviceProperty[j].m_deviceHandle) {
844  return 1;
845  }
846  }
847 
848  return 0;
849 }
850 
851 
852 static void
853 btrMgr_SetDevConnected (
854  BTRMgrDeviceHandle ahBTRMgrDevHdl,
855  unsigned char aui8isDeviceConnected
856 ) {
857  int i = 0;
858 
859  for (i = 0; i < gListOfPairedDevices.m_numOfDevices; i++) {
860  if (ahBTRMgrDevHdl == gListOfPairedDevices.m_deviceProperty[i].m_deviceHandle) {
861  gListOfPairedDevices.m_deviceProperty[i].m_isConnected = aui8isDeviceConnected;
862  BTRMGRLOG_WARN ("Setting = %lld - \tConnected = %d\n", ahBTRMgrDevHdl, aui8isDeviceConnected);
863  break;
864  }
865  }
866 }
867 
868 
869 static unsigned char
870 btrMgr_IsDevConnected (
871  BTRMgrDeviceHandle ahBTRMgrDevHdl
872 ) {
873  unsigned char lui8isDeviceConnected = 0;
874  int i = 0;
875 
876  for (i = 0; i < gListOfPairedDevices.m_numOfDevices; i++) {
877  if (ahBTRMgrDevHdl == gListOfPairedDevices.m_deviceProperty[i].m_deviceHandle) {
878  lui8isDeviceConnected = gListOfPairedDevices.m_deviceProperty[i].m_isConnected;
879  BTRMGRLOG_WARN ("Getting = %lld - \tConnected = %d\n", ahBTRMgrDevHdl, lui8isDeviceConnected);
880  }
881  }
882 
883  return lui8isDeviceConnected;
884 }
885 
886 
887 static unsigned char
888 btrMgr_IsDevNameSameAsAddress (
889  char* apcDeviceName,
890  char* apcDeviceAddress,
891  unsigned int ui32StrLen
892 ) {
893  if (ui32StrLen > 17)
894  return 0;
895 
896 
897  if ((apcDeviceName[0] == apcDeviceAddress[0]) &&
898  (apcDeviceName[1] == apcDeviceAddress[1]) &&
899  (apcDeviceName[3] == apcDeviceAddress[3]) &&
900  (apcDeviceName[4] == apcDeviceAddress[4]) &&
901  (apcDeviceName[6] == apcDeviceAddress[6]) &&
902  (apcDeviceName[7] == apcDeviceAddress[7]) &&
903  (apcDeviceName[9] == apcDeviceAddress[9]) &&
904  (apcDeviceName[10] == apcDeviceAddress[10]) &&
905  (apcDeviceName[12] == apcDeviceAddress[12]) &&
906  (apcDeviceName[13] == apcDeviceAddress[13]) &&
907  (apcDeviceName[15] == apcDeviceAddress[15]) &&
908  (apcDeviceName[16] == apcDeviceAddress[16]) ) {
909  return 1;
910  }
911  else {
912  return 0;
913  }
914 }
915 
916 
917 static unsigned char
918 btrMgr_CheckIfDevicePrevDetected (
919  BTRMgrDeviceHandle ahBTRMgrDevHdl
920 ) {
921  int j = 0;
922 
923  for (j = 0; j < gListOfDiscoveredDevices.m_numOfDevices; j++) {
924  if (ahBTRMgrDevHdl == gListOfDiscoveredDevices.m_deviceProperty[j].m_deviceHandle) {
925  BTRMGRLOG_WARN ("DevicePrevDetected = %lld - %s\n", gListOfDiscoveredDevices.m_deviceProperty[j].m_deviceHandle, gListOfDiscoveredDevices.m_deviceProperty[j].m_name);
926  return 1;
927  }
928  }
929 
930  return 0;
931 }
932 
933 
934 static BTRMGR_DeviceType_t
935 btrMgr_MapDeviceTypeFromCore (
936  enBTRCoreDeviceClass device_type
937 ) {
938  BTRMGR_DeviceType_t type = BTRMGR_DEVICE_TYPE_UNKNOWN;
939  switch (device_type) {
940  case enBTRCore_DC_Tablet:
941  type = BTRMGR_DEVICE_TYPE_TABLET;
942  break;
943  case enBTRCore_DC_SmartPhone:
944  type = BTRMGR_DEVICE_TYPE_SMARTPHONE;
945  break;
946  case enBTRCore_DC_WearableHeadset:
947  type = BTRMGR_DEVICE_TYPE_WEARABLE_HEADSET;
948  break;
949  case enBTRCore_DC_Handsfree:
950  type = BTRMGR_DEVICE_TYPE_HANDSFREE;
951  break;
952  case enBTRCore_DC_Microphone:
953  type = BTRMGR_DEVICE_TYPE_MICROPHONE;
954  break;
955  case enBTRCore_DC_Loudspeaker:
956  type = BTRMGR_DEVICE_TYPE_LOUDSPEAKER;
957  break;
958  case enBTRCore_DC_Headphones:
959  type = BTRMGR_DEVICE_TYPE_HEADPHONES;
960  break;
961  case enBTRCore_DC_PortableAudio:
962  // type = BTRMGR_DEVICE_TYPE_PORTABLE_AUDIO;
963  type = BTRMGR_DEVICE_TYPE_LOUDSPEAKER;
964  break;
965  case enBTRCore_DC_CarAudio:
966  // type = BTRMGR_DEVICE_TYPE_CAR_AUDIO;
967  type = BTRMGR_DEVICE_TYPE_LOUDSPEAKER;
968  break;
969  case enBTRCore_DC_STB:
970  type = BTRMGR_DEVICE_TYPE_STB;
971  break;
972  case enBTRCore_DC_HIFIAudioDevice:
973  // type = BTRMGR_DEVICE_TYPE_HIFI_AUDIO_DEVICE;
974  type = BTRMGR_DEVICE_TYPE_LOUDSPEAKER;
975  break;
976  case enBTRCore_DC_VCR:
977  type = BTRMGR_DEVICE_TYPE_VCR;
978  break;
979  case enBTRCore_DC_VideoCamera:
980  type = BTRMGR_DEVICE_TYPE_VIDEO_CAMERA;
981  break;
982  case enBTRCore_DC_Camcoder:
983  type = BTRMGR_DEVICE_TYPE_CAMCODER;
984  break;
985  case enBTRCore_DC_VideoMonitor:
986  type = BTRMGR_DEVICE_TYPE_VIDEO_MONITOR;
987  break;
988  case enBTRCore_DC_TV:
989  type = BTRMGR_DEVICE_TYPE_TV;
990  break;
991  case enBTRCore_DC_VideoConference:
992  type = BTRMGR_DEVICE_TYPE_VIDEO_CONFERENCE;
993  break;
994  case enBTRCore_DC_Tile:
995  type = BTRMGR_DEVICE_TYPE_TILE;
996  break;
997  case enBTRCore_DC_HID_Keyboard:
998  type = BTRMGR_DEVICE_TYPE_HID;
999  break;
1000  case enBTRCore_DC_HID_Mouse:
1001  type = BTRMGR_DEVICE_TYPE_HID;
1002  break;
1003  case enBTRCore_DC_HID_MouseKeyBoard:
1004  type = BTRMGR_DEVICE_TYPE_HID;
1005  break;
1006  case enBTRCore_DC_HID_Joystick:
1007  type = BTRMGR_DEVICE_TYPE_HID;
1008  break;
1009  case enBTRCore_DC_HID_GamePad:
1010  type = BTRMGR_DEVICE_TYPE_HID_GAMEPAD;
1011  break;
1012  case enBTRCore_DC_HID_AudioRemote:
1013  type = BTRMGR_DEVICE_TYPE_HID;
1014  break;
1015  case enBTRCore_DC_Reserved:
1016  case enBTRCore_DC_Unknown:
1017  type = BTRMGR_DEVICE_TYPE_UNKNOWN;
1018  break;
1019  }
1020 
1021  return type;
1022 }
1023 
1024 static BTRMGR_DeviceOperationType_t
1025 btrMgr_MapDeviceOpFromDeviceType (
1026  BTRMGR_DeviceType_t device_type
1027 ) {
1028  BTRMGR_DeviceOperationType_t devOpType = BTRMGR_DEVICE_OP_TYPE_UNKNOWN;
1029 
1030  switch (device_type) {
1031  case BTRMGR_DEVICE_TYPE_WEARABLE_HEADSET:
1032  case BTRMGR_DEVICE_TYPE_HANDSFREE:
1033  case BTRMGR_DEVICE_TYPE_LOUDSPEAKER:
1034  case BTRMGR_DEVICE_TYPE_HEADPHONES:
1035  case BTRMGR_DEVICE_TYPE_PORTABLE_AUDIO:
1036  case BTRMGR_DEVICE_TYPE_CAR_AUDIO:
1037  case BTRMGR_DEVICE_TYPE_HIFI_AUDIO_DEVICE:
1038  devOpType = BTRMGR_DEVICE_OP_TYPE_AUDIO_OUTPUT;
1039  break;
1040  case BTRMGR_DEVICE_TYPE_SMARTPHONE:
1041  case BTRMGR_DEVICE_TYPE_TABLET:
1042  devOpType = BTRMGR_DEVICE_OP_TYPE_AUDIO_INPUT;
1043  break;
1044  case BTRMGR_DEVICE_TYPE_TILE:
1045  devOpType = BTRMGR_DEVICE_OP_TYPE_LE;
1046  break;
1047  case BTRMGR_DEVICE_TYPE_HID:
1048  case BTRMGR_DEVICE_TYPE_HID_GAMEPAD:
1049  devOpType = BTRMGR_DEVICE_OP_TYPE_HID;
1050  break;
1051  case BTRMGR_DEVICE_TYPE_STB:
1052  case BTRMGR_DEVICE_TYPE_MICROPHONE:
1053  case BTRMGR_DEVICE_TYPE_VCR:
1054  case BTRMGR_DEVICE_TYPE_VIDEO_CAMERA:
1055  case BTRMGR_DEVICE_TYPE_CAMCODER:
1056  case BTRMGR_DEVICE_TYPE_VIDEO_MONITOR:
1057  case BTRMGR_DEVICE_TYPE_TV:
1058  case BTRMGR_DEVICE_TYPE_VIDEO_CONFERENCE:
1059  case BTRMGR_DEVICE_TYPE_RESERVED:
1060  case BTRMGR_DEVICE_TYPE_UNKNOWN:
1061  default:
1062  devOpType = BTRMGR_DEVICE_OP_TYPE_UNKNOWN;
1063  }
1064 
1065  return devOpType;
1066 }
1067 
1068 static BTRMGR_RSSIValue_t
1069 btrMgr_MapSignalStrengthToRSSI (
1070  int signalStrength
1071 ) {
1072  BTRMGR_RSSIValue_t rssi = BTRMGR_RSSI_NONE;
1073 
1074  if (signalStrength >= BTRMGR_SIGNAL_GOOD)
1075  rssi = BTRMGR_RSSI_EXCELLENT;
1076  else if (signalStrength >= BTRMGR_SIGNAL_FAIR)
1077  rssi = BTRMGR_RSSI_GOOD;
1078  else if (signalStrength >= BTRMGR_SIGNAL_POOR)
1079  rssi = BTRMGR_RSSI_FAIR;
1080  else
1081  rssi = BTRMGR_RSSI_POOR;
1082 
1083  return rssi;
1084 }
1085 
1086 static eBTRMgrRet
1087 btrMgr_MapDevstatusInfoToEventInfo (
1088  void* p_StatusCB, /* device status info */
1089  BTRMGR_EventMessage_t* apstEventMessage, /* event message */
1090  BTRMGR_Events_t type /* event type */
1091 ) {
1092  eBTRMgrRet lenBtrMgrRet = eBTRMgrSuccess;
1093 
1094  apstEventMessage->m_adapterIndex = 0;
1095  apstEventMessage->m_eventType = type;
1096 
1097  if (!p_StatusCB)
1098  return eBTRMgrFailure;
1099 
1100 
1101  if (type == BTRMGR_EVENT_DEVICE_DISCOVERY_UPDATE) {
1102  apstEventMessage->m_discoveredDevice.m_deviceHandle = ((stBTRCoreBTDevice*)p_StatusCB)->tDeviceId;
1103  apstEventMessage->m_discoveredDevice.m_signalLevel = ((stBTRCoreBTDevice*)p_StatusCB)->i32RSSI;
1104  apstEventMessage->m_discoveredDevice.m_deviceType = btrMgr_MapDeviceTypeFromCore(((stBTRCoreBTDevice*)p_StatusCB)->enDeviceType);
1105  apstEventMessage->m_discoveredDevice.m_rssi = btrMgr_MapSignalStrengthToRSSI(((stBTRCoreBTDevice*)p_StatusCB)->i32RSSI);
1106  apstEventMessage->m_discoveredDevice.m_isPairedDevice = btrMgr_GetDevPaired(apstEventMessage->m_discoveredDevice.m_deviceHandle);
1107  apstEventMessage->m_discoveredDevice.m_isLowEnergyDevice = (apstEventMessage->m_discoveredDevice.m_deviceType==BTRMGR_DEVICE_TYPE_TILE)?1:0;//We shall make it generic later
1108 
1109  apstEventMessage->m_discoveredDevice.m_isDiscovered = ((stBTRCoreBTDevice*)p_StatusCB)->bFound;
1110  apstEventMessage->m_discoveredDevice.m_isLastConnectedDevice= (ghBTRMgrDevHdlLastConnected == apstEventMessage->m_discoveredDevice.m_deviceHandle) ? 1 : 0;
1111  apstEventMessage->m_discoveredDevice.m_ui32DevClassBtSpec = ((stBTRCoreBTDevice*)p_StatusCB)->ui32DevClassBtSpec;
1112 
1113  strncpy(apstEventMessage->m_discoveredDevice.m_name, ((stBTRCoreBTDevice*)p_StatusCB)->pcDeviceName, BTRMGR_NAME_LEN_MAX - 1);
1114  strncpy(apstEventMessage->m_discoveredDevice.m_deviceAddress, ((stBTRCoreBTDevice*)p_StatusCB)->pcDeviceAddress, BTRMGR_NAME_LEN_MAX - 1);
1115  }
1116  else if (type == BTRMGR_EVENT_RECEIVED_EXTERNAL_PAIR_REQUEST) {
1117  apstEventMessage->m_externalDevice.m_deviceHandle = ((stBTRCoreConnCBInfo*)p_StatusCB)->stFoundDevice.tDeviceId;
1118  apstEventMessage->m_externalDevice.m_deviceType = btrMgr_MapDeviceTypeFromCore(((stBTRCoreConnCBInfo*)p_StatusCB)->stFoundDevice.enDeviceType);
1119  apstEventMessage->m_externalDevice.m_vendorID = ((stBTRCoreConnCBInfo*)p_StatusCB)->stFoundDevice.ui32VendorId;
1120  apstEventMessage->m_externalDevice.m_isLowEnergyDevice = 0;
1121  apstEventMessage->m_externalDevice.m_externalDevicePIN = ((stBTRCoreConnCBInfo*)p_StatusCB)->ui32devPassKey;
1122  apstEventMessage->m_externalDevice.m_requestConfirmation = ((stBTRCoreConnCBInfo*)p_StatusCB)->ucIsReqConfirmation;
1123  strncpy(apstEventMessage->m_externalDevice.m_name, ((stBTRCoreConnCBInfo*)p_StatusCB)->stFoundDevice.pcDeviceName, BTRMGR_NAME_LEN_MAX - 1);
1124  strncpy(apstEventMessage->m_externalDevice.m_deviceAddress, ((stBTRCoreConnCBInfo*)p_StatusCB)->stFoundDevice.pcDeviceAddress, BTRMGR_NAME_LEN_MAX - 1);
1125  }
1126  else if (type == BTRMGR_EVENT_RECEIVED_EXTERNAL_CONNECT_REQUEST) {
1127  apstEventMessage->m_externalDevice.m_deviceHandle = ((stBTRCoreConnCBInfo*)p_StatusCB)->stKnownDevice.tDeviceId;
1128  apstEventMessage->m_externalDevice.m_deviceType = btrMgr_MapDeviceTypeFromCore(((stBTRCoreConnCBInfo*)p_StatusCB)->stKnownDevice.enDeviceType);
1129  apstEventMessage->m_externalDevice.m_vendorID = ((stBTRCoreConnCBInfo*)p_StatusCB)->stKnownDevice.ui32VendorId;
1130  apstEventMessage->m_externalDevice.m_isLowEnergyDevice = 0;
1131  strncpy(apstEventMessage->m_externalDevice.m_name, ((stBTRCoreConnCBInfo*)p_StatusCB)->stKnownDevice.pcDeviceName, BTRMGR_NAME_LEN_MAX - 1);
1132  strncpy(apstEventMessage->m_externalDevice.m_deviceAddress, ((stBTRCoreConnCBInfo*)p_StatusCB)->stKnownDevice.pcDeviceAddress, BTRMGR_NAME_LEN_MAX - 1);
1133  }
1134  else if (type == BTRMGR_EVENT_RECEIVED_EXTERNAL_PLAYBACK_REQUEST) {
1135  apstEventMessage->m_externalDevice.m_deviceHandle = ((stBTRCoreDevStatusCBInfo*)p_StatusCB)->deviceId;
1136  apstEventMessage->m_externalDevice.m_deviceType = btrMgr_MapDeviceTypeFromCore(((stBTRCoreDevStatusCBInfo*)p_StatusCB)->eDeviceClass);
1137  apstEventMessage->m_externalDevice.m_vendorID = 0;
1138  apstEventMessage->m_externalDevice.m_isLowEnergyDevice = 0;
1139  strncpy(apstEventMessage->m_externalDevice.m_name, ((stBTRCoreDevStatusCBInfo*)p_StatusCB)->deviceName, BTRMGR_NAME_LEN_MAX - 1);
1140  strncpy(apstEventMessage->m_externalDevice.m_deviceAddress, "TO BE FILLED", BTRMGR_NAME_LEN_MAX - 1);
1141  // Need to check for devAddress, if possible ?
1142  }
1143  else if (type == BTRMGR_EVENT_DEVICE_OP_INFORMATION) {
1144  if (enBTRCoreLE == ((stBTRCoreDevStatusCBInfo*)p_StatusCB)->eDeviceType) {
1145  apstEventMessage->m_deviceOpInfo.m_deviceHandle = ((stBTRCoreDevStatusCBInfo*)p_StatusCB)->deviceId;
1146  apstEventMessage->m_deviceOpInfo.m_deviceType = btrMgr_MapDeviceTypeFromCore(((stBTRCoreDevStatusCBInfo*)p_StatusCB)->eDeviceClass);
1147  apstEventMessage->m_deviceOpInfo.m_leOpType = ((stBTRCoreDevStatusCBInfo*)p_StatusCB)->eCoreLeOper;
1148 
1149  strncpy(apstEventMessage->m_deviceOpInfo.m_name, ((stBTRCoreDevStatusCBInfo*)p_StatusCB)->deviceName,
1150  strlen(((stBTRCoreDevStatusCBInfo*)p_StatusCB)->deviceName) < BTRMGR_NAME_LEN_MAX ? strlen (((stBTRCoreDevStatusCBInfo*)p_StatusCB)->deviceName) : BTRMGR_NAME_LEN_MAX - 1);
1151  strncpy(apstEventMessage->m_deviceOpInfo.m_deviceAddress, ((stBTRCoreDevStatusCBInfo*)p_StatusCB)->deviceAddress,
1152  strlen(((stBTRCoreDevStatusCBInfo*)p_StatusCB)->deviceAddress) < BTRMGR_NAME_LEN_MAX ? strlen (((stBTRCoreDevStatusCBInfo*)p_StatusCB)->deviceAddress) : BTRMGR_NAME_LEN_MAX - 1);
1153  strncpy(apstEventMessage->m_deviceOpInfo.m_uuid, ((stBTRCoreDevStatusCBInfo*)p_StatusCB)->uuid,
1154  strlen(((stBTRCoreDevStatusCBInfo*)p_StatusCB)->uuid) < BTRMGR_MAX_STR_LEN ? strlen(((stBTRCoreDevStatusCBInfo*)p_StatusCB)->uuid) : BTRMGR_MAX_STR_LEN - 1);
1155  }
1156  }
1157  else {
1158  apstEventMessage->m_pairedDevice.m_deviceHandle = ((stBTRCoreDevStatusCBInfo*)p_StatusCB)->deviceId;
1159  apstEventMessage->m_pairedDevice.m_deviceType = btrMgr_MapDeviceTypeFromCore(((stBTRCoreDevStatusCBInfo*)p_StatusCB)->eDeviceClass);
1160  apstEventMessage->m_pairedDevice.m_isLastConnectedDevice = (ghBTRMgrDevHdlLastConnected == apstEventMessage->m_pairedDevice.m_deviceHandle) ? 1 : 0;
1161 
1162  if (apstEventMessage->m_pairedDevice.m_deviceType == BTRMGR_DEVICE_TYPE_TILE) {
1163  apstEventMessage->m_pairedDevice.m_isLowEnergyDevice = 1;//We shall make it generic later
1164  }
1165  else {
1166  apstEventMessage->m_pairedDevice.m_isLowEnergyDevice = (((stBTRCoreDevStatusCBInfo*)p_StatusCB)->eDeviceType == enBTRCoreLE)?1:0;//We shall make it generic later
1167  }
1168 
1169  apstEventMessage->m_pairedDevice.m_ui32DevClassBtSpec = ((stBTRCoreDevStatusCBInfo*)p_StatusCB)->ui32DevClassBtSpec;
1170  strncpy(apstEventMessage->m_pairedDevice.m_name, ((stBTRCoreDevStatusCBInfo*)p_StatusCB)->deviceName,
1171  strlen(((stBTRCoreDevStatusCBInfo*)p_StatusCB)->deviceName) < BTRMGR_NAME_LEN_MAX ? strlen (((stBTRCoreDevStatusCBInfo*)p_StatusCB)->deviceName) : BTRMGR_NAME_LEN_MAX - 1);
1172  strncpy(apstEventMessage->m_pairedDevice.m_deviceAddress, ((stBTRCoreDevStatusCBInfo*)p_StatusCB)->deviceAddress,
1173  strlen(((stBTRCoreDevStatusCBInfo*)p_StatusCB)->deviceAddress) < BTRMGR_NAME_LEN_MAX ? strlen (((stBTRCoreDevStatusCBInfo*)p_StatusCB)->deviceAddress) : BTRMGR_NAME_LEN_MAX - 1);
1174  }
1175 
1176  return lenBtrMgrRet;
1177 }
1178 
1179 static eBTRMgrRet
1180 btrMgr_StartCastingAudio (
1181  int outFileFd,
1182  int outMTUSize,
1183  unsigned int outDevDelay,
1184  eBTRCoreDevMediaType aenBtrCoreDevOutMType,
1185  void* apstBtrCoreDevOutMCodecInfo
1186 ) {
1187  stBTRMgrOutASettings lstBtrMgrAcOutASettings;
1188  stBTRMgrInASettings lstBtrMgrSoInASettings;
1189  stBTRMgrOutASettings lstBtrMgrSoOutASettings;
1190  eBTRMgrRet lenBtrMgrRet = eBTRMgrSuccess;
1191 
1192  int inBytesToEncode = 3072; // Corresponds to MTU size of 895
1193 
1194  BTRMGR_StreamOut_Type_t lenCurrentSoType = gstBTRMgrStreamingInfo.tBTRMgrSoType;
1195  tBTRMgrAcType lpi8BTRMgrAcType= BTRMGR_AC_TYPE_PRIMARY;
1196 #ifdef RDKTV_PERSIST_VOLUME_SKY
1197  unsigned char ui8Volume = BTRMGR_SO_MAX_VOLUME;
1198  gboolean lbMute = FALSE;
1199 #endif
1200 
1201  if ((ghBTRMgrDevHdlCurStreaming != 0) || (outMTUSize == 0)) {
1202  return eBTRMgrFailInArg;
1203  }
1204 
1205 
1206  /* Reset the buffer */
1207  memset(&gstBTRMgrStreamingInfo, 0, sizeof(gstBTRMgrStreamingInfo));
1208 
1209  memset(&lstBtrMgrAcOutASettings, 0, sizeof(lstBtrMgrAcOutASettings));
1210  memset(&lstBtrMgrSoInASettings, 0, sizeof(lstBtrMgrSoInASettings));
1211  memset(&lstBtrMgrSoOutASettings, 0, sizeof(lstBtrMgrSoOutASettings));
1212 
1213  /* Init StreamOut module - Create Pipeline */
1214  if ((lenBtrMgrRet = BTRMgr_SO_Init(&gstBTRMgrStreamingInfo.hBTRMgrSoHdl, btrMgr_SOStatusCb, &gstBTRMgrStreamingInfo)) != eBTRMgrSuccess) {
1215  BTRMGRLOG_ERROR ("BTRMgr_SO_Init FAILED\n");
1216  return eBTRMgrInitFailure;
1217  }
1218 
1219  if (lenCurrentSoType == BTRMGR_STREAM_PRIMARY) {
1220  lpi8BTRMgrAcType = BTRMGR_AC_TYPE_PRIMARY;
1221  gstBTRMgrStreamingInfo.tBTRMgrSoType = lenCurrentSoType;
1222  }
1223  else if (lenCurrentSoType == BTRMGR_STREAM_AUXILIARY) {
1224  lpi8BTRMgrAcType = BTRMGR_AC_TYPE_AUXILIARY;
1225  gstBTRMgrStreamingInfo.tBTRMgrSoType = lenCurrentSoType;
1226  }
1227  else {
1228  lpi8BTRMgrAcType = BTRMGR_AC_TYPE_PRIMARY;
1229  gstBTRMgrStreamingInfo.tBTRMgrSoType = BTRMGR_STREAM_PRIMARY;
1230  }
1231 
1232  if ((lenBtrMgrRet = BTRMgr_AC_Init(&gstBTRMgrStreamingInfo.hBTRMgrAcHdl, lpi8BTRMgrAcType)) != eBTRMgrSuccess) {
1233  BTRMGRLOG_ERROR ("BTRMgr_AC_Init FAILED\n");
1234  return eBTRMgrInitFailure;
1235  }
1236 
1237  /* could get defaults from audio capture, but for the sample app we want to write a the wav header first*/
1238  gstBTRMgrStreamingInfo.bitsPerSample = 16;
1239  gstBTRMgrStreamingInfo.samplerate = 48000;
1240  gstBTRMgrStreamingInfo.channels = 2;
1241 
1242 
1243  lstBtrMgrAcOutASettings.pstBtrMgrOutCodecInfo = (void*)malloc((sizeof(stBTRMgrPCMInfo) > sizeof(stBTRMgrSBCInfo) ? sizeof(stBTRMgrPCMInfo) : sizeof(stBTRMgrSBCInfo)) > sizeof(stBTRMgrMPEGInfo) ?
1244  (sizeof(stBTRMgrPCMInfo) > sizeof(stBTRMgrSBCInfo) ? sizeof(stBTRMgrPCMInfo) : sizeof(stBTRMgrSBCInfo)) : sizeof(stBTRMgrMPEGInfo));
1245  lstBtrMgrSoInASettings.pstBtrMgrInCodecInfo = (void*)malloc((sizeof(stBTRMgrPCMInfo) > sizeof(stBTRMgrSBCInfo) ? sizeof(stBTRMgrPCMInfo) : sizeof(stBTRMgrSBCInfo)) > sizeof(stBTRMgrMPEGInfo) ?
1246  (sizeof(stBTRMgrPCMInfo) > sizeof(stBTRMgrSBCInfo) ? sizeof(stBTRMgrPCMInfo) : sizeof(stBTRMgrSBCInfo)) : sizeof(stBTRMgrMPEGInfo));
1247  lstBtrMgrSoOutASettings.pstBtrMgrOutCodecInfo = (void*)malloc((sizeof(stBTRMgrPCMInfo) > sizeof(stBTRMgrSBCInfo) ? sizeof(stBTRMgrPCMInfo) : sizeof(stBTRMgrSBCInfo)) > sizeof(stBTRMgrMPEGInfo) ?
1248  (sizeof(stBTRMgrPCMInfo) > sizeof(stBTRMgrSBCInfo) ? sizeof(stBTRMgrPCMInfo) : sizeof(stBTRMgrSBCInfo)) : sizeof(stBTRMgrMPEGInfo));
1249 
1250 
1251  if (!(lstBtrMgrAcOutASettings.pstBtrMgrOutCodecInfo) || !(lstBtrMgrSoInASettings.pstBtrMgrInCodecInfo) || !(lstBtrMgrSoOutASettings.pstBtrMgrOutCodecInfo)) {
1252  BTRMGRLOG_ERROR ("MEMORY ALLOC FAILED\n");
1253  return eBTRMgrFailure;
1254  }
1255 
1256 
1257  if ((lenBtrMgrRet = BTRMgr_AC_GetDefaultSettings(gstBTRMgrStreamingInfo.hBTRMgrAcHdl, &lstBtrMgrAcOutASettings)) != eBTRMgrSuccess) {
1258  BTRMGRLOG_ERROR("BTRMgr_AC_GetDefaultSettings FAILED\n");
1259  }
1260 
1261 
1262  lstBtrMgrSoInASettings.eBtrMgrInAType = lstBtrMgrAcOutASettings.eBtrMgrOutAType;
1263 
1264  if (lstBtrMgrSoInASettings.eBtrMgrInAType == eBTRMgrATypePCM) {
1265  stBTRMgrPCMInfo* pstBtrMgrSoInPcmInfo = (stBTRMgrPCMInfo*)(lstBtrMgrSoInASettings.pstBtrMgrInCodecInfo);
1266  stBTRMgrPCMInfo* pstBtrMgrAcOutPcmInfo = (stBTRMgrPCMInfo*)(lstBtrMgrAcOutASettings.pstBtrMgrOutCodecInfo);
1267 
1268  memcpy(pstBtrMgrSoInPcmInfo, pstBtrMgrAcOutPcmInfo, sizeof(stBTRMgrPCMInfo));
1269  }
1270 
1271 
1272  if (aenBtrCoreDevOutMType == eBTRCoreDevMediaTypeSBC) {
1273  stBTRMgrSBCInfo* pstBtrMgrSoOutSbcInfo = ((stBTRMgrSBCInfo*)(lstBtrMgrSoOutASettings.pstBtrMgrOutCodecInfo));
1274  stBTRCoreDevMediaSbcInfo* pstBtrCoreDevMediaSbcInfo = (stBTRCoreDevMediaSbcInfo*)apstBtrCoreDevOutMCodecInfo;
1275 
1276  lstBtrMgrSoOutASettings.eBtrMgrOutAType = eBTRMgrATypeSBC;
1277  if (pstBtrMgrSoOutSbcInfo && pstBtrCoreDevMediaSbcInfo) {
1278 
1279  if (pstBtrCoreDevMediaSbcInfo->ui32DevMSFreq == 8000) {
1280  pstBtrMgrSoOutSbcInfo->eBtrMgrSbcSFreq = eBTRMgrSFreq8K;
1281  }
1282  else if (pstBtrCoreDevMediaSbcInfo->ui32DevMSFreq == 16000) {
1283  pstBtrMgrSoOutSbcInfo->eBtrMgrSbcSFreq = eBTRMgrSFreq16K;
1284  }
1285  else if (pstBtrCoreDevMediaSbcInfo->ui32DevMSFreq == 32000) {
1286  pstBtrMgrSoOutSbcInfo->eBtrMgrSbcSFreq = eBTRMgrSFreq32K;
1287  }
1288  else if (pstBtrCoreDevMediaSbcInfo->ui32DevMSFreq == 44100) {
1289  pstBtrMgrSoOutSbcInfo->eBtrMgrSbcSFreq = eBTRMgrSFreq44_1K;
1290  }
1291  else if (pstBtrCoreDevMediaSbcInfo->ui32DevMSFreq == 48000) {
1292  pstBtrMgrSoOutSbcInfo->eBtrMgrSbcSFreq = eBTRMgrSFreq48K;
1293  }
1294  else {
1295  pstBtrMgrSoOutSbcInfo->eBtrMgrSbcSFreq = eBTRMgrSFreqUnknown;
1296  }
1297 
1298 
1299  switch (pstBtrCoreDevMediaSbcInfo->eDevMAChan) {
1300  case eBTRCoreDevMediaAChanMono:
1301  pstBtrMgrSoOutSbcInfo->eBtrMgrSbcAChan = eBTRMgrAChanMono;
1302  break;
1303  case eBTRCoreDevMediaAChanDualChannel:
1304  pstBtrMgrSoOutSbcInfo->eBtrMgrSbcAChan = eBTRMgrAChanDualChannel;
1305  break;
1306  case eBTRCoreDevMediaAChanStereo:
1307  pstBtrMgrSoOutSbcInfo->eBtrMgrSbcAChan = eBTRMgrAChanStereo;
1308  break;
1309  case eBTRCoreDevMediaAChanJointStereo:
1310  pstBtrMgrSoOutSbcInfo->eBtrMgrSbcAChan = eBTRMgrAChanJStereo;
1311  break;
1312  case eBTRCoreDevMediaAChan5_1:
1313  pstBtrMgrSoOutSbcInfo->eBtrMgrSbcAChan = eBTRMgrAChan5_1;
1314  break;
1315  case eBTRCoreDevMediaAChan7_1:
1316  pstBtrMgrSoOutSbcInfo->eBtrMgrSbcAChan = eBTRMgrAChan7_1;
1317  break;
1318  case eBTRCoreDevMediaAChanUnknown:
1319  default:
1320  pstBtrMgrSoOutSbcInfo->eBtrMgrSbcAChan = eBTRMgrAChanUnknown;
1321  break;
1322  }
1323 
1324  pstBtrMgrSoOutSbcInfo->ui8SbcAllocMethod = pstBtrCoreDevMediaSbcInfo->ui8DevMSbcAllocMethod;
1325  pstBtrMgrSoOutSbcInfo->ui8SbcSubbands = pstBtrCoreDevMediaSbcInfo->ui8DevMSbcSubbands;
1326  pstBtrMgrSoOutSbcInfo->ui8SbcBlockLength = pstBtrCoreDevMediaSbcInfo->ui8DevMSbcBlockLength;
1327  pstBtrMgrSoOutSbcInfo->ui8SbcMinBitpool = pstBtrCoreDevMediaSbcInfo->ui8DevMSbcMinBitpool;
1328  pstBtrMgrSoOutSbcInfo->ui8SbcMaxBitpool = pstBtrCoreDevMediaSbcInfo->ui8DevMSbcMaxBitpool;
1329  pstBtrMgrSoOutSbcInfo->ui16SbcFrameLen = pstBtrCoreDevMediaSbcInfo->ui16DevMSbcFrameLen;
1330  pstBtrMgrSoOutSbcInfo->ui16SbcBitrate = pstBtrCoreDevMediaSbcInfo->ui16DevMSbcBitrate;
1331  }
1332  }
1333 
1334  lstBtrMgrSoOutASettings.i32BtrMgrDevFd = outFileFd;
1335  lstBtrMgrSoOutASettings.i32BtrMgrDevMtu = outMTUSize;
1336 
1337 
1338  if ((lenBtrMgrRet = BTRMgr_SO_GetEstimatedInABufSize(gstBTRMgrStreamingInfo.hBTRMgrSoHdl, &lstBtrMgrSoInASettings, &lstBtrMgrSoOutASettings)) != eBTRMgrSuccess) {
1339  BTRMGRLOG_ERROR ("BTRMgr_SO_GetEstimatedInABufSize FAILED\n");
1340  lstBtrMgrSoInASettings.i32BtrMgrInBufMaxSize = inBytesToEncode;
1341  }
1342  else {
1343  gstBTRMgrStreamingInfo.i32BytesToEncode = lstBtrMgrSoInASettings.i32BtrMgrInBufMaxSize;
1344  }
1345 
1346 #ifdef RDKTV_PERSIST_VOLUME_SKY
1347  if (btrMgr_GetLastVolume(0, &ui8Volume) == eBTRMgrSuccess) {
1348  if (!gui8IsSoDevAvrcpSupported && (BTRMgr_SO_SetVolume(gstBTRMgrStreamingInfo.hBTRMgrSoHdl, ui8Volume) != eBTRMgrSuccess)) {
1349  BTRMGRLOG_ERROR (" BTRMgr_SO_SetVolume FAILED \n");
1350  }
1351  }
1352 
1353  if (btrMgr_GetLastMuteState(0, &lbMute) == eBTRMgrSuccess) {
1354  if (BTRMgr_SO_SetMute(gstBTRMgrStreamingInfo.hBTRMgrSoHdl, lbMute) != eBTRMgrSuccess) {
1355  BTRMGRLOG_ERROR (" BTRMgr_SO_SetMute FAILED \n");
1356  }
1357  }
1358 #endif
1359 
1360  if ((lenBtrMgrRet = BTRMgr_SO_Start(gstBTRMgrStreamingInfo.hBTRMgrSoHdl, &lstBtrMgrSoInASettings, &lstBtrMgrSoOutASettings)) != eBTRMgrSuccess) {
1361  BTRMGRLOG_ERROR ("BTRMgr_SO_Start FAILED\n");
1362  }
1363 
1364  if (lenBtrMgrRet == eBTRMgrSuccess) {
1365  lstBtrMgrAcOutASettings.i32BtrMgrOutBufMaxSize = lstBtrMgrSoInASettings.i32BtrMgrInBufMaxSize;
1366  lstBtrMgrAcOutASettings.ui32BtrMgrDevDelay = outDevDelay;
1367 
1368  if ((lenBtrMgrRet = BTRMgr_AC_Start(gstBTRMgrStreamingInfo.hBTRMgrAcHdl,
1369  &lstBtrMgrAcOutASettings,
1370  btrMgr_ACDataReadyCb,
1371  btrMgr_ACStatusCb,
1372  &gstBTRMgrStreamingInfo)) != eBTRMgrSuccess) {
1373  BTRMGRLOG_ERROR ("BTRMgr_AC_Start FAILED\n");
1374  }
1375  }
1376 
1377  if (lstBtrMgrSoOutASettings.pstBtrMgrOutCodecInfo)
1378  free(lstBtrMgrSoOutASettings.pstBtrMgrOutCodecInfo);
1379 
1380  if (lstBtrMgrSoInASettings.pstBtrMgrInCodecInfo)
1381  free(lstBtrMgrSoInASettings.pstBtrMgrInCodecInfo);
1382 
1383  if (lstBtrMgrAcOutASettings.pstBtrMgrOutCodecInfo)
1384  free(lstBtrMgrAcOutASettings.pstBtrMgrOutCodecInfo);
1385 
1386  return lenBtrMgrRet;
1387 }
1388 
1389 static eBTRMgrRet
1390 btrMgr_StopCastingAudio (
1391  void
1392 ) {
1393  eBTRMgrRet lenBtrMgrRet = eBTRMgrSuccess;
1394 
1395  if (ghBTRMgrDevHdlCurStreaming == 0) {
1396  return eBTRMgrFailInArg;
1397  }
1398 
1399 
1400  if ((lenBtrMgrRet = BTRMgr_AC_Stop(gstBTRMgrStreamingInfo.hBTRMgrAcHdl)) != eBTRMgrSuccess) {
1401  BTRMGRLOG_ERROR ("BTRMgr_AC_Stop FAILED\n");
1402  }
1403 
1404  if ((lenBtrMgrRet = BTRMgr_SO_SendEOS(gstBTRMgrStreamingInfo.hBTRMgrSoHdl)) != eBTRMgrSuccess) {
1405  BTRMGRLOG_ERROR ("BTRMgr_SO_SendEOS FAILED\n");
1406  }
1407 
1408  if ((lenBtrMgrRet = BTRMgr_SO_Stop(gstBTRMgrStreamingInfo.hBTRMgrSoHdl)) != eBTRMgrSuccess) {
1409  BTRMGRLOG_ERROR ("BTRMgr_SO_Stop FAILED\n");
1410  }
1411 
1412  if ((lenBtrMgrRet = BTRMgr_AC_DeInit(gstBTRMgrStreamingInfo.hBTRMgrAcHdl)) != eBTRMgrSuccess) {
1413  BTRMGRLOG_ERROR ("BTRMgr_AC_DeInit FAILED\n");
1414  }
1415 
1416  if ((lenBtrMgrRet = BTRMgr_SO_DeInit(gstBTRMgrStreamingInfo.hBTRMgrSoHdl)) != eBTRMgrSuccess) {
1417  BTRMGRLOG_ERROR ("BTRMgr_SO_DeInit FAILED\n");
1418  }
1419 
1420  gstBTRMgrStreamingInfo.hBTRMgrAcHdl = NULL;
1421  gstBTRMgrStreamingInfo.hBTRMgrSoHdl = NULL;
1422 
1423  return lenBtrMgrRet;
1424 }
1425 
1426 static eBTRMgrRet
1427 btrMgr_SwitchCastingAudio_AC (
1428  BTRMGR_StreamOut_Type_t aenCurrentSoType
1429 ) {
1430  eBTRMgrRet lenBtrMgrRet = eBTRMgrSuccess;
1431  tBTRMgrAcType lpi8BTRMgrAcType = BTRMGR_AC_TYPE_PRIMARY;
1432  stBTRMgrOutASettings lstBtrMgrAcOutASettings;
1433 
1434 
1435  if (ghBTRMgrDevHdlCurStreaming == 0) {
1436  return eBTRMgrFailInArg;
1437  }
1438 
1439 
1440  if ((lenBtrMgrRet = BTRMgr_AC_Stop(gstBTRMgrStreamingInfo.hBTRMgrAcHdl)) != eBTRMgrSuccess) {
1441  BTRMGRLOG_ERROR ("BTRMgr_AC_Stop FAILED\n");
1442  }
1443 
1444  if ((lenBtrMgrRet = BTRMgr_SO_Pause(gstBTRMgrStreamingInfo.hBTRMgrSoHdl)) != eBTRMgrSuccess) {
1445  BTRMGRLOG_ERROR ("BTRMgr_SO_Pause FAILED\n");
1446  }
1447 
1448  if ((lenBtrMgrRet = BTRMgr_AC_DeInit(gstBTRMgrStreamingInfo.hBTRMgrAcHdl)) != eBTRMgrSuccess) {
1449  BTRMGRLOG_ERROR ("BTRMgr_AC_DeInit FAILED\n");
1450  }
1451 
1452  gstBTRMgrStreamingInfo.hBTRMgrAcHdl = NULL;
1453 
1454 
1455  if (aenCurrentSoType == BTRMGR_STREAM_PRIMARY) {
1456  lpi8BTRMgrAcType = BTRMGR_AC_TYPE_PRIMARY;
1457  }
1458  else if (aenCurrentSoType == BTRMGR_STREAM_AUXILIARY) {
1459  lpi8BTRMgrAcType = BTRMGR_AC_TYPE_AUXILIARY;
1460  }
1461  else {
1462  lpi8BTRMgrAcType = BTRMGR_AC_TYPE_PRIMARY;
1463  }
1464 
1465 
1466  if ((lenBtrMgrRet = BTRMgr_AC_Init(&gstBTRMgrStreamingInfo.hBTRMgrAcHdl, lpi8BTRMgrAcType)) != eBTRMgrSuccess) {
1467  BTRMGRLOG_ERROR ("BTRMgr_AC_Init FAILED\n");
1468  return eBTRMgrInitFailure;
1469  }
1470 
1471  /* Reset the buffer */
1472  memset(&lstBtrMgrAcOutASettings, 0, sizeof(lstBtrMgrAcOutASettings));
1473  lstBtrMgrAcOutASettings.pstBtrMgrOutCodecInfo = (void*)malloc((sizeof(stBTRMgrPCMInfo) > sizeof(stBTRMgrSBCInfo) ? sizeof(stBTRMgrPCMInfo) : sizeof(stBTRMgrSBCInfo)) > sizeof(stBTRMgrMPEGInfo) ?
1474  (sizeof(stBTRMgrPCMInfo) > sizeof(stBTRMgrSBCInfo) ? sizeof(stBTRMgrPCMInfo) : sizeof(stBTRMgrSBCInfo)) : sizeof(stBTRMgrMPEGInfo));
1475  if (!lstBtrMgrAcOutASettings.pstBtrMgrOutCodecInfo) {
1476  BTRMGRLOG_ERROR ("MEMORY ALLOC FAILED\n");
1477  return eBTRMgrFailure;
1478  }
1479 
1480 
1481  if ((lenBtrMgrRet = BTRMgr_AC_GetDefaultSettings(gstBTRMgrStreamingInfo.hBTRMgrAcHdl, &lstBtrMgrAcOutASettings)) != eBTRMgrSuccess) {
1482  BTRMGRLOG_ERROR("BTRMgr_AC_GetDefaultSettings FAILED\n");
1483  }
1484 
1485  if ((lenBtrMgrRet = BTRMgr_SO_Resume(gstBTRMgrStreamingInfo.hBTRMgrSoHdl)) != eBTRMgrSuccess) {
1486  BTRMGRLOG_ERROR ("BTRMgr_SO_Resume FAILED\n");
1487  }
1488 
1489  lstBtrMgrAcOutASettings.i32BtrMgrOutBufMaxSize = gstBTRMgrStreamingInfo.i32BytesToEncode;
1490  if ((lenBtrMgrRet = BTRMgr_AC_Start(gstBTRMgrStreamingInfo.hBTRMgrAcHdl,
1491  &lstBtrMgrAcOutASettings,
1492  btrMgr_ACDataReadyCb,
1493  btrMgr_ACStatusCb,
1494  &gstBTRMgrStreamingInfo)) != eBTRMgrSuccess) {
1495  BTRMGRLOG_ERROR ("BTRMgr_AC_Start FAILED\n");
1496  }
1497 
1498  if (lstBtrMgrAcOutASettings.pstBtrMgrOutCodecInfo)
1499  free(lstBtrMgrAcOutASettings.pstBtrMgrOutCodecInfo);
1500 
1501  return lenBtrMgrRet;
1502 }
1503 
1504 static eBTRMgrRet
1505 btrMgr_StartReceivingAudio (
1506  int inFileFd,
1507  int inMTUSize,
1508  unsigned int inDevDelay,
1509  eBTRCoreDevMediaType aenBtrCoreDevInMType,
1510  void* apstBtrCoreDevInMCodecInfo
1511 ) {
1512  eBTRMgrRet lenBtrMgrRet = eBTRMgrSuccess;
1513  int inBytesToEncode = 3072;
1514  stBTRMgrInASettings lstBtrMgrSiInASettings;
1515 
1516 
1517  if ((ghBTRMgrDevHdlCurStreaming != 0) || (inMTUSize == 0)) {
1518  return eBTRMgrFailInArg;
1519  }
1520 
1521 
1522  /* Reset the buffer */
1523  memset(&lstBtrMgrSiInASettings, 0, sizeof(lstBtrMgrSiInASettings));
1524 
1525 
1526  /* Init StreamIn module - Create Pipeline */
1527  if ((lenBtrMgrRet = BTRMgr_SI_Init(&gstBTRMgrStreamingInfo.hBTRMgrSiHdl, btrMgr_SIStatusCb, &gstBTRMgrStreamingInfo)) != eBTRMgrSuccess) {
1528  BTRMGRLOG_ERROR ("BTRMgr_SI_Init FAILED\n");
1529  return eBTRMgrInitFailure;
1530  }
1531 
1532 
1533  lstBtrMgrSiInASettings.pstBtrMgrInCodecInfo = (void*)malloc((sizeof(stBTRMgrPCMInfo) > sizeof(stBTRMgrSBCInfo) ? sizeof(stBTRMgrPCMInfo) : sizeof(stBTRMgrSBCInfo)) > sizeof(stBTRMgrMPEGInfo) ?
1534  (sizeof(stBTRMgrPCMInfo) > sizeof(stBTRMgrSBCInfo) ? sizeof(stBTRMgrPCMInfo) : sizeof(stBTRMgrSBCInfo)) : sizeof(stBTRMgrMPEGInfo));
1535 
1536  if (aenBtrCoreDevInMType == eBTRCoreDevMediaTypeSBC) {
1537  stBTRMgrSBCInfo* pstBtrMgrSiInSbcInfo = ((stBTRMgrSBCInfo*)(lstBtrMgrSiInASettings.pstBtrMgrInCodecInfo));
1538  stBTRCoreDevMediaSbcInfo* pstBtrCoreDevMediaSbcInfo = (stBTRCoreDevMediaSbcInfo*)apstBtrCoreDevInMCodecInfo;
1539 
1540  lstBtrMgrSiInASettings.eBtrMgrInAType = eBTRMgrATypeSBC;
1541  if (pstBtrMgrSiInSbcInfo && pstBtrCoreDevMediaSbcInfo) {
1542 
1543  if (pstBtrCoreDevMediaSbcInfo->ui32DevMSFreq == 8000) {
1544  pstBtrMgrSiInSbcInfo->eBtrMgrSbcSFreq = eBTRMgrSFreq8K;
1545  }
1546  else if (pstBtrCoreDevMediaSbcInfo->ui32DevMSFreq == 16000) {
1547  pstBtrMgrSiInSbcInfo->eBtrMgrSbcSFreq = eBTRMgrSFreq16K;
1548  }
1549  else if (pstBtrCoreDevMediaSbcInfo->ui32DevMSFreq == 32000) {
1550  pstBtrMgrSiInSbcInfo->eBtrMgrSbcSFreq = eBTRMgrSFreq32K;
1551  }
1552  else if (pstBtrCoreDevMediaSbcInfo->ui32DevMSFreq == 44100) {
1553  pstBtrMgrSiInSbcInfo->eBtrMgrSbcSFreq = eBTRMgrSFreq44_1K;
1554  }
1555  else if (pstBtrCoreDevMediaSbcInfo->ui32DevMSFreq == 48000) {
1556  pstBtrMgrSiInSbcInfo->eBtrMgrSbcSFreq = eBTRMgrSFreq48K;
1557  }
1558  else {
1559  pstBtrMgrSiInSbcInfo->eBtrMgrSbcSFreq = eBTRMgrSFreqUnknown;
1560  }
1561 
1562 
1563  switch (pstBtrCoreDevMediaSbcInfo->eDevMAChan) {
1564  case eBTRCoreDevMediaAChanMono:
1565  pstBtrMgrSiInSbcInfo->eBtrMgrSbcAChan = eBTRMgrAChanMono;
1566  break;
1567  case eBTRCoreDevMediaAChanDualChannel:
1568  pstBtrMgrSiInSbcInfo->eBtrMgrSbcAChan = eBTRMgrAChanDualChannel;
1569  break;
1570  case eBTRCoreDevMediaAChanStereo:
1571  pstBtrMgrSiInSbcInfo->eBtrMgrSbcAChan = eBTRMgrAChanStereo;
1572  break;
1573  case eBTRCoreDevMediaAChanJointStereo:
1574  pstBtrMgrSiInSbcInfo->eBtrMgrSbcAChan = eBTRMgrAChanJStereo;
1575  break;
1576  case eBTRCoreDevMediaAChan5_1:
1577  pstBtrMgrSiInSbcInfo->eBtrMgrSbcAChan = eBTRMgrAChan5_1;
1578  break;
1579  case eBTRCoreDevMediaAChan7_1:
1580  pstBtrMgrSiInSbcInfo->eBtrMgrSbcAChan = eBTRMgrAChan7_1;
1581  break;
1582  case eBTRCoreDevMediaAChanUnknown:
1583  default:
1584  pstBtrMgrSiInSbcInfo->eBtrMgrSbcAChan = eBTRMgrAChanUnknown;
1585  break;
1586  }
1587 
1588  pstBtrMgrSiInSbcInfo->ui8SbcAllocMethod = pstBtrCoreDevMediaSbcInfo->ui8DevMSbcAllocMethod;
1589  pstBtrMgrSiInSbcInfo->ui8SbcSubbands = pstBtrCoreDevMediaSbcInfo->ui8DevMSbcSubbands;
1590  pstBtrMgrSiInSbcInfo->ui8SbcBlockLength = pstBtrCoreDevMediaSbcInfo->ui8DevMSbcBlockLength;
1591  pstBtrMgrSiInSbcInfo->ui8SbcMinBitpool = pstBtrCoreDevMediaSbcInfo->ui8DevMSbcMinBitpool;
1592  pstBtrMgrSiInSbcInfo->ui8SbcMaxBitpool = pstBtrCoreDevMediaSbcInfo->ui8DevMSbcMaxBitpool;
1593  pstBtrMgrSiInSbcInfo->ui16SbcFrameLen = pstBtrCoreDevMediaSbcInfo->ui16DevMSbcFrameLen;
1594  pstBtrMgrSiInSbcInfo->ui16SbcBitrate = pstBtrCoreDevMediaSbcInfo->ui16DevMSbcBitrate;
1595  }
1596  }
1597  else if (aenBtrCoreDevInMType == eBTRCoreDevMediaTypeAAC) {
1598  stBTRMgrMPEGInfo* pstBtrMgrSiInAacInfo = ((stBTRMgrMPEGInfo*)(lstBtrMgrSiInASettings.pstBtrMgrInCodecInfo));
1599  stBTRCoreDevMediaMpegInfo* pstBtrCoreDevMediaAacInfo = (stBTRCoreDevMediaMpegInfo*)apstBtrCoreDevInMCodecInfo;
1600 
1601  lstBtrMgrSiInASettings.eBtrMgrInAType = eBTRMgrATypeAAC;
1602  if (pstBtrMgrSiInAacInfo && pstBtrCoreDevMediaAacInfo) {
1603 
1604  if (pstBtrCoreDevMediaAacInfo->ui32DevMSFreq == 8000) {
1605  pstBtrMgrSiInAacInfo->eBtrMgrMpegSFreq = eBTRMgrSFreq8K;
1606  }
1607  else if (pstBtrCoreDevMediaAacInfo->ui32DevMSFreq == 16000) {
1608  pstBtrMgrSiInAacInfo->eBtrMgrMpegSFreq = eBTRMgrSFreq16K;
1609  }
1610  else if (pstBtrCoreDevMediaAacInfo->ui32DevMSFreq == 32000) {
1611  pstBtrMgrSiInAacInfo->eBtrMgrMpegSFreq = eBTRMgrSFreq32K;
1612  }
1613  else if (pstBtrCoreDevMediaAacInfo->ui32DevMSFreq == 44100) {
1614  pstBtrMgrSiInAacInfo->eBtrMgrMpegSFreq = eBTRMgrSFreq44_1K;
1615  }
1616  else if (pstBtrCoreDevMediaAacInfo->ui32DevMSFreq == 48000) {
1617  pstBtrMgrSiInAacInfo->eBtrMgrMpegSFreq = eBTRMgrSFreq48K;
1618  }
1619  else {
1620  pstBtrMgrSiInAacInfo->eBtrMgrMpegSFreq = eBTRMgrSFreqUnknown;
1621  }
1622 
1623 
1624  switch (pstBtrCoreDevMediaAacInfo->eDevMAChan) {
1625  case eBTRCoreDevMediaAChanMono:
1626  pstBtrMgrSiInAacInfo->eBtrMgrMpegAChan = eBTRMgrAChanMono;
1627  break;
1628  case eBTRCoreDevMediaAChanDualChannel:
1629  pstBtrMgrSiInAacInfo->eBtrMgrMpegAChan = eBTRMgrAChanDualChannel;
1630  break;
1631  case eBTRCoreDevMediaAChanStereo:
1632  pstBtrMgrSiInAacInfo->eBtrMgrMpegAChan = eBTRMgrAChanStereo;
1633  break;
1634  case eBTRCoreDevMediaAChanJointStereo:
1635  pstBtrMgrSiInAacInfo->eBtrMgrMpegAChan = eBTRMgrAChanJStereo;
1636  break;
1637  case eBTRCoreDevMediaAChan5_1:
1638  pstBtrMgrSiInAacInfo->eBtrMgrMpegAChan = eBTRMgrAChan5_1;
1639  break;
1640  case eBTRCoreDevMediaAChan7_1:
1641  pstBtrMgrSiInAacInfo->eBtrMgrMpegAChan = eBTRMgrAChan7_1;
1642  break;
1643  case eBTRCoreDevMediaAChanUnknown:
1644  default:
1645  pstBtrMgrSiInAacInfo->eBtrMgrMpegAChan = eBTRMgrAChanUnknown;
1646  break;
1647  }
1648 
1649  pstBtrMgrSiInAacInfo->ui8MpegCrc = pstBtrCoreDevMediaAacInfo->ui8DevMMpegCrc;
1650  pstBtrMgrSiInAacInfo->ui8MpegLayer = pstBtrCoreDevMediaAacInfo->ui8DevMMpegLayer;
1651  pstBtrMgrSiInAacInfo->ui8MpegMpf = pstBtrCoreDevMediaAacInfo->ui8DevMMpegMpf;
1652  pstBtrMgrSiInAacInfo->ui8MpegRfa = pstBtrCoreDevMediaAacInfo->ui8DevMMpegRfa;
1653  pstBtrMgrSiInAacInfo->ui16MpegBitrate = pstBtrCoreDevMediaAacInfo->ui16DevMMpegBitrate;
1654  }
1655  }
1656 
1657 
1658 
1659  lstBtrMgrSiInASettings.i32BtrMgrDevFd = inFileFd;
1660  lstBtrMgrSiInASettings.i32BtrMgrDevMtu = inMTUSize;
1661 
1662 
1663  if ((lenBtrMgrRet = BTRMgr_SI_Start(gstBTRMgrStreamingInfo.hBTRMgrSiHdl, inBytesToEncode, &lstBtrMgrSiInASettings)) != eBTRMgrSuccess) {
1664  BTRMGRLOG_ERROR ("BTRMgr_SI_Start FAILED\n");
1665  }
1666 
1667 
1668  if (lstBtrMgrSiInASettings.pstBtrMgrInCodecInfo)
1669  free(lstBtrMgrSiInASettings.pstBtrMgrInCodecInfo);
1670 
1671  return lenBtrMgrRet;
1672 }
1673 
1674 static eBTRMgrRet
1675 btrMgr_StopReceivingAudio (
1676  void
1677 ) {
1678  eBTRMgrRet lenBtrMgrRet = eBTRMgrSuccess;
1679 
1680  if (ghBTRMgrDevHdlCurStreaming == 0) {
1681  return eBTRMgrFailInArg;
1682  }
1683 
1684 
1685  if ((lenBtrMgrRet = BTRMgr_SI_SendEOS(gstBTRMgrStreamingInfo.hBTRMgrSiHdl)) != eBTRMgrSuccess) {
1686  BTRMGRLOG_ERROR ("BTRMgr_SI_SendEOS FAILED\n");
1687  }
1688 
1689  if ((lenBtrMgrRet = BTRMgr_SI_Stop(gstBTRMgrStreamingInfo.hBTRMgrSiHdl)) != eBTRMgrSuccess) {
1690  BTRMGRLOG_ERROR ("BTRMgr_SI_Stop FAILED\n");
1691  }
1692 
1693  if ((lenBtrMgrRet = BTRMgr_SI_DeInit(gstBTRMgrStreamingInfo.hBTRMgrSiHdl)) != eBTRMgrSuccess) {
1694  BTRMGRLOG_ERROR ("BTRMgr_SI_DeInit FAILED\n");
1695  }
1696 
1697  gstBTRMgrStreamingInfo.hBTRMgrSiHdl = NULL;
1698 
1699  return lenBtrMgrRet;
1700 }
1701 
1702 
1703 
1704 static eBTRMgrRet
1705 btrMgr_ConnectToDevice (
1706  unsigned char aui8AdapterIdx,
1707  BTRMgrDeviceHandle ahBTRMgrDevHdl,
1708  BTRMGR_DeviceOperationType_t connectAs,
1709  unsigned int aui32ConnectRetryIdx,
1710  unsigned int aui32ConfirmIdx
1711 ) {
1712  eBTRMgrRet lenBtrMgrRet = eBTRMgrSuccess;
1713  enBTRCoreRet lenBtrCoreRet = enBTRCoreSuccess;
1714  int i32PairDevIdx = 0;
1715  unsigned int ui32retryIdx = aui32ConnectRetryIdx + 1;
1716  enBTRCoreDeviceType lenBTRCoreDeviceType= enBTRCoreUnknown;
1717  BTRMGR_DeviceOperationType_t lenMgrLConDevOpType = BTRMGR_DEVICE_OP_TYPE_UNKNOWN;
1718  BOOLEAN lbtriggerConnectCompleteEvt = FALSE;
1719 
1720  lenBtrMgrRet = btrMgr_PreCheckDiscoveryStatus(aui8AdapterIdx, connectAs);
1721 
1722  if (eBTRMgrSuccess != lenBtrMgrRet) {
1723  BTRMGRLOG_ERROR ("Pre Check Discovery State Rejected !!!\n");
1724  return lenBtrMgrRet;
1725  }
1726 
1727  switch (connectAs) {
1728  case BTRMGR_DEVICE_OP_TYPE_AUDIO_OUTPUT:
1729  gui8IsSoDevAvrcpSupported = 0; // TODO: Find a better way to do this
1730  lenBTRCoreDeviceType = enBTRCoreSpeakers;
1731  break;
1732  case BTRMGR_DEVICE_OP_TYPE_AUDIO_INPUT:
1733  lenBTRCoreDeviceType = enBTRCoreMobileAudioIn;
1734  if (!gIsAudioInEnabled) {
1735  BTRMGRLOG_WARN ("Connection Rejected - BTR AudioIn is currently Disabled!\n");
1736  return BTRMGR_RESULT_GENERIC_FAILURE;
1737  }
1738  break;
1739  case BTRMGR_DEVICE_OP_TYPE_LE:
1740  lenBTRCoreDeviceType = enBTRCoreLE;
1741  break;
1742  case BTRMGR_DEVICE_OP_TYPE_HID:
1743  // Indicates that the event was already emitted from DeviceStatus_Cb
1744  lbtriggerConnectCompleteEvt = btrMgr_IsDevConnected(ahBTRMgrDevHdl);
1745  lenBTRCoreDeviceType = enBTRCoreHID;
1746  break;
1747  case BTRMGR_DEVICE_OP_TYPE_UNKNOWN:
1748  default:
1749  lenBTRCoreDeviceType = enBTRCoreUnknown;
1750  break;
1751  }
1752 
1753 
1754  do {
1755  /* connectAs param is unused for now.. */
1756  lenBtrCoreRet = BTRCore_ConnectDevice (ghBTRCoreHdl, ahBTRMgrDevHdl, lenBTRCoreDeviceType);
1757  if (lenBtrCoreRet != enBTRCoreSuccess) {
1758  BTRMGRLOG_ERROR ("Failed to Connect to this device - %llu\n", ahBTRMgrDevHdl);
1759  lenBtrMgrRet = eBTRMgrFailure;
1760  }
1761  else {
1762  for (i32PairDevIdx = 0; i32PairDevIdx <= gListOfPairedDevices.m_numOfDevices; i32PairDevIdx++) {
1763  if (ahBTRMgrDevHdl == gListOfPairedDevices.m_deviceProperty[i32PairDevIdx].m_deviceHandle) {
1764  BTRMGRLOG_INFO ("Connected Successfully - %llu - Name - %s\n",ahBTRMgrDevHdl,gListOfPairedDevices.m_deviceProperty[i32PairDevIdx].m_name);
1765  break;
1766  }
1767  }
1768 
1769  lenBtrMgrRet = eBTRMgrSuccess;
1770  if ((lenBTRCoreDeviceType == enBTRCoreSpeakers) || (lenBTRCoreDeviceType == enBTRCoreHeadSet) ||
1771  (lenBTRCoreDeviceType == enBTRCoreMobileAudioIn) || (lenBTRCoreDeviceType == enBTRCorePCAudioIn)) {
1772  if (ghBTRMgrDevHdlLastConnected && ghBTRMgrDevHdlLastConnected != ahBTRMgrDevHdl) {
1773  BTRMGRLOG_DEBUG ("Remove persistent entry for previously connected device(%llu)\n", ghBTRMgrDevHdlLastConnected);
1774 
1775  for (i32PairDevIdx = 0; i32PairDevIdx < gListOfPairedDevices.m_numOfDevices; i32PairDevIdx++) {
1776  if (ghBTRMgrDevHdlLastConnected == gListOfPairedDevices.m_deviceProperty[i32PairDevIdx].m_deviceHandle) {
1777  lenMgrLConDevOpType = btrMgr_MapDeviceOpFromDeviceType(gListOfPairedDevices.m_deviceProperty[i32PairDevIdx].m_deviceType);
1778  }
1779  }
1780 
1781  if (lenMgrLConDevOpType == BTRMGR_DEVICE_OP_TYPE_AUDIO_OUTPUT) {
1782  btrMgr_RemovePersistentEntry(aui8AdapterIdx, ghBTRMgrDevHdlLastConnected, BTRMGR_A2DP_SINK_PROFILE_ID);
1783  }
1784  else if (lenMgrLConDevOpType == BTRMGR_DEVICE_OP_TYPE_AUDIO_INPUT) {
1785  btrMgr_RemovePersistentEntry(aui8AdapterIdx, ghBTRMgrDevHdlLastConnected, BTRMGR_A2DP_SRC_PROFILE_ID);
1786  }
1787  }
1788 
1789  if ((lenBTRCoreDeviceType == enBTRCoreSpeakers) || (lenBTRCoreDeviceType == enBTRCoreHeadSet)) {
1790  btrMgr_AddPersistentEntry(aui8AdapterIdx, ahBTRMgrDevHdl, BTRMGR_A2DP_SINK_PROFILE_ID, 1);
1791  }
1792  else if ((lenBTRCoreDeviceType == enBTRCoreMobileAudioIn) || (lenBTRCoreDeviceType == enBTRCorePCAudioIn)) {
1793  btrMgr_AddPersistentEntry(aui8AdapterIdx, ahBTRMgrDevHdl, BTRMGR_A2DP_SRC_PROFILE_ID, 1);
1794  }
1795  }
1796  }
1797 
1798  if (lenBtrMgrRet != eBTRMgrFailure) {
1799  /* Max 15 sec timeout - Polled at 1 second interval: Confirmed 5 times */
1800  unsigned int ui32sleepTimeOut = 1;
1801  unsigned int ui32confirmIdx = aui32ConfirmIdx + 1;
1802  unsigned int ui32AdjSleepIdx = (aui32ConfirmIdx > BTRMGR_DEVCONN_CHECK_RETRY_ATTEMPTS) ? 2 : 5; //Interval in attempts
1803 
1804  do {
1805  unsigned int ui32sleepIdx = ui32AdjSleepIdx;
1806 
1807  do {
1808  sleep(ui32sleepTimeOut);
1809  lenBtrCoreRet = BTRCore_GetDeviceConnected(ghBTRCoreHdl, ahBTRMgrDevHdl, lenBTRCoreDeviceType);
1810  } while ((lenBtrCoreRet != enBTRCoreSuccess) && (--ui32sleepIdx));
1811  } while (--ui32confirmIdx);
1812 
1813  if (lenBtrCoreRet != enBTRCoreSuccess) {
1814  BTRMGRLOG_ERROR ("Failed to Connect to this device - Confirmed - %llu\n", ahBTRMgrDevHdl);
1815  lenBtrMgrRet = eBTRMgrFailure;
1816 
1817  if ((lenBTRCoreDeviceType == enBTRCoreSpeakers) || (lenBTRCoreDeviceType == enBTRCoreHeadSet)) {
1818  btrMgr_RemovePersistentEntry(aui8AdapterIdx, ahBTRMgrDevHdl, BTRMGR_A2DP_SINK_PROFILE_ID);
1819  }
1820  else if ((lenBTRCoreDeviceType == enBTRCoreMobileAudioIn) || (lenBTRCoreDeviceType == enBTRCorePCAudioIn)) {
1821  btrMgr_RemovePersistentEntry(aui8AdapterIdx, ahBTRMgrDevHdl, BTRMGR_A2DP_SRC_PROFILE_ID);
1822  }
1823 
1824  if (ghBTRMgrDevHdlLastConnected && ghBTRMgrDevHdlLastConnected != ahBTRMgrDevHdl) {
1825  BTRMGRLOG_DEBUG ("Add back persistent entry for previously connected device(%llu)\n", ghBTRMgrDevHdlLastConnected);
1826 
1827  if (lenMgrLConDevOpType == BTRMGR_DEVICE_OP_TYPE_AUDIO_OUTPUT) {
1828  btrMgr_AddPersistentEntry(aui8AdapterIdx, ghBTRMgrDevHdlLastConnected, BTRMGR_A2DP_SINK_PROFILE_ID, 1);
1829  }
1830  else if (lenMgrLConDevOpType == BTRMGR_DEVICE_OP_TYPE_AUDIO_INPUT) {
1831  btrMgr_AddPersistentEntry(aui8AdapterIdx, ghBTRMgrDevHdlLastConnected, BTRMGR_A2DP_SRC_PROFILE_ID, 1);
1832  }
1833  }
1834 
1835  if (BTRCore_DisconnectDevice (ghBTRCoreHdl, ahBTRMgrDevHdl, lenBTRCoreDeviceType) != enBTRCoreSuccess) {
1836  BTRMGRLOG_ERROR ("Failed to Disconnect - %llu\n", ahBTRMgrDevHdl);
1837  }
1838  }
1839  else {
1840  BTRMGRLOG_DEBUG ("Succes Connect to this device - Confirmed - %llu\n", ahBTRMgrDevHdl);
1841 
1842  if (lenBTRCoreDeviceType == enBTRCoreLE) {
1843  gIsLeDeviceConnected = 1;
1844  }
1845  else if ((lenBTRCoreDeviceType == enBTRCoreSpeakers) || (lenBTRCoreDeviceType == enBTRCoreHeadSet) ||
1846  (lenBTRCoreDeviceType == enBTRCoreMobileAudioIn) || (lenBTRCoreDeviceType == enBTRCorePCAudioIn)) {
1847  btrMgr_SetDevConnected(ahBTRMgrDevHdl, 1);
1848  gIsUserInitiated = 0;
1849  ghBTRMgrDevHdlLastConnected = ahBTRMgrDevHdl;
1850  }
1851  else if (lenBTRCoreDeviceType == enBTRCoreHID) {
1852  btrMgr_SetDevConnected(ahBTRMgrDevHdl, 1);
1853  if (lbtriggerConnectCompleteEvt) {
1854  BTRMGR_EventMessage_t lstEventMessage;
1855  memset(&lstEventMessage, 0, sizeof(lstEventMessage));
1856 
1857  lstEventMessage.m_adapterIndex = aui8AdapterIdx;
1858  lstEventMessage.m_eventType = BTRMGR_EVENT_DEVICE_CONNECTION_COMPLETE;
1859  memcpy(&lstEventMessage.m_pairedDevice, &gListOfPairedDevices.m_deviceProperty[i32PairDevIdx], sizeof(BTRMGR_PairedDevices_t));
1860 
1861  if (gfpcBBTRMgrEventOut) {
1862  gfpcBBTRMgrEventOut(lstEventMessage); /* Post a callback */
1863  }
1864  }
1865  }
1866  else {
1867  btrMgr_SetDevConnected(ahBTRMgrDevHdl, 1);
1868  }
1869  }
1870  }
1871  } while ((lenBtrMgrRet == eBTRMgrFailure) && (--ui32retryIdx));
1872 
1873  if (lenBtrMgrRet == eBTRMgrFailure && lenBTRCoreDeviceType == enBTRCoreLE) {
1874  connectAs = BTRMGR_DEVICE_OP_TYPE_UNKNOWN;
1875  }
1876 
1877  btrMgr_PostCheckDiscoveryStatus(aui8AdapterIdx, connectAs);
1878 
1879  return lenBtrMgrRet;
1880 }
1881 
1882 static eBTRMgrRet
1883 btrMgr_StartAudioStreamingOut (
1884  unsigned char aui8AdapterIdx,
1885  BTRMgrDeviceHandle ahBTRMgrDevHdl,
1886  BTRMGR_DeviceOperationType_t streamOutPref,
1887  unsigned int aui32ConnectRetryIdx,
1888  unsigned int aui32ConfirmIdx,
1889  unsigned int aui32SleepIdx
1890 ) {
1891  BTRMGR_Result_t lenBtrMgrResult = BTRMGR_RESULT_SUCCESS;
1892  eBTRMgrRet lenBtrMgrRet = eBTRMgrSuccess;
1893  enBTRCoreRet lenBtrCoreRet = enBTRCoreSuccess;
1894  unsigned char isFound = 0;
1895  int i = 0;
1896  int deviceFD = 0;
1897  int deviceReadMTU = 0;
1898  int deviceWriteMTU = 0;
1899  unsigned int deviceDelay = 0xFFFFu;
1900  unsigned int ui32retryIdx = aui32ConnectRetryIdx + 1;
1901  stBTRCorePairedDevicesCount listOfPDevices;
1902  eBTRCoreDevMediaType lenBtrCoreDevOutMType = eBTRCoreDevMediaTypeUnknown;
1903  void* lpstBtrCoreDevOutMCodecInfo = NULL;
1904 
1905 
1906  if (ghBTRMgrDevHdlCurStreaming == ahBTRMgrDevHdl) {
1907  BTRMGRLOG_WARN ("Its already streaming out in this device.. Check the volume :)\n");
1908  return eBTRMgrSuccess;
1909  }
1910 
1911 
1912  if ((ghBTRMgrDevHdlCurStreaming != 0) && (ghBTRMgrDevHdlCurStreaming != ahBTRMgrDevHdl)) {
1913  enBTRCoreDeviceType lenBTRCoreDevTy = enBTRCoreUnknown;
1914  enBTRCoreDeviceClass lenBTRCoreDevCl = enBTRCore_DC_Unknown;
1915 
1916  BTRMGRLOG_WARN ("Its already streaming out. lets stop this and start on other device \n");
1917 
1918  lenBtrCoreRet = BTRCore_GetDeviceTypeClass(ghBTRCoreHdl, ghBTRMgrDevHdlCurStreaming, &lenBTRCoreDevTy, &lenBTRCoreDevCl);
1919  BTRMGRLOG_DEBUG ("Status = %d\t Device Type = %d\t Device Class = %x\n", lenBtrCoreRet, lenBTRCoreDevTy, lenBTRCoreDevCl);
1920 
1921  if ((lenBTRCoreDevTy == enBTRCoreSpeakers) || (lenBTRCoreDevTy == enBTRCoreHeadSet)) {
1922  /* Streaming-Out is happening; stop it */
1923  if ((lenBtrMgrResult = BTRMGR_StopAudioStreamingOut(aui8AdapterIdx, ghBTRMgrDevHdlCurStreaming)) != BTRMGR_RESULT_SUCCESS) {
1924  BTRMGRLOG_ERROR ("This device is being Connected n Playing. Failed to stop Playback.-Out\n");
1925  BTRMGRLOG_ERROR ("Failed to stop streaming at the current device..\n");
1926  return lenBtrMgrResult;
1927  }
1928  }
1929  else if ((lenBTRCoreDevTy == enBTRCoreMobileAudioIn) || (lenBTRCoreDevTy == enBTRCorePCAudioIn)) {
1930  /* Streaming-In is happening; stop it */
1931  if ((lenBtrMgrResult = BTRMGR_StopAudioStreamingIn(aui8AdapterIdx, ghBTRMgrDevHdlCurStreaming)) != BTRMGR_RESULT_SUCCESS) {
1932  BTRMGRLOG_ERROR ("This device is being Connected n Playing. Failed to stop Playback.-In\n");
1933  BTRMGRLOG_ERROR ("Failed to stop streaming at the current device..\n");
1934  return lenBtrMgrResult;
1935  }
1936  }
1937  }
1938 
1939  /* Check whether the device is in the paired list */
1940  memset(&listOfPDevices, 0, sizeof(listOfPDevices));
1941  if ((lenBtrCoreRet = BTRCore_GetListOfPairedDevices(ghBTRCoreHdl, &listOfPDevices)) != enBTRCoreSuccess) {
1942  BTRMGRLOG_ERROR ("Failed to get the paired devices list\n");
1943  return eBTRMgrFailure;
1944  }
1945 
1946 
1947  if (!listOfPDevices.numberOfDevices) {
1948  BTRMGRLOG_ERROR ("No device is paired yet; Will not be able to play at this moment\n");
1949  return eBTRMgrFailure;
1950  }
1951 
1952 
1953  for (i = 0; i < listOfPDevices.numberOfDevices; i++) {
1954  if (ahBTRMgrDevHdl == listOfPDevices.devices[i].tDeviceId) {
1955  isFound = 1;
1956  break;
1957  }
1958  }
1959 
1960  if (!isFound) {
1961  BTRMGRLOG_ERROR ("Failed to find this device in the paired devices list\n");
1962  return eBTRMgrFailure;
1963  }
1964 
1965 
1966  if (aui32ConnectRetryIdx) {
1967  unsigned int ui32sleepTimeOut = 2;
1968  unsigned int ui32confirmIdx = aui32ConfirmIdx + 1;
1969 
1970  do {
1971  unsigned int ui32sleepIdx = aui32SleepIdx + 1;
1972  do {
1973  sleep(ui32sleepTimeOut);
1974  lenBtrCoreRet = BTRCore_IsDeviceConnectable(ghBTRCoreHdl, listOfPDevices.devices[i].tDeviceId);
1975  } while ((lenBtrCoreRet != enBTRCoreSuccess) && (--ui32sleepIdx));
1976  } while ((lenBtrCoreRet != enBTRCoreSuccess) && (--ui32confirmIdx));
1977 
1978  if (lenBtrCoreRet != enBTRCoreSuccess) {
1979  BTRMGRLOG_ERROR ("Device Not Connectable\n");
1980  return eBTRMgrFailure;
1981  }
1982  else if (((btrMgr_IsDevConnected(listOfPDevices.devices[i].tDeviceId) == 1) ||
1983  (ghBTRMgrDevHdlCurStreaming == listOfPDevices.devices[i].tDeviceId)) &&
1984  (ghBTRMgrDevHdlLastConnected == listOfPDevices.devices[i].tDeviceId)) {
1985  BTRMGRLOG_INFO ("Device Already Connected and Streaming = %lld\n", listOfPDevices.devices[i].tDeviceId);
1986  return eBTRMgrSuccess;
1987  }
1988  }
1989 
1990 
1991  do {
1992  unsigned short ui16DevMediaBitrate = 0;
1993 
1994  /* Connect the device - If the device is not connected, Connect to it */
1995  if (aui32ConnectRetryIdx) {
1996  lenBtrMgrRet = btrMgr_ConnectToDevice(aui8AdapterIdx, listOfPDevices.devices[i].tDeviceId, streamOutPref, BTRMGR_CONNECT_RETRY_ATTEMPTS, BTRMGR_DEVCONN_CHECK_RETRY_ATTEMPTS);
1997  }
1998  else if (strstr(listOfPDevices.devices[i].pcDeviceName, "Denon") || strstr(listOfPDevices.devices[i].pcDeviceName, "AVR") ||
1999  strstr(listOfPDevices.devices[i].pcDeviceName, "DENON") || strstr(listOfPDevices.devices[i].pcDeviceName, "Avr")) {
2000  lenBtrMgrRet = btrMgr_ConnectToDevice(aui8AdapterIdx, listOfPDevices.devices[i].tDeviceId, streamOutPref, 0, BTRMGR_DEVCONN_CHECK_RETRY_ATTEMPTS + 2);
2001  }
2002  else {
2003  lenBtrMgrRet = btrMgr_ConnectToDevice(aui8AdapterIdx, listOfPDevices.devices[i].tDeviceId, streamOutPref, 0, 1);
2004  }
2005 
2006  if (lenBtrMgrRet == eBTRMgrSuccess) {
2007  if (gstBtrCoreDevMediaInfo.pstBtrCoreDevMCodecInfo) {
2008  free (gstBtrCoreDevMediaInfo.pstBtrCoreDevMCodecInfo);
2009  gstBtrCoreDevMediaInfo.pstBtrCoreDevMCodecInfo = NULL;
2010  }
2011 
2012 
2013  gstBtrCoreDevMediaInfo.pstBtrCoreDevMCodecInfo = (void*)malloc((sizeof(stBTRCoreDevMediaPcmInfo) > sizeof(stBTRCoreDevMediaSbcInfo) ? sizeof(stBTRCoreDevMediaPcmInfo) : sizeof(stBTRCoreDevMediaSbcInfo)) > sizeof(stBTRCoreDevMediaMpegInfo) ?
2014  (sizeof(stBTRCoreDevMediaPcmInfo) > sizeof(stBTRCoreDevMediaSbcInfo) ? sizeof(stBTRCoreDevMediaPcmInfo) : sizeof(stBTRCoreDevMediaSbcInfo)) : sizeof(stBTRCoreDevMediaMpegInfo));
2015 
2016  lenBtrCoreRet = BTRCore_GetDeviceMediaInfo(ghBTRCoreHdl, listOfPDevices.devices[i].tDeviceId, enBTRCoreSpeakers, &gstBtrCoreDevMediaInfo);
2017  if (lenBtrCoreRet == enBTRCoreSuccess) {
2018  lenBtrCoreDevOutMType = gstBtrCoreDevMediaInfo.eBtrCoreDevMType;
2019  lpstBtrCoreDevOutMCodecInfo= gstBtrCoreDevMediaInfo.pstBtrCoreDevMCodecInfo;
2020 
2021  if (lenBtrCoreDevOutMType == eBTRCoreDevMediaTypeSBC) {
2022  stBTRCoreDevMediaSbcInfo* lpstBtrCoreDevMSbcInfo = (stBTRCoreDevMediaSbcInfo*)lpstBtrCoreDevOutMCodecInfo;
2023 
2024  ui16DevMediaBitrate = lpstBtrCoreDevMSbcInfo->ui16DevMSbcBitrate;
2025 
2026  BTRMGRLOG_INFO ("DevMedInfo SFreq = %d\n", lpstBtrCoreDevMSbcInfo->ui32DevMSFreq);
2027  BTRMGRLOG_INFO ("DevMedInfo AChan = %d\n", lpstBtrCoreDevMSbcInfo->eDevMAChan);
2028  BTRMGRLOG_INFO ("DevMedInfo SbcAllocMethod= %d\n", lpstBtrCoreDevMSbcInfo->ui8DevMSbcAllocMethod);
2029  BTRMGRLOG_INFO ("DevMedInfo SbcSubbands = %d\n", lpstBtrCoreDevMSbcInfo->ui8DevMSbcSubbands);
2030  BTRMGRLOG_INFO ("DevMedInfo SbcBlockLength= %d\n", lpstBtrCoreDevMSbcInfo->ui8DevMSbcBlockLength);
2031  BTRMGRLOG_INFO ("DevMedInfo SbcMinBitpool = %d\n", lpstBtrCoreDevMSbcInfo->ui8DevMSbcMinBitpool);
2032  BTRMGRLOG_INFO ("DevMedInfo SbcMaxBitpool = %d\n", lpstBtrCoreDevMSbcInfo->ui8DevMSbcMaxBitpool);
2033  BTRMGRLOG_INFO ("DevMedInfo SbcFrameLen = %d\n", lpstBtrCoreDevMSbcInfo->ui16DevMSbcFrameLen);
2034  BTRMGRLOG_DEBUG("DevMedInfo SbcBitrate = %d\n", lpstBtrCoreDevMSbcInfo->ui16DevMSbcBitrate);
2035  }
2036  }
2037 
2038  if (ui16DevMediaBitrate) {
2039  /* Aquire Device Data Path to start the audio casting */
2040  lenBtrCoreRet = BTRCore_AcquireDeviceDataPath(ghBTRCoreHdl, listOfPDevices.devices[i].tDeviceId, enBTRCoreSpeakers, &deviceFD, &deviceReadMTU, &deviceWriteMTU, &deviceDelay);
2041  if ((lenBtrCoreRet == enBTRCoreSuccess) && deviceWriteMTU) {
2042  /* Now that you got the FD & Read/Write MTU, start casting the audio */
2043  if ((lenBtrMgrRet = btrMgr_StartCastingAudio(deviceFD, deviceWriteMTU, deviceDelay, lenBtrCoreDevOutMType, lpstBtrCoreDevOutMCodecInfo)) == eBTRMgrSuccess) {
2044  ghBTRMgrDevHdlCurStreaming = listOfPDevices.devices[i].tDeviceId;
2045  BTRMGRLOG_INFO("Streaming Started.. Enjoy the show..! :)\n");
2046 
2047  if (BTRCore_SetDeviceDataAckTimeout(ghBTRCoreHdl, 100) != enBTRCoreSuccess) {
2048  BTRMGRLOG_WARN ("Failed to set timeout for Audio drop. EXPECT AV SYNC ISSUES!\n");
2049  }
2050  }
2051  else {
2052  BTRMGRLOG_ERROR ("Failed to stream now\n");
2053  }
2054  }
2055  }
2056 
2057  }
2058 
2059 
2060  if (!ui16DevMediaBitrate || (lenBtrCoreRet != enBTRCoreSuccess) || (lenBtrMgrRet != eBTRMgrSuccess)) {
2061  BTRMGRLOG_ERROR ("Failed to get Device Data Path. So Will not be able to stream now\n");
2062  BTRMGRLOG_ERROR ("Failed to get Valid MediaBitrate. So Will not be able to stream now\n");
2063  BTRMGRLOG_ERROR ("Failed to StartCastingAudio. So Will not be able to stream now\n");
2064  BTRMGRLOG_ERROR ("Failed to connect to device and not playing\n");
2065  lenBtrCoreRet = BTRCore_DisconnectDevice (ghBTRCoreHdl, listOfPDevices.devices[i].tDeviceId, enBTRCoreSpeakers);
2066  if (lenBtrCoreRet == enBTRCoreSuccess) {
2067  /* Max 4 sec timeout - Polled at 1 second interval: Confirmed 2 times */
2068  unsigned int ui32sleepTimeOut = 1;
2069  unsigned int ui32confirmIdx = aui32ConfirmIdx + 1;
2070 
2071  do {
2072  unsigned int ui32sleepIdx = aui32SleepIdx + 1;
2073 
2074  do {
2075  sleep(ui32sleepTimeOut);
2076  lenBtrCoreRet = BTRCore_GetDeviceDisconnected(ghBTRCoreHdl, listOfPDevices.devices[i].tDeviceId, enBTRCoreSpeakers);
2077  } while ((lenBtrCoreRet != enBTRCoreSuccess) && (--ui32sleepIdx));
2078  } while (--ui32confirmIdx);
2079 
2080  if (lenBtrCoreRet != enBTRCoreSuccess) {
2081  BTRMGRLOG_ERROR ("Failed to Disconnect from this device - Confirmed - %llu\n", listOfPDevices.devices[i].tDeviceId);
2082  lenBtrMgrRet = eBTRMgrFailure;
2083  }
2084  else
2085  BTRMGRLOG_DEBUG ("Success Disconnect from this device - Confirmed - %llu\n", listOfPDevices.devices[i].tDeviceId);
2086  }
2087 
2088  lenBtrMgrRet = eBTRMgrFailure;
2089  }
2090 
2091 
2092  } while ((lenBtrMgrRet == eBTRMgrFailure) && (--ui32retryIdx));
2093 
2094 
2095  {
2096  BTRMGR_EventMessage_t lstEventMessage;
2097  memset (&lstEventMessage, 0, sizeof(lstEventMessage));
2098 
2099  lstEventMessage.m_adapterIndex = aui8AdapterIdx;
2100  lstEventMessage.m_pairedDevice.m_deviceHandle = listOfPDevices.devices[i].tDeviceId;
2101  lstEventMessage.m_pairedDevice.m_deviceType = btrMgr_MapDeviceTypeFromCore(listOfPDevices.devices[i].enDeviceType);
2102  lstEventMessage.m_pairedDevice.m_isConnected = (btrMgr_IsDevConnected(listOfPDevices.devices[i].tDeviceId)) ? 1 : 0;
2103  lstEventMessage.m_pairedDevice.m_isLowEnergyDevice = (lstEventMessage.m_pairedDevice.m_deviceType==BTRMGR_DEVICE_TYPE_TILE)?1:0;//will make it generic later
2104  strncpy(lstEventMessage.m_pairedDevice.m_name, listOfPDevices.devices[i].pcDeviceName, BTRMGR_NAME_LEN_MAX);
2105  strncpy(lstEventMessage.m_pairedDevice.m_deviceAddress, listOfPDevices.devices[i].pcDeviceAddress, BTRMGR_NAME_LEN_MAX);
2106 
2107  if (lenBtrMgrRet == eBTRMgrSuccess) {
2108  lstEventMessage.m_eventType = BTRMGR_EVENT_DEVICE_CONNECTION_COMPLETE;
2109 
2110  if (gfpcBBTRMgrEventOut) {
2111  gfpcBBTRMgrEventOut(lstEventMessage); /* Post a callback */
2112  }
2113  }
2114  else if (lenBtrMgrRet == eBTRMgrFailure) {
2115  lstEventMessage.m_eventType = BTRMGR_EVENT_DEVICE_CONNECTION_FAILED;
2116 
2117  if (gfpcBBTRMgrEventOut) {
2118  gfpcBBTRMgrEventOut(lstEventMessage); /* Post a callback */
2119  }
2120  }
2121  else {
2122  //TODO: Some error specific event to XRE
2123  }
2124  }
2125 
2126  return lenBtrMgrRet;
2127 }
2128 
2129 static eBTRMgrRet
2130 btrMgr_AddPersistentEntry (
2131  unsigned char aui8AdapterIdx,
2132  BTRMgrDeviceHandle ahBTRMgrDevHdl,
2133  const char* apui8ProfileStr,
2134  int ai32DevConnected
2135 ) {
2136  char lui8adapterAddr[BD_NAME_LEN] = {'\0'};
2137  eBTRMgrRet lenBtrMgrPiRet = eBTRMgrFailure;
2138 
2139  BTRCore_GetAdapterAddr(ghBTRCoreHdl, aui8AdapterIdx, lui8adapterAddr);
2140 
2141  // Device connected add data from json file
2142  BTRMGR_Profile_t btPtofile;
2143  strncpy(btPtofile.adapterId, lui8adapterAddr, BTRMGR_NAME_LEN_MAX -1);
2144  btPtofile.adapterId[BTRMGR_NAME_LEN_MAX -1] = '\0';
2145  strncpy(btPtofile.profileId, apui8ProfileStr, BTRMGR_NAME_LEN_MAX -1);
2146  btPtofile.profileId[BTRMGR_NAME_LEN_MAX -1] = '\0'; //CID:136398 - Bufefr size warning
2147  btPtofile.deviceId = ahBTRMgrDevHdl;
2148  btPtofile.isConnect = ai32DevConnected;
2149 
2150  lenBtrMgrPiRet = BTRMgr_PI_AddProfile(ghBTRMgrPiHdl, &btPtofile);
2151  if(lenBtrMgrPiRet == eBTRMgrSuccess) {
2152  BTRMGRLOG_INFO ("Persistent File updated successfully\n");
2153  }
2154  else {
2155  BTRMGRLOG_ERROR ("Persistent File update failed \n");
2156  }
2157 
2158  return lenBtrMgrPiRet;
2159 }
2160 
2161 static eBTRMgrRet
2162 btrMgr_RemovePersistentEntry (
2163  unsigned char aui8AdapterIdx,
2164  BTRMgrDeviceHandle ahBTRMgrDevHdl,
2165  const char* apui8ProfileStr
2166 ) {
2167  char lui8adapterAddr[BD_NAME_LEN] = {'\0'};
2168  eBTRMgrRet lenBtrMgrPiRet = eBTRMgrFailure;
2169 
2170  BTRCore_GetAdapterAddr(ghBTRCoreHdl, aui8AdapterIdx, lui8adapterAddr);
2171 
2172  // Device disconnected remove data from json file
2173  BTRMGR_Profile_t btPtofile;
2174  strncpy(btPtofile.adapterId, lui8adapterAddr, BTRMGR_NAME_LEN_MAX -1);
2175  btPtofile.adapterId[BTRMGR_NAME_LEN_MAX -1] = '\0';
2176  strncpy(btPtofile.profileId, apui8ProfileStr, BTRMGR_NAME_LEN_MAX -1);
2177  btPtofile.profileId[BTRMGR_NAME_LEN_MAX -1] = '\0'; //CID:136475 - Buffer size warning
2178  btPtofile.deviceId = ahBTRMgrDevHdl;
2179  btPtofile.isConnect = 1;
2180 
2181  lenBtrMgrPiRet = BTRMgr_PI_RemoveProfile(ghBTRMgrPiHdl, &btPtofile);
2182  if(lenBtrMgrPiRet == eBTRMgrSuccess) {
2183  BTRMGRLOG_INFO ("Persistent File updated successfully\n");
2184  }
2185  else {
2186  BTRMGRLOG_ERROR ("Persistent File update failed \n");
2187  }
2188 
2189  return lenBtrMgrPiRet;
2190 }
2191 
2192 static BTRMGR_SysDiagChar_t
2193 btrMgr_MapUUIDtoDiagElement(
2194  char *aUUID
2195 ) {
2196  BTRMGR_SysDiagChar_t lDiagChar = BTRMGR_SYS_DIAG_UNKNOWN;
2197 #ifndef BTRTEST_LE_ONBRDG_ENABLE
2198  if (!strcmp(aUUID, BTRMGR_SYSTEM_ID_UUID)) { lDiagChar = BTRMGR_SYS_DIAG_SYSTEMID; }
2199  else if (!strcmp(aUUID, BTRMGR_MODEL_NUMBER_UUID)) { lDiagChar = BTRMGR_SYS_DIAG_MODELNUMBER; }
2200  else if (!strcmp(aUUID, BTRMGR_SERIAL_NUMBER_UUID)) { lDiagChar = BTRMGR_SYS_DIAG_SERIALNUMBER; }
2201  else if (!strcmp(aUUID, BTRMGR_FIRMWARE_REVISION_UUID)) { lDiagChar = BTRMGR_SYS_DIAG_FWREVISION; }
2202  else if (!strcmp(aUUID, BTRMGR_HARDWARE_REVISION_UUID)) { lDiagChar = BTRMGR_SYS_DIAG_HWREVISION; }
2203  else if (!strcmp(aUUID, BTRMGR_SOFTWARE_REVISION_UUID)) { lDiagChar = BTRMGR_SYS_DIAG_SWREVISION; }
2204  else if (!strcmp(aUUID, BTRMGR_MANUFACTURER_NAME_UUID)) { lDiagChar = BTRMGR_SYS_DIAG_MFGRNAME; }
2205 #else
2206  if (!strcmp(aUUID, BTRMGR_SYSTEM_ID_UUID)) { lDiagChar = BTRMGR_LE_ONBRDG_SYSTEMID; }
2207  else if (!strcmp(aUUID, BTRMGR_MODEL_NUMBER_UUID)) { lDiagChar = BTRMGR_LE_ONBRDG_MODELNUMBER; }
2208  else if (!strcmp(aUUID, BTRMGR_SERIAL_NUMBER_UUID)) { lDiagChar = BTRMGR_LE_ONBRDG_SERIALNUMBER; }
2209  else if (!strcmp(aUUID, BTRMGR_FIRMWARE_REVISION_UUID)) { lDiagChar = BTRMGR_LE_ONBRDG_FWREVISION; }
2210  else if (!strcmp(aUUID, BTRMGR_HARDWARE_REVISION_UUID)) { lDiagChar = BTRMGR_LE_ONBRDG_HWREVISION; }
2211  else if (!strcmp(aUUID, BTRMGR_SOFTWARE_REVISION_UUID)) { lDiagChar = BTRMGR_LE_ONBRDG_SWREVISION; }
2212  else if (!strcmp(aUUID, BTRMGR_MANUFACTURER_NAME_UUID)) { lDiagChar = BTRMGR_LE_ONBRDG_MFGRNAME; }
2213 #endif
2214  else if (!strcmp(aUUID, BTRMGR_LEONBRDG_UUID_QR_CODE)) { lDiagChar = BTRMGR_LE_ONBRDG_UUID_QR_CODE; }
2215  else if (!strcmp(aUUID, BTRMGR_LEONBRDG_UUID_PROVISION_STATUS)) { lDiagChar = BTRMGR_LE_ONBRDG_UUID_PROVISION_STATUS; }
2216  else if (!strcmp(aUUID, BTRMGR_LEONBRDG_UUID_PUBLIC_KEY)) { lDiagChar = BTRMGR_LE_ONBRDG_UUID_PUBLIC_KEY; }
2217  else if (!strcmp(aUUID, BTRMGR_LEONBRDG_UUID_WIFI_CONFIG)) { lDiagChar = BTRMGR_LE_ONBRDG_UUID_WIFI_CONFIG; }
2218  else if (!strcmp(aUUID, BTRMGR_DEVICE_STATUS_UUID)) { lDiagChar = BTRMGR_SYS_DIAG_DEVICESTATUS; }
2219  else if (!strcmp(aUUID, BTRMGR_FWDOWNLOAD_STATUS_UUID)) { lDiagChar = BTRMGR_SYS_DIAG_FWDOWNLOADSTATUS; }
2220  else if (!strcmp(aUUID, BTRMGR_WEBPA_STATUS_UUID)) { lDiagChar = BTRMGR_SYS_DIAG_WEBPASTATUS; }
2221  else if (!strcmp(aUUID, BTRMGR_WIFIRADIO1_STATUS_UUID)) { lDiagChar = BTRMGR_SYS_DIAG_WIFIRADIO1STATUS; }
2222  else if (!strcmp(aUUID, BTRMGR_WIFIRADIO2_STATUS_UUID)) { lDiagChar = BTRMGR_SYS_DIAG_WIFIRADIO2STATUS; }
2223  else if (!strcmp(aUUID, BTRMGR_RF_STATUS_UUID)) { lDiagChar = BTRMGR_SYS_DIAG_RFSTATUS; }
2224  else if (!strcmp(aUUID, BTRMGR_DEVICE_MAC)) { lDiagChar = BTRMGR_SYS_DIAG_DEVICEMAC; }
2225  else if (!strcmp(aUUID, BTRMGR_COLUMBO_START)) { lDiagChar = BTRMGR_SYSDIAG_COLUMBO_START; }
2226  else if (!strcmp(aUUID, BTRMGR_COLUMBO_STOP)) { lDiagChar = BTRMGR_SYSDIAG_COLUMBO_STOP; }
2227  else { lDiagChar = BTRMGR_SYS_DIAG_UNKNOWN; }
2228 
2229  return lDiagChar;
2230 }
2231 
2232 #if 0
2233 static void btrMgr_AddColumboGATTInfo(
2234 ){
2235  char l16BitUUID[4] = "";
2236  char l128BitUUID[BTRMGR_NAME_LEN_MAX] = "";
2237 
2238  strncpy(l128BitUUID, BTRMGR_COLUMBO_UUID, BTRMGR_NAME_LEN_MAX - 1);
2239  snprintf(l16BitUUID, 5, "%s", l128BitUUID);
2240 
2241  /* add to GAP advertisement */
2242  BTRCore_SetServiceUUIDs(ghBTRCoreHdl, l16BitUUID);
2243  /* Add to GATT Info */
2244  BTRCore_SetServiceInfo(ghBTRCoreHdl, BTRMGR_COLUMBO_UUID, TRUE);
2245  BTRCore_SetGattInfo(ghBTRCoreHdl, BTRMGR_COLUMBO_UUID, BTRMGR_COLUMBO_START, 0x2, " ", enBTRCoreLePropGChar); /* uuid_columbo_service_char_start */
2246  BTRCore_SetGattInfo(ghBTRCoreHdl, BTRMGR_COLUMBO_UUID, BTRMGR_COLUMBO_STOP, 0x2, " ", enBTRCoreLePropGChar); /* uuid_columbo_service_char_stop */
2247  BTRCore_SetGattInfo(ghBTRCoreHdl, BTRMGR_COLUMBO_UUID, BTRMGR_COLUMBO_STATUS, 0x1, " ", enBTRCoreLePropGChar); /* uuid_columbo_service_char_status */
2248  BTRCore_SetGattInfo(ghBTRCoreHdl, BTRMGR_COLUMBO_UUID, BTRMGR_COLUMBO_REPORT, 0x1, " ", enBTRCoreLePropGChar); /* uuid_columbo_service_char_report */
2249 }
2250 
2251 static void btrMgr_AddStandardAdvGattInfo(
2252 ){
2253  char lPropertyValue[BTRMGR_MAX_STR_LEN] = "";
2254 
2255  BTRMGRLOG_INFO("Adding default local services : DEVICE_INFORMATION_UUID - 0x180a, RDKDIAGNOSTICS_UUID - 0xFDB9\n");
2256  BTRMGR_LE_SetServiceInfo(0, BTRMGR_DEVICE_INFORMATION_UUID, 1);
2257  BTRMGR_LE_SetServiceInfo(0, BTRMGR_RDKDIAGNOSTICS_UUID, 1);
2258 
2259  /* Get model number */
2260  BTRMGR_SysDiagInfo(0, BTRMGR_SYSTEM_ID_UUID, lPropertyValue, BTRMGR_LE_OP_READ_VALUE);
2261  BTRMGRLOG_INFO("Adding char for the default local services : 0x180a, 0xFDB9\n");
2262  BTRMGR_LE_SetGattInfo(0, BTRMGR_DEVICE_INFORMATION_UUID, BTRMGR_SYSTEM_ID_UUID, 0x1, lPropertyValue, BTRMGR_LE_PROP_CHAR); /* system ID */
2263  BTRMGR_LE_SetGattInfo(0, BTRMGR_DEVICE_INFORMATION_UUID, BTRMGR_MODEL_NUMBER_UUID, 0x1, lPropertyValue, BTRMGR_LE_PROP_CHAR); /* model number */
2264  /*Get HW revision*/
2265  BTRMGR_LE_SetGattInfo(0, BTRMGR_DEVICE_INFORMATION_UUID, BTRMGR_HARDWARE_REVISION_UUID, 0x1, lPropertyValue, BTRMGR_LE_PROP_CHAR); /* Hardware revision */
2266  /* Get serial number */
2267  BTRMGR_SysDiagInfo(0, BTRMGR_SERIAL_NUMBER_UUID, lPropertyValue, BTRMGR_LE_OP_READ_VALUE);
2268  BTRMGR_LE_SetGattInfo(0, BTRMGR_DEVICE_INFORMATION_UUID, BTRMGR_SERIAL_NUMBER_UUID, 0x1, lPropertyValue, BTRMGR_LE_PROP_CHAR); /* serial number */
2269  /* Get firmware revision */
2270  BTRMGR_SysDiagInfo(0, BTRMGR_FIRMWARE_REVISION_UUID, lPropertyValue, BTRMGR_LE_OP_READ_VALUE);
2271  BTRMGR_LE_SetGattInfo(0, BTRMGR_DEVICE_INFORMATION_UUID, BTRMGR_FIRMWARE_REVISION_UUID, 0x1, lPropertyValue, BTRMGR_LE_PROP_CHAR); /* Firmware revision */
2272  BTRMGR_LE_SetGattInfo(0, BTRMGR_DEVICE_INFORMATION_UUID, BTRMGR_SOFTWARE_REVISION_UUID, 0x1, lPropertyValue, BTRMGR_LE_PROP_CHAR); /* Software revision */
2273  /* Get manufacturer name */
2274  BTRMGR_SysDiagInfo(0, BTRMGR_MANUFACTURER_NAME_UUID, lPropertyValue, BTRMGR_LE_OP_READ_VALUE);
2275  BTRMGR_LE_SetGattInfo(0, BTRMGR_DEVICE_INFORMATION_UUID, BTRMGR_MANUFACTURER_NAME_UUID, 0x1, lPropertyValue, BTRMGR_LE_PROP_CHAR); /* Manufacturer name */
2276 
2277  /* 0xFDB9 */
2278  BTRMGR_LE_SetGattInfo(0, BTRMGR_RDKDIAGNOSTICS_UUID, BTRMGR_DEVICE_STATUS_UUID, 0x1, "READY", BTRMGR_LE_PROP_CHAR); /* DeviceStatus */
2279  BTRMGR_SysDiagInfo(0, BTRMGR_FWDOWNLOAD_STATUS_UUID, lPropertyValue, BTRMGR_LE_OP_READ_VALUE);
2280  BTRMGR_LE_SetGattInfo(0, BTRMGR_RDKDIAGNOSTICS_UUID, BTRMGR_FWDOWNLOAD_STATUS_UUID, 0x103, lPropertyValue, BTRMGR_LE_PROP_CHAR); /* FWDownloadStatus */
2281  BTRMGR_SysDiagInfo(0, BTRMGR_WEBPA_STATUS_UUID, lPropertyValue, BTRMGR_LE_OP_READ_VALUE);
2282  BTRMGR_LE_SetGattInfo(0, BTRMGR_RDKDIAGNOSTICS_UUID, BTRMGR_WEBPA_STATUS_UUID, 0x1, lPropertyValue, BTRMGR_LE_PROP_CHAR); /* WebPAStatus */
2283  BTRMGR_SysDiagInfo(0, BTRMGR_WIFIRADIO1_STATUS_UUID, lPropertyValue, BTRMGR_LE_OP_READ_VALUE);
2284  BTRMGR_LE_SetGattInfo(0, BTRMGR_RDKDIAGNOSTICS_UUID, BTRMGR_WIFIRADIO1_STATUS_UUID, 0x1, lPropertyValue, BTRMGR_LE_PROP_CHAR); /* WiFiRadio1Status */
2285  BTRMGR_LE_SetGattInfo(0, BTRMGR_RDKDIAGNOSTICS_UUID, BTRMGR_WIFIRADIO2_STATUS_UUID, 0x1, lPropertyValue, BTRMGR_LE_PROP_CHAR); /* WiFiRadio2Status */
2286  BTRMGR_SysDiagInfo(0, BTRMGR_RF_STATUS_UUID, lPropertyValue, BTRMGR_LE_OP_READ_VALUE);
2287  BTRMGR_LE_SetGattInfo(0, BTRMGR_RDKDIAGNOSTICS_UUID, BTRMGR_RF_STATUS_UUID, 0x1, "NOT CONNECTED", BTRMGR_LE_PROP_CHAR); /* RFStatus */
2288 }
2289 #endif
2290 /* Local Op Threads */
2291 
2292 
2293 /* Interfaces - Public Functions */
2294 BTRMGR_Result_t
2295 BTRMGR_Init (
2296  void
2297 ) {
2298  BTRMGR_Result_t lenBtrMgrResult= BTRMGR_RESULT_SUCCESS;
2299  enBTRCoreRet lenBtrCoreRet = enBTRCoreSuccess;
2300  eBTRMgrRet lenBtrMgrPiRet = eBTRMgrFailure;
2301  eBTRMgrRet lenBtrMgrSdRet = eBTRMgrFailure;
2302  GMainLoop* pMainLoop = NULL;
2303  GThread* pMainLoopThread= NULL;
2304 
2305  char lpcBtVersion[BTRCORE_STR_LEN] = {'\0'};
2306 
2307  if (ghBTRCoreHdl) {
2308  BTRMGRLOG_WARN("Already Inited; Return Success\n");
2309  return lenBtrMgrResult;
2310  }
2311 
2312 #ifdef RDK_LOGGER_ENABLED
2313  const char* pDebugConfig = NULL;
2314  const char* BTRMGR_DEBUG_ACTUAL_PATH = "/etc/debug.ini";
2315  const char* BTRMGR_DEBUG_OVERRIDE_PATH = "/opt/debug.ini";
2316 
2317  /* Init the logger */
2318  if (access(BTRMGR_DEBUG_OVERRIDE_PATH, F_OK) != -1) {
2319  pDebugConfig = BTRMGR_DEBUG_OVERRIDE_PATH;
2320  }
2321  else {
2322  pDebugConfig = BTRMGR_DEBUG_ACTUAL_PATH;
2323  }
2324 
2325  if (0 == rdk_logger_init(pDebugConfig)) {
2326  b_rdk_logger_enabled = 1;
2327  }
2328 #endif
2329 
2330  /* Initialze all the database */
2331  memset(&gDefaultAdapterContext, 0, sizeof(gDefaultAdapterContext));
2332  memset(&gListOfAdapters, 0, sizeof(gListOfAdapters));
2333  memset(&gstBTRMgrStreamingInfo, 0, sizeof(gstBTRMgrStreamingInfo));
2334  memset(&gListOfPairedDevices, 0, sizeof(gListOfPairedDevices));
2335  memset(&gstBtrCoreDevMediaInfo, 0, sizeof(gstBtrCoreDevMediaInfo));
2336  //gIsDiscoveryInProgress = 0;
2337 
2338 
2339  /* Init the mutex */
2340 
2341  /* Call the Core/HAL init */
2342  lenBtrCoreRet = BTRCore_Init(&ghBTRCoreHdl);
2343  if ((!ghBTRCoreHdl) || (lenBtrCoreRet != enBTRCoreSuccess)) {
2344  BTRMGRLOG_ERROR ("Could not initialize BTRCore/HAL module\n");
2345  return BTRMGR_RESULT_GENERIC_FAILURE;
2346  }
2347 
2348 
2349  if (enBTRCoreSuccess != BTRCore_GetVersionInfo(ghBTRCoreHdl, lpcBtVersion)) {
2350  BTRMGRLOG_ERROR ("BTR Bluetooth Version: FAILED\n");
2351  }
2352  BTRMGRLOG_INFO("BTR Bluetooth Version: %s\n", lpcBtVersion);
2353 
2354  if (enBTRCoreSuccess != BTRCore_GetListOfAdapters (ghBTRCoreHdl, &gListOfAdapters)) {
2355  BTRMGRLOG_ERROR ("Failed to get the total number of Adapters present\n"); /* Not a Error case anyway */
2356  }
2357  BTRMGRLOG_INFO ("Number of Adapters found are = %u\n", gListOfAdapters.number_of_adapters);
2358 
2359  if (0 == gListOfAdapters.number_of_adapters) {
2360  BTRMGRLOG_WARN("Bluetooth adapter NOT Found..!!!!\n");
2361  return BTRMGR_RESULT_GENERIC_FAILURE;
2362  }
2363 
2364 
2365  /* you have atlesat one Bluetooth adapter. Now get the Default Adapter path for future usages; */
2366  gDefaultAdapterContext.bFirstAvailable = 1; /* This is unused by core now but lets fill it */
2367  if (enBTRCoreSuccess != BTRCore_GetAdapter(ghBTRCoreHdl, &gDefaultAdapterContext)) {
2368  BTRMGRLOG_WARN("Bluetooth adapter NOT received..!!!!\n");
2369  return BTRMGR_RESULT_GENERIC_FAILURE;
2370  }
2371 
2372  BTRMGRLOG_DEBUG ("Aquired default Adapter; Path is %s\n", gDefaultAdapterContext.pcAdapterPath);
2373  /* TODO: Handling multiple Adapters */
2374  if (gListOfAdapters.number_of_adapters > 1) {
2375  BTRMGRLOG_WARN("Number of Bluetooth Adapters Found : %u !! Lets handle it properly\n", gListOfAdapters.number_of_adapters);
2376  }
2377 
2378 
2379  /* Register for callback to get the status of connected Devices */
2380  BTRCore_RegisterStatusCb(ghBTRCoreHdl, btrMgr_DeviceStatusCb, NULL);
2381 
2382  /* Register for callback to get the Discovered Devices */
2383  BTRCore_RegisterDiscoveryCb(ghBTRCoreHdl, btrMgr_DeviceDiscoveryCb, NULL);
2384 
2385  /* Register for callback to process incoming pairing requests */
2386  BTRCore_RegisterConnectionIntimationCb(ghBTRCoreHdl, btrMgr_ConnectionInIntimationCb, NULL);
2387 
2388  /* Register for callback to process incoming connection requests */
2389  BTRCore_RegisterConnectionAuthenticationCb(ghBTRCoreHdl, btrMgr_ConnectionInAuthenticationCb, NULL);
2390 
2391  /* Register for callback to process incoming media events */
2392  BTRCore_RegisterMediaStatusCb(ghBTRCoreHdl, btrMgr_MediaStatusCb, NULL);
2393 
2394 
2395  /* Activate Agent on Init */
2396  if (!btrMgr_GetAgentActivated()) {
2397  BTRMGRLOG_INFO ("Activate agent\n");
2398  if ((lenBtrCoreRet = BTRCore_RegisterAgent(ghBTRCoreHdl, 1)) != enBTRCoreSuccess) {
2399  BTRMGRLOG_ERROR ("Failed to Activate Agent\n");
2400  lenBtrMgrResult = BTRMGR_RESULT_GENERIC_FAILURE;
2401  }
2402  else {
2403  btrMgr_SetAgentActivated(1);
2404  }
2405  }
2406 
2407  btrMgr_SetBgDiscoveryType (BTRMGR_DEVICE_OP_TYPE_LE);
2408 
2409  /* Initialize the Paired Device List for Default adapter */
2410  BTRMGR_GetPairedDevices (gDefaultAdapterContext.adapter_number, &gListOfPairedDevices);
2411 
2412 
2413  // Init Persistent handles
2414  if ((lenBtrMgrPiRet = BTRMgr_PI_Init(&ghBTRMgrPiHdl)) != eBTRMgrSuccess) {
2415  BTRMGRLOG_ERROR ("Could not initialize PI module\n");
2416  }
2417 
2418  // Init SysDiag handles
2419  if ((lenBtrMgrSdRet = BTRMgr_SD_Init(&ghBTRMgrSdHdl, btrMgr_SDStatusCb, NULL)) != eBTRMgrSuccess) {
2420  BTRMGRLOG_ERROR ("Could not initialize SD - SysDiag module\n");
2421  }
2422 
2423  btrMgr_CheckAudioInServiceAvailability();
2424  btrMgr_CheckHidGamePadServiceAvailability();
2425 #if 0
2426  // Set the beacon and start the advertisement
2427 
2428  char lDeviceMAC[BTRMGR_MAX_STR_LEN] = "";
2429 
2430  BTRMGR_SysDiagInfo(0, BTRMGR_DEVICE_MAC, lDeviceMAC, BTRMGR_LE_OP_READ_VALUE);
2431  strncpy((char*)stCoreCustomAdv.device_mac, lDeviceMAC, strlen(lDeviceMAC));
2432  /* Add Columbo Gatt info */
2433  btrMgr_AddColumboGATTInfo();
2434 
2435  BTRMGR_LE_StartAdvertisement(0, &stCoreCustomAdv);
2436 #endif
2437  pMainLoop = g_main_loop_new (NULL, FALSE);
2438  gpvMainLoop = (void*)pMainLoop;
2439 
2440 
2441  pMainLoopThread = g_thread_new("btrMgr_g_main_loop_Task", btrMgr_g_main_loop_Task, gpvMainLoop);
2442  gpvMainLoopThread = (void*)pMainLoopThread;
2443  if ((pMainLoop == NULL) || (pMainLoopThread == NULL)) {
2444  BTRMGRLOG_ERROR ("Could not initialize g_main module\n");
2445  BTRMGR_DeInit();
2446  return BTRMGR_RESULT_GENERIC_FAILURE;
2447  }
2448 
2449 
2450  return lenBtrMgrResult;
2451 }
2452 
2453 
2454 BTRMGR_Result_t
2455 BTRMGR_DeInit (
2456  void
2457 ) {
2458  eBTRMgrRet lenBtrMgrRet = eBTRMgrSuccess;
2459  enBTRCoreRet lenBtrCoreRet = enBTRCoreSuccess;
2460  BTRMGR_Result_t lenBtrMgrResult = BTRMGR_RESULT_SUCCESS;
2461  BTRMGR_DiscoveryHandle_t* ldiscoveryHdl = NULL;
2462  unsigned short ui16LoopIdx = 0;
2463  BTRMGR_ConnectedDevicesList_t lstConnectedDevices;
2464  unsigned int ui32sleepTimeOut = 1;
2465 
2466 
2467  if (btrMgr_isTimeOutSet()) {
2468  btrMgr_ClearDiscoveryHoldOffTimer();
2469  gDiscHoldOffTimeOutCbData = 0;
2470  }
2471 
2472  if ((ldiscoveryHdl = btrMgr_GetDiscoveryInProgress())) {
2473  lenBtrMgrRet = btrMgr_StopDeviceDiscovery (0, ldiscoveryHdl);
2474  BTRMGRLOG_DEBUG ("Exit Discovery Status = %d\n", lenBtrMgrRet);
2475  }
2476 
2477  if ((lenBtrMgrResult = BTRMGR_GetConnectedDevices(0, &lstConnectedDevices)) == BTRMGR_RESULT_SUCCESS) {
2478  BTRMGRLOG_DEBUG ("Connected Devices = %d\n", lstConnectedDevices.m_numOfDevices);
2479 
2480  for (ui16LoopIdx = 0; ui16LoopIdx < lstConnectedDevices.m_numOfDevices; ui16LoopIdx++) {
2481  unsigned int ui32confirmIdx = 2;
2482  enBTRCoreDeviceType lenBtrCoreDevTy = enBTRCoreUnknown;
2483  enBTRCoreDeviceClass lenBtrCoreDevCl = enBTRCore_DC_Unknown;
2484 
2485  BTRCore_GetDeviceTypeClass(ghBTRCoreHdl, lstConnectedDevices.m_deviceProperty[ui16LoopIdx].m_deviceHandle, &lenBtrCoreDevTy, &lenBtrCoreDevCl);
2486  if (BTRCore_DisconnectDevice(ghBTRCoreHdl, lstConnectedDevices.m_deviceProperty[ui16LoopIdx].m_deviceHandle, lenBtrCoreDevTy) != enBTRCoreSuccess) {
2487  BTRMGRLOG_ERROR ("Failed to Disconnect - %llu\n", lstConnectedDevices.m_deviceProperty[ui16LoopIdx].m_deviceHandle);
2488  }
2489 
2490  do {
2491  unsigned int ui32sleepIdx = 2;
2492 
2493  do {
2494  sleep(ui32sleepTimeOut);
2495  lenBtrCoreRet = BTRCore_GetDeviceDisconnected(ghBTRCoreHdl, lstConnectedDevices.m_deviceProperty[ui16LoopIdx].m_deviceHandle, lenBtrCoreDevTy);
2496  } while ((lenBtrCoreRet != enBTRCoreSuccess) && (--ui32sleepIdx));
2497  } while (--ui32confirmIdx);
2498  }
2499  }
2500 
2501  if (gpvMainLoop) {
2502  g_main_loop_quit(gpvMainLoop);
2503  }
2504 
2505  if (gpvMainLoopThread) {
2506  g_thread_join(gpvMainLoopThread);
2507  gpvMainLoopThread = NULL;
2508  }
2509 
2510  if (gpvMainLoop) {
2511  g_main_loop_unref(gpvMainLoop);
2512  gpvMainLoop = NULL;
2513  }
2514 
2515 
2516  if (!ghBTRCoreHdl) {
2517  BTRMGRLOG_ERROR ("BTRCore is not Inited\n");
2518  return BTRMGR_RESULT_INIT_FAILED;
2519  }
2520 
2521  if (ghBTRMgrSdHdl) {
2522  lenBtrMgrRet = BTRMgr_SD_DeInit(ghBTRMgrSdHdl);
2523  ghBTRMgrSdHdl = NULL;
2524  BTRMGRLOG_ERROR ("SD Module DeInited = %d\n", lenBtrMgrRet);
2525  }
2526 
2527  if (ghBTRMgrPiHdl) {
2528  lenBtrMgrRet = BTRMgr_PI_DeInit(ghBTRMgrPiHdl);
2529  ghBTRMgrPiHdl = NULL;
2530  BTRMGRLOG_ERROR ("PI Module DeInited = %d\n", lenBtrMgrRet);
2531  }
2532 
2533 
2534  if (ghBTRCoreHdl) {
2535  lenBtrCoreRet = BTRCore_DeInit(ghBTRCoreHdl);
2536  ghBTRCoreHdl = NULL;
2537  BTRMGRLOG_ERROR ("BTRCore DeInited; Now will we exit the app = %d\n", lenBtrCoreRet);
2538  }
2539 
2540  lenBtrMgrResult = ((lenBtrMgrRet == eBTRMgrSuccess) &&
2541  (lenBtrCoreRet == enBTRCoreSuccess)) ? BTRMGR_RESULT_SUCCESS : BTRMGR_RESULT_GENERIC_FAILURE;
2542  BTRMGRLOG_DEBUG ("Exit Status = %d\n", lenBtrMgrResult);
2543 
2544 
2545  return lenBtrMgrResult;
2546 }
2547 
2548 
2549 BTRMGR_Result_t
2550 BTRMGR_GetNumberOfAdapters (
2551  unsigned char* pNumOfAdapters
2552 ) {
2553  BTRMGR_Result_t lenBtrMgrResult = BTRMGR_RESULT_SUCCESS;
2554  enBTRCoreRet lenBtrCoreRet = enBTRCoreSuccess;
2555  stBTRCoreListAdapters listOfAdapters;
2556 
2557 
2558  if (!ghBTRCoreHdl) {
2559  BTRMGRLOG_ERROR ("BTRCore is not Inited\n");
2560  return BTRMGR_RESULT_INIT_FAILED;
2561  }
2562  else if (!pNumOfAdapters) {
2563  BTRMGRLOG_ERROR ("Input is invalid\n");
2564  return BTRMGR_RESULT_INVALID_INPUT;
2565  }
2566 
2567 
2568  memset(&listOfAdapters, 0, sizeof(listOfAdapters));
2569 
2570  lenBtrCoreRet = BTRCore_GetListOfAdapters(ghBTRCoreHdl, &listOfAdapters);
2571  if (lenBtrCoreRet == enBTRCoreSuccess) {
2572  *pNumOfAdapters = listOfAdapters.number_of_adapters;
2573  /* Copy to our backup */
2574  if (listOfAdapters.number_of_adapters != gListOfAdapters.number_of_adapters)
2575  memcpy (&gListOfAdapters, &listOfAdapters, sizeof (stBTRCoreListAdapters));
2576 
2577  BTRMGRLOG_DEBUG ("Available Adapters = %d\n", listOfAdapters.number_of_adapters);
2578  }
2579  else {
2580  BTRMGRLOG_ERROR ("Could not find Adapters\n");
2581  lenBtrMgrResult = BTRMGR_RESULT_GENERIC_FAILURE;
2582  }
2583 
2584 
2585  return lenBtrMgrResult;
2586 }
2587 
2588 BTRMGR_Result_t
2589 BTRMGR_ResetAdapter (
2590  unsigned char aui8AdapterIdx
2591 ) {
2592  BTRMGR_Result_t lenBtrMgrResult = BTRMGR_RESULT_SUCCESS;
2593  enBTRCoreRet lenBtrCoreRet = enBTRCoreSuccess;
2594  const char* pAdapterPath = NULL;
2595  char name[BTRMGR_NAME_LEN_MAX] = {'\0'};
2596 
2597  if (!ghBTRCoreHdl) {
2598  BTRMGRLOG_ERROR ("BTRCore is not Inited\n");
2599  return BTRMGR_RESULT_INIT_FAILED;
2600  }
2601  else if (aui8AdapterIdx > btrMgr_GetAdapterCnt()) {
2602  BTRMGRLOG_ERROR ("Input is invalid\n");
2603  return BTRMGR_RESULT_INVALID_INPUT;
2604  }
2605 
2606 
2607  if (!(pAdapterPath = btrMgr_GetAdapterPath(aui8AdapterIdx))) {
2608  BTRMGRLOG_ERROR ("Failed to get adapter path\n");
2609  return BTRMGR_RESULT_GENERIC_FAILURE;
2610  }
2611 
2612 
2613  lenBtrCoreRet = BTRCore_DisableAdapter(ghBTRCoreHdl,&gDefaultAdapterContext);
2614 
2615  if (lenBtrCoreRet != enBTRCoreSuccess) {
2616  BTRMGRLOG_ERROR ("Failed to disable Adapter - %s\n", pAdapterPath);
2617  lenBtrMgrResult = BTRMGR_RESULT_GENERIC_FAILURE;
2618  }
2619  else {
2620  BTRMGRLOG_INFO ("Bluetooth Adapter Disabled Successfully - %s\n", pAdapterPath);
2621  sleep(1);
2622 
2623  lenBtrCoreRet = BTRCore_SetAdapterName(ghBTRCoreHdl, pAdapterPath, name);
2624  if (lenBtrCoreRet != enBTRCoreSuccess) {
2625  BTRMGRLOG_ERROR ("Failed to set Adapter Name\n");
2626  lenBtrMgrResult = BTRMGR_RESULT_GENERIC_FAILURE;
2627  }
2628 
2629 
2630  lenBtrCoreRet = BTRCore_EnableAdapter(ghBTRCoreHdl,&gDefaultAdapterContext);
2631  if (lenBtrCoreRet != enBTRCoreSuccess) {
2632  BTRMGRLOG_ERROR ("Failed to enable Adapter\n");
2633  lenBtrMgrResult = BTRMGR_RESULT_GENERIC_FAILURE;
2634  }
2635  else {
2636  BTRMGRLOG_INFO ("Bluetooth Adapter Enabled Successfully - %s\n", pAdapterPath);
2637  }
2638  }
2639 
2640  return lenBtrMgrResult;
2641 }
2642 
2643 
2644 BTRMGR_Result_t
2645 BTRMGR_SetAdapterName (
2646  unsigned char aui8AdapterIdx,
2647  const char* pNameOfAdapter
2648 ) {
2649  BTRMGR_Result_t lenBtrMgrResult = BTRMGR_RESULT_SUCCESS;
2650  enBTRCoreRet lenBtrCoreRet = enBTRCoreSuccess;
2651  const char* pAdapterPath = NULL;
2652  char name[BTRMGR_NAME_LEN_MAX] = {'\0'};
2653 
2654  if (!ghBTRCoreHdl) {
2655  BTRMGRLOG_ERROR ("BTRCore is not Inited\n");
2656  return BTRMGR_RESULT_INIT_FAILED;
2657  }
2658  else if ((aui8AdapterIdx > btrMgr_GetAdapterCnt()) || (!pNameOfAdapter)) {
2659  BTRMGRLOG_ERROR ("Input is invalid\n");
2660  return BTRMGR_RESULT_INVALID_INPUT;
2661  }
2662 
2663 
2664  if (!(pAdapterPath = btrMgr_GetAdapterPath(aui8AdapterIdx))) {
2665  BTRMGRLOG_ERROR ("Failed to get adapter path\n");
2666  return BTRMGR_RESULT_GENERIC_FAILURE;
2667  }
2668 
2669 
2670  strncpy (name, pNameOfAdapter, (BTRMGR_NAME_LEN_MAX - 1));
2671  lenBtrCoreRet = BTRCore_SetAdapterName(ghBTRCoreHdl, pAdapterPath, name);
2672  if (lenBtrCoreRet != enBTRCoreSuccess) {
2673  BTRMGRLOG_ERROR ("Failed to set Adapter Name\n");
2674  lenBtrMgrResult = BTRMGR_RESULT_GENERIC_FAILURE;
2675  }
2676  else {
2677  BTRMGRLOG_INFO ("Set Successfully\n");
2678  }
2679 
2680 
2681  return lenBtrMgrResult;
2682 }
2683 
2684 BTRMGR_Result_t
2685 BTRMGR_GetAdapterName (
2686  unsigned char aui8AdapterIdx,
2687  char* pNameOfAdapter
2688 ) {
2689  BTRMGR_Result_t lenBtrMgrResult = BTRMGR_RESULT_SUCCESS;
2690  enBTRCoreRet lenBtrCoreRet = enBTRCoreSuccess;
2691  const char* pAdapterPath = NULL;
2692  char name[BTRMGR_NAME_LEN_MAX] = {'\0'};
2693 
2694  if (!ghBTRCoreHdl) {
2695  BTRMGRLOG_ERROR ("BTRCore is not Inited\n");
2696  return BTRMGR_RESULT_INIT_FAILED;
2697  }
2698  else if ((aui8AdapterIdx > btrMgr_GetAdapterCnt()) || (!pNameOfAdapter)) {
2699  BTRMGRLOG_ERROR ("Input is invalid\n");
2700  return BTRMGR_RESULT_INVALID_INPUT;
2701  }
2702 
2703 
2704  if (!(pAdapterPath = btrMgr_GetAdapterPath(aui8AdapterIdx))) {
2705  BTRMGRLOG_ERROR ("Failed to get adapter path\n");
2706  return BTRMGR_RESULT_GENERIC_FAILURE;
2707  }
2708 
2709 
2710  lenBtrCoreRet = BTRCore_GetAdapterName(ghBTRCoreHdl, pAdapterPath, name);
2711  if (lenBtrCoreRet != enBTRCoreSuccess) {
2712  BTRMGRLOG_ERROR ("Failed to get Adapter Name\n");
2713  lenBtrMgrResult = BTRMGR_RESULT_GENERIC_FAILURE;
2714  }
2715  else {
2716  BTRMGRLOG_INFO ("Fetched Successfully\n");
2717  }
2718 
2719  /* Copy regardless of success or failure. */
2720  strncpy (pNameOfAdapter, name, (strlen(pNameOfAdapter) > BTRMGR_NAME_LEN_MAX -1) ? BTRMGR_NAME_LEN_MAX -1 : strlen(name));
2721  pNameOfAdapter[(strlen(pNameOfAdapter) > BTRMGR_NAME_LEN_MAX -1) ? BTRMGR_NAME_LEN_MAX -1 : strlen(name)] = '\0';
2722 
2723 
2724  return lenBtrMgrResult;
2725 }
2726 
2727 BTRMGR_Result_t
2728 BTRMGR_SetAdapterPowerStatus (
2729  unsigned char aui8AdapterIdx,
2730  unsigned char power_status
2731 ) {
2732  BTRMGR_Result_t lenBtrMgrResult = BTRMGR_RESULT_SUCCESS;
2733  enBTRCoreRet lenBtrCoreRet = enBTRCoreSuccess;
2734  enBTRCoreDeviceType lenBTRCoreDevTy = enBTRCoreSpeakers;
2735  enBTRCoreDeviceClass lenBTRCoreDevCl = enBTRCore_DC_Unknown;
2736  const char* pAdapterPath = NULL;
2737 
2738  if (!ghBTRCoreHdl) {
2739  BTRMGRLOG_ERROR ("BTRCore is not Inited\n");
2740  return BTRMGR_RESULT_INIT_FAILED;
2741  }
2742  else if ((aui8AdapterIdx > btrMgr_GetAdapterCnt()) || (power_status > 1)) {
2743  BTRMGRLOG_ERROR ("Input is invalid\n");
2744  return BTRMGR_RESULT_INVALID_INPUT;
2745  }
2746 
2747 
2748  /* Check whether the requested device is connected n playing. */
2749  if ((ghBTRMgrDevHdlCurStreaming) && (power_status == 0)) {
2750  /* This will internall stops the playback as well as disconnects. */
2751  lenBtrCoreRet = BTRCore_GetDeviceTypeClass(ghBTRCoreHdl, ghBTRMgrDevHdlCurStreaming, &lenBTRCoreDevTy, &lenBTRCoreDevCl);
2752  BTRMGRLOG_DEBUG ("Status = %d\t Device Type = %d\t Device Class = %x\n", lenBtrCoreRet, lenBTRCoreDevTy, lenBTRCoreDevCl);
2753 
2754  if ((lenBTRCoreDevTy == enBTRCoreSpeakers) || (lenBTRCoreDevTy == enBTRCoreHeadSet)) {
2755  /* Streaming-Out is happening; stop it */
2756  if ((lenBtrMgrResult = BTRMGR_StopAudioStreamingOut(aui8AdapterIdx, ghBTRMgrDevHdlCurStreaming)) != BTRMGR_RESULT_SUCCESS) {
2757  BTRMGRLOG_ERROR ("This device is being Connected n Playing. Failed to stop Playback. Going Ahead to power off Adapter.-Out\n");
2758  }
2759  }
2760  else if ((lenBTRCoreDevTy == enBTRCoreMobileAudioIn) || (lenBTRCoreDevTy == enBTRCorePCAudioIn)) {
2761  /* Streaming-In is happening; stop it */
2762  if ((lenBtrMgrResult = BTRMGR_StopAudioStreamingIn(aui8AdapterIdx, ghBTRMgrDevHdlCurStreaming)) != BTRMGR_RESULT_SUCCESS) {
2763  BTRMGRLOG_ERROR ("This device is being Connected n Playing. Failed to stop Playback. Going Ahead to power off Adapter.-In\n");
2764  }
2765  }
2766  }
2767 
2768 
2769  if (!(pAdapterPath = btrMgr_GetAdapterPath(aui8AdapterIdx))) {
2770  BTRMGRLOG_ERROR ("Failed to get adapter path\n");
2771  return BTRMGR_RESULT_GENERIC_FAILURE;
2772  }
2773 
2774 
2775 
2776  lenBtrCoreRet = BTRCore_SetAdapterPower(ghBTRCoreHdl, pAdapterPath, power_status);
2777  if (lenBtrCoreRet != enBTRCoreSuccess) {
2778  BTRMGRLOG_ERROR ("Failed to set Adapter Power Status\n");
2779  lenBtrMgrResult = BTRMGR_RESULT_GENERIC_FAILURE;
2780  }
2781  else {
2782  BTRMGRLOG_INFO ("Set Successfully\n");
2783  }
2784 
2785 
2786  return lenBtrMgrResult;
2787 }
2788 
2789 BTRMGR_Result_t
2790 BTRMGR_GetAdapterPowerStatus (
2791  unsigned char aui8AdapterIdx,
2792  unsigned char* pPowerStatus
2793 ) {
2794  BTRMGR_Result_t lenBtrMgrResult = BTRMGR_RESULT_SUCCESS;
2795  enBTRCoreRet lenBtrCoreRet = enBTRCoreSuccess;
2796  const char* pAdapterPath = NULL;
2797  unsigned char power_status = 0;
2798 
2799  if (!ghBTRCoreHdl) {
2800  BTRMGRLOG_ERROR ("BTRCore is not Inited\n");
2801  return BTRMGR_RESULT_INIT_FAILED;
2802  }
2803  else if ((aui8AdapterIdx > btrMgr_GetAdapterCnt()) || (!pPowerStatus)) {
2804  BTRMGRLOG_ERROR ("Input is invalid\n");
2805  return BTRMGR_RESULT_INVALID_INPUT;
2806  }
2807 
2808 
2809  if (!(pAdapterPath = btrMgr_GetAdapterPath(aui8AdapterIdx))) {
2810  BTRMGRLOG_ERROR ("Failed to get adapter path\n");
2811  return BTRMGR_RESULT_GENERIC_FAILURE;
2812  }
2813 
2814 
2815  lenBtrCoreRet = BTRCore_GetAdapterPower(ghBTRCoreHdl, pAdapterPath, &power_status);
2816  if (lenBtrCoreRet != enBTRCoreSuccess) {
2817  BTRMGRLOG_ERROR ("Failed to get Adapter Power\n");
2818  lenBtrMgrResult = BTRMGR_RESULT_GENERIC_FAILURE;
2819  }
2820  else {
2821  BTRMGRLOG_INFO ("Fetched Successfully\n");
2822  *pPowerStatus = power_status;
2823  }
2824 
2825 
2826  return lenBtrMgrResult;
2827 }
2828 
2829 BTRMGR_Result_t
2830 BTRMGR_SetAdapterDiscoverable (
2831  unsigned char aui8AdapterIdx,
2832  unsigned char discoverable,
2833  int timeout
2834 ) {
2835  BTRMGR_Result_t lenBtrMgrResult = BTRMGR_RESULT_SUCCESS;
2836  enBTRCoreRet lenBtrCoreRet = enBTRCoreSuccess;
2837  const char* pAdapterPath = NULL;
2838 
2839  if (!ghBTRCoreHdl) {
2840  BTRMGRLOG_ERROR ("BTRCore is not Inited\n");
2841  return BTRMGR_RESULT_INIT_FAILED;
2842 
2843  }
2844 
2845  if ((aui8AdapterIdx > btrMgr_GetAdapterCnt()) || (discoverable > 1)) {
2846  BTRMGRLOG_ERROR ("Input is invalid\n");
2847  return BTRMGR_RESULT_INVALID_INPUT;
2848  }
2849 
2850 
2851  if (!(pAdapterPath = btrMgr_GetAdapterPath(aui8AdapterIdx))) {
2852  BTRMGRLOG_ERROR ("Failed to get adapter path\n");
2853  return BTRMGR_RESULT_GENERIC_FAILURE;
2854  }
2855 
2856 
2857  //timeout=0 -> no timeout, -1 -> default timeout (180 secs), x -> x seconds
2858  if (timeout >= 0) {
2859  lenBtrCoreRet = BTRCore_SetAdapterDiscoverableTimeout(ghBTRCoreHdl, pAdapterPath, timeout);
2860  if (lenBtrCoreRet != enBTRCoreSuccess) {
2861  BTRMGRLOG_ERROR ("Failed to set Adapter discovery timeout\n");
2862  }
2863  else {
2864  BTRMGRLOG_INFO ("Set timeout Successfully\n");
2865  }
2866  }
2867 
2868  /* Set the discoverable state */
2869  if ((lenBtrCoreRet = BTRCore_SetAdapterDiscoverable(ghBTRCoreHdl, pAdapterPath, discoverable)) != enBTRCoreSuccess) {
2870  BTRMGRLOG_ERROR ("Failed to set Adapter discoverable status\n");
2871  lenBtrMgrResult = BTRMGR_RESULT_GENERIC_FAILURE;
2872  }
2873  else {
2874  BTRMGRLOG_INFO ("Set discoverable status Successfully\n");
2875  if (discoverable) {
2876  if (!btrMgr_GetAgentActivated()) {
2877  BTRMGRLOG_INFO ("Activate agent\n");
2878  if ((lenBtrCoreRet = BTRCore_RegisterAgent(ghBTRCoreHdl, 1)) != enBTRCoreSuccess) {
2879  BTRMGRLOG_ERROR ("Failed to Activate Agent\n");
2880  lenBtrMgrResult = BTRMGR_RESULT_GENERIC_FAILURE;
2881  }
2882  else {
2883  btrMgr_SetAgentActivated(1);
2884  }
2885  }
2886  }
2887  }
2888 
2889  return lenBtrMgrResult;
2890 }
2891 
2892 
2893 BTRMGR_Result_t
2894 BTRMGR_IsAdapterDiscoverable (
2895  unsigned char aui8AdapterIdx,
2896  unsigned char* pDiscoverable
2897 ) {
2898  BTRMGR_Result_t lenBtrMgrResult = BTRMGR_RESULT_SUCCESS;
2899  enBTRCoreRet lenBtrCoreRet = enBTRCoreSuccess;
2900  const char* pAdapterPath = NULL;
2901  unsigned char discoverable = 0;
2902 
2903  if (!ghBTRCoreHdl) {
2904  BTRMGRLOG_ERROR ("BTRCore is not Inited\n");
2905  return BTRMGR_RESULT_INIT_FAILED;
2906  }
2907 
2908  if ((aui8AdapterIdx > btrMgr_GetAdapterCnt()) || (!pDiscoverable)) {
2909  BTRMGRLOG_ERROR ("Input is invalid\n");
2910  return BTRMGR_RESULT_INVALID_INPUT;
2911  }
2912 
2913 
2914  if (!(pAdapterPath = btrMgr_GetAdapterPath(aui8AdapterIdx))) {
2915  BTRMGRLOG_ERROR ("Failed to get adapter path\n");
2916  return BTRMGR_RESULT_GENERIC_FAILURE;
2917  }
2918 
2919 
2920  if ((lenBtrCoreRet = BTRCore_GetAdapterDiscoverableStatus(ghBTRCoreHdl, pAdapterPath, &discoverable)) != enBTRCoreSuccess) {
2921  BTRMGRLOG_ERROR ("Failed to get Adapter Status\n");
2922  lenBtrMgrResult = BTRMGR_RESULT_GENERIC_FAILURE;
2923  }
2924  else {
2925  BTRMGRLOG_INFO ("Fetched Successfully\n");
2926  *pDiscoverable = discoverable;
2927  if (discoverable) {
2928  if (!btrMgr_GetAgentActivated()) {
2929  BTRMGRLOG_INFO ("Activate agent\n");
2930  if ((lenBtrCoreRet = BTRCore_RegisterAgent(ghBTRCoreHdl, 1)) != enBTRCoreSuccess) {
2931  BTRMGRLOG_ERROR ("Failed to Activate Agent\n");
2932  lenBtrMgrResult = BTRMGR_RESULT_GENERIC_FAILURE;
2933  }
2934  else {
2935  btrMgr_SetAgentActivated(1);
2936  }
2937  }
2938  }
2939  }
2940 
2941  return lenBtrMgrResult;
2942 }
2943 
2944 static BTRMGR_Result_t
2945 BTRMGR_StartDeviceDiscovery_Internal (
2946  unsigned char aui8AdapterIdx,
2947  BTRMGR_DeviceOperationType_t aenBTRMgrDevOpT
2948 ) {
2949  BTRMGR_Result_t lenBtrMgrResult = BTRMGR_RESULT_SUCCESS;
2950  enBTRCoreRet lenBtrCoreRet = enBTRCoreSuccess;
2951  enBTRCoreDeviceType lenBTRCoreDeviceType = enBTRCoreUnknown;
2952  const char* pAdapterPath = NULL;
2953  BTRMGR_DiscoveryHandle_t* ldiscoveryHdl = NULL;
2954 
2955  if (!ghBTRCoreHdl) {
2956  BTRMGRLOG_ERROR ("BTRCore is not Inited\n");
2957  return BTRMGR_RESULT_INIT_FAILED;
2958  }
2959  else if (aui8AdapterIdx > btrMgr_GetAdapterCnt()) {
2960  BTRMGRLOG_ERROR ("Input is invalid\n");
2961  return BTRMGR_RESULT_INVALID_INPUT;
2962  }
2963 
2964  if (!(pAdapterPath = btrMgr_GetAdapterPath(aui8AdapterIdx))) {
2965  BTRMGRLOG_ERROR ("Failed to get adapter path\n");
2966  return BTRMGR_RESULT_GENERIC_FAILURE;
2967  }
2968  // TODO Try to move this check logically into btrMgr_PreCheckDiscoveryStatus
2969  if ((ldiscoveryHdl = btrMgr_GetDiscoveryInProgress())) {
2970  if (aenBTRMgrDevOpT == btrMgr_GetDiscoveryDeviceType(ldiscoveryHdl)) {
2971  BTRMGRLOG_WARN ("[%s] Scan already in Progress...\n"
2972  , btrMgr_GetDiscoveryDeviceTypeAsString (btrMgr_GetDiscoveryDeviceType(ldiscoveryHdl)));
2973  return BTRMGR_RESULT_SUCCESS;
2974  }
2975  }
2976 
2977  if (eBTRMgrSuccess != btrMgr_PreCheckDiscoveryStatus(aui8AdapterIdx, aenBTRMgrDevOpT)) {
2978  BTRMGRLOG_ERROR ("Pre Check Discovery State Rejected !!!\n");
2979  return BTRMGR_RESULT_GENERIC_FAILURE;
2980  }
2981 
2982  /* Populate the currently Paired Devices. This will be used only for the callback DS update */
2983  BTRMGR_GetPairedDevices (aui8AdapterIdx, &gListOfPairedDevices);
2984 
2985 
2986  switch (aenBTRMgrDevOpT) {
2987  case BTRMGR_DEVICE_OP_TYPE_AUDIO_OUTPUT:
2988  lenBTRCoreDeviceType = enBTRCoreSpeakers;
2989  break;
2990  case BTRMGR_DEVICE_OP_TYPE_AUDIO_INPUT:
2991  lenBTRCoreDeviceType = enBTRCoreMobileAudioIn;
2992  break;
2993  case BTRMGR_DEVICE_OP_TYPE_LE:
2994  lenBTRCoreDeviceType = enBTRCoreLE;
2995  break;
2996  case BTRMGR_DEVICE_OP_TYPE_HID:
2997  lenBTRCoreDeviceType = enBTRCoreHID;
2998  break;
2999  case BTRMGR_DEVICE_OP_TYPE_UNKNOWN:
3000  default:
3001  lenBTRCoreDeviceType = enBTRCoreUnknown;
3002  break;
3003  }
3004 
3005 
3006  lenBtrCoreRet = BTRCore_StartDiscovery(ghBTRCoreHdl, pAdapterPath, lenBTRCoreDeviceType, 0);
3007  if (lenBtrCoreRet != enBTRCoreSuccess) {
3008  BTRMGRLOG_ERROR ("Failed to start discovery\n");
3009  lenBtrMgrResult = BTRMGR_RESULT_GENERIC_FAILURE;
3010  }
3011  else {
3012  { /* Max 3 sec timeout - Polled at 5ms second interval */
3013  unsigned int ui32sleepIdx = 600;
3014 
3015  do {
3016  usleep(5000);
3017  } while ((!gIsAdapterDiscovering) && (--ui32sleepIdx));
3018  }
3019 
3020  if (!gIsAdapterDiscovering) {
3021  BTRMGRLOG_WARN ("Discovery is not yet Started !!!\n");
3022  }
3023  else {
3024  BTRMGRLOG_INFO ("Discovery started Successfully\n");
3025  }
3026 
3027  btrMgr_SetDiscoveryHandle (aenBTRMgrDevOpT, BTRMGR_DISCOVERY_ST_STARTED);
3028  }
3029 
3030  return lenBtrMgrResult;
3031 }
3032 
3033 
3034 static BTRMGR_Result_t
3035 BTRMGR_StopDeviceDiscovery_Internal (
3036  unsigned char aui8AdapterIdx,
3037  BTRMGR_DeviceOperationType_t aenBTRMgrDevOpT
3038 ) {
3039  BTRMGR_Result_t lenBtrMgrResult = BTRMGR_RESULT_SUCCESS;
3040  enBTRCoreRet lenBtrCoreRet = enBTRCoreSuccess;
3041  enBTRCoreDeviceType lenBTRCoreDeviceType = enBTRCoreUnknown;
3042  const char* pAdapterPath = NULL;
3043  BTRMGR_DiscoveryHandle_t* ahdiscoveryHdl = NULL;
3044 
3045  if (!ghBTRCoreHdl) {
3046  BTRMGRLOG_ERROR ("BTRCore is not Inited\n");
3047  return BTRMGR_RESULT_INIT_FAILED;
3048  }
3049 
3050  if (aui8AdapterIdx > btrMgr_GetAdapterCnt()) {
3051  BTRMGRLOG_ERROR ("Input is invalid\n");
3052  return BTRMGR_RESULT_INVALID_INPUT;
3053  }
3054 
3055  if (!(pAdapterPath = btrMgr_GetAdapterPath(aui8AdapterIdx))) {
3056  BTRMGRLOG_ERROR ("Failed to get adapter path\n");
3057  return BTRMGR_RESULT_GENERIC_FAILURE;
3058  }
3059 
3060  if (!(ahdiscoveryHdl = btrMgr_GetDiscoveryInProgress())) {
3061  BTRMGRLOG_WARN("Scanning is not running now\n");
3062  }
3063 
3064  switch (aenBTRMgrDevOpT) {
3065  case BTRMGR_DEVICE_OP_TYPE_AUDIO_OUTPUT:
3066  lenBTRCoreDeviceType = enBTRCoreSpeakers;
3067  break;
3068  case BTRMGR_DEVICE_OP_TYPE_AUDIO_INPUT:
3069  lenBTRCoreDeviceType = enBTRCoreMobileAudioIn;
3070  break;
3071  case BTRMGR_DEVICE_OP_TYPE_LE:
3072  lenBTRCoreDeviceType = enBTRCoreLE;
3073  break;
3074  case BTRMGR_DEVICE_OP_TYPE_HID:
3075  lenBTRCoreDeviceType = enBTRCoreHID;
3076  break;
3077  case BTRMGR_DEVICE_OP_TYPE_UNKNOWN:
3078  default:
3079  lenBTRCoreDeviceType = enBTRCoreUnknown;
3080  break;
3081  }
3082 
3083 
3084  lenBtrCoreRet = BTRCore_StopDiscovery(ghBTRCoreHdl, pAdapterPath, lenBTRCoreDeviceType);
3085  if (lenBtrCoreRet != enBTRCoreSuccess) {
3086  BTRMGRLOG_ERROR ("Failed to stop discovery\n");
3087  lenBtrMgrResult = BTRMGR_RESULT_GENERIC_FAILURE;
3088  }
3089  else {
3090  BTRMGRLOG_INFO ("Discovery Stopped Successfully\n");
3091 
3092 #if 0
3093  Let we not make the OutTask Context of BTRCore Layer wait here
3094  TODO: Confirm Discovery Stop
3095 
3096  { /* Max 3 sec timeout - Polled at 500ms second interval */
3097  unsigned int ui32sleepIdx = 6;
3098 
3099  while ((gIsAdapterDiscovering) && (ui32sleepIdx--)) {
3100  usleep(500000);
3101  }
3102  }
3103 
3104  if (gIsAdapterDiscovering) {
3105  BTRMGRLOG_WARN ("Discovery is not yet Stopped !!!\n");
3106  }
3107  else {
3108  BTRMGRLOG_INFO ("Discovery Stopped Successfully\n");
3109  }
3110 #endif
3111 
3112  if (ahdiscoveryHdl) {
3113  if ((btrMgr_GetDiscoveryDeviceType(ahdiscoveryHdl) == BTRMGR_DEVICE_OP_TYPE_LE && aenBTRMgrDevOpT == BTRMGR_DEVICE_OP_TYPE_LE)
3114  || btrMgr_GetDiscoveryDeviceType(ahdiscoveryHdl) != BTRMGR_DEVICE_OP_TYPE_LE) {
3115 
3116  btrMgr_SetDiscoveryState (ahdiscoveryHdl, BTRMGR_DISCOVERY_ST_STOPPED);
3117  if (btrMgr_GetDiscoveryDeviceType(ahdiscoveryHdl) != BTRMGR_DEVICE_OP_TYPE_LE &&
3118  btrMgr_GetDiscoveryState(&ghBTRMgrBgDiscoveryHdl) == BTRMGR_DISCOVERY_ST_PAUSED) {
3119  btrMgr_ClearDiscoveryHoldOffTimer();
3120  btrMgr_SetDiscoveryHoldOffTimer(aui8AdapterIdx);
3121  }
3122  }
3123  else {
3124  btrMgr_SetDiscoveryState (ahdiscoveryHdl, BTRMGR_DISCOVERY_ST_PAUSED);
3125  btrMgr_SetDiscoveryHoldOffTimer(aui8AdapterIdx);
3126  }
3127  }
3128  else if (aenBTRMgrDevOpT == BTRMGR_DEVICE_OP_TYPE_LE) {
3129  if (btrMgr_GetDiscoveryState(&ghBTRMgrBgDiscoveryHdl) == BTRMGR_DISCOVERY_ST_PAUSED) {
3130  btrMgr_ClearDiscoveryHoldOffTimer();
3131  btrMgr_SetDiscoveryState (&ghBTRMgrBgDiscoveryHdl, BTRMGR_DISCOVERY_ST_STOPPED);
3132  }
3133  }
3134  }
3135 
3136  return lenBtrMgrResult;
3137 }
3138 
3139 
3140 BTRMGR_Result_t
3141 BTRMGR_StartDeviceDiscovery (
3142  unsigned char aui8AdapterIdx,
3143  BTRMGR_DeviceOperationType_t aenBTRMgrDevOpT
3144 ) {
3145  BTRMGR_Result_t result = BTRMGR_RESULT_GENERIC_FAILURE;
3146 
3147  gIsDiscoveryOpInternal = FALSE;
3148 
3149  memset (&gListOfDiscoveredDevices, 0, sizeof(gListOfDiscoveredDevices));
3150  result = BTRMGR_StartDeviceDiscovery_Internal(aui8AdapterIdx, aenBTRMgrDevOpT);
3151 
3152  if ((result == BTRMGR_RESULT_SUCCESS) && gfpcBBTRMgrEventOut) {
3153  BTRMGR_EventMessage_t lstEventMessage;
3154  memset (&lstEventMessage, 0, sizeof(lstEventMessage));
3155 
3156  lstEventMessage.m_adapterIndex = aui8AdapterIdx;
3157  if (gIsAdapterDiscovering) {
3158  lstEventMessage.m_eventType = BTRMGR_EVENT_DEVICE_DISCOVERY_STARTED;
3159  }
3160 
3161  gfpcBBTRMgrEventOut(lstEventMessage); /* Post a callback */
3162  }
3163 
3164  return result;
3165 }
3166 
3167 
3168 BTRMGR_Result_t
3169 BTRMGR_StopDeviceDiscovery (
3170  unsigned char aui8AdapterIdx,
3171  BTRMGR_DeviceOperationType_t aenBTRMgrDevOpT
3172 ) {
3173  BTRMGR_Result_t result = BTRMGR_RESULT_GENERIC_FAILURE;
3174 
3175  gIsDiscoveryOpInternal = FALSE;
3176  result = BTRMGR_StopDeviceDiscovery_Internal(aui8AdapterIdx, aenBTRMgrDevOpT);
3177 
3178  if ((result == BTRMGR_RESULT_SUCCESS) && gfpcBBTRMgrEventOut) {
3179  BTRMGR_EventMessage_t lstEventMessage;
3180  memset (&lstEventMessage, 0, sizeof(lstEventMessage));
3181 
3182  lstEventMessage.m_adapterIndex = aui8AdapterIdx;
3183  if (!gIsAdapterDiscovering) {
3184  lstEventMessage.m_eventType = BTRMGR_EVENT_DEVICE_DISCOVERY_COMPLETE;
3185  }
3186 
3187  gfpcBBTRMgrEventOut(lstEventMessage); /* Post a callback */
3188  }
3189 
3190  return result;
3191 }
3192 
3193 
3194 BTRMGR_Result_t
3195 BTRMGR_GetDiscoveryStatus (
3196  unsigned char aui8AdapterIdx,
3197  BTRMGR_DiscoveryStatus_t* isDiscoveryInProgress,
3198  BTRMGR_DeviceOperationType_t* aenBTRMgrDevOpT
3199 ) {
3200  BTRMGR_Result_t result = BTRMGR_RESULT_SUCCESS;
3201  BTRMGR_DiscoveryHandle_t* ldiscoveryHdl = NULL;
3202 
3203  if (!ghBTRCoreHdl) {
3204  BTRMGRLOG_ERROR ("BTRCore is not Inited\n");
3205  return BTRMGR_RESULT_INIT_FAILED;
3206  }
3207  else if ((aui8AdapterIdx > btrMgr_GetAdapterCnt()) || (!isDiscoveryInProgress) || (!aenBTRMgrDevOpT)) {
3208  BTRMGRLOG_ERROR ("Input is invalid\n");
3209  return BTRMGR_RESULT_INVALID_INPUT;
3210  }
3211 
3212  if ((ldiscoveryHdl = btrMgr_GetDiscoveryInProgress())) {
3213  *isDiscoveryInProgress = BTRMGR_DISCOVERY_STATUS_IN_PROGRESS;
3214  *aenBTRMgrDevOpT = btrMgr_GetDiscoveryDeviceType(ldiscoveryHdl);
3215  BTRMGRLOG_WARN ("[%s] Scan already in Progress\n"
3216  , btrMgr_GetDiscoveryDeviceTypeAsString (btrMgr_GetDiscoveryDeviceType(ldiscoveryHdl)));
3217  }
3218  else {
3219  *isDiscoveryInProgress = BTRMGR_DISCOVERY_STATUS_OFF;
3220  *aenBTRMgrDevOpT = BTRMGR_DEVICE_OP_TYPE_UNKNOWN;
3221  }
3222  return result;
3223 }
3224 
3225 BTRMGR_Result_t
3226 BTRMGR_GetDiscoveredDevices (
3227  unsigned char aui8AdapterIdx,
3228  BTRMGR_DiscoveredDevicesList_t* pDiscoveredDevices
3229 ) {
3230  return BTRMGR_GetDiscoveredDevices_Internal(aui8AdapterIdx, pDiscoveredDevices);
3231 }
3232 
3233 
3234 static BTRMGR_Result_t
3235 BTRMGR_GetDiscoveredDevices_Internal (
3236  unsigned char aui8AdapterIdx,
3237  BTRMGR_DiscoveredDevicesList_t* pDiscoveredDevices
3238 ) {
3239  BTRMGR_Result_t lenBtrMgrResult = BTRMGR_RESULT_SUCCESS;
3240  enBTRCoreRet lenBtrCoreRet = enBTRCoreSuccess;
3241  stBTRCoreScannedDevicesCount lstBtrCoreListOfSDevices;
3242  BTRMGR_DeviceType_t lenBtrMgrDevType = BTRMGR_DEVICE_TYPE_UNKNOWN;
3243  int i = 0;
3244  int j = 0;
3245 
3246  if (!ghBTRCoreHdl) {
3247  BTRMGRLOG_ERROR ("BTRCore is not Inited\n");
3248  return BTRMGR_RESULT_INIT_FAILED;
3249  }
3250 
3251  if ((aui8AdapterIdx > btrMgr_GetAdapterCnt()) || (!pDiscoveredDevices)) {
3252  BTRMGRLOG_ERROR ("Input is invalid\n");
3253  return BTRMGR_RESULT_INVALID_INPUT;
3254  }
3255 
3256 
3257  lenBtrCoreRet = BTRCore_GetListOfScannedDevices(ghBTRCoreHdl, &lstBtrCoreListOfSDevices);
3258  if (lenBtrCoreRet != enBTRCoreSuccess) {
3259  BTRMGRLOG_ERROR ("Failed to get list of discovered devices\n");
3260  lenBtrMgrResult = BTRMGR_RESULT_GENERIC_FAILURE;
3261  }
3262  else {
3263  memset (pDiscoveredDevices, 0, sizeof(BTRMGR_DiscoveredDevicesList_t));
3264 
3265  if (lstBtrCoreListOfSDevices.numberOfDevices) {
3266  BTRMGR_DiscoveredDevices_t *lpstBtrMgrSDevice = NULL;
3267 
3268  pDiscoveredDevices->m_numOfDevices = (lstBtrCoreListOfSDevices.numberOfDevices < BTRMGR_DEVICE_COUNT_MAX) ?
3269  lstBtrCoreListOfSDevices.numberOfDevices : BTRMGR_DEVICE_COUNT_MAX;
3270 
3271  for (i = 0,j = 0; j < pDiscoveredDevices->m_numOfDevices; i++,j++) {
3272  lenBtrMgrDevType = btrMgr_MapDeviceTypeFromCore(lstBtrCoreListOfSDevices.devices[i].enDeviceType);
3273  if (!gIsHidGamePadEnabled && (lenBtrMgrDevType == BTRMGR_DEVICE_TYPE_HID_GAMEPAD)) {
3274  j--;
3275  pDiscoveredDevices->m_numOfDevices--;
3276  BTRMGRLOG_WARN ("HID GamePad RFC not enable, HID GamePad devices are not listing \n");
3277  continue;
3278  }
3279 
3280  lpstBtrMgrSDevice = &pDiscoveredDevices->m_deviceProperty[j];
3281 
3282  lpstBtrMgrSDevice->m_deviceHandle = lstBtrCoreListOfSDevices.devices[i].tDeviceId;
3283  lpstBtrMgrSDevice->m_signalLevel = lstBtrCoreListOfSDevices.devices[i].i32RSSI;
3284  lpstBtrMgrSDevice->m_rssi = btrMgr_MapSignalStrengthToRSSI (lstBtrCoreListOfSDevices.devices[i].i32RSSI);
3285  lpstBtrMgrSDevice->m_deviceType = btrMgr_MapDeviceTypeFromCore(lstBtrCoreListOfSDevices.devices[i].enDeviceType);
3286  lpstBtrMgrSDevice->m_isPairedDevice = btrMgr_GetDevPaired(lstBtrCoreListOfSDevices.devices[i].tDeviceId);
3287 
3288  strncpy(lpstBtrMgrSDevice->m_name, lstBtrCoreListOfSDevices.devices[i].pcDeviceName, (BTRMGR_NAME_LEN_MAX - 1));
3289  strncpy(lpstBtrMgrSDevice->m_deviceAddress, lstBtrCoreListOfSDevices.devices[i].pcDeviceAddress,(BTRMGR_NAME_LEN_MAX - 1));
3290 
3291  if (lstBtrCoreListOfSDevices.devices[i].bDeviceConnected) {
3292  lpstBtrMgrSDevice->m_isConnected = 1;
3293  }
3294 
3295  if (!btrMgr_CheckIfDevicePrevDetected(lpstBtrMgrSDevice->m_deviceHandle) && (gListOfDiscoveredDevices.m_numOfDevices < BTRMGR_DEVICE_COUNT_MAX)) {
3296  /* Update BTRMgr DiscoveredDev List cache */
3297  memcpy(&gListOfDiscoveredDevices.m_deviceProperty[gListOfDiscoveredDevices.m_numOfDevices], lpstBtrMgrSDevice, sizeof(BTRMGR_DiscoveredDevices_t));
3298  gListOfDiscoveredDevices.m_numOfDevices++;
3299  }
3300  }
3301  /* Success */
3302  BTRMGRLOG_INFO ("Successful\n");
3303  }
3304  else {
3305  BTRMGRLOG_WARN("No Device is found yet\n");
3306  }
3307  }
3308 
3309  return lenBtrMgrResult;
3310 }
3311 
3312 BTRMGR_Result_t
3313 BTRMGR_PairDevice (
3314  unsigned char aui8AdapterIdx,
3315  BTRMgrDeviceHandle ahBTRMgrDevHdl
3316 ) {
3317  BTRMGR_Result_t lenBtrMgrResult = BTRMGR_RESULT_SUCCESS;
3318  enBTRCoreRet lenBtrCoreRet = enBTRCoreSuccess;
3319  BTRMGR_Events_t lBtMgrOutEvent = -1;
3320  unsigned char ui8reActivateAgent = 0;
3321  enBTRCoreDeviceType lenBTRCoreDevTy = enBTRCoreSpeakers;
3322  enBTRCoreDeviceClass lenBTRCoreDevCl = enBTRCore_DC_Unknown;
3323 
3324  if (!ghBTRCoreHdl) {
3325  BTRMGRLOG_ERROR ("BTRCore is not Inited\n");
3326  return BTRMGR_RESULT_INIT_FAILED;
3327  }
3328 
3329  if ((aui8AdapterIdx > btrMgr_GetAdapterCnt()) || (!ahBTRMgrDevHdl)) {
3330  BTRMGRLOG_ERROR ("Input is invalid\n");
3331  return BTRMGR_RESULT_INVALID_INPUT;
3332  }
3333 
3334  btrMgr_PreCheckDiscoveryStatus(aui8AdapterIdx, BTRMGR_DEVICE_OP_TYPE_UNKNOWN);
3335 
3336  /* Update the Paired Device List */
3337  BTRMGR_GetPairedDevices (aui8AdapterIdx, &gListOfPairedDevices);
3338  if (1 == btrMgr_GetDevPaired(ahBTRMgrDevHdl)) {
3339  BTRMGRLOG_INFO ("Already a Paired Device; Nothing Done...\n");
3340  return BTRMGR_RESULT_SUCCESS;
3341  }
3342 
3343  BTRCore_GetDeviceTypeClass(ghBTRCoreHdl, ahBTRMgrDevHdl, &lenBTRCoreDevTy, &lenBTRCoreDevCl);
3344  BTRMGRLOG_DEBUG ("Status = %d\t Device Type = %d\t Device Class = %x\n", lenBtrCoreRet, lenBTRCoreDevTy, lenBTRCoreDevCl);
3345 
3346  if (!gIsHidGamePadEnabled && (lenBTRCoreDevCl == enBTRCore_DC_HID_GamePad)) {
3347  BTRMGRLOG_WARN ("BTR HID GamePad is currently Disabled\n");
3348  return BTRMGR_RESULT_GENERIC_FAILURE;
3349  }
3350  if (!gIsAudioInEnabled && ((lenBTRCoreDevTy == enBTRCoreMobileAudioIn) || (lenBTRCoreDevTy == enBTRCorePCAudioIn))) {
3351  BTRMGRLOG_WARN ("Pairing Rejected - BTR AudioIn is currently Disabled!\n");
3352  return BTRMGR_RESULT_GENERIC_FAILURE;
3353  }
3354  /* We always need a agent to get the pairing done.. if no agent registered, default agent will be used.
3355  * But we will not able able to get the PIN and other stuff received at our level. We have to have agent
3356  * for pairing process..
3357  *
3358  * We are using the default-agent for the audio devices and we have it deployed to field already.
3359  *
3360  * Since HID is new device and to not to break the Audio devices, BTMGR specific Agent is registered only for HID devices.
3361  */
3362  if (lenBTRCoreDevTy != enBTRCoreHID) {
3363  if (btrMgr_GetAgentActivated()) {
3364  BTRMGRLOG_INFO ("De-Activate agent\n");
3365  if ((lenBtrCoreRet = BTRCore_UnregisterAgent(ghBTRCoreHdl)) != enBTRCoreSuccess) {
3366  BTRMGRLOG_ERROR ("Failed to Deactivate Agent\n");
3367  lenBtrMgrResult = BTRMGR_RESULT_GENERIC_FAILURE;
3368  }
3369  else {
3370  btrMgr_SetAgentActivated(0);
3371  ui8reActivateAgent = 1;
3372  }
3373  }
3374  }
3375  else
3376  BTRMGRLOG_DEBUG ("For HID Devices, let us use the agent\n");
3377 
3378  if (enBTRCoreSuccess != BTRCore_PairDevice(ghBTRCoreHdl, ahBTRMgrDevHdl)) {
3379  BTRMGRLOG_ERROR ("Failed to pair a device\n");
3380  lenBtrMgrResult = BTRMGR_RESULT_GENERIC_FAILURE;
3381  lBtMgrOutEvent = BTRMGR_EVENT_DEVICE_PAIRING_FAILED;
3382  }
3383  else {
3384  lenBtrMgrResult = BTRMGR_RESULT_SUCCESS;
3385  lBtMgrOutEvent = BTRMGR_EVENT_DEVICE_PAIRING_COMPLETE;
3386  }
3387 
3388  /* The Paring is not a blocking call for HID. So we can sent the pairing complete msg when paring actually completed and gets a notification.
3389  * But the pairing failed, we must send it right here. */
3390  if ((lenBtrMgrResult != BTRMGR_RESULT_SUCCESS) ||
3391  ((lenBtrMgrResult == BTRMGR_RESULT_SUCCESS) &&
3392  ((lenBTRCoreDevTy != enBTRCoreHID) && (lenBTRCoreDevTy != enBTRCoreMobileAudioIn) && (lenBTRCoreDevTy != enBTRCorePCAudioIn)))) {
3393  BTRMGR_EventMessage_t lstEventMessage;
3394  memset (&lstEventMessage, 0, sizeof(lstEventMessage));
3395  btrMgr_GetDiscoveredDevInfo (ahBTRMgrDevHdl, &lstEventMessage.m_discoveredDevice);
3396 
3397  if (lstEventMessage.m_discoveredDevice.m_deviceHandle != ahBTRMgrDevHdl) {
3398  BTRMGRLOG_WARN ("Attempted to pair Undiscovered device - %lld\n", ahBTRMgrDevHdl);
3399  lstEventMessage.m_discoveredDevice.m_deviceHandle = ahBTRMgrDevHdl;
3400  }
3401 
3402  lstEventMessage.m_adapterIndex = aui8AdapterIdx;
3403  lstEventMessage.m_eventType = lBtMgrOutEvent;
3404 
3405  if (gfpcBBTRMgrEventOut) {
3406  gfpcBBTRMgrEventOut(lstEventMessage);
3407  }
3408  }
3409 
3410  /* Update the Paired Device List */
3411  if(lenBTRCoreDevTy == enBTRCoreHID){
3412  sleep(3);
3413  }
3414  BTRMGR_GetPairedDevices (aui8AdapterIdx, &gListOfPairedDevices);
3415  int j ;
3416  for (j = 0; j <= gListOfPairedDevices.m_numOfDevices; j++) {
3417  if ((ahBTRMgrDevHdl == gListOfPairedDevices.m_deviceProperty[j].m_deviceHandle) && ( BTRMGR_EVENT_DEVICE_PAIRING_COMPLETE == lBtMgrOutEvent )) {
3418  BTRMGRLOG_INFO ("Paired Successfully - %llu - Name - %s\n",ahBTRMgrDevHdl,gListOfPairedDevices.m_deviceProperty[j].m_name);
3419  break;
3420  }
3421  }
3422 
3423  if (ui8reActivateAgent) {
3424  BTRMGRLOG_INFO ("Activate agent\n");
3425  if ((lenBtrCoreRet = BTRCore_RegisterAgent(ghBTRCoreHdl, 1)) != enBTRCoreSuccess) {
3426  BTRMGRLOG_ERROR ("Failed to Activate Agent\n");
3427  lenBtrMgrResult = BTRMGR_RESULT_GENERIC_FAILURE;
3428  }
3429  else {
3430  btrMgr_SetAgentActivated(1);
3431  }
3432  }
3433 
3434  btrMgr_PostCheckDiscoveryStatus(aui8AdapterIdx, btrMgr_MapDeviceOpFromDeviceType( btrMgr_MapDeviceTypeFromCore(lenBTRCoreDevCl)));
3435 
3436  return lenBtrMgrResult;
3437 }
3438 
3439 BTRMGR_Result_t
3440 BTRMGR_UnpairDevice (
3441  unsigned char aui8AdapterIdx,
3442  BTRMgrDeviceHandle ahBTRMgrDevHdl
3443 ) {
3444  BTRMGR_Result_t lenBtrMgrResult = BTRMGR_RESULT_SUCCESS;
3445  enBTRCoreRet lenBtrCoreRet = enBTRCoreSuccess;
3446  enBTRCoreDeviceType lenBTRCoreDevTy = enBTRCoreSpeakers;
3447  enBTRCoreDeviceClass lenBTRCoreDevCl = enBTRCore_DC_Unknown;
3448  BTRMGR_Events_t lBtMgrOutEvent = -1;
3449  unsigned char ui8reActivateAgent = 0;
3450  BTRMGR_EventMessage_t lstEventMessage;
3451 
3452 
3453  if (!ghBTRCoreHdl) {
3454  BTRMGRLOG_ERROR ("BTRCore is not Inited\n");
3455  return BTRMGR_RESULT_INIT_FAILED;
3456  }
3457 
3458  if ((aui8AdapterIdx > btrMgr_GetAdapterCnt()) || (!ahBTRMgrDevHdl)) {
3459  BTRMGRLOG_ERROR ("Input is invalid\n");
3460  return BTRMGR_RESULT_INVALID_INPUT;
3461  }
3462 
3463  btrMgr_PreCheckDiscoveryStatus(aui8AdapterIdx, BTRMGR_DEVICE_OP_TYPE_UNKNOWN);
3464 
3465  /* Get the latest Paired Device List; This is added as the developer could add a device thro test application and try unpair thro' UI */
3466  BTRMGR_GetPairedDevices (aui8AdapterIdx, &gListOfPairedDevices);
3467  memset (&lstEventMessage, 0, sizeof(lstEventMessage));
3468  btrMgr_GetPairedDevInfo (ahBTRMgrDevHdl, &lstEventMessage.m_pairedDevice);
3469 
3470  if (!lstEventMessage.m_pairedDevice.m_deviceHandle) {
3471  BTRMGRLOG_ERROR ("Not a Paired device...\n");
3472  return BTRMGR_RESULT_GENERIC_FAILURE;
3473  }
3474 
3475  lenBtrCoreRet = BTRCore_GetDeviceTypeClass(ghBTRCoreHdl, ahBTRMgrDevHdl, &lenBTRCoreDevTy, &lenBTRCoreDevCl);
3476  BTRMGRLOG_DEBUG ("Status = %d\t Device Type = %d\t Device Class = %x\n", lenBtrCoreRet, lenBTRCoreDevTy, lenBTRCoreDevCl);
3477 
3478  if (btrMgr_GetAgentActivated()) {
3479  BTRMGRLOG_INFO ("De-Activate agent\n");
3480  if ((lenBtrCoreRet = BTRCore_UnregisterAgent(ghBTRCoreHdl)) != enBTRCoreSuccess) {
3481  BTRMGRLOG_ERROR ("Failed to Deactivate Agent\n");
3482  lenBtrMgrResult = BTRMGR_RESULT_GENERIC_FAILURE;
3483  }
3484  else {
3485  btrMgr_SetAgentActivated(0);
3486  ui8reActivateAgent = 1;
3487  }
3488  }
3489 
3490 
3491  /* Check whether the requested device is connected n playing. */
3492  if (ghBTRMgrDevHdlCurStreaming == ahBTRMgrDevHdl) {
3493  /* This will internall stops the playback as well as disconnects. */
3494  if ((lenBTRCoreDevTy == enBTRCoreSpeakers) || (lenBTRCoreDevTy == enBTRCoreHeadSet)) {
3495  /* Streaming-Out is happening; stop it */
3496  if ((lenBtrMgrResult = BTRMGR_StopAudioStreamingOut(aui8AdapterIdx, ghBTRMgrDevHdlCurStreaming)) != BTRMGR_RESULT_SUCCESS) {
3497  BTRMGRLOG_ERROR ("BTRMGR_UnpairDevice :This device is being Connected n Playing. Failed to stop Playback. Going Ahead to unpair.-Out\n");
3498  }
3499  }
3500  else if ((lenBTRCoreDevTy == enBTRCoreMobileAudioIn) || (lenBTRCoreDevTy == enBTRCorePCAudioIn)) {
3501  /* Streaming-In is happening; stop it */
3502  if ((lenBtrMgrResult = BTRMGR_StopAudioStreamingIn(aui8AdapterIdx, ghBTRMgrDevHdlCurStreaming)) != BTRMGR_RESULT_SUCCESS) {
3503  BTRMGRLOG_ERROR ("BTRMGR_UnpairDevice :This device is being Connected n Playing. Failed to stop Playback. Going Ahead to unpair.-In\n");
3504  }
3505  }
3506  }
3507 
3508 
3509  if (enBTRCoreSuccess != BTRCore_UnPairDevice(ghBTRCoreHdl, ahBTRMgrDevHdl)) {
3510  BTRMGRLOG_ERROR ("Failed to unpair\n");
3511  lenBtrMgrResult = BTRMGR_RESULT_GENERIC_FAILURE;
3512  lBtMgrOutEvent = BTRMGR_EVENT_DEVICE_UNPAIRING_FAILED;
3513  }
3514  else {
3515  int j;
3516  for (j = 0; j <= gListOfPairedDevices.m_numOfDevices; j++) {
3517  if (ahBTRMgrDevHdl == gListOfPairedDevices.m_deviceProperty[j].m_deviceHandle) {
3518  BTRMGRLOG_INFO ("Unpaired Successfully - %llu - Name - %s\n",ahBTRMgrDevHdl,gListOfPairedDevices.m_deviceProperty[j].m_name);
3519  break;
3520  }
3521  }
3522  lenBtrMgrResult = BTRMGR_RESULT_SUCCESS;
3523  lBtMgrOutEvent = BTRMGR_EVENT_DEVICE_UNPAIRING_COMPLETE;
3524  }
3525 
3526 
3527  {
3528  lstEventMessage.m_adapterIndex = aui8AdapterIdx;
3529  lstEventMessage.m_eventType = lBtMgrOutEvent;
3530 
3531  if (gfpcBBTRMgrEventOut) {
3532  gfpcBBTRMgrEventOut(lstEventMessage); /* Post a callback */
3533  }
3534  }
3535 
3536  /* Update the Paired Device List */
3537  BTRMGR_GetPairedDevices (aui8AdapterIdx, &gListOfPairedDevices);
3538 
3539  if (ui8reActivateAgent) {
3540  BTRMGRLOG_INFO ("Activate agent\n");
3541  if ((lenBtrCoreRet = BTRCore_RegisterAgent(ghBTRCoreHdl, 1)) != enBTRCoreSuccess) {
3542  BTRMGRLOG_ERROR ("Failed to Activate Agent\n");
3543  lenBtrMgrResult = BTRMGR_RESULT_GENERIC_FAILURE;
3544  }
3545  else {
3546  btrMgr_SetAgentActivated(1);
3547  }
3548  }
3549 
3550  btrMgr_PostCheckDiscoveryStatus(aui8AdapterIdx, btrMgr_MapDeviceOpFromDeviceType( btrMgr_MapDeviceTypeFromCore(lenBTRCoreDevCl)));
3551 
3552  return lenBtrMgrResult;
3553 }
3554 
3555 BTRMGR_Result_t
3556 BTRMGR_GetPairedDevices (
3557  unsigned char aui8AdapterIdx,
3558  BTRMGR_PairedDevicesList_t* pPairedDevices
3559 ) {
3560  BTRMGR_Result_t lenBtrMgrResult = BTRMGR_RESULT_SUCCESS;
3561  enBTRCoreRet lenBtrCoreRet = enBTRCoreSuccess;
3562  stBTRCorePairedDevicesCount lstBtrCoreListOfPDevices;
3563  int i = 0;
3564  int j = 0;
3565 
3566  if (!ghBTRCoreHdl) {
3567  BTRMGRLOG_ERROR ("BTRCore is not Inited\n");
3568  return BTRMGR_RESULT_INIT_FAILED;
3569  }
3570 
3571  if ((aui8AdapterIdx > btrMgr_GetAdapterCnt()) || (!pPairedDevices)) {
3572  BTRMGRLOG_ERROR ("Input is invalid\n");
3573  return BTRMGR_RESULT_INVALID_INPUT;
3574  }
3575 
3576  lstBtrCoreListOfPDevices.numberOfDevices = 0;
3577  for (i = 0; i < BTRCORE_MAX_NUM_BT_DEVICES; i++) {
3578  memset (&lstBtrCoreListOfPDevices.devices[i], 0, sizeof(stBTRCoreBTDevice));
3579  }
3580 
3581 
3582  lenBtrCoreRet = BTRCore_GetListOfPairedDevices(ghBTRCoreHdl, &lstBtrCoreListOfPDevices);
3583  if (lenBtrCoreRet != enBTRCoreSuccess) {
3584  BTRMGRLOG_ERROR ("Failed to get list of paired devices\n");
3585  lenBtrMgrResult = BTRMGR_RESULT_GENERIC_FAILURE;
3586  }
3587  else {
3588  pPairedDevices->m_numOfDevices = 0;
3589  for (i = 0; i < BTRMGR_DEVICE_COUNT_MAX; i++) {
3590  memset (&pPairedDevices->m_deviceProperty[i], 0, sizeof(BTRMGR_PairedDevices_t)); /* Reset the values to 0 */
3591  }
3592 
3593  if (lstBtrCoreListOfPDevices.numberOfDevices) {
3594  BTRMGR_PairedDevices_t* lpstBtrMgrPDevice = NULL;
3595 
3596  pPairedDevices->m_numOfDevices = (lstBtrCoreListOfPDevices.numberOfDevices < BTRMGR_DEVICE_COUNT_MAX) ?
3597  lstBtrCoreListOfPDevices.numberOfDevices : BTRMGR_DEVICE_COUNT_MAX;
3598 
3599  for (i = 0; i < pPairedDevices->m_numOfDevices; i++) {
3600  lpstBtrMgrPDevice = &pPairedDevices->m_deviceProperty[i];
3601 
3602  lpstBtrMgrPDevice->m_deviceHandle = lstBtrCoreListOfPDevices.devices[i].tDeviceId;
3603  lpstBtrMgrPDevice->m_deviceType = btrMgr_MapDeviceTypeFromCore (lstBtrCoreListOfPDevices.devices[i].enDeviceType);
3604 
3605  strncpy(lpstBtrMgrPDevice->m_name, lstBtrCoreListOfPDevices.devices[i].pcDeviceName, (BTRMGR_NAME_LEN_MAX - 1));
3606  strncpy(lpstBtrMgrPDevice->m_deviceAddress, lstBtrCoreListOfPDevices.devices[i].pcDeviceAddress,(BTRMGR_NAME_LEN_MAX - 1));
3607 
3608  BTRMGRLOG_INFO ("Paired Device ID = %lld Connected = %d\n", lstBtrCoreListOfPDevices.devices[i].tDeviceId, lstBtrCoreListOfPDevices.devices[i].bDeviceConnected);
3609 
3610  lpstBtrMgrPDevice->m_serviceInfo.m_numOfService = lstBtrCoreListOfPDevices.devices[i].stDeviceProfile.numberOfService;
3611  for (j = 0; j < lstBtrCoreListOfPDevices.devices[i].stDeviceProfile.numberOfService; j++) {
3612  BTRMGRLOG_TRACE ("Profile ID = %u; Profile Name = %s\n", lstBtrCoreListOfPDevices.devices[i].stDeviceProfile.profile[j].uuid_value,
3613  lstBtrCoreListOfPDevices.devices[i].stDeviceProfile.profile[j].profile_name);
3614  lpstBtrMgrPDevice->m_serviceInfo.m_profileInfo[j].m_uuid = lstBtrCoreListOfPDevices.devices[i].stDeviceProfile.profile[j].uuid_value;
3615  strcpy (lpstBtrMgrPDevice->m_serviceInfo.m_profileInfo[j].m_profile, lstBtrCoreListOfPDevices.devices[i].stDeviceProfile.profile[j].profile_name);
3616  }
3617 
3618  if (lstBtrCoreListOfPDevices.devices[i].bDeviceConnected) {
3619  lpstBtrMgrPDevice->m_isConnected = 1;
3620  }
3621  }
3622  /* Success */
3623  BTRMGRLOG_TRACE ("Successful\n");
3624  }
3625  else {
3626  BTRMGRLOG_WARN("No Device is paired yet\n");
3627  }
3628  }
3629 
3630  return lenBtrMgrResult;
3631 }
3632 
3633 
3634 BTRMGR_Result_t
3635 BTRMGR_ConnectToDevice (
3636  unsigned char aui8AdapterIdx,
3637  BTRMgrDeviceHandle ahBTRMgrDevHdl,
3638  BTRMGR_DeviceOperationType_t connectAs
3639 ) {
3640  BTRMGR_Result_t lenBtrMgrResult = BTRMGR_RESULT_SUCCESS;
3641  enBTRCoreDeviceType lenBTRCoreDevTy = enBTRCoreUnknown;
3642  enBTRCoreDeviceClass lenBTRCoreDevCl = enBTRCore_DC_Unknown;
3643 
3644 
3645  if (!ghBTRCoreHdl) {
3646  BTRMGRLOG_ERROR ("BTRCore is not Inited\n");
3647  return BTRMGR_RESULT_INIT_FAILED;
3648 
3649  }
3650 
3651  if ((aui8AdapterIdx > btrMgr_GetAdapterCnt()) || (!ahBTRMgrDevHdl)) {
3652  BTRMGRLOG_ERROR ("Input is invalid\n");
3653  return BTRMGR_RESULT_INVALID_INPUT;
3654  }
3655 
3656  BTRCore_GetDeviceTypeClass(ghBTRCoreHdl, ahBTRMgrDevHdl, &lenBTRCoreDevTy, &lenBTRCoreDevCl);
3657  BTRMGRLOG_DEBUG (" Device Type = %d\t Device Class = %x\n", lenBTRCoreDevTy, lenBTRCoreDevCl);
3658 
3659  if (!gIsHidGamePadEnabled && (lenBTRCoreDevCl == enBTRCore_DC_HID_GamePad)) {
3660  BTRMGRLOG_WARN ("BTR HID GamePad is currently Disabled\n");
3661  return BTRMGR_RESULT_GENERIC_FAILURE;
3662  }
3663 
3664  if (btrMgr_ConnectToDevice(aui8AdapterIdx, ahBTRMgrDevHdl, connectAs, 0, 1) != eBTRMgrSuccess) {
3665  BTRMGRLOG_ERROR ("Failure\n");
3666  lenBtrMgrResult = BTRMGR_RESULT_GENERIC_FAILURE;
3667  }
3668 
3669  return lenBtrMgrResult;
3670 }
3671 
3672 
3673 BTRMGR_Result_t
3674 BTRMGR_DisconnectFromDevice (
3675  unsigned char aui8AdapterIdx,
3676  BTRMgrDeviceHandle ahBTRMgrDevHdl
3677 ) {
3678  BTRMGR_Result_t lenBtrMgrResult = BTRMGR_RESULT_SUCCESS;
3679  enBTRCoreRet lenBtrCoreRet = enBTRCoreSuccess;
3680  enBTRCoreDeviceType lenBTRCoreDevTy = enBTRCoreSpeakers;
3681  enBTRCoreDeviceClass lenBTRCoreDevCl = enBTRCore_DC_Unknown;
3682  BTRMGR_DeviceOperationType_t lenBtrMgrDevOpType = BTRMGR_DEVICE_OP_TYPE_UNKNOWN;
3683 
3684  if (!ghBTRCoreHdl) {
3685  BTRMGRLOG_ERROR ("BTRCore is not Inited\n");
3686  return BTRMGR_RESULT_INIT_FAILED;
3687  }
3688 
3689  if ((aui8AdapterIdx > btrMgr_GetAdapterCnt()) || (!ahBTRMgrDevHdl)) {
3690  BTRMGRLOG_ERROR ("Input is invalid\n");
3691  return BTRMGR_RESULT_INVALID_INPUT;
3692  }
3693 
3694  lenBtrCoreRet = BTRCore_GetDeviceTypeClass(ghBTRCoreHdl, ahBTRMgrDevHdl, &lenBTRCoreDevTy, &lenBTRCoreDevCl);
3695  BTRMGRLOG_DEBUG ("Status = %d\t Device Type = %d\t Device Class = %x\n", lenBtrCoreRet, lenBTRCoreDevTy, lenBTRCoreDevCl);
3696 
3697  if (((lenBtrMgrDevOpType = btrMgr_MapDeviceOpFromDeviceType( btrMgr_MapDeviceTypeFromCore(lenBTRCoreDevCl))) == BTRMGR_DEVICE_OP_TYPE_UNKNOWN) &&
3698  (lenBtrCoreRet == enBTRCoreFailure) &&
3699  (lenBTRCoreDevTy == enBTRCoreUnknown)) {
3700  //TODO: Bad Bad Bad way to treat a Unknown device as LE device, when we are unable to determine from BTRCore
3701  // BTRCore_GetDeviceTypeClass. Means device was removed from the lower layer Scanned/Paired devices
3702  // After Discovered/Paired lists by operation of another client of BTRMgr
3703  lenBTRCoreDevTy = enBTRCoreLE;
3704  lenBtrMgrDevOpType = BTRMGR_DEVICE_OP_TYPE_LE;
3705  }
3706 
3707  if (eBTRMgrSuccess != btrMgr_PreCheckDiscoveryStatus(aui8AdapterIdx, lenBtrMgrDevOpType)) {
3708  BTRMGRLOG_ERROR ("Pre Check Discovery State Failed !!!\n");
3709  if (lenBTRCoreDevTy == enBTRCoreLE) {
3710  btrMgr_PostCheckDiscoveryStatus(aui8AdapterIdx, BTRMGR_DEVICE_OP_TYPE_UNKNOWN);
3711  }
3712  return BTRMGR_RESULT_GENERIC_FAILURE;
3713  }
3714 
3715  if ((lenBTRCoreDevTy != enBTRCoreLE) && !btrMgr_IsDevConnected(ahBTRMgrDevHdl)) {
3716  BTRMGRLOG_ERROR ("No Device is connected at this time\n");
3717  btrMgr_PostCheckDiscoveryStatus(aui8AdapterIdx, lenBtrMgrDevOpType);
3718  return BTRMGR_RESULT_GENERIC_FAILURE;
3719  }
3720 
3721  if (lenBTRCoreDevTy == enBTRCoreLE && !gIsLeDeviceConnected) {
3722  BTRMGRLOG_ERROR ("No LE Device is connected at this time\n");
3723  btrMgr_PostCheckDiscoveryStatus(aui8AdapterIdx, BTRMGR_DEVICE_OP_TYPE_UNKNOWN);
3724  return BTRMGR_RESULT_GENERIC_FAILURE;
3725  }
3726 
3727 
3728  if (lenBTRCoreDevTy != enBTRCoreLE) {
3729 
3730  if (ghBTRMgrDevHdlCurStreaming) {
3731  if ((lenBTRCoreDevTy == enBTRCoreSpeakers) || (lenBTRCoreDevTy == enBTRCoreHeadSet)) {
3732  /* Streaming-Out is happening; stop it */
3733  if ((lenBtrMgrResult = BTRMGR_StopAudioStreamingOut(aui8AdapterIdx, ghBTRMgrDevHdlCurStreaming)) != BTRMGR_RESULT_SUCCESS) {
3734  BTRMGRLOG_ERROR ("Streamout failed to stop\n");
3735  }
3736  }
3737  else if ((lenBTRCoreDevTy == enBTRCoreMobileAudioIn) || (lenBTRCoreDevTy == enBTRCorePCAudioIn)) {
3738  /* Streaming-In is happening; stop it */
3739  if ((lenBtrMgrResult = BTRMGR_StopAudioStreamingIn(aui8AdapterIdx, ghBTRMgrDevHdlCurStreaming)) != BTRMGR_RESULT_SUCCESS) {
3740  BTRMGRLOG_ERROR ("Streamin failed to stop\n");
3741  }
3742  }
3743  }
3744 
3745  gIsUserInitiated = 1;
3746  }
3747 
3748 
3749  /* connectAs param is unused for now.. */
3750  lenBtrCoreRet = BTRCore_DisconnectDevice (ghBTRCoreHdl, ahBTRMgrDevHdl, lenBTRCoreDevTy);
3751  if (lenBtrCoreRet != enBTRCoreSuccess) {
3752  BTRMGRLOG_ERROR ("Failed to Disconnect - %llu\n", ahBTRMgrDevHdl);
3753  lenBtrMgrResult = BTRMGR_RESULT_GENERIC_FAILURE;
3754 
3755  {
3756  BTRMGR_EventMessage_t lstEventMessage;
3757  memset (&lstEventMessage, 0, sizeof(lstEventMessage));
3758 
3759  btrMgr_GetPairedDevInfo(ahBTRMgrDevHdl, &lstEventMessage.m_pairedDevice);
3760 
3761  lstEventMessage.m_adapterIndex = aui8AdapterIdx;
3762  lstEventMessage.m_eventType = BTRMGR_EVENT_DEVICE_DISCONNECT_FAILED;
3763  lstEventMessage.m_pairedDevice.m_isLowEnergyDevice = (lenBTRCoreDevCl==enBTRCore_DC_Tile)?1:0;//Will make it generic later
3764 
3765  if (gfpcBBTRMgrEventOut) {
3766  gfpcBBTRMgrEventOut(lstEventMessage); /* Post a callback */
3767  }
3768  }
3769  }
3770  else {
3771  int j;
3772  for (j = 0; j <= gListOfPairedDevices.m_numOfDevices; j++) {
3773  if (ahBTRMgrDevHdl == gListOfPairedDevices.m_deviceProperty[j].m_deviceHandle) {
3774  BTRMGRLOG_INFO ("Disconnected Successfully - %llu - Name - %s\n",ahBTRMgrDevHdl,gListOfPairedDevices.m_deviceProperty[j].m_name);
3775  break;
3776  }
3777  }
3778  if ((lenBTRCoreDevTy == enBTRCoreSpeakers) || (lenBTRCoreDevTy == enBTRCoreHeadSet)) {
3779  btrMgr_RemovePersistentEntry(aui8AdapterIdx, ahBTRMgrDevHdl, BTRMGR_A2DP_SINK_PROFILE_ID);
3780  }
3781  else if ((lenBTRCoreDevTy == enBTRCoreMobileAudioIn) || (lenBTRCoreDevTy == enBTRCorePCAudioIn)) {
3782  btrMgr_RemovePersistentEntry(aui8AdapterIdx, ahBTRMgrDevHdl, BTRMGR_A2DP_SRC_PROFILE_ID);
3783  }
3784  }
3785 
3786 
3787  if (lenBtrMgrResult != BTRMGR_RESULT_GENERIC_FAILURE) {
3788  /* Max 4 sec timeout - Polled at 1 second interval: Confirmed 2 times */
3789  unsigned int ui32sleepTimeOut = 1;
3790  unsigned int ui32confirmIdx = 2;
3791 
3792  do {
3793  unsigned int ui32sleepIdx = 2;
3794 
3795  do {
3796  sleep(ui32sleepTimeOut);
3797  lenBtrCoreRet = BTRCore_GetDeviceDisconnected(ghBTRCoreHdl, ahBTRMgrDevHdl, lenBTRCoreDevTy);
3798  } while ((lenBtrCoreRet != enBTRCoreSuccess) && (--ui32sleepIdx));
3799  } while (--ui32confirmIdx);
3800 
3801  if (lenBtrCoreRet != enBTRCoreSuccess) {
3802  BTRMGRLOG_ERROR ("Failed to Disconnect from this device - Confirmed\n");
3803  lenBtrMgrResult = BTRMGR_RESULT_GENERIC_FAILURE;
3804  if ((lenBTRCoreDevTy == enBTRCoreSpeakers) || (lenBTRCoreDevTy == enBTRCoreHeadSet)) {
3805  btrMgr_AddPersistentEntry(aui8AdapterIdx, ahBTRMgrDevHdl, BTRMGR_A2DP_SINK_PROFILE_ID, 1);
3806  }
3807  else if ((lenBTRCoreDevTy == enBTRCoreMobileAudioIn) || (lenBTRCoreDevTy == enBTRCorePCAudioIn)) {
3808  btrMgr_AddPersistentEntry(aui8AdapterIdx, ahBTRMgrDevHdl, BTRMGR_A2DP_SRC_PROFILE_ID, 1);
3809  }
3810  }
3811  else {
3812  BTRMGRLOG_DEBUG ("Success Disconnect from this device - Confirmed\n");
3813 
3814  if (lenBTRCoreDevTy == enBTRCoreLE) {
3815  gIsLeDeviceConnected = 0;
3816  }
3817  else if ((lenBTRCoreDevTy == enBTRCoreSpeakers) || (lenBTRCoreDevTy == enBTRCoreHeadSet)) {
3818  btrMgr_SetDevConnected(ahBTRMgrDevHdl, 0);
3819  ghBTRMgrDevHdlLastConnected = 0;
3820  }
3821  else if ((lenBTRCoreDevTy == enBTRCoreMobileAudioIn) || (lenBTRCoreDevTy == enBTRCorePCAudioIn)) {
3822  btrMgr_SetDevConnected(ahBTRMgrDevHdl, 0);
3823  ghBTRMgrDevHdlLastConnected = 0;
3824  }
3825  else if (lenBTRCoreDevTy == enBTRCoreHID) {
3826  btrMgr_SetDevConnected(ahBTRMgrDevHdl, 0);
3827  }
3828  else {
3829  btrMgr_SetDevConnected(ahBTRMgrDevHdl, 0);
3830  }
3831  }
3832  }
3833 
3834  if (lenBtrMgrDevOpType == BTRMGR_DEVICE_OP_TYPE_LE) {
3835  lenBtrMgrDevOpType = BTRMGR_DEVICE_OP_TYPE_UNKNOWN;
3836  }
3837 
3838  btrMgr_PostCheckDiscoveryStatus(aui8AdapterIdx, lenBtrMgrDevOpType);
3839 
3840  return lenBtrMgrResult;
3841 }
3842 
3843 
3844 BTRMGR_Result_t
3845 BTRMGR_GetConnectedDevices (
3846  unsigned char aui8AdapterIdx,
3847  BTRMGR_ConnectedDevicesList_t* pConnectedDevices
3848 ) {
3849  BTRMGR_Result_t lenBtrMgrResult = BTRMGR_RESULT_SUCCESS;
3850  enBTRCoreRet lenBtrCoreRet = enBTRCoreSuccess;
3851  stBTRCorePairedDevicesCount lstBtrCoreListOfPDevices;
3852  stBTRCoreScannedDevicesCount lstBtrCoreListOfSDevices;
3853  unsigned char i = 0;
3854  unsigned char j = 0;
3855 
3856  if (!ghBTRCoreHdl) {
3857  BTRMGRLOG_ERROR ("BTRCore is not Inited\n");
3858  return BTRMGR_RESULT_INIT_FAILED;
3859  }
3860 
3861  if ((aui8AdapterIdx > btrMgr_GetAdapterCnt()) || (!pConnectedDevices)) {
3862  BTRMGRLOG_ERROR ("Input is invalid\n");
3863  return BTRMGR_RESULT_INVALID_INPUT;
3864  }
3865 
3866 
3867  memset (pConnectedDevices, 0, sizeof(BTRMGR_ConnectedDevicesList_t));
3868  memset (&lstBtrCoreListOfPDevices, 0, sizeof(lstBtrCoreListOfPDevices));
3869  memset (&lstBtrCoreListOfSDevices, 0, sizeof(lstBtrCoreListOfSDevices));
3870 
3871  lenBtrCoreRet = BTRCore_GetListOfPairedDevices(ghBTRCoreHdl, &lstBtrCoreListOfPDevices);
3872  if (lenBtrCoreRet == enBTRCoreSuccess) {
3873  if (lstBtrCoreListOfPDevices.numberOfDevices) {
3874  BTRMGR_ConnectedDevice_t* lpstBtrMgrPDevice = NULL;
3875 
3876  for (i = 0; i < lstBtrCoreListOfPDevices.numberOfDevices; i++) {
3877  if ((lstBtrCoreListOfPDevices.devices[i].bDeviceConnected) && (pConnectedDevices->m_numOfDevices < BTRMGR_DEVICE_COUNT_MAX)) {
3878  lpstBtrMgrPDevice = &pConnectedDevices->m_deviceProperty[pConnectedDevices->m_numOfDevices];
3879 
3880  lpstBtrMgrPDevice->m_deviceType = btrMgr_MapDeviceTypeFromCore(lstBtrCoreListOfPDevices.devices[i].enDeviceType);
3881  lpstBtrMgrPDevice->m_deviceHandle = lstBtrCoreListOfPDevices.devices[i].tDeviceId;
3882 
3883  if ((lpstBtrMgrPDevice->m_deviceType == BTRMGR_DEVICE_TYPE_WEARABLE_HEADSET) ||
3884  (lpstBtrMgrPDevice->m_deviceType == BTRMGR_DEVICE_TYPE_HANDSFREE) ||
3885  (lpstBtrMgrPDevice->m_deviceType == BTRMGR_DEVICE_TYPE_LOUDSPEAKER) ||
3886  (lpstBtrMgrPDevice->m_deviceType == BTRMGR_DEVICE_TYPE_HEADPHONES) ||
3887  (lpstBtrMgrPDevice->m_deviceType == BTRMGR_DEVICE_TYPE_PORTABLE_AUDIO) ||
3888  (lpstBtrMgrPDevice->m_deviceType == BTRMGR_DEVICE_TYPE_CAR_AUDIO) ||
3889  (lpstBtrMgrPDevice->m_deviceType == BTRMGR_DEVICE_TYPE_HIFI_AUDIO_DEVICE) ){
3890 
3891  if (lpstBtrMgrPDevice->m_deviceHandle != ghBTRMgrDevHdlCurStreaming)
3892  continue;
3893  }
3894 
3895  lpstBtrMgrPDevice->m_vendorID = lstBtrCoreListOfPDevices.devices[i].ui32VendorId;
3896  lpstBtrMgrPDevice->m_isConnected = 1;
3897 
3898  strncpy (lpstBtrMgrPDevice->m_name, lstBtrCoreListOfPDevices.devices[i].pcDeviceName, (BTRMGR_NAME_LEN_MAX - 1));
3899  strncpy (lpstBtrMgrPDevice->m_deviceAddress, lstBtrCoreListOfPDevices.devices[i].pcDeviceAddress,(BTRMGR_NAME_LEN_MAX - 1));
3900 
3901  lpstBtrMgrPDevice->m_serviceInfo.m_numOfService = lstBtrCoreListOfPDevices.devices[i].stDeviceProfile.numberOfService;
3902  for (j = 0; j < lstBtrCoreListOfPDevices.devices[i].stDeviceProfile.numberOfService; j++) {
3903  lpstBtrMgrPDevice->m_serviceInfo.m_profileInfo[j].m_uuid = lstBtrCoreListOfPDevices.devices[i].stDeviceProfile.profile[j].uuid_value;
3904  strncpy (lpstBtrMgrPDevice->m_serviceInfo.m_profileInfo[j].m_profile, lstBtrCoreListOfPDevices.devices[i].stDeviceProfile.profile[j].profile_name, BTRMGR_NAME_LEN_MAX -1);
3905  lpstBtrMgrPDevice->m_serviceInfo.m_profileInfo[j].m_profile[BTRMGR_NAME_LEN_MAX -1] = '\0'; ///CID:136654 - Buffer size warning
3906  }
3907 
3908  pConnectedDevices->m_numOfDevices++;
3909  BTRMGRLOG_TRACE ("Successfully obtained the connected device information from paried list\n");
3910  }
3911  }
3912  }
3913  else {
3914  BTRMGRLOG_WARN("No Device in paired list\n");
3915  }
3916  }
3917 
3918  lenBtrCoreRet = BTRCore_GetListOfScannedDevices (ghBTRCoreHdl, &lstBtrCoreListOfSDevices);
3919  if (lenBtrCoreRet == enBTRCoreSuccess) {
3920  if (lstBtrCoreListOfSDevices.numberOfDevices) {
3921  BTRMGR_ConnectedDevice_t* lpstBtrMgrSDevice = NULL;
3922 
3923  for (i = 0; i < lstBtrCoreListOfSDevices.numberOfDevices; i++) {
3924  if ((lstBtrCoreListOfSDevices.devices[i].bDeviceConnected) && (pConnectedDevices->m_numOfDevices < BTRMGR_DEVICE_COUNT_MAX)) {
3925  lpstBtrMgrSDevice = &pConnectedDevices->m_deviceProperty[pConnectedDevices->m_numOfDevices];
3926 
3927  lpstBtrMgrSDevice->m_isConnected = 1;
3928  lpstBtrMgrSDevice->m_deviceHandle = lstBtrCoreListOfSDevices.devices[i].tDeviceId;
3929  lpstBtrMgrSDevice->m_vendorID = lstBtrCoreListOfSDevices.devices[i].ui32VendorId;
3930  lpstBtrMgrSDevice->m_deviceType = btrMgr_MapDeviceTypeFromCore(lstBtrCoreListOfSDevices.devices[i].enDeviceType);
3931 
3932  strncpy (lpstBtrMgrSDevice->m_name, lstBtrCoreListOfSDevices.devices[i].pcDeviceName, (BTRMGR_NAME_LEN_MAX - 1));
3933  strncpy (lpstBtrMgrSDevice->m_deviceAddress, lstBtrCoreListOfSDevices.devices[i].pcDeviceAddress,(BTRMGR_NAME_LEN_MAX - 1));
3934 
3935  lpstBtrMgrSDevice->m_serviceInfo.m_numOfService = lstBtrCoreListOfSDevices.devices[i].stDeviceProfile.numberOfService;
3936  for (j = 0; j < lstBtrCoreListOfSDevices.devices[i].stDeviceProfile.numberOfService; j++) {
3937  lpstBtrMgrSDevice->m_serviceInfo.m_profileInfo[j].m_uuid = lstBtrCoreListOfSDevices.devices[i].stDeviceProfile.profile[j].uuid_value;
3938  strncpy (lpstBtrMgrSDevice->m_serviceInfo.m_profileInfo[j].m_profile, lstBtrCoreListOfSDevices.devices[i].stDeviceProfile.profile[j].profile_name, BTRMGR_NAME_LEN_MAX -1);
3939  lpstBtrMgrSDevice->m_serviceInfo.m_profileInfo[j].m_profile[BTRMGR_NAME_LEN_MAX -1] = '\0';
3940  }
3941 
3942  pConnectedDevices->m_numOfDevices++;
3943  BTRMGRLOG_TRACE ("Successfully obtained the connected device information from scanned list\n");
3944  }
3945  }
3946  }
3947  else {
3948  BTRMGRLOG_WARN("No Device in scan list\n");
3949  }
3950  }
3951 
3952  if (enBTRCoreSuccess != lenBtrCoreRet) {
3953  BTRMGRLOG_ERROR ("Failed to get connected device information\n");
3954  lenBtrMgrResult = BTRMGR_RESULT_GENERIC_FAILURE;
3955  }
3956 
3957  return lenBtrMgrResult;
3958 }
3959 
3960 BTRMGR_Result_t
3961 BTRMGR_GetDeviceProperties (
3962  unsigned char aui8AdapterIdx,
3963  BTRMgrDeviceHandle ahBTRMgrDevHdl,
3964  BTRMGR_DevicesProperty_t* pDeviceProperty
3965 ) {
3966  BTRMGR_Result_t lenBtrMgrResult = BTRMGR_RESULT_SUCCESS;
3967  enBTRCoreRet lenBtrCoreRet = enBTRCoreSuccess;
3968  stBTRCorePairedDevicesCount lstBtrCoreListOfPDevices;
3969  stBTRCoreScannedDevicesCount lstBtrCoreListOfSDevices;
3970  unsigned char isFound = 0;
3971  int i = 0;
3972  int j = 0;
3973 
3974  if (!ghBTRCoreHdl) {
3975  BTRMGRLOG_ERROR ("BTRCore is not Inited\n");
3976  return BTRMGR_RESULT_INIT_FAILED;
3977  }
3978 
3979  if ((aui8AdapterIdx > btrMgr_GetAdapterCnt()) || (!pDeviceProperty) || (!ahBTRMgrDevHdl)) {
3980  BTRMGRLOG_ERROR ("Input is invalid\n");
3981  return BTRMGR_RESULT_INVALID_INPUT;
3982  }
3983 
3984 
3985  /* Reset the values to 0 */
3986  memset (&lstBtrCoreListOfPDevices, 0, sizeof(lstBtrCoreListOfPDevices));
3987  memset (&lstBtrCoreListOfSDevices, 0, sizeof(lstBtrCoreListOfSDevices));
3988  memset (pDeviceProperty, 0, sizeof(BTRMGR_DevicesProperty_t));
3989 
3990  lenBtrCoreRet = BTRCore_GetListOfPairedDevices(ghBTRCoreHdl, &lstBtrCoreListOfPDevices);
3991  if (lenBtrCoreRet == enBTRCoreSuccess) {
3992  if (lstBtrCoreListOfPDevices.numberOfDevices) {
3993 
3994  for (i = 0; i < lstBtrCoreListOfPDevices.numberOfDevices; i++) {
3995  if (ahBTRMgrDevHdl == lstBtrCoreListOfPDevices.devices[i].tDeviceId) {
3996  pDeviceProperty->m_deviceHandle = lstBtrCoreListOfPDevices.devices[i].tDeviceId;
3997  pDeviceProperty->m_deviceType = btrMgr_MapDeviceTypeFromCore(lstBtrCoreListOfPDevices.devices[i].enDeviceType);
3998  pDeviceProperty->m_vendorID = lstBtrCoreListOfPDevices.devices[i].ui32VendorId;
3999  pDeviceProperty->m_isLowEnergyDevice = (pDeviceProperty->m_deviceType==BTRMGR_DEVICE_TYPE_TILE)?1:0; //We shall make it generic later
4000  pDeviceProperty->m_isPaired = 1;
4001 
4002  strncpy(pDeviceProperty->m_name, lstBtrCoreListOfPDevices.devices[i].pcDeviceName, (BTRMGR_NAME_LEN_MAX - 1));
4003  strncpy(pDeviceProperty->m_deviceAddress, lstBtrCoreListOfPDevices.devices[i].pcDeviceAddress, (BTRMGR_NAME_LEN_MAX - 1));
4004 
4005  pDeviceProperty->m_serviceInfo.m_numOfService = lstBtrCoreListOfPDevices.devices[i].stDeviceProfile.numberOfService;
4006  for (j = 0; j < lstBtrCoreListOfPDevices.devices[i].stDeviceProfile.numberOfService; j++) {
4007  BTRMGRLOG_TRACE ("Profile ID = %d; Profile Name = %s \n", lstBtrCoreListOfPDevices.devices[i].stDeviceProfile.profile[j].uuid_value,
4008  lstBtrCoreListOfPDevices.devices[i].stDeviceProfile.profile[j].profile_name);
4009  pDeviceProperty->m_serviceInfo.m_profileInfo[j].m_uuid = lstBtrCoreListOfPDevices.devices[i].stDeviceProfile.profile[j].uuid_value;
4010  strncpy (pDeviceProperty->m_serviceInfo.m_profileInfo[j].m_profile, lstBtrCoreListOfPDevices.devices[i].stDeviceProfile.profile[j].profile_name, BTRMGR_NAME_LEN_MAX -1);
4011  pDeviceProperty->m_serviceInfo.m_profileInfo[j].m_profile[BTRMGR_NAME_LEN_MAX -1] = '\0'; //CID:136651 - Buffer size warning
4012  }
4013 
4014  if (lstBtrCoreListOfPDevices.devices[i].bDeviceConnected) {
4015  pDeviceProperty->m_isConnected = 1;
4016  }
4017 
4018  isFound = 1;
4019  break;
4020  }
4021  }
4022  }
4023  else {
4024  BTRMGRLOG_WARN("No Device is paired yet\n");
4025  }
4026  }
4027 
4028 
4029  if (isFound) {
4030  BTRMGRLOG_DEBUG("GetDeviceProperties - Paired Device\n");
4031  return lenBtrMgrResult;
4032  }
4033 
4034 
4035  lenBtrCoreRet = BTRCore_GetListOfScannedDevices (ghBTRCoreHdl, &lstBtrCoreListOfSDevices);
4036  if (lenBtrCoreRet == enBTRCoreSuccess) {
4037  if (lstBtrCoreListOfSDevices.numberOfDevices) {
4038 
4039  for (i = 0; i < lstBtrCoreListOfSDevices.numberOfDevices; i++) {
4040  if (ahBTRMgrDevHdl == lstBtrCoreListOfSDevices.devices[i].tDeviceId) {
4041  if (!isFound) {
4042  pDeviceProperty->m_deviceHandle = lstBtrCoreListOfSDevices.devices[i].tDeviceId;
4043  pDeviceProperty->m_deviceType = btrMgr_MapDeviceTypeFromCore(lstBtrCoreListOfSDevices.devices[i].enDeviceType);
4044  pDeviceProperty->m_vendorID = lstBtrCoreListOfSDevices.devices[i].ui32VendorId;
4045  pDeviceProperty->m_isLowEnergyDevice = (pDeviceProperty->m_deviceType==BTRMGR_DEVICE_TYPE_TILE)?1:0; //We shall make it generic later
4046 
4047  strncpy(pDeviceProperty->m_name, lstBtrCoreListOfSDevices.devices[i].pcDeviceName, (BTRMGR_NAME_LEN_MAX - 1));
4048  strncpy(pDeviceProperty->m_deviceAddress, lstBtrCoreListOfSDevices.devices[i].pcDeviceAddress, (BTRMGR_NAME_LEN_MAX - 1));
4049 
4050  pDeviceProperty->m_serviceInfo.m_numOfService = lstBtrCoreListOfSDevices.devices[i].stDeviceProfile.numberOfService;
4051  for (j = 0; j < lstBtrCoreListOfSDevices.devices[i].stDeviceProfile.numberOfService; j++) {
4052  BTRMGRLOG_TRACE ("Profile ID = %d; Profile Name = %s \n", lstBtrCoreListOfSDevices.devices[i].stDeviceProfile.profile[j].uuid_value,
4053  lstBtrCoreListOfSDevices.devices[i].stDeviceProfile.profile[j].profile_name);
4054  pDeviceProperty->m_serviceInfo.m_profileInfo[j].m_uuid = lstBtrCoreListOfSDevices.devices[i].stDeviceProfile.profile[j].uuid_value;
4055  strncpy (pDeviceProperty->m_serviceInfo.m_profileInfo[j].m_profile, lstBtrCoreListOfSDevices.devices[i].stDeviceProfile.profile[j].profile_name, BTRMGR_NAME_LEN_MAX -1);
4056  pDeviceProperty->m_serviceInfo.m_profileInfo[j].m_profile[BTRMGR_NAME_LEN_MAX -1] = '\0';
4057 
4058  if(0 != lstBtrCoreListOfSDevices.devices[i].stAdServiceData[j].len)
4059  {
4060  fprintf(stderr, "%d\t: %s - ServiceData for UUID : %s \n", __LINE__, __FUNCTION__, lstBtrCoreListOfSDevices.devices[i].stAdServiceData[j].pcUUIDs);
4061  strncpy (pDeviceProperty->m_adServiceData[j].m_UUIDs, lstBtrCoreListOfSDevices.devices[i].stAdServiceData[j].pcUUIDs, (BTRMGR_UUID_STR_LEN_MAX - 1));
4062  memcpy(pDeviceProperty->m_adServiceData[j].m_ServiceData, lstBtrCoreListOfSDevices.devices[i].stAdServiceData[j].pcData, lstBtrCoreListOfSDevices.devices[i].stAdServiceData[j].len);
4063  pDeviceProperty->m_adServiceData[j].m_len = lstBtrCoreListOfSDevices.devices[i].stAdServiceData[j].len;
4064 
4065  for (int k=0; k < pDeviceProperty->m_adServiceData[j].m_len; k++){
4066  fprintf(stderr, "%d\t: %s - ServiceData[%d] = [%x]\n ", __LINE__, __FUNCTION__, k, pDeviceProperty->m_adServiceData[j].m_ServiceData[k]);
4067  }
4068  }
4069  }
4070  }
4071 
4072  pDeviceProperty->m_signalLevel = lstBtrCoreListOfSDevices.devices[i].i32RSSI;
4073 
4074  if (lstBtrCoreListOfSDevices.devices[i].bDeviceConnected) {
4075  pDeviceProperty->m_isConnected = 1;
4076  }
4077 
4078  isFound = 1;
4079  break;
4080  }
4081  }
4082  }
4083  else {
4084  BTRMGRLOG_WARN("No Device in scan list\n");
4085  }
4086  }
4087  pDeviceProperty->m_rssi = btrMgr_MapSignalStrengthToRSSI (pDeviceProperty->m_signalLevel);
4088 
4089  if (!isFound) {
4090  BTRMGRLOG_ERROR ("Could not retrive info for this device\n");
4091  lenBtrMgrResult = BTRMGR_RESULT_GENERIC_FAILURE;
4092  }
4093 
4094  BTRMGRLOG_DEBUG("GetDeviceProperties - Scanned Device\n");
4095  return lenBtrMgrResult;
4096 }
4097 
4098 
4099 BTRMGR_Result_t
4100 BTRMGR_StartAudioStreamingOut_StartUp (
4101  unsigned char aui8AdapterIdx,
4102  BTRMGR_DeviceOperationType_t aenBTRMgrDevConT
4103 ) {
4104  char lui8adapterAddr[BD_NAME_LEN] = {'\0'};
4105  int i32ProfileIdx = 0;
4106  int i32DeviceIdx = 0;
4107  int numOfProfiles = 0;
4108  int deviceCount = 0;
4109  int isConnected = 0;
4110 
4111  BTRMGR_PersistentData_t lstPersistentData;
4112  BTRMgrDeviceHandle lDeviceHandle;
4113 
4114  BTRMGR_Result_t lenBtrMgrResult = BTRMGR_RESULT_SUCCESS;
4115 
4116  gIsAudOutStartupInProgress = BTRMGR_STARTUP_AUD_UNKNOWN;
4117  if (BTRMgr_PI_GetAllProfiles(ghBTRMgrPiHdl, &lstPersistentData) == eBTRMgrFailure) {
4118  btrMgr_AddPersistentEntry (aui8AdapterIdx, 0, BTRMGR_A2DP_SINK_PROFILE_ID, isConnected);
4119  return BTRMGR_RESULT_GENERIC_FAILURE;
4120  }
4121 
4122 
4123  BTRMGRLOG_INFO ("Successfully get all profiles\n");
4124  BTRCore_GetAdapterAddr(ghBTRCoreHdl, aui8AdapterIdx, lui8adapterAddr);
4125 
4126  if (strcmp(lstPersistentData.adapterId, lui8adapterAddr) == 0) {
4127  gIsAudOutStartupInProgress = BTRMGR_STARTUP_AUD_INPROGRESS;
4128  numOfProfiles = lstPersistentData.numOfProfiles;
4129 
4130  BTRMGRLOG_DEBUG ("Adapter matches = %s\n", lui8adapterAddr);
4131  BTRMGRLOG_DEBUG ("Number of Profiles = %d\n", numOfProfiles);
4132 
4133  for (i32ProfileIdx = 0; i32ProfileIdx < numOfProfiles; i32ProfileIdx++) {
4134  deviceCount = lstPersistentData.profileList[i32ProfileIdx].numOfDevices;
4135 
4136  for (i32DeviceIdx = 0; i32DeviceIdx < deviceCount ; i32DeviceIdx++) {
4137  lDeviceHandle = lstPersistentData.profileList[i32ProfileIdx].deviceList[i32DeviceIdx].deviceId;
4138  isConnected = lstPersistentData.profileList[i32ProfileIdx].deviceList[i32DeviceIdx].isConnected;
4139 
4140  if (isConnected && lDeviceHandle) {
4141  ghBTRMgrDevHdlLastConnected = lDeviceHandle;
4142  if(strcmp(lstPersistentData.profileList[i32ProfileIdx].profileId, BTRMGR_A2DP_SINK_PROFILE_ID) == 0) {
4143  char lPropValue[BTRMGR_LE_STR_LEN_MAX] = {'\0'};
4144  BTRMGR_SysDiagChar_t lenDiagElement = BTRMGR_SYS_DIAG_POWERSTATE;
4145 
4146  if (eBTRMgrSuccess != BTRMGR_SysDiag_GetData(ghBTRMgrSdHdl, lenDiagElement, lPropValue)) {
4147  gIsAudOutStartupInProgress = BTRMGR_STARTUP_AUD_UNKNOWN;
4148  BTRMGRLOG_ERROR("Could not get diagnostic data\n");
4149  lenBtrMgrResult = BTRMGR_RESULT_GENERIC_FAILURE;
4150  }
4151 
4152  if ((lenBtrMgrResult == BTRMGR_RESULT_GENERIC_FAILURE) ||
4153  !strncmp(lPropValue, BTRMGR_SYS_DIAG_PWRST_ON, strlen(BTRMGR_SYS_DIAG_PWRST_ON))) {
4154  BTRMGRLOG_INFO ("Streaming to Device = %lld\n", lDeviceHandle);
4155  if (btrMgr_StartAudioStreamingOut(0, lDeviceHandle, aenBTRMgrDevConT, 1, 1, 1) != eBTRMgrSuccess) {
4156  BTRMGRLOG_ERROR ("btrMgr_StartAudioStreamingOut - Failure\n");
4157  lenBtrMgrResult = BTRMGR_RESULT_GENERIC_FAILURE;
4158  }
4159 
4160  gIsAudOutStartupInProgress = BTRMGR_STARTUP_AUD_COMPLETED;
4161  }
4162  else {
4163  gIsAudOutStartupInProgress = BTRMGR_STARTUP_AUD_SKIPPED;
4164  }
4165  }
4166  }
4167  }
4168  }
4169 
4170  if (gIsAudOutStartupInProgress == BTRMGR_STARTUP_AUD_INPROGRESS)
4171  gIsAudOutStartupInProgress = BTRMGR_STARTUP_AUD_UNKNOWN;
4172  }
4173 
4174  return lenBtrMgrResult;
4175 }
4176 
4177 
4178 BTRMGR_Result_t
4179 BTRMGR_StartAudioStreamingOut (
4180  unsigned char aui8AdapterIdx,
4181  BTRMgrDeviceHandle ahBTRMgrDevHdl,
4182  BTRMGR_DeviceOperationType_t streamOutPref
4183 ) {
4184  BTRMGR_Result_t lenBtrMgrResult = BTRMGR_RESULT_SUCCESS;
4185 
4186  if (!ghBTRCoreHdl) {
4187  BTRMGRLOG_ERROR ("BTRCore is not Inited\n");
4188  return BTRMGR_RESULT_INIT_FAILED;
4189  }
4190  else if ((aui8AdapterIdx > btrMgr_GetAdapterCnt()) || (!ahBTRMgrDevHdl)) {
4191  BTRMGRLOG_ERROR ("Input is invalid\n");
4192  return BTRMGR_RESULT_INVALID_INPUT;
4193  }
4194 
4195 
4196  if (btrMgr_StartAudioStreamingOut(aui8AdapterIdx, ahBTRMgrDevHdl, streamOutPref, 0, 0, 0) != eBTRMgrSuccess) {
4197  BTRMGRLOG_ERROR ("Failure\n");
4198  lenBtrMgrResult = BTRMGR_RESULT_GENERIC_FAILURE;
4199  }
4200 
4201  return lenBtrMgrResult;
4202 }
4203 
4204 BTRMGR_Result_t
4205 BTRMGR_StopAudioStreamingOut (
4206  unsigned char aui8AdapterIdx,
4207  BTRMgrDeviceHandle ahBTRMgrDevHdl
4208 ) {
4209  BTRMGR_Result_t lenBtrMgrResult = BTRMGR_RESULT_SUCCESS;
4210  eBTRMgrRet lenBtrMgrRet = eBTRMgrSuccess;
4211 
4212 
4213  if (!ghBTRCoreHdl) {
4214  BTRMGRLOG_ERROR ("BTRCore is not Inited\n");
4215  return BTRMGR_RESULT_INIT_FAILED;
4216  }
4217 
4218  if (aui8AdapterIdx > btrMgr_GetAdapterCnt()) {
4219  BTRMGRLOG_ERROR ("Input is invalid\n");
4220  return BTRMGR_RESULT_INVALID_INPUT;
4221  }
4222 
4223 
4224  if (ghBTRMgrDevHdlCurStreaming != ahBTRMgrDevHdl) {
4225  BTRMGRLOG_ERROR ("Input is invalid\n");
4226  return BTRMGR_RESULT_INVALID_INPUT;
4227  }
4228 
4229 
4230  if ((lenBtrMgrRet = btrMgr_StopCastingAudio()) != eBTRMgrSuccess) {
4231  BTRMGRLOG_ERROR ("btrMgr_StopCastingAudio = %d\n", lenBtrMgrRet);
4232  }
4233 
4234  if (btrMgr_IsDevConnected(ahBTRMgrDevHdl) == 1) {
4235  BTRCore_ReleaseDeviceDataPath (ghBTRCoreHdl, ghBTRMgrDevHdlCurStreaming, enBTRCoreSpeakers);
4236  }
4237 
4238  ghBTRMgrDevHdlCurStreaming = 0;
4239 
4240  if (gstBtrCoreDevMediaInfo.pstBtrCoreDevMCodecInfo) {
4241  free (gstBtrCoreDevMediaInfo.pstBtrCoreDevMCodecInfo);
4242  gstBtrCoreDevMediaInfo.pstBtrCoreDevMCodecInfo = NULL;
4243  }
4244 
4245  /* We had Reset the ghBTRMgrDevHdlCurStreaming to avoid recursion/looping; so no worries */
4246  lenBtrMgrResult = BTRMGR_DisconnectFromDevice(aui8AdapterIdx, ahBTRMgrDevHdl);
4247 
4248  return lenBtrMgrResult;
4249 }
4250 
4251 BTRMGR_Result_t
4252 BTRMGR_IsAudioStreamingOut (
4253  unsigned char aui8AdapterIdx,
4254  unsigned char* pStreamingStatus
4255 ) {
4256  BTRMGR_Result_t lenBtrMgrResult = BTRMGR_RESULT_SUCCESS;
4257 
4258 
4259  if (!ghBTRCoreHdl) {
4260  BTRMGRLOG_ERROR ("BTRCore is not Inited\n");
4261  return BTRMGR_RESULT_INIT_FAILED;
4262  }
4263 
4264  if (aui8AdapterIdx > btrMgr_GetAdapterCnt()) {
4265  BTRMGRLOG_ERROR ("Input is invalid\n");
4266  return BTRMGR_RESULT_INVALID_INPUT;
4267  }
4268 
4269 
4270  if(!pStreamingStatus) {
4271  lenBtrMgrResult = BTRMGR_RESULT_INVALID_INPUT;
4272  BTRMGRLOG_ERROR ("Input is invalid\n");
4273  }
4274  else {
4275  if (ghBTRMgrDevHdlCurStreaming)
4276  *pStreamingStatus = 1;
4277  else
4278  *pStreamingStatus = 0;
4279 
4280  BTRMGRLOG_INFO ("BTRMGR_IsAudioStreamingOut: Returned status Successfully\n");
4281  }
4282 
4283  return lenBtrMgrResult;
4284 }
4285 
4286 BTRMGR_Result_t
4287 BTRMGR_SetAudioStreamingOutType (
4288  unsigned char aui8AdapterIdx,
4289  BTRMGR_StreamOut_Type_t aenCurrentSoType
4290 ) {
4291  BTRMGR_Result_t lenBtrMgrResult = BTRMGR_RESULT_SUCCESS;
4292 
4293  if (!ghBTRCoreHdl) {
4294  BTRMGRLOG_ERROR ("BTRCore is not Inited\n");
4295  return BTRMGR_RESULT_INIT_FAILED;
4296  }
4297 
4298  if (aui8AdapterIdx > btrMgr_GetAdapterCnt()) {
4299  BTRMGRLOG_ERROR ("Input is invalid\n");
4300  return BTRMGR_RESULT_INVALID_INPUT;
4301  }
4302 
4303  BTRMGRLOG_INFO ("Audio output - Stored %d - Switching to %d\n", gstBTRMgrStreamingInfo.tBTRMgrSoType, aenCurrentSoType);
4304  if (gstBTRMgrStreamingInfo.tBTRMgrSoType != aenCurrentSoType) {
4305  unsigned char ui8StreamingStatus = 0;
4306  BTRMGR_StreamOut_Type_t lenCurrentSoType = gstBTRMgrStreamingInfo.tBTRMgrSoType;
4307 
4308  gstBTRMgrStreamingInfo.tBTRMgrSoType = aenCurrentSoType;
4309  if ((BTRMGR_RESULT_SUCCESS == BTRMGR_IsAudioStreamingOut(aui8AdapterIdx, &ui8StreamingStatus)) && ui8StreamingStatus) {
4310  enBTRCoreRet lenBtrCoreRet = enBTRCoreSuccess;
4311  enBTRCoreDeviceType lenBTRCoreDevTy = enBTRCoreUnknown;
4312  enBTRCoreDeviceClass lenBTRCoreDevCl = enBTRCore_DC_Unknown;
4313 
4314  BTRMGRLOG_WARN ("Its already streaming. lets Switch\n");
4315 
4316  lenBtrCoreRet = BTRCore_GetDeviceTypeClass(ghBTRCoreHdl, ghBTRMgrDevHdlCurStreaming, &lenBTRCoreDevTy, &lenBTRCoreDevCl);
4317  BTRMGRLOG_DEBUG ("Status = %d\t Device Type = %d\t Device Class = %x\n", lenBtrCoreRet, lenBTRCoreDevTy, lenBTRCoreDevCl);
4318 
4319  if ((lenBTRCoreDevTy == enBTRCoreSpeakers) || (lenBTRCoreDevTy == enBTRCoreHeadSet)) {
4320  /* Streaming-Out is happening; Lets switch it */
4321  if (btrMgr_SwitchCastingAudio_AC(aenCurrentSoType) != eBTRMgrSuccess) {
4322  gstBTRMgrStreamingInfo.tBTRMgrSoType = lenCurrentSoType;
4323  BTRMGRLOG_ERROR ("This device is being Connected n Playing. Failed to switch to %d\n", aenCurrentSoType);
4324  BTRMGRLOG_ERROR ("Failed to switch streaming on the current device. Streaming %d\n", gstBTRMgrStreamingInfo.tBTRMgrSoType);
4325  if (btrMgr_SwitchCastingAudio_AC(gstBTRMgrStreamingInfo.tBTRMgrSoType) == eBTRMgrSuccess) {
4326  BTRMGRLOG_WARN ("Streaming on the current device. Streaming %d\n", gstBTRMgrStreamingInfo.tBTRMgrSoType);
4327  }
4328 
4329  return BTRMGR_RESULT_GENERIC_FAILURE;
4330  }
4331  }
4332  }
4333  }
4334 
4335  return lenBtrMgrResult;
4336 }
4337 
4338 BTRMGR_Result_t
4339 BTRMGR_StartAudioStreamingIn (
4340  unsigned char aui8AdapterIdx,
4341  BTRMgrDeviceHandle ahBTRMgrDevHdl,
4342  BTRMGR_DeviceOperationType_t connectAs
4343 ) {
4344  BTRMGR_Result_t lenBtrMgrResult = BTRMGR_RESULT_SUCCESS;
4345  BTRMGR_DeviceType_t lenBtrMgrDevType = BTRMGR_DEVICE_TYPE_UNKNOWN;
4346  eBTRMgrRet lenBtrMgrRet = eBTRMgrSuccess;
4347  enBTRCoreRet lenBtrCoreRet = enBTRCoreSuccess;
4348  enBTRCoreDeviceType lenBtrCoreDevType = enBTRCoreUnknown;
4349  stBTRCorePairedDevicesCount listOfPDevices;
4350  int i = 0;
4351  int i32IsFound = 0;
4352  int i32DeviceFD = 0;
4353  int i32DeviceReadMTU = 0;
4354  int i32DeviceWriteMTU = 0;
4355  unsigned int ui32deviceDelay = 0xFFFFu;
4356  eBTRCoreDevMediaType lenBtrCoreDevInMType = eBTRCoreDevMediaTypeUnknown;
4357  void* lpstBtrCoreDevInMCodecInfo = NULL;
4358 
4359  if (!ghBTRCoreHdl) {
4360  BTRMGRLOG_ERROR ("BTRCore is not Inited\n");
4361  return BTRMGR_RESULT_INIT_FAILED;
4362  }
4363 
4364  if ((aui8AdapterIdx > btrMgr_GetAdapterCnt()) || (!ahBTRMgrDevHdl)) {
4365  BTRMGRLOG_ERROR ("Input is invalid\n");
4366  return BTRMGR_RESULT_INVALID_INPUT;
4367  }
4368 
4369  if (ghBTRMgrDevHdlCurStreaming == ahBTRMgrDevHdl) {
4370 
4371  if (gMediaPlaybackStPrev == BTRMGR_EVENT_MEDIA_TRACK_STOPPED) {
4372  BTRMGRLOG_DEBUG ("Starting Media Playback.\n");
4373  lenBtrMgrResult = BTRMGR_MediaControl (aui8AdapterIdx, ahBTRMgrDevHdl, BTRMGR_MEDIA_CTRL_PLAY);
4374  }
4375  else if (gMediaPlaybackStPrev == BTRMGR_EVENT_MEDIA_TRACK_PAUSED) {
4376  BTRMGRLOG_DEBUG ("Resuming Media Playback.\n");
4377  lenBtrMgrResult = BTRMGR_MediaControl (aui8AdapterIdx, ahBTRMgrDevHdl, BTRMGR_MEDIA_CTRL_PLAY);
4378  }
4379  else {
4380  BTRMGRLOG_WARN ("Its already streaming-in in this device.. Check the volume :)\n");
4381  }
4382 
4383  if (lenBtrMgrResult != BTRMGR_RESULT_SUCCESS) {
4384  BTRMGRLOG_ERROR ("Failed to perform Media Control!\n");
4385  }
4386 
4387  return lenBtrMgrResult;
4388  }
4389 
4390 
4391  if ((ghBTRMgrDevHdlCurStreaming != 0) && (ghBTRMgrDevHdlCurStreaming != ahBTRMgrDevHdl)) {
4392  enBTRCoreDeviceType lenBTRCoreDevTy = enBTRCoreUnknown;
4393  enBTRCoreDeviceClass lenBTRCoreDevCl = enBTRCore_DC_Unknown;
4394 
4395  BTRMGRLOG_WARN ("Its already streaming in. lets stop this and start on other device \n");
4396 
4397  lenBtrCoreRet = BTRCore_GetDeviceTypeClass(ghBTRCoreHdl, ghBTRMgrDevHdlCurStreaming, &lenBTRCoreDevTy, &lenBTRCoreDevCl);
4398  BTRMGRLOG_DEBUG ("Status = %d\t Device Type = %d\t Device Class = %x\n", lenBtrCoreRet, lenBTRCoreDevTy, lenBTRCoreDevCl);
4399 
4400  if ((lenBTRCoreDevTy == enBTRCoreSpeakers) || (lenBTRCoreDevTy == enBTRCoreHeadSet)) {
4401  /* Streaming-Out is happening; stop it */
4402  if ((lenBtrMgrResult = BTRMGR_StopAudioStreamingOut(aui8AdapterIdx, ghBTRMgrDevHdlCurStreaming)) != BTRMGR_RESULT_SUCCESS) {
4403  BTRMGRLOG_ERROR ("This device is being Connected n Playing. Failed to stop Playback.-Out\n");
4404  BTRMGRLOG_ERROR ("Failed to stop streaming at the current device..\n");
4405  return lenBtrMgrResult;
4406  }
4407  }
4408  else if ((lenBTRCoreDevTy == enBTRCoreMobileAudioIn) || (lenBTRCoreDevTy == enBTRCorePCAudioIn)) {
4409  /* Streaming-In is happening; stop it */
4410  if ((lenBtrMgrResult = BTRMGR_StopAudioStreamingIn(aui8AdapterIdx, ghBTRMgrDevHdlCurStreaming)) != BTRMGR_RESULT_SUCCESS) {
4411  BTRMGRLOG_ERROR ("This device is being Connected n Playing. Failed to stop Playback.-In\n");
4412  BTRMGRLOG_ERROR ("Failed to stop streaming at the current device..\n");
4413  return lenBtrMgrResult;
4414  }
4415  }
4416  }
4417 
4418  /* Check whether the device is in the paired list */
4419  memset(&listOfPDevices, 0, sizeof(listOfPDevices));
4420  if (BTRCore_GetListOfPairedDevices(ghBTRCoreHdl, &listOfPDevices) != enBTRCoreSuccess) {
4421  BTRMGRLOG_ERROR ("Failed to get the paired devices list\n");
4422  return BTRMGR_RESULT_GENERIC_FAILURE;
4423  }
4424 
4425  if (!listOfPDevices.numberOfDevices) {
4426  BTRMGRLOG_ERROR ("No device is paired yet; Will not be able to play at this moment\n");
4427  return BTRMGR_RESULT_GENERIC_FAILURE;
4428  }
4429 
4430 
4431  for (i = 0; i < listOfPDevices.numberOfDevices; i++) {
4432  if (ahBTRMgrDevHdl == listOfPDevices.devices[i].tDeviceId) {
4433  i32IsFound = 1;
4434  break;
4435  }
4436  }
4437 
4438  if (!i32IsFound) {
4439  BTRMGRLOG_ERROR ("Failed to find this device in the paired devices list\n");
4440  return BTRMGR_RESULT_GENERIC_FAILURE;
4441  }
4442 
4443 
4444  lenBtrMgrDevType = btrMgr_MapDeviceTypeFromCore(listOfPDevices.devices[i].enDeviceType);
4445  if (lenBtrMgrDevType == BTRMGR_DEVICE_TYPE_SMARTPHONE) {
4446  lenBtrCoreDevType = enBTRCoreMobileAudioIn;
4447  }
4448  else if (lenBtrMgrDevType == BTRMGR_DEVICE_TYPE_TABLET) {
4449  lenBtrCoreDevType = enBTRCorePCAudioIn;
4450  }
4451  if (!gIsAudioInEnabled && ((lenBtrCoreDevType == enBTRCoreMobileAudioIn) || (lenBtrCoreDevType == enBTRCorePCAudioIn))) {
4452  BTRMGRLOG_WARN ("StreamingIn Rejected - BTR AudioIn is currently Disabled!\n");
4453  return BTRMGR_RESULT_GENERIC_FAILURE;
4454  }
4455 
4456 
4457  if (!listOfPDevices.devices[i].bDeviceConnected || (ghBTRMgrDevHdlCurStreaming != listOfPDevices.devices[i].tDeviceId)) {
4458  if ((lenBtrMgrRet = btrMgr_ConnectToDevice(aui8AdapterIdx, listOfPDevices.devices[i].tDeviceId, connectAs, 0, 1)) == eBTRMgrSuccess) {
4459  gMediaPlaybackStPrev = BTRMGR_EVENT_MEDIA_TRACK_STOPPED; //TODO: Bad Bad Bad way of doing this
4460  }
4461  else {
4462  BTRMGRLOG_ERROR ("Failure\n");
4463  return BTRMGR_RESULT_GENERIC_FAILURE;
4464  }
4465  }
4466 
4467 
4468  if (gstBtrCoreDevMediaInfo.pstBtrCoreDevMCodecInfo) {
4469  free (gstBtrCoreDevMediaInfo.pstBtrCoreDevMCodecInfo);
4470  gstBtrCoreDevMediaInfo.pstBtrCoreDevMCodecInfo = NULL;
4471  }
4472 
4473 
4474  gstBtrCoreDevMediaInfo.pstBtrCoreDevMCodecInfo = (void*)malloc((sizeof(stBTRCoreDevMediaPcmInfo) > sizeof(stBTRCoreDevMediaSbcInfo) ? sizeof(stBTRCoreDevMediaPcmInfo) : sizeof(stBTRCoreDevMediaSbcInfo)) > sizeof(stBTRCoreDevMediaMpegInfo) ?
4475  (sizeof(stBTRCoreDevMediaPcmInfo) > sizeof(stBTRCoreDevMediaSbcInfo) ? sizeof(stBTRCoreDevMediaPcmInfo) : sizeof(stBTRCoreDevMediaSbcInfo)) : sizeof(stBTRCoreDevMediaMpegInfo));
4476 
4477  lenBtrCoreRet = BTRCore_GetDeviceMediaInfo(ghBTRCoreHdl, listOfPDevices.devices[i].tDeviceId, lenBtrCoreDevType, &gstBtrCoreDevMediaInfo);
4478  if (lenBtrCoreRet == enBTRCoreSuccess) {
4479  lenBtrCoreDevInMType = gstBtrCoreDevMediaInfo.eBtrCoreDevMType;
4480  lpstBtrCoreDevInMCodecInfo= gstBtrCoreDevMediaInfo.pstBtrCoreDevMCodecInfo;
4481 
4482  if (lenBtrCoreDevInMType == eBTRCoreDevMediaTypeSBC) {
4483  stBTRCoreDevMediaSbcInfo* lpstBtrCoreDevMSbcInfo = (stBTRCoreDevMediaSbcInfo*)lpstBtrCoreDevInMCodecInfo;
4484 
4485  BTRMGRLOG_INFO ("DevMedInfo SFreq = %d\n", lpstBtrCoreDevMSbcInfo->ui32DevMSFreq);
4486  BTRMGRLOG_INFO ("DevMedInfo AChan = %d\n", lpstBtrCoreDevMSbcInfo->eDevMAChan);
4487  BTRMGRLOG_INFO ("DevMedInfo SbcAllocMethod = %d\n", lpstBtrCoreDevMSbcInfo->ui8DevMSbcAllocMethod);
4488  BTRMGRLOG_INFO ("DevMedInfo SbcSubbands = %d\n", lpstBtrCoreDevMSbcInfo->ui8DevMSbcSubbands);
4489  BTRMGRLOG_INFO ("DevMedInfo SbcBlockLength = %d\n", lpstBtrCoreDevMSbcInfo->ui8DevMSbcBlockLength);
4490  BTRMGRLOG_INFO ("DevMedInfo SbcMinBitpool = %d\n", lpstBtrCoreDevMSbcInfo->ui8DevMSbcMinBitpool);
4491  BTRMGRLOG_INFO ("DevMedInfo SbcMaxBitpool = %d\n", lpstBtrCoreDevMSbcInfo->ui8DevMSbcMaxBitpool);
4492  BTRMGRLOG_INFO ("DevMedInfo SbcFrameLen = %d\n", lpstBtrCoreDevMSbcInfo->ui16DevMSbcFrameLen);
4493  BTRMGRLOG_DEBUG("DevMedInfo SbcBitrate = %d\n", lpstBtrCoreDevMSbcInfo->ui16DevMSbcBitrate);
4494  }
4495  else if (lenBtrCoreDevInMType == eBTRCoreDevMediaTypeAAC) {
4496  stBTRCoreDevMediaMpegInfo* lpstBtrCoreDevMAacInfo = (stBTRCoreDevMediaMpegInfo*)lpstBtrCoreDevInMCodecInfo;
4497 
4498  BTRMGRLOG_INFO ("DevMedInfo SFreq = %d\n", lpstBtrCoreDevMAacInfo->ui32DevMSFreq);
4499  BTRMGRLOG_INFO ("DevMedInfo AChan = %d\n", lpstBtrCoreDevMAacInfo->eDevMAChan);
4500  BTRMGRLOG_INFO ("DevMedInfo AacMpegCrc = %d\n", lpstBtrCoreDevMAacInfo->ui8DevMMpegCrc);
4501  BTRMGRLOG_INFO ("DevMedInfo AacMpegLayer = %d\n", lpstBtrCoreDevMAacInfo->ui8DevMMpegLayer);
4502  BTRMGRLOG_INFO ("DevMedInfo AacMpegMpf = %d\n", lpstBtrCoreDevMAacInfo->ui8DevMMpegMpf);
4503  BTRMGRLOG_INFO ("DevMedInfo AacMpegRfa = %d\n", lpstBtrCoreDevMAacInfo->ui8DevMMpegRfa);
4504  BTRMGRLOG_INFO ("DevMedInfo AacMpegFrmLen = %d\n", lpstBtrCoreDevMAacInfo->ui16DevMMpegFrameLen);
4505  BTRMGRLOG_INFO ("DevMedInfo AacMpegBitrate = %d\n", lpstBtrCoreDevMAacInfo->ui16DevMMpegBitrate);
4506  }
4507  }
4508 
4509  /* Aquire Device Data Path to start audio reception */
4510  lenBtrCoreRet = BTRCore_AcquireDeviceDataPath (ghBTRCoreHdl, listOfPDevices.devices[i].tDeviceId, lenBtrCoreDevType, &i32DeviceFD, &i32DeviceReadMTU, &i32DeviceWriteMTU, &ui32deviceDelay);
4511  if (lenBtrCoreRet == enBTRCoreSuccess) {
4512  if ((lenBtrMgrRet = btrMgr_StartReceivingAudio(i32DeviceFD, i32DeviceReadMTU, ui32deviceDelay, lenBtrCoreDevInMType, lpstBtrCoreDevInMCodecInfo)) == eBTRMgrSuccess) {
4513  ghBTRMgrDevHdlCurStreaming = listOfPDevices.devices[i].tDeviceId;
4514  BTRMGRLOG_INFO("Audio Reception Started.. Enjoy the show..! :)\n");
4515  }
4516  else {
4517  BTRMGRLOG_ERROR ("Failed to read audio now\n");
4518  lenBtrMgrResult = BTRMGR_RESULT_GENERIC_FAILURE;
4519  }
4520  }
4521  else {
4522  BTRMGRLOG_ERROR ("Failed to get Device Data Path. So Will not be able to stream now\n");
4523  lenBtrMgrResult = BTRMGR_RESULT_GENERIC_FAILURE;
4524  }
4525 
4526  return lenBtrMgrResult;
4527 }
4528 
4529 BTRMGR_Result_t
4530 BTRMGR_StopAudioStreamingIn (
4531  unsigned char aui8AdapterIdx,
4532  BTRMgrDeviceHandle ahBTRMgrDevHdl
4533 ) {
4534  BTRMGR_Result_t lenBtrMgrResult = BTRMGR_RESULT_SUCCESS;
4535  eBTRMgrRet lenBtrMgrRet = eBTRMgrSuccess;
4536 
4537  if (!ghBTRCoreHdl) {
4538  BTRMGRLOG_ERROR ("BTRCore is not Inited\n");
4539  return BTRMGR_RESULT_INIT_FAILED;
4540  }
4541 
4542  if (aui8AdapterIdx > btrMgr_GetAdapterCnt()) {
4543  BTRMGRLOG_ERROR ("Input is invalid\n");
4544  return BTRMGR_RESULT_INVALID_INPUT;
4545  }
4546 
4547 
4548  if ((ghBTRMgrDevHdlCurStreaming != ahBTRMgrDevHdl) && (ghBTRMgrDevHdlLastConnected != ahBTRMgrDevHdl)) {
4549  return BTRMGR_RESULT_INVALID_INPUT;
4550  }
4551 
4552 
4553  if ((lenBtrMgrRet = btrMgr_StopReceivingAudio()) != eBTRMgrSuccess) {
4554  BTRMGRLOG_ERROR ("btrMgr_StopReceivingAudio = %d\n", lenBtrMgrRet);
4555  }
4556 
4557  // TODO : determine enBTRCoreDeviceType from get Paired dev list
4558  BTRCore_ReleaseDeviceDataPath (ghBTRCoreHdl, ghBTRMgrDevHdlCurStreaming, enBTRCoreMobileAudioIn);
4559 
4560  ghBTRMgrDevHdlCurStreaming = 0;
4561 
4562  if (gstBtrCoreDevMediaInfo.pstBtrCoreDevMCodecInfo) {
4563  free (gstBtrCoreDevMediaInfo.pstBtrCoreDevMCodecInfo);
4564  gstBtrCoreDevMediaInfo.pstBtrCoreDevMCodecInfo = NULL;
4565  }
4566 
4567  /* We had Reset the ghBTRMgrDevHdlCurStreaming to avoid recursion/looping; so no worries */
4568  lenBtrMgrResult = BTRMGR_DisconnectFromDevice(aui8AdapterIdx, ahBTRMgrDevHdl);
4569 
4570  return lenBtrMgrResult;
4571 }
4572 
4573 BTRMGR_Result_t
4574 BTRMGR_IsAudioStreamingIn (
4575  unsigned char aui8AdapterIdx,
4576  unsigned char* pStreamingStatus
4577 ) {
4578  BTRMGR_Result_t lenBtrMgrRet = BTRMGR_RESULT_SUCCESS;
4579 
4580  if (!ghBTRCoreHdl) {
4581  BTRMGRLOG_ERROR ("BTRCore is not Inited\n");
4582  return BTRMGR_RESULT_INIT_FAILED;
4583  }
4584 
4585  if ((aui8AdapterIdx > btrMgr_GetAdapterCnt()) || (!pStreamingStatus)) {
4586  BTRMGRLOG_ERROR ("Input is invalid\n");
4587  return BTRMGR_RESULT_INVALID_INPUT;
4588  }
4589 
4590 
4591  if (ghBTRMgrDevHdlCurStreaming)
4592  *pStreamingStatus = 1;
4593  else
4594  *pStreamingStatus = 0;
4595 
4596  BTRMGRLOG_INFO ("BTRMGR_IsAudioStreamingIn: Returned status Successfully\n");
4597 
4598  return lenBtrMgrRet;
4599 }
4600 
4601 BTRMGR_Result_t
4602 BTRMGR_SetEventResponse (
4603  unsigned char aui8AdapterIdx,
4604  BTRMGR_EventResponse_t* apstBTRMgrEvtRsp
4605 ) {
4606  BTRMGR_Result_t lenBtrMgrResult = BTRMGR_RESULT_SUCCESS;
4607 
4608  if (!ghBTRCoreHdl) {
4609  BTRMGRLOG_ERROR ("BTRCore is not Inited\n");
4610  return BTRMGR_RESULT_INIT_FAILED;
4611  }
4612 
4613  if ((aui8AdapterIdx > btrMgr_GetAdapterCnt()) || (!apstBTRMgrEvtRsp)) {
4614  BTRMGRLOG_ERROR ("Input is invalid\n");
4615  return BTRMGR_RESULT_INVALID_INPUT;
4616  }
4617 
4618 
4619  switch (apstBTRMgrEvtRsp->m_eventType) {
4620  case BTRMGR_EVENT_DEVICE_OUT_OF_RANGE:
4621  break;
4622  case BTRMGR_EVENT_DEVICE_DISCOVERY_UPDATE:
4623  break;
4624  case BTRMGR_EVENT_DEVICE_DISCOVERY_COMPLETE:
4625  break;
4626  case BTRMGR_EVENT_DEVICE_PAIRING_COMPLETE:
4627  break;
4628  case BTRMGR_EVENT_DEVICE_UNPAIRING_COMPLETE:
4629  break;
4630  case BTRMGR_EVENT_DEVICE_CONNECTION_COMPLETE:
4631  break;
4632  case BTRMGR_EVENT_DEVICE_DISCONNECT_COMPLETE:
4633  break;
4634  case BTRMGR_EVENT_DEVICE_PAIRING_FAILED:
4635  break;
4636  case BTRMGR_EVENT_DEVICE_UNPAIRING_FAILED:
4637  break;
4638  case BTRMGR_EVENT_DEVICE_CONNECTION_FAILED:
4639  break;
4640  case BTRMGR_EVENT_DEVICE_DISCONNECT_FAILED:
4641  break;
4642  case BTRMGR_EVENT_RECEIVED_EXTERNAL_PAIR_REQUEST:
4643  gEventRespReceived = 1;
4644  if (apstBTRMgrEvtRsp->m_eventResp) {
4645  gAcceptConnection = 1;
4646  }
4647  break;
4648  case BTRMGR_EVENT_RECEIVED_EXTERNAL_CONNECT_REQUEST:
4649  gEventRespReceived = 1;
4650  gAcceptConnection = 0;
4651  if (apstBTRMgrEvtRsp->m_eventResp) {
4652  gAcceptConnection = 1;
4653  }
4654  break;
4655  case BTRMGR_EVENT_RECEIVED_EXTERNAL_PLAYBACK_REQUEST:
4656  if (apstBTRMgrEvtRsp->m_eventResp && apstBTRMgrEvtRsp->m_deviceHandle) {
4657  BTRMGR_DeviceOperationType_t stream_pref = BTRMGR_DEVICE_OP_TYPE_AUDIO_INPUT;
4658  lenBtrMgrResult = BTRMGR_StartAudioStreamingIn(aui8AdapterIdx, apstBTRMgrEvtRsp->m_deviceHandle, stream_pref);
4659  }
4660  break;
4661  case BTRMGR_EVENT_DEVICE_FOUND:
4662  break;
4663  case BTRMGR_EVENT_DEVICE_OP_INFORMATION:
4664  if (apstBTRMgrEvtRsp->m_eventResp) {
4665  strncpy(gLeReadOpResponse, apstBTRMgrEvtRsp->m_writeData, BTRMGR_MAX_DEV_OP_DATA_LEN - 1);
4666  gEventRespReceived = 1;
4667  }
4668  break;
4669  case BTRMGR_EVENT_MAX:
4670  default:
4671  break;
4672  }
4673 
4674 
4675  return lenBtrMgrResult;
4676 }
4677 
4678 
4679 BTRMGR_Result_t
4680 BTRMGR_MediaControl (
4681  unsigned char aui8AdapterIdx,
4682  BTRMgrDeviceHandle ahBTRMgrDevHdl,
4683  BTRMGR_MediaControlCommand_t mediaCtrlCmd
4684 ) {
4685  BTRMGR_Result_t lenBtrMgrResult = BTRMGR_RESULT_SUCCESS;
4686  enBTRCoreRet lenBtrCoreRet = enBTRCoreSuccess;
4687  enBTRCoreDeviceType lenBtrCoreDevTy = enBTRCoreUnknown;
4688  enBTRCoreDeviceClass lenBtrCoreDevCl = enBTRCore_DC_Unknown;
4689  BTRMGR_MediaDeviceStatus_t lstMediaDeviceStatus;
4690 
4691 
4692  if (!ghBTRCoreHdl) {
4693  BTRMGRLOG_ERROR ("BTRCore is not Inited\n");
4694  return BTRMGR_RESULT_INIT_FAILED;
4695  }
4696 
4697  if (aui8AdapterIdx > btrMgr_GetAdapterCnt()) {
4698  BTRMGRLOG_ERROR ("Input is invalid\n");
4699  return BTRMGR_RESULT_INVALID_INPUT;
4700  }
4701 
4702  if (!btrMgr_IsDevConnected(ahBTRMgrDevHdl)) {
4703  BTRMGRLOG_ERROR ("Device Handle(%lld) not connected\n", ahBTRMgrDevHdl);
4704  return BTRMGR_RESULT_INVALID_INPUT;
4705  }
4706 
4707  lenBtrCoreRet = BTRCore_GetDeviceTypeClass(ghBTRCoreHdl, ahBTRMgrDevHdl, &lenBtrCoreDevTy, &lenBtrCoreDevCl);
4708  BTRMGRLOG_DEBUG ("Status = %d\t Device Type = %d\t Device Class = %x\n", lenBtrCoreRet, lenBtrCoreDevTy, lenBtrCoreDevCl);
4709 
4710 
4711  lstMediaDeviceStatus.m_ui8mediaDevVolume= BTRMGR_SO_MAX_VOLUME;
4712  lstMediaDeviceStatus.m_enmediaCtrlCmd = mediaCtrlCmd;
4713  if (mediaCtrlCmd == BTRMGR_MEDIA_CTRL_MUTE)
4714  lstMediaDeviceStatus.m_ui8mediaDevMute = 1;
4715  else if (mediaCtrlCmd == BTRMGR_MEDIA_CTRL_UNMUTE)
4716  lstMediaDeviceStatus.m_ui8mediaDevMute = 0;
4717  else
4718  lstMediaDeviceStatus.m_ui8mediaDevMute = BTRMGR_SO_MAX_VOLUME; // To handle alternate options
4719 
4720 
4721  if (btrMgr_MediaControl(aui8AdapterIdx, ahBTRMgrDevHdl, &lstMediaDeviceStatus, lenBtrCoreDevTy, lenBtrCoreDevCl, NULL) != eBTRMgrSuccess)
4722  lenBtrMgrResult = BTRMGR_RESULT_GENERIC_FAILURE;
4723 
4724  return lenBtrMgrResult;
4725 }
4726 
4727 eBTRMgrRet
4728 btrMgr_MediaControl (
4729  unsigned char aui8AdapterIdx,
4730  BTRMgrDeviceHandle ahBTRMgrDevHdl,
4731  BTRMGR_MediaDeviceStatus_t* apstMediaDeviceStatus,
4732  enBTRCoreDeviceType aenBtrCoreDevTy,
4733  enBTRCoreDeviceClass aenBtrCoreDevCl,
4734  stBTRCoreMediaCtData* apstBtrCoreMediaCData
4735 ) {
4736  enBTRCoreMediaCtrl lenBTRCoreMediaCtrl = enBTRCoreMediaCtrlUnknown;
4737  eBTRMgrRet lenBtrMgrRet = eBTRMgrFailure;
4738 
4739  switch (apstMediaDeviceStatus->m_enmediaCtrlCmd) {
4740  case BTRMGR_MEDIA_CTRL_PLAY:
4741  lenBTRCoreMediaCtrl = enBTRCoreMediaCtrlPlay;
4742  break;
4743  case BTRMGR_MEDIA_CTRL_PAUSE:
4744  lenBTRCoreMediaCtrl = enBTRCoreMediaCtrlPause;
4745  break;
4746  case BTRMGR_MEDIA_CTRL_STOP:
4747  lenBTRCoreMediaCtrl = enBTRCoreMediaCtrlStop;
4748  break;
4749  case BTRMGR_MEDIA_CTRL_NEXT:
4750  lenBTRCoreMediaCtrl = enBTRCoreMediaCtrlNext;
4751  break;
4752  case BTRMGR_MEDIA_CTRL_PREVIOUS:
4753  lenBTRCoreMediaCtrl = enBTRCoreMediaCtrlPrevious;
4754  break;
4755  case BTRMGR_MEDIA_CTRL_FASTFORWARD:
4756  lenBTRCoreMediaCtrl = enBTRCoreMediaCtrlFastForward;
4757  break;
4758  case BTRMGR_MEDIA_CTRL_REWIND:
4759  lenBTRCoreMediaCtrl = enBTRCoreMediaCtrlRewind;
4760  break;
4761  case BTRMGR_MEDIA_CTRL_VOLUMEUP:
4762  lenBTRCoreMediaCtrl = enBTRCoreMediaCtrlVolumeUp;
4763  break;
4764  case BTRMGR_MEDIA_CTRL_VOLUMEDOWN:
4765  lenBTRCoreMediaCtrl = enBTRCoreMediaCtrlVolumeDown;
4766  break;
4767  case BTRMGR_MEDIA_CTRL_EQUALIZER_OFF:
4768  lenBTRCoreMediaCtrl = enBTRCoreMediaCtrlEqlzrOff;
4769  break;
4770  case BTRMGR_MEDIA_CTRL_EQUALIZER_ON:
4771  lenBTRCoreMediaCtrl = enBTRCoreMediaCtrlEqlzrOn;
4772  break;
4773  case BTRMGR_MEDIA_CTRL_SHUFFLE_OFF:
4774  lenBTRCoreMediaCtrl = enBTRCoreMediaCtrlShflOff;
4775  break;
4776  case BTRMGR_MEDIA_CTRL_SHUFFLE_ALLTRACKS:
4777  lenBTRCoreMediaCtrl = enBTRCoreMediaCtrlShflAllTracks;
4778  break;
4779  case BTRMGR_MEDIA_CTRL_SHUFFLE_GROUP:
4780  lenBTRCoreMediaCtrl = enBTRCoreMediaCtrlShflGroup;
4781  break;
4782  case BTRMGR_MEDIA_CTRL_REPEAT_OFF:
4783  lenBTRCoreMediaCtrl = enBTRCoreMediaCtrlRptOff;
4784  break;
4785  case BTRMGR_MEDIA_CTRL_REPEAT_SINGLETRACK:
4786  lenBTRCoreMediaCtrl = enBTRCoreMediaCtrlRptSingleTrack;
4787  break;
4788  case BTRMGR_MEDIA_CTRL_REPEAT_ALLTRACKS:
4789  lenBTRCoreMediaCtrl = enBTRCoreMediaCtrlRptAllTracks;
4790  break;
4791  case BTRMGR_MEDIA_CTRL_REPEAT_GROUP:
4792  lenBTRCoreMediaCtrl = enBTRCoreMediaCtrlRptGroup;
4793  break;
4794  case BTRMGR_MEDIA_CTRL_MUTE:
4795  lenBTRCoreMediaCtrl = enBTRCoreMediaCtrlMute;
4796  break;
4797  case BTRMGR_MEDIA_CTRL_UNMUTE:
4798  lenBTRCoreMediaCtrl = enBTRCoreMediaCtrlUnMute;
4799  break;
4800  case BTRMGR_MEDIA_CTRL_UNKNOWN:
4801  default:
4802  lenBTRCoreMediaCtrl = enBTRCoreMediaCtrlUnknown;
4803  }
4804 
4805 
4806  if (lenBTRCoreMediaCtrl != enBTRCoreMediaCtrlUnknown) {
4807 
4808  if ((aenBtrCoreDevTy == enBTRCoreSpeakers) || (aenBtrCoreDevTy == enBTRCoreHeadSet)) {
4809  if ((ghBTRMgrDevHdlCurStreaming == ahBTRMgrDevHdl) ) {
4810  BTRMGR_EventMessage_t lstEventMessage;
4811 
4812  memset (&lstEventMessage, 0, sizeof(lstEventMessage));
4813 
4814  switch (apstMediaDeviceStatus->m_enmediaCtrlCmd) {
4815  case BTRMGR_MEDIA_CTRL_VOLUMEUP:
4816  if (enBTRCoreSuccess == BTRCore_MediaControl(ghBTRCoreHdl, ahBTRMgrDevHdl, aenBtrCoreDevTy, lenBTRCoreMediaCtrl, apstBtrCoreMediaCData)) {
4817  BTRMGRLOG_INFO ("Media Control Command BTRMGR_MEDIA_CTRL_VOLUMEUP for %llu Success for streamout!!!\n", ahBTRMgrDevHdl);
4818  lenBtrMgrRet = eBTRMgrSuccess;
4819  }
4820  else if (apstMediaDeviceStatus->m_ui8mediaDevMute == BTRMGR_SO_MAX_VOLUME) {
4821  unsigned char ui8CurVolume = 0;
4822 
4823  BTRMgr_SO_GetVolume(gstBTRMgrStreamingInfo.hBTRMgrSoHdl,&ui8CurVolume);
4824  BTRMGRLOG_DEBUG ("ui8CurVolume %d \n ",ui8CurVolume);
4825 
4826  if (apstBtrCoreMediaCData != NULL) {
4827  ui8CurVolume = apstBtrCoreMediaCData->m_mediaAbsoluteVolume;
4828  }
4829  else {
4830  if(ui8CurVolume < 5)
4831  ui8CurVolume = 5;
4832  else if (ui8CurVolume <= 245 && ui8CurVolume >= 5)
4833  ui8CurVolume = ui8CurVolume + 10; // Increment steps in 10
4834  else
4835  ui8CurVolume = BTRMGR_SO_MAX_VOLUME;
4836  }
4837 
4838  if ((lenBtrMgrRet = BTRMgr_SO_SetVolume(gstBTRMgrStreamingInfo.hBTRMgrSoHdl, ui8CurVolume)) == eBTRMgrSuccess) {
4839  lstEventMessage.m_eventType = BTRMGR_EVENT_DEVICE_MEDIA_STATUS;
4840  lstEventMessage.m_mediaInfo.m_mediaDevStatus.m_ui8mediaDevVolume = ui8CurVolume;
4841  lstEventMessage.m_mediaInfo.m_mediaDevStatus.m_ui8mediaDevMute = (ui8CurVolume) ? FALSE : TRUE;
4842  lstEventMessage.m_mediaInfo.m_mediaDevStatus.m_enmediaCtrlCmd = BTRMGR_MEDIA_CTRL_VOLUMEUP;
4843  BTRMGRLOG_DEBUG (" Volume Up %d \n", ui8CurVolume);
4844 #ifdef RDKTV_PERSIST_VOLUME_SKY
4845  btrMgr_SetLastVolume(0, ui8CurVolume);
4846 #endif
4847  }
4848  }
4849  break;
4850 
4851  case BTRMGR_MEDIA_CTRL_VOLUMEDOWN:
4852  if (enBTRCoreSuccess == BTRCore_MediaControl(ghBTRCoreHdl, ahBTRMgrDevHdl, aenBtrCoreDevTy, lenBTRCoreMediaCtrl, apstBtrCoreMediaCData)) {
4853  BTRMGRLOG_INFO ("Media Control Command BTRMGR_MEDIA_CTRL_VOLUMEDOWN for %llu Success for streamout!!!\n", ahBTRMgrDevHdl);
4854  lenBtrMgrRet = eBTRMgrSuccess;
4855  }
4856  else if (apstMediaDeviceStatus->m_ui8mediaDevMute == BTRMGR_SO_MAX_VOLUME) {
4857  unsigned char ui8CurVolume = 0;
4858 
4859  BTRMgr_SO_GetVolume(gstBTRMgrStreamingInfo.hBTRMgrSoHdl,&ui8CurVolume);
4860  BTRMGRLOG_DEBUG ("ui8CurVolume %d \n ",ui8CurVolume);
4861 
4862  if (apstBtrCoreMediaCData != NULL) {
4863  ui8CurVolume = apstBtrCoreMediaCData->m_mediaAbsoluteVolume;
4864  }
4865  else {
4866  if (ui8CurVolume > 250)
4867  ui8CurVolume = 250;
4868  else if (ui8CurVolume <= 250 && ui8CurVolume >= 10)
4869  ui8CurVolume = ui8CurVolume - 10; // Decrement steps in 10
4870  else
4871  ui8CurVolume = 0;
4872  }
4873 
4874  lenBtrMgrRet = BTRMgr_SO_SetVolume(gstBTRMgrStreamingInfo.hBTRMgrSoHdl, ui8CurVolume);
4875 
4876  if (lenBtrMgrRet == eBTRMgrSuccess) {
4877  lstEventMessage.m_eventType = BTRMGR_EVENT_DEVICE_MEDIA_STATUS;
4878  lstEventMessage.m_mediaInfo.m_mediaDevStatus.m_ui8mediaDevVolume= ui8CurVolume;
4879  lstEventMessage.m_mediaInfo.m_mediaDevStatus.m_ui8mediaDevMute = (ui8CurVolume) ? FALSE : TRUE;
4880  lstEventMessage.m_mediaInfo.m_mediaDevStatus.m_enmediaCtrlCmd = BTRMGR_MEDIA_CTRL_VOLUMEDOWN;
4881  BTRMGRLOG_DEBUG (" Volume Down %d \n", ui8CurVolume);
4882 #ifdef RDKTV_PERSIST_VOLUME_SKY
4883  btrMgr_SetLastVolume(0, ui8CurVolume);
4884 #endif
4885  }
4886  }
4887  break;
4888 
4889  case BTRMGR_MEDIA_CTRL_MUTE:
4890  if ((lenBtrMgrRet = BTRMgr_SO_SetMute(gstBTRMgrStreamingInfo.hBTRMgrSoHdl, TRUE)) == eBTRMgrSuccess) {
4891  unsigned char ui8CurVolume = 0;
4892  BTRMgr_SO_GetVolume(gstBTRMgrStreamingInfo.hBTRMgrSoHdl,&ui8CurVolume);
4893 
4894  lstEventMessage.m_eventType = BTRMGR_EVENT_DEVICE_MEDIA_STATUS;
4895  lstEventMessage.m_mediaInfo.m_mediaDevStatus.m_ui8mediaDevVolume= ui8CurVolume;
4896  lstEventMessage.m_mediaInfo.m_mediaDevStatus.m_ui8mediaDevMute = TRUE;
4897  lstEventMessage.m_mediaInfo.m_mediaDevStatus.m_enmediaCtrlCmd = BTRMGR_MEDIA_CTRL_MUTE;
4898  BTRMGRLOG_DEBUG (" Mute set success \n");
4899 #ifdef RDKTV_PERSIST_VOLUME_SKY
4900  btrMgr_SetLastMuteState(0, TRUE);
4901 #endif
4902  }
4903  break;
4904 
4905  case BTRMGR_MEDIA_CTRL_UNMUTE:
4906  if ((lenBtrMgrRet = BTRMgr_SO_SetMute(gstBTRMgrStreamingInfo.hBTRMgrSoHdl, FALSE)) == eBTRMgrSuccess) {
4907  unsigned char ui8CurVolume = 0;
4908  BTRMgr_SO_GetVolume(gstBTRMgrStreamingInfo.hBTRMgrSoHdl,&ui8CurVolume);
4909 
4910  lstEventMessage.m_eventType = BTRMGR_EVENT_DEVICE_MEDIA_STATUS;
4911  lstEventMessage.m_mediaInfo.m_mediaDevStatus.m_ui8mediaDevVolume= ui8CurVolume;
4912  lstEventMessage.m_mediaInfo.m_mediaDevStatus.m_ui8mediaDevMute = FALSE;
4913  lstEventMessage.m_mediaInfo.m_mediaDevStatus.m_enmediaCtrlCmd = BTRMGR_MEDIA_CTRL_UNMUTE;
4914  BTRMGRLOG_DEBUG (" UnMute set success \n");
4915 #ifdef RDKTV_PERSIST_VOLUME_SKY
4916  btrMgr_SetLastMuteState(0, FALSE);
4917 #endif
4918  }
4919  break;
4920 
4921  default:
4922  if (enBTRCoreSuccess == BTRCore_MediaControl(ghBTRCoreHdl, ahBTRMgrDevHdl, aenBtrCoreDevTy, lenBTRCoreMediaCtrl, apstBtrCoreMediaCData)) {
4923  lenBtrMgrRet = eBTRMgrSuccess;
4924  }
4925  else {
4926  BTRMGRLOG_ERROR ("Media Control Command for %llu Failed for streamout!!!\n", ahBTRMgrDevHdl);
4927  lenBtrMgrRet = eBTRMgrFailure;
4928  }
4929  }
4930 
4931  if ((lenBtrMgrRet == eBTRMgrSuccess) && (gfpcBBTRMgrEventOut)) {
4932  lstEventMessage.m_mediaInfo.m_deviceHandle = ahBTRMgrDevHdl;
4933  lstEventMessage.m_mediaInfo.m_deviceType = btrMgr_MapDeviceTypeFromCore(aenBtrCoreDevCl);
4934  for (int j = 0; j <= gListOfPairedDevices.m_numOfDevices; j++) {
4935  if (ahBTRMgrDevHdl == gListOfPairedDevices.m_deviceProperty[j].m_deviceHandle) {
4936  strncpy(lstEventMessage.m_mediaInfo.m_name, gListOfPairedDevices.m_deviceProperty[j].m_name, BTRMGR_NAME_LEN_MAX -1);
4937  break;
4938  }
4939  }
4940 
4941  gfpcBBTRMgrEventOut(lstEventMessage); /* Post a callback */
4942  }
4943 
4944  } else {
4945  BTRMGRLOG_ERROR ("pstBtrMgrSoHdl Null or streaming out not started \n");
4946  lenBtrMgrRet = eBTRMgrFailure;
4947  }
4948  }
4949  else {
4950  if (enBTRCoreSuccess != BTRCore_MediaControl(ghBTRCoreHdl, ahBTRMgrDevHdl, aenBtrCoreDevTy, lenBTRCoreMediaCtrl, apstBtrCoreMediaCData)) {
4951  BTRMGRLOG_ERROR ("Media Control Command for %llu Failed!!!\n", ahBTRMgrDevHdl);
4952  lenBtrMgrRet = eBTRMgrFailure;
4953  }
4954  }
4955  }
4956  else {
4957  BTRMGRLOG_ERROR ("Media Control Command for %llu Unknown!!!\n", ahBTRMgrDevHdl);
4958  lenBtrMgrRet = eBTRMgrFailure;
4959  }
4960 
4961  return lenBtrMgrRet;
4962 }
4963 
4964 
4965 BTRMGR_Result_t
4966 BTRMGR_GetDeviceVolumeMute (
4967  unsigned char aui8AdapterIdx,
4968  BTRMgrDeviceHandle ahBTRMgrDevHdl,
4969  BTRMGR_DeviceOperationType_t deviceOpType,
4970  unsigned char* pui8Volume,
4971  unsigned char* pui8Mute
4972 ) {
4973  BTRMGR_Result_t lenBtrMgrResult = BTRMGR_RESULT_SUCCESS;
4974  eBTRMgrRet lenBtrMgrRet = eBTRMgrSuccess;
4975  eBTRMgrRet lenBtrMgrPersistRet = eBTRMgrFailure;
4976  enBTRCoreRet lenBtrCoreRet = enBTRCoreSuccess;
4977  enBTRCoreDeviceType lenBtrCoreDevTy = enBTRCoreUnknown;
4978  enBTRCoreDeviceClass lenBtrCoreDevCl = enBTRCore_DC_Unknown;
4979  unsigned char lui8CurVolume = 0;
4980  gboolean lbCurMute = FALSE;
4981 
4982 #ifdef RDKTV_PERSIST_VOLUME_SKY
4983  unsigned char lui8PersistedVolume = 0;
4984  gboolean lbPersistedMute = FALSE;
4985 #endif
4986 
4987  if (!ghBTRCoreHdl) {
4988  BTRMGRLOG_ERROR ("BTRCore is not Inited\n");
4989  return BTRMGR_RESULT_INIT_FAILED;
4990  }
4991 
4992  if (aui8AdapterIdx > btrMgr_GetAdapterCnt()) {
4993  BTRMGRLOG_ERROR ("Input is invalid\n");
4994  return BTRMGR_RESULT_INVALID_INPUT;
4995  }
4996 
4997  if (!btrMgr_IsDevConnected(ahBTRMgrDevHdl) || (gstBTRMgrStreamingInfo.hBTRMgrSoHdl == NULL)) {
4998  BTRMGRLOG_ERROR ("Device Handle(%lld) not connected/streaming\n", ahBTRMgrDevHdl);
4999  return BTRMGR_RESULT_INVALID_INPUT;
5000  }
5001 
5002  // Currently implemented for audio out only
5003  if (deviceOpType != BTRMGR_DEVICE_OP_TYPE_AUDIO_OUTPUT) {
5004  BTRMGRLOG_ERROR ("Device Handle(%lld) not audio out\n", ahBTRMgrDevHdl);
5005  return BTRMGR_RESULT_INVALID_INPUT;
5006  }
5007 
5008  lenBtrCoreRet = BTRCore_GetDeviceTypeClass(ghBTRCoreHdl, ahBTRMgrDevHdl, &lenBtrCoreDevTy, &lenBtrCoreDevCl);
5009  BTRMGRLOG_DEBUG ("Status = %d\t Device Type = %d\t Device Class = %x\n", lenBtrCoreRet, lenBtrCoreDevTy, lenBtrCoreDevCl);
5010 
5011 #ifdef RDKTV_PERSIST_VOLUME_SKY
5012  if ((lenBtrMgrPersistRet = btrMgr_GetLastVolume(0, &lui8PersistedVolume)) == eBTRMgrSuccess) {
5013  lui8CurVolume = lui8PersistedVolume;
5014  }
5015  else {
5016  BTRMGRLOG_WARN ("Device Handle(%lld) Persist audio out volume get fail\n", ahBTRMgrDevHdl);
5017  }
5018 #endif
5019 
5020  if ((lenBtrMgrPersistRet == eBTRMgrFailure) &&
5021  ((lenBtrMgrRet = BTRMgr_SO_GetVolume(gstBTRMgrStreamingInfo.hBTRMgrSoHdl,&lui8CurVolume)) != eBTRMgrSuccess)) {
5022  BTRMGRLOG_ERROR ("Device Handle(%lld) audio out volume get fail\n", ahBTRMgrDevHdl);
5023  lenBtrMgrResult = BTRMGR_RESULT_GENERIC_FAILURE;
5024  }
5025 
5026 #ifdef RDKTV_PERSIST_VOLUME_SKY
5027  if ((lenBtrMgrPersistRet = btrMgr_GetLastMuteState(0, &lbPersistedMute)) == eBTRMgrSuccess) {
5028  lbCurMute = lbPersistedMute;
5029  }
5030  else {
5031  BTRMGRLOG_ERROR ("Device Handle(%lld) Persist audio out mute get fail\n", ahBTRMgrDevHdl);
5032  }
5033 #endif
5034 
5035  if ((lenBtrMgrPersistRet == eBTRMgrFailure) &&
5036  ((lenBtrMgrRet = BTRMgr_SO_GetMute(gstBTRMgrStreamingInfo.hBTRMgrSoHdl,&lbCurMute)) != eBTRMgrSuccess)) {
5037  BTRMGRLOG_ERROR ("Device Handle(%lld) audio out mute get fail\n", ahBTRMgrDevHdl);
5038  lenBtrMgrResult = BTRMGR_RESULT_GENERIC_FAILURE;
5039  }
5040 
5041  if (lenBtrMgrRet == eBTRMgrSuccess) {
5042  *pui8Volume = lui8CurVolume;
5043  *pui8Mute = (unsigned char)lbCurMute;
5044  }
5045 
5046  return lenBtrMgrResult;
5047 }
5048 
5049 
5050 BTRMGR_Result_t
5051 BTRMGR_SetDeviceVolumeMute (
5052  unsigned char aui8AdapterIdx,
5053  BTRMgrDeviceHandle ahBTRMgrDevHdl,
5054  BTRMGR_DeviceOperationType_t deviceOpType,
5055  unsigned char aui8Volume,
5056  unsigned char aui8Mute
5057 ) {
5058  BTRMGR_Result_t lenBtrMgrResult = BTRMGR_RESULT_SUCCESS;
5059  eBTRMgrRet lenBtrMgrRet = eBTRMgrSuccess;
5060  enBTRCoreRet lenBtrCoreRet = enBTRCoreSuccess;
5061  enBTRCoreDeviceType lenBtrCoreDevTy = enBTRCoreUnknown;
5062  enBTRCoreDeviceClass lenBtrCoreDevCl = enBTRCore_DC_Unknown;
5063  unsigned char lui8Volume = BTRMGR_SO_MAX_VOLUME - 1;
5064  gboolean lbMuted = FALSE;
5065  gboolean abMuted = FALSE;
5066  BTRMGR_MediaDeviceStatus_t lstMediaDeviceStatus;
5067  stBTRCoreMediaCtData lstBTRCoreMediaCData;
5068  BTRMGR_EventMessage_t lstEventMessage;
5069 
5070 
5071  memset (&lstEventMessage, 0, sizeof(lstEventMessage));
5072  if (!ghBTRCoreHdl) {
5073  BTRMGRLOG_ERROR ("BTRCore is not Inited\n");
5074  return BTRMGR_RESULT_INIT_FAILED;
5075  }
5076 
5077  if (aui8AdapterIdx > btrMgr_GetAdapterCnt() || aui8Mute > 1) {
5078  BTRMGRLOG_ERROR ("Input is invalid\n");
5079  return BTRMGR_RESULT_INVALID_INPUT;
5080  }
5081 
5082  if (!btrMgr_IsDevConnected(ahBTRMgrDevHdl) || (gstBTRMgrStreamingInfo.hBTRMgrSoHdl == NULL)) {
5083  BTRMGRLOG_ERROR ("Device Handle(%lld) not connected/streaming\n", ahBTRMgrDevHdl);
5084  return BTRMGR_RESULT_INVALID_INPUT;
5085  }
5086 
5087  // Currently implemented for audio out only
5088  if (deviceOpType != BTRMGR_DEVICE_OP_TYPE_AUDIO_OUTPUT) {
5089  BTRMGRLOG_ERROR ("Device Handle(%lld) not audio out\n", ahBTRMgrDevHdl);
5090  return BTRMGR_RESULT_INVALID_INPUT;
5091  }
5092 
5093  lenBtrCoreRet = BTRCore_GetDeviceTypeClass(ghBTRCoreHdl, ahBTRMgrDevHdl, &lenBtrCoreDevTy, &lenBtrCoreDevCl);
5094  BTRMGRLOG_DEBUG ("Status = %d\t Device Type = %d\t Device Class = %x\n", lenBtrCoreRet, lenBtrCoreDevTy, lenBtrCoreDevCl);
5095 
5096 #ifdef RDKTV_PERSIST_VOLUME_SKY
5097  btrMgr_GetLastVolume(0, &lui8Volume);
5098  btrMgr_GetLastMuteState(0, &lbMuted);
5099 #endif
5100 
5101  lstMediaDeviceStatus.m_enmediaCtrlCmd = BTRMGR_MEDIA_CTRL_UNKNOWN;
5102  lstMediaDeviceStatus.m_ui8mediaDevVolume= aui8Volume;
5103  lstMediaDeviceStatus.m_ui8mediaDevMute = aui8Mute;
5104 
5105  lstBTRCoreMediaCData.m_mediaAbsoluteVolume = aui8Volume;
5106 
5107  if (aui8Volume > lui8Volume)
5108  lstMediaDeviceStatus.m_enmediaCtrlCmd = BTRMGR_MEDIA_CTRL_VOLUMEUP;
5109  else if (aui8Volume < lui8Volume)
5110  lstMediaDeviceStatus.m_enmediaCtrlCmd = BTRMGR_MEDIA_CTRL_VOLUMEDOWN;
5111 
5112 
5113  if ((lenBtrMgrRet = btrMgr_MediaControl(aui8AdapterIdx, ahBTRMgrDevHdl, &lstMediaDeviceStatus, lenBtrCoreDevTy, lenBtrCoreDevCl, &lstBTRCoreMediaCData)) == eBTRMgrSuccess) {
5114  BTRMGRLOG_INFO ("Device Handle(%lld) AVRCP audio out volume Set Success\n", ahBTRMgrDevHdl);
5115  if (BTRMgr_SO_SetVolume(gstBTRMgrStreamingInfo.hBTRMgrSoHdl, BTRMGR_SO_MAX_VOLUME) != eBTRMgrSuccess) {
5116  BTRMGRLOG_ERROR ("Device Handle(%lld) AVRCP audio-out SO volume Set fail\n", ahBTRMgrDevHdl);
5117  }
5118  }
5119  else if ((aui8Volume != lui8Volume) && ((lenBtrMgrRet = BTRMgr_SO_SetVolume(gstBTRMgrStreamingInfo.hBTRMgrSoHdl, aui8Volume)) != eBTRMgrSuccess)) {
5120  BTRMGRLOG_ERROR ("Device Handle(%lld) audio out volume Set fail\n", ahBTRMgrDevHdl);
5121  lenBtrMgrResult = BTRMGR_RESULT_GENERIC_FAILURE;
5122  }
5123 
5124 #ifdef RDKTV_PERSIST_VOLUME_SKY
5125  if (lenBtrMgrRet == eBTRMgrSuccess)
5126  btrMgr_SetLastVolume(0, aui8Volume);
5127 #endif
5128 
5129  abMuted = aui8Mute ? TRUE : FALSE;
5130  if ((lenBtrMgrRet = BTRMgr_SO_SetMute(gstBTRMgrStreamingInfo.hBTRMgrSoHdl, abMuted)) != eBTRMgrSuccess) {
5131  BTRMGRLOG_ERROR ("Device Handle(%lld) not audio out mute set fail\n", ahBTRMgrDevHdl);
5132  lenBtrMgrResult = BTRMGR_RESULT_GENERIC_FAILURE;
5133  }
5134  else {
5135 #ifdef RDKTV_PERSIST_VOLUME_SKY
5136  btrMgr_SetLastMuteState(0, abMuted);
5137 #endif
5138  }
5139 
5140  if ((lenBtrMgrResult == BTRMGR_RESULT_SUCCESS) && gfpcBBTRMgrEventOut) {
5141  lstEventMessage.m_eventType = BTRMGR_EVENT_DEVICE_MEDIA_STATUS;
5142  lstEventMessage.m_mediaInfo.m_deviceType = btrMgr_MapDeviceTypeFromCore(lenBtrCoreDevCl);
5143  lstEventMessage.m_mediaInfo.m_mediaDevStatus.m_ui8mediaDevVolume = aui8Volume;
5144  lstEventMessage.m_mediaInfo.m_mediaDevStatus.m_ui8mediaDevMute = aui8Mute;
5145 
5146  if ((abMuted != lbMuted) && abMuted)
5147  lstEventMessage.m_mediaInfo.m_mediaDevStatus.m_enmediaCtrlCmd = BTRMGR_MEDIA_CTRL_MUTE;
5148  else if ((abMuted != lbMuted) && !abMuted)
5149  lstEventMessage.m_mediaInfo.m_mediaDevStatus.m_enmediaCtrlCmd = BTRMGR_MEDIA_CTRL_UNMUTE;
5150  else if (aui8Volume > lui8Volume)
5151  lstEventMessage.m_mediaInfo.m_mediaDevStatus.m_enmediaCtrlCmd = BTRMGR_MEDIA_CTRL_VOLUMEUP;
5152  else if (aui8Volume < lui8Volume)
5153  lstEventMessage.m_mediaInfo.m_mediaDevStatus.m_enmediaCtrlCmd = BTRMGR_MEDIA_CTRL_VOLUMEDOWN;
5154  else
5155  lstEventMessage.m_mediaInfo.m_mediaDevStatus.m_enmediaCtrlCmd = BTRMGR_MEDIA_CTRL_UNKNOWN;
5156 
5157  for (int j = 0; j <= gListOfPairedDevices.m_numOfDevices; j++) {
5158  if (ahBTRMgrDevHdl == gListOfPairedDevices.m_deviceProperty[j].m_deviceHandle) {
5159  lstEventMessage.m_mediaInfo.m_deviceHandle = ahBTRMgrDevHdl;
5160  strncpy(lstEventMessage.m_mediaInfo.m_name, gListOfPairedDevices.m_deviceProperty[j].m_name, BTRMGR_NAME_LEN_MAX -1);
5161  break;
5162  }
5163  }
5164 
5165  gfpcBBTRMgrEventOut(lstEventMessage); /* Post a callback */
5166  }
5167 
5168  return lenBtrMgrResult;
5169 }
5170 
5171 BTRMGR_Result_t
5172 BTRMGR_GetMediaTrackInfo (
5173  unsigned char aui8AdapterIdx,
5174  BTRMgrDeviceHandle ahBTRMgrDevHdl,
5175  BTRMGR_MediaTrackInfo_t *mediaTrackInfo
5176 ) {
5177  BTRMGR_Result_t lenBtrMgrResult = BTRMGR_RESULT_SUCCESS;
5178  enBTRCoreRet lenBtrCoreRet = enBTRCoreSuccess;
5179  enBTRCoreDeviceType lenBtrCoreDevTy = enBTRCoreUnknown;
5180  enBTRCoreDeviceClass lenBtrCoreDevCl = enBTRCore_DC_Unknown;
5181 
5182 
5183  if (!ghBTRCoreHdl) {
5184  BTRMGRLOG_ERROR ("BTRCore is not Inited\n");
5185  return BTRMGR_RESULT_INIT_FAILED;
5186  }
5187 
5188  if (aui8AdapterIdx > btrMgr_GetAdapterCnt()) {
5189  BTRMGRLOG_ERROR ("Input is invalid\n");
5190  return BTRMGR_RESULT_INVALID_INPUT;
5191  }
5192 
5193  if (!btrMgr_IsDevConnected(ahBTRMgrDevHdl)) {
5194  BTRMGRLOG_ERROR ("Device Handle(%lld) not connected\n", ahBTRMgrDevHdl);
5195  return BTRMGR_RESULT_INVALID_INPUT;
5196  }
5197 
5198  lenBtrCoreRet = BTRCore_GetDeviceTypeClass(ghBTRCoreHdl, ahBTRMgrDevHdl, &lenBtrCoreDevTy, &lenBtrCoreDevCl);
5199  BTRMGRLOG_DEBUG ("Status = %d\t Device Type = %d\t Device Class = %x\n", lenBtrCoreRet, lenBtrCoreDevTy, lenBtrCoreDevCl);
5200 
5201  if (enBTRCoreSuccess != BTRCore_GetMediaTrackInfo(ghBTRCoreHdl, ahBTRMgrDevHdl, lenBtrCoreDevTy, (stBTRCoreMediaTrackInfo*)mediaTrackInfo)) {
5202  BTRMGRLOG_ERROR ("Get Media Track Information for %llu Failed!!!\n", ahBTRMgrDevHdl);
5203  lenBtrMgrResult = BTRMGR_RESULT_GENERIC_FAILURE;
5204  }
5205 
5206  return lenBtrMgrResult;
5207 }
5208 
5209 BTRMGR_Result_t
5210 BTRMGR_GetMediaElementTrackInfo (
5211  unsigned char aui8AdapterIdx,
5212  BTRMgrDeviceHandle ahBTRMgrDevHdl,
5213  BTRMgrMediaElementHandle ahBTRMgrMedElementHdl,
5214  BTRMGR_MediaTrackInfo_t *mediaTrackInfo
5215 ) {
5216  BTRMGR_Result_t lenBtrMgrResult = BTRMGR_RESULT_SUCCESS;
5217  enBTRCoreRet lenBtrCoreRet = enBTRCoreSuccess;
5218  enBTRCoreDeviceType lenBtrCoreDevTy = enBTRCoreUnknown;
5219  enBTRCoreDeviceClass lenBtrCoreDevCl = enBTRCore_DC_Unknown;
5220 
5221 
5222  if (!ghBTRCoreHdl) {
5223  BTRMGRLOG_ERROR ("BTRCore is not Inited\n");
5224  return BTRMGR_RESULT_INIT_FAILED;
5225  }
5226 
5227  if (aui8AdapterIdx > btrMgr_GetAdapterCnt()) {
5228  BTRMGRLOG_ERROR ("Input is invalid\n");
5229  return BTRMGR_RESULT_INVALID_INPUT;
5230  }
5231 
5232  if (!btrMgr_IsDevConnected(ahBTRMgrDevHdl)) {
5233  BTRMGRLOG_ERROR ("Device Handle(%lld) not connected\n", ahBTRMgrDevHdl);
5234  return BTRMGR_RESULT_INVALID_INPUT;
5235  }
5236 
5237  lenBtrCoreRet = BTRCore_GetDeviceTypeClass(ghBTRCoreHdl, ahBTRMgrDevHdl, &lenBtrCoreDevTy, &lenBtrCoreDevCl);
5238  BTRMGRLOG_DEBUG ("Status = %d\t Device Type = %d\t Device Class = %x\n", lenBtrCoreRet, lenBtrCoreDevTy, lenBtrCoreDevCl);
5239 
5240  if (enBTRCoreSuccess != BTRCore_GetMediaElementTrackInfo(ghBTRCoreHdl, ahBTRMgrDevHdl,
5241  lenBtrCoreDevTy, ahBTRMgrMedElementHdl, (stBTRCoreMediaTrackInfo*)mediaTrackInfo)) {
5242  BTRMGRLOG_ERROR ("Get Media Track Information for %llu Failed!!!\n", ahBTRMgrDevHdl);
5243  lenBtrMgrResult = BTRMGR_RESULT_GENERIC_FAILURE;
5244  }
5245 
5246  return lenBtrMgrResult;
5247 }
5248 
5249 
5250 BTRMGR_Result_t
5251 BTRMGR_GetMediaCurrentPosition (
5252  unsigned char aui8AdapterIdx,
5253  BTRMgrDeviceHandle ahBTRMgrDevHdl,
5254  BTRMGR_MediaPositionInfo_t *mediaPositionInfo
5255 ) {
5256  BTRMGR_Result_t lenBtrMgrResult = BTRMGR_RESULT_SUCCESS;
5257  enBTRCoreRet lenBtrCoreRet = enBTRCoreSuccess;
5258  enBTRCoreDeviceType lenBtrCoreDevTy = enBTRCoreUnknown;
5259  enBTRCoreDeviceClass lenBtrCoreDevCl = enBTRCore_DC_Unknown;
5260 
5261 
5262  if (!ghBTRCoreHdl) {
5263  BTRMGRLOG_ERROR ("BTRCore is not Inited\n");
5264  return BTRMGR_RESULT_INIT_FAILED;
5265  }
5266 
5267  if (aui8AdapterIdx > btrMgr_GetAdapterCnt()) {
5268  BTRMGRLOG_ERROR ("Input is invalid\n");
5269  return BTRMGR_RESULT_INVALID_INPUT;
5270  }
5271 
5272  if (!btrMgr_IsDevConnected(ahBTRMgrDevHdl)) {
5273  BTRMGRLOG_ERROR ("Device Handle(%lld) not connected\n", ahBTRMgrDevHdl);
5274  return BTRMGR_RESULT_INVALID_INPUT;
5275  }
5276 
5277  lenBtrCoreRet = BTRCore_GetDeviceTypeClass(ghBTRCoreHdl, ahBTRMgrDevHdl, &lenBtrCoreDevTy, &lenBtrCoreDevCl);
5278  BTRMGRLOG_DEBUG ("Status = %d\t Device Type = %d\t Device Class = %x\n", lenBtrCoreRet, lenBtrCoreDevTy, lenBtrCoreDevCl);
5279 
5280  if (enBTRCoreSuccess != BTRCore_GetMediaPositionInfo(ghBTRCoreHdl, ahBTRMgrDevHdl, lenBtrCoreDevTy, (stBTRCoreMediaPositionInfo*)mediaPositionInfo)) {
5281  BTRMGRLOG_ERROR ("Get Media Current Position for %llu Failed!!!\n", ahBTRMgrDevHdl);
5282  lenBtrMgrResult = BTRMGR_RESULT_GENERIC_FAILURE;
5283  }
5284 
5285  return lenBtrMgrResult;
5286 }
5287 
5288 
5289 BTRMGR_Result_t
5290 BTRMGR_SetMediaElementActive (
5291  unsigned char aui8AdapterIdx,
5292  BTRMgrDeviceHandle ahBTRMgrDevHdl,
5293  BTRMgrMediaElementHandle ahBTRMgrMedElementHdl,
5294  BTRMGR_MediaElementType_t aMediaElementType
5295 ) {
5296  BTRMGR_Result_t lenBtrMgrResult = BTRMGR_RESULT_SUCCESS;
5297  enBTRCoreRet lenBtrCoreRet = enBTRCoreSuccess;
5298  enBTRCoreDeviceType lenBtrCoreDevTy = enBTRCoreUnknown;
5299  enBTRCoreDeviceClass lenBtrCoreDevCl = enBTRCore_DC_Unknown;
5300  eBTRCoreMedElementType lenMediaElementType = enBTRCoreMedETypeUnknown;
5301 
5302  if (!ghBTRCoreHdl) {
5303  BTRMGRLOG_ERROR ("BTRCore is not Inited\n");
5304  return BTRMGR_RESULT_INIT_FAILED;
5305  }
5306 
5307  if (aui8AdapterIdx > btrMgr_GetAdapterCnt()) {
5308  BTRMGRLOG_ERROR ("Input is invalid\n");
5309  return BTRMGR_RESULT_INVALID_INPUT;
5310  }
5311 
5312  if (!btrMgr_IsDevConnected(ahBTRMgrDevHdl)) {
5313  BTRMGRLOG_ERROR ("Device Handle(%lld) not connected\n", ahBTRMgrDevHdl);
5314  return BTRMGR_RESULT_INVALID_INPUT;
5315  }
5316 
5317  lenBtrCoreRet = BTRCore_GetDeviceTypeClass(ghBTRCoreHdl, ahBTRMgrDevHdl, &lenBtrCoreDevTy, &lenBtrCoreDevCl);
5318  BTRMGRLOG_DEBUG ("Status = %d\t Device Type = %d\t Device Class = %x\n", lenBtrCoreRet, lenBtrCoreDevTy, lenBtrCoreDevCl);
5319 
5320  switch (aMediaElementType) {
5321  case BTRMGR_MEDIA_ELEMENT_TYPE_ALBUM:
5322  lenMediaElementType = enBTRCoreMedETypeAlbum;
5323  break;
5324  case BTRMGR_MEDIA_ELEMENT_TYPE_ARTIST:
5325  lenMediaElementType = enBTRCoreMedETypeArtist;
5326  break;
5327  case BTRMGR_MEDIA_ELEMENT_TYPE_GENRE:
5328  lenMediaElementType = enBTRCoreMedETypeGenre;
5329  break;
5330  case BTRMGR_MEDIA_ELEMENT_TYPE_COMPILATIONS:
5331  lenMediaElementType = enBTRCoreMedETypeCompilation;
5332  break;
5333  case BTRMGR_MEDIA_ELEMENT_TYPE_PLAYLIST:
5334  lenMediaElementType = enBTRCoreMedETypePlayList;
5335  break;
5336  case BTRMGR_MEDIA_ELEMENT_TYPE_TRACKLIST:
5337  lenMediaElementType = enBTRCoreMedETypeTrackList;
5338  break;
5339  case BTRMGR_MEDIA_ELEMENT_TYPE_TRACK:
5340  lenMediaElementType = enBTRCoreMedETypeTrack;
5341  break;
5342  default:
5343  break;
5344  }
5345 
5346  /* Add intelligence to prefetch MediaElementInfo based on users' interest/navigation */
5347 
5348  if (enBTRCoreSuccess != BTRCore_SetMediaElementActive (ghBTRCoreHdl,
5349  ahBTRMgrDevHdl,
5350  ahBTRMgrMedElementHdl,
5351  lenBtrCoreDevTy,
5352  lenMediaElementType)) {
5353  BTRMGRLOG_ERROR ("Set Active Media Element(%llu) List for Dev %llu Failed!!!\n", ahBTRMgrMedElementHdl, ahBTRMgrDevHdl);
5354  lenBtrMgrResult = BTRMGR_RESULT_GENERIC_FAILURE;
5355  }
5356 
5357  return lenBtrMgrResult;
5358 }
5359 
5360 
5361 BTRMGR_Result_t
5362 BTRMGR_GetMediaElementList (
5363  unsigned char aui8AdapterIdx,
5364  BTRMgrDeviceHandle ahBTRMgrDevHdl,
5365  BTRMgrMediaElementHandle ahBTRMgrMedElementHdl,
5366  unsigned short aui16MediaElementStartIdx,
5367  unsigned short aui16MediaElementEndIdx,
5368  unsigned char abMediaElementListDepth,
5369  BTRMGR_MediaElementType_t aMediaElementType,
5370  BTRMGR_MediaElementListInfo_t* aMediaElementListInfo
5371 ) {
5372  BTRMGR_Result_t lenBtrMgrResult = BTRMGR_RESULT_SUCCESS;
5373  enBTRCoreRet lenBtrCoreRet = enBTRCoreSuccess;
5374  enBTRCoreDeviceType lenBtrCoreDevTy = enBTRCoreUnknown;
5375  enBTRCoreDeviceClass lenBtrCoreDevCl = enBTRCore_DC_Unknown;
5376  stBTRCoreMediaElementInfoList lpstBTRCoreMediaElementInfoList;
5377 
5378  if (!ghBTRCoreHdl) {
5379  BTRMGRLOG_ERROR ("BTRCore is not Inited\n");
5380  return BTRMGR_RESULT_INIT_FAILED;
5381  }
5382 
5383  if (aui8AdapterIdx > btrMgr_GetAdapterCnt() || !aMediaElementListInfo ||
5384  aui16MediaElementStartIdx > aui16MediaElementEndIdx) {
5385  BTRMGRLOG_ERROR ("Input is invalid\n");
5386  return BTRMGR_RESULT_INVALID_INPUT;
5387  }
5388 
5389  if (aui16MediaElementEndIdx - aui16MediaElementStartIdx > BTRMGR_MEDIA_ELEMENT_COUNT_MAX -1) {
5390  aui16MediaElementEndIdx = aui16MediaElementStartIdx + BTRMGR_MEDIA_ELEMENT_COUNT_MAX -1;
5391  }
5392 
5393  if (!btrMgr_IsDevConnected(ahBTRMgrDevHdl)) {
5394  BTRMGRLOG_ERROR ("Device Handle(%lld) not connected\n", ahBTRMgrDevHdl);
5395  return BTRMGR_RESULT_INVALID_INPUT;
5396  }
5397 
5398  lenBtrCoreRet = BTRCore_GetDeviceTypeClass(ghBTRCoreHdl, ahBTRMgrDevHdl, &lenBtrCoreDevTy, &lenBtrCoreDevCl);
5399  BTRMGRLOG_DEBUG ("Status = %d\t Device Type = %d\t Device Class = %x\n", lenBtrCoreRet, lenBtrCoreDevTy, lenBtrCoreDevCl);
5400 
5401  memset (&lpstBTRCoreMediaElementInfoList, 0, sizeof(stBTRCoreMediaElementInfoList));
5402 
5403  /* TODO Retrive required List from the populated DataBase */
5404  /* In below passing argument aMediaElementType is not transitioning now due to
5405  * BTRMGR_MediaElementType_t and eBTRCoreMedElementType both enums are same.
5406  * In future if change the any enums it will impact */
5407  if (enBTRCoreSuccess != BTRCore_GetMediaElementList (ghBTRCoreHdl,
5408  ahBTRMgrDevHdl,
5409  ahBTRMgrMedElementHdl,
5410  aui16MediaElementStartIdx,
5411  aui16MediaElementEndIdx,
5412  lenBtrCoreDevTy,
5413  aMediaElementType,
5414  &lpstBTRCoreMediaElementInfoList)) {
5415  BTRMGRLOG_ERROR ("Get Media Element(%llu) List for Dev %llu Failed!!!\n", ahBTRMgrMedElementHdl, ahBTRMgrDevHdl);
5416  lenBtrMgrResult = BTRMGR_RESULT_GENERIC_FAILURE;
5417  }
5418  else {
5419  unsigned short ui16LoopIdx = 0;
5420  stBTRCoreMediaElementInfo* srcElement = 0;
5421  BTRMGR_MediaElementInfo_t* desElement = 0;
5422 
5423  if (lpstBTRCoreMediaElementInfoList.m_numOfElements > BTRMGR_MEDIA_ELEMENT_COUNT_MAX) {
5424  lpstBTRCoreMediaElementInfoList.m_numOfElements = BTRMGR_MEDIA_ELEMENT_COUNT_MAX;
5425  }
5426 
5427  while (ui16LoopIdx < lpstBTRCoreMediaElementInfoList.m_numOfElements) {
5428  srcElement = &lpstBTRCoreMediaElementInfoList.m_mediaElementInfo[ui16LoopIdx];
5429  desElement = &aMediaElementListInfo->m_mediaElementInfo[ui16LoopIdx++];
5430 
5431  desElement->m_mediaElementHdl = srcElement->ui32MediaElementId;
5432  desElement->m_IsPlayable = srcElement->bIsPlayable;
5433  strncpy (desElement->m_mediaElementName, srcElement->m_mediaElementName, BTRMGR_MAX_STR_LEN -1);
5434  memcpy (&desElement->m_mediaTrackInfo, &srcElement->m_mediaTrackInfo, sizeof(BTRMGR_MediaTrackInfo_t));
5435  }
5436  aMediaElementListInfo->m_numberOfElements = lpstBTRCoreMediaElementInfoList.m_numOfElements;
5437  }
5438 
5439  return lenBtrMgrResult;
5440 }
5441 
5442 
5443 BTRMGR_Result_t
5444 BTRMGR_SelectMediaElement (
5445  unsigned char aui8AdapterIdx,
5446  BTRMgrDeviceHandle ahBTRMgrDevHdl,
5447  BTRMgrMediaElementHandle ahBTRMgrMedElementHdl,
5448  BTRMGR_MediaElementType_t aMediaElementType
5449 ) {
5450  BTRMGR_Result_t lenBtrMgrResult = BTRMGR_RESULT_SUCCESS;
5451  enBTRCoreRet lenBtrCoreRet = enBTRCoreSuccess;
5452  enBTRCoreDeviceType lenBtrCoreDevTy = enBTRCoreUnknown;
5453  enBTRCoreDeviceClass lenBtrCoreDevCl = enBTRCore_DC_Unknown;
5454  eBTRCoreMedElementType lenMediaElementType = enBTRCoreMedETypeUnknown;
5455 
5456  if (!ghBTRCoreHdl) {
5457  BTRMGRLOG_ERROR ("BTRCore is not Inited\n");
5458  return BTRMGR_RESULT_INIT_FAILED;
5459  }
5460 
5461  if (aui8AdapterIdx > btrMgr_GetAdapterCnt()) {
5462  BTRMGRLOG_ERROR ("Input is invalid\n");
5463  return BTRMGR_RESULT_INVALID_INPUT;
5464  }
5465 
5466  if (!btrMgr_IsDevConnected(ahBTRMgrDevHdl)) {
5467  BTRMGRLOG_ERROR ("Device Handle(%lld) not connected\n", ahBTRMgrDevHdl);
5468  return BTRMGR_RESULT_INVALID_INPUT;
5469  }
5470 
5471  lenBtrCoreRet = BTRCore_GetDeviceTypeClass(ghBTRCoreHdl, ahBTRMgrDevHdl, &lenBtrCoreDevTy, &lenBtrCoreDevCl);
5472  BTRMGRLOG_DEBUG ("Status = %d\t Device Type = %d\t Device Class = %x\n", lenBtrCoreRet, lenBtrCoreDevTy, lenBtrCoreDevCl);
5473 
5474 
5475  switch (aMediaElementType) {
5476  case BTRMGR_MEDIA_ELEMENT_TYPE_ALBUM:
5477  lenMediaElementType = enBTRCoreMedETypeAlbum;
5478  break;
5479  case BTRMGR_MEDIA_ELEMENT_TYPE_ARTIST:
5480  lenMediaElementType = enBTRCoreMedETypeArtist;
5481  break;
5482  case BTRMGR_MEDIA_ELEMENT_TYPE_GENRE:
5483  lenMediaElementType = enBTRCoreMedETypeGenre;
5484  break;
5485  case BTRMGR_MEDIA_ELEMENT_TYPE_COMPILATIONS:
5486  lenMediaElementType = enBTRCoreMedETypeCompilation;
5487  break;
5488  case BTRMGR_MEDIA_ELEMENT_TYPE_PLAYLIST:
5489  lenMediaElementType = enBTRCoreMedETypePlayList;
5490  break;
5491  case BTRMGR_MEDIA_ELEMENT_TYPE_TRACKLIST:
5492  lenMediaElementType = enBTRCoreMedETypeTrackList;
5493  break;
5494  case BTRMGR_MEDIA_ELEMENT_TYPE_TRACK:
5495  lenMediaElementType = enBTRCoreMedETypeTrack;
5496  break;
5497  default:
5498  break;
5499  }
5500 
5501  if (enBTRCoreSuccess != BTRCore_SelectMediaElement (ghBTRCoreHdl,
5502  ahBTRMgrDevHdl,
5503  ahBTRMgrMedElementHdl,
5504  lenBtrCoreDevTy,
5505  lenMediaElementType)) {
5506  BTRMGRLOG_ERROR ("Select Media Element(%llu) on Dev %llu Failed!!!\n", ahBTRMgrMedElementHdl, ahBTRMgrDevHdl);
5507  lenBtrMgrResult = BTRMGR_RESULT_GENERIC_FAILURE;
5508  }
5509 
5510  return lenBtrMgrResult;
5511 }
5512 
5513 
5514 const char*
5515 BTRMGR_GetDeviceTypeAsString (
5516  BTRMGR_DeviceType_t type
5517 ) {
5518  if (type == BTRMGR_DEVICE_TYPE_WEARABLE_HEADSET)
5519  return "WEARABLE HEADSET";
5520  else if (type == BTRMGR_DEVICE_TYPE_HANDSFREE)
5521  return "HANDSFREE";
5522  else if (type == BTRMGR_DEVICE_TYPE_MICROPHONE)
5523  return "MICROPHONE";
5524  else if (type == BTRMGR_DEVICE_TYPE_LOUDSPEAKER)
5525  return "LOUDSPEAKER";
5526  else if (type == BTRMGR_DEVICE_TYPE_HEADPHONES)
5527  return "HEADPHONES";
5528  else if (type == BTRMGR_DEVICE_TYPE_PORTABLE_AUDIO)
5529  return "PORTABLE AUDIO DEVICE";
5530  else if (type == BTRMGR_DEVICE_TYPE_CAR_AUDIO)
5531  return "CAR AUDIO";
5532  else if (type == BTRMGR_DEVICE_TYPE_STB)
5533  return "STB";
5534  else if (type == BTRMGR_DEVICE_TYPE_HIFI_AUDIO_DEVICE)
5535  return "HIFI AUDIO DEVICE";
5536  else if (type == BTRMGR_DEVICE_TYPE_VCR)
5537  return "VCR";
5538  else if (type == BTRMGR_DEVICE_TYPE_VIDEO_CAMERA)
5539  return "VIDEO CAMERA";
5540  else if (type == BTRMGR_DEVICE_TYPE_CAMCODER)
5541  return "CAMCODER";
5542  else if (type == BTRMGR_DEVICE_TYPE_VIDEO_MONITOR)
5543  return "VIDEO MONITOR";
5544  else if (type == BTRMGR_DEVICE_TYPE_TV)
5545  return "TV";
5546  else if (type == BTRMGR_DEVICE_TYPE_VIDEO_CONFERENCE)
5547  return "VIDEO CONFERENCING";
5548  else if (type == BTRMGR_DEVICE_TYPE_SMARTPHONE)
5549  return "SMARTPHONE";
5550  else if (type == BTRMGR_DEVICE_TYPE_TABLET)
5551  return "TABLET";
5552  else if (type == BTRMGR_DEVICE_TYPE_TILE)
5553  return "LE TILE";
5554  else if ((type == BTRMGR_DEVICE_TYPE_HID) || (type == BTRMGR_DEVICE_TYPE_HID_GAMEPAD))
5555  return "HUMAN INTERFACE DEVICE";
5556  else
5557  return "UNKNOWN DEVICE";
5558 }
5559 
5560 
5561 BTRMGR_Result_t
5562 BTRMGR_SetAudioInServiceState (
5563  unsigned char aui8AdapterIdx,
5564  unsigned char aui8State
5565 ) {
5566  if ((gIsAudioInEnabled = aui8State)) {
5567  BTRMGRLOG_INFO ("AudioIn Service is Enabled.\n");
5568  }
5569  else {
5570  BTRMGRLOG_INFO ("AudioIn Service is Disabled.\n");
5571  }
5572  return BTRMGR_RESULT_SUCCESS;
5573 }
5574 
5575 BTRMGR_Result_t
5576 BTRMGR_SetHidGamePadServiceState (
5577  unsigned char aui8AdapterIdx,
5578  unsigned char aui8State
5579 ) {
5580  if ((gIsHidGamePadEnabled = aui8State)) {
5581  BTRMGRLOG_INFO ("HID GamePad Service is Enabled.\n");
5582  }
5583  else {
5584  BTRMGRLOG_INFO ("HID GamePad Service is Disabled.\n");
5585  }
5586  return BTRMGR_RESULT_SUCCESS;
5587 }
5588 
5589 BTRMGR_Result_t
5590 BTRMGR_GetLimitBeaconDetection (
5591  unsigned char aui8AdapterIdx,
5592  unsigned char *pLimited
5593 ) {
5594 
5595  if ((aui8AdapterIdx > btrMgr_GetAdapterCnt())) {
5596  BTRMGRLOG_ERROR ("Input is invalid\n");
5597  return BTRMGR_RESULT_INVALID_INPUT;
5598  }
5599 
5600  BTRMGR_Beacon_PersistentData_t BeaconPersistentData;
5601  if (BTRMgr_PI_GetLEBeaconLimitingStatus(&BeaconPersistentData) == eBTRMgrFailure) {
5602  BTRMGRLOG_INFO ("Failed to get limit for beacon detection from json.\n");
5603  return BTRMGR_RESULT_GENERIC_FAILURE;
5604  }
5605 
5606  if (pLimited != NULL) {
5607  *pLimited = (unsigned char)((!strncasecmp(BeaconPersistentData.limitBeaconDetection, "true", 4)) ? 1 : 0 );
5608  BTRMGRLOG_INFO ("the beacon detection detection : %s\n", *pLimited? "true":"false");
5609  } //CID:45164 - Reverse_inull
5610  else {
5611  BTRMGRLOG_INFO ("Failed to get limit for beacon detection.\n");
5612  return BTRMGR_RESULT_GENERIC_FAILURE;
5613  }
5614 
5615  return BTRMGR_RESULT_SUCCESS;
5616 }
5617 
5618 BTRMGR_Result_t
5619 BTRMGR_SetLimitBeaconDetection (
5620  unsigned char aui8AdapterIdx,
5621  unsigned char limited
5622 ) {
5623 
5624  if ((aui8AdapterIdx > btrMgr_GetAdapterCnt())) {
5625  BTRMGRLOG_ERROR ("Input is invalid\n");
5626  return BTRMGR_RESULT_INVALID_INPUT;
5627  }
5628 
5629  BTRMGR_Beacon_PersistentData_t BeaconPersistentData;
5630  sprintf(BeaconPersistentData.limitBeaconDetection, "%s", limited ? "true" : "false");
5631  if (BTRMgr_PI_SetLEBeaconLimitingStatus(&BeaconPersistentData) == eBTRMgrFailure) {
5632  BTRMGRLOG_ERROR ("Failed to set limit for beacon detection from json.\n");
5633  return BTRMGR_RESULT_GENERIC_FAILURE;
5634  }
5635 
5636  if (limited) {
5637  BTRMGRLOG_INFO ("Limiting the beacon detection.\n");
5638  }
5639  else {
5640  BTRMGRLOG_INFO ("Removing the limit for beacon detection\n");
5641  }
5642  return BTRMGR_RESULT_SUCCESS;
5643 }
5644 
5645 #ifdef RDKTV_PERSIST_VOLUME_SKY
5646 static eBTRMgrRet
5647 btrMgr_SetLastVolume (
5648  unsigned char aui8AdapterIdx,
5649  unsigned char volume
5650 ) {
5651 
5652  if ((aui8AdapterIdx > btrMgr_GetAdapterCnt())) {
5653  BTRMGRLOG_ERROR ("Input is invalid\n");
5654  return eBTRMgrFailInArg;
5655  }
5656 
5657  BTRMGR_Volume_PersistentData_t VolumePersistentData;
5658  VolumePersistentData.Volume = volume;
5659  if (BTRMgr_PI_SetVolume(&VolumePersistentData) == eBTRMgrFailure) {
5660  BTRMGRLOG_ERROR ("Failed to set volume from json.\n");
5661  return eBTRMgrFailure;
5662  }
5663 
5664  BTRMGRLOG_INFO ("set volume %d.\n",volume);
5665  return eBTRMgrSuccess;
5666 }
5667 
5668 static eBTRMgrRet
5669 btrMgr_GetLastVolume (
5670  unsigned char aui8AdapterIdx,
5671  unsigned char *pVolume
5672 ) {
5673 
5674  if ((aui8AdapterIdx > btrMgr_GetAdapterCnt()) || !(pVolume)) {
5675  BTRMGRLOG_ERROR ("Input is invalid\n");
5676  return eBTRMgrFailInArg;
5677  }
5678 
5679  BTRMGR_Volume_PersistentData_t VolumePersistentData;
5680  if (BTRMgr_PI_GetVolume(&VolumePersistentData) == eBTRMgrFailure) {
5681  BTRMGRLOG_INFO ("Failed to get volume detection from json.\n");
5682  return eBTRMgrFailure;
5683  }
5684 
5685  *pVolume = VolumePersistentData.Volume;
5686  BTRMGRLOG_INFO ("get volume %d \n",*pVolume);
5687  return eBTRMgrSuccess;
5688 }
5689 
5690 static eBTRMgrRet
5691 btrMgr_SetLastMuteState (
5692  unsigned char aui8AdapterIdx,
5693  gboolean muted
5694 ) {
5695 
5696  if ((aui8AdapterIdx > btrMgr_GetAdapterCnt())) {
5697  BTRMGRLOG_ERROR ("Input is invalid\n");
5698  return eBTRMgrFailInArg;
5699  }
5700 
5701  BTRMGR_Mute_PersistentData_t MutePersistentData;
5702  sprintf(MutePersistentData.Mute, "%s", muted ? "true" : "false");
5703  if (BTRMgr_PI_SetMute(&MutePersistentData) == eBTRMgrFailure) {
5704  BTRMGRLOG_ERROR ("Failed to set mute from json.\n");
5705  return eBTRMgrFailure;
5706  }
5707 
5708  BTRMGRLOG_INFO (" set mute %s.\n", muted ? "true":"false");
5709  return eBTRMgrSuccess;
5710 }
5711 
5712 static eBTRMgrRet
5713 btrMgr_GetLastMuteState (
5714  unsigned char aui8AdapterIdx,
5715  gboolean *pMute
5716 ) {
5717 
5718  if ((aui8AdapterIdx > btrMgr_GetAdapterCnt()) || !(pMute)) {
5719  BTRMGRLOG_ERROR ("Input is invalid\n");
5720  return eBTRMgrFailInArg;
5721  }
5722 
5723  BTRMGR_Mute_PersistentData_t MutePersistentData;
5724  if (BTRMgr_PI_GetMute(&MutePersistentData) == eBTRMgrFailure) {
5725  BTRMGRLOG_INFO ("Failed to get mute detection from json.\n");
5726  return eBTRMgrFailure;
5727  }
5728 
5729  *pMute = (unsigned char)((!strncasecmp(MutePersistentData.Mute, "true", 4)) ? 1 : 0 );
5730  BTRMGRLOG_INFO (" get mute %s.\n", *pMute ? "true":"false");
5731  return eBTRMgrSuccess;
5732 }
5733 #endif
5734 
5735 BTRMGR_Result_t
5736 BTRMGR_GetLeProperty (
5737  unsigned char aui8AdapterIdx,
5738  BTRMgrDeviceHandle ahBTRMgrDevHdl,
5739  const char* apBtrPropUuid,
5740  BTRMGR_LeProperty_t aenLeProperty,
5741  void* vpPropValue
5742 ) {
5743  BTRMGR_Result_t lenBtrMgrResult = BTRMGR_RESULT_SUCCESS;
5744 
5745  if (!ghBTRCoreHdl) {
5746  BTRMGRLOG_ERROR ("BTRCore is not Inited\n");
5747  return BTRMGR_RESULT_INIT_FAILED;
5748  }
5749 
5750  if (aui8AdapterIdx > btrMgr_GetAdapterCnt() || !apBtrPropUuid) {
5751  BTRMGRLOG_ERROR ("Input is invalid\n");
5752  return BTRMGR_RESULT_INVALID_INPUT;
5753  }
5754 
5755  if (eBTRMgrSuccess != btrMgr_PreCheckDiscoveryStatus(aui8AdapterIdx, BTRMGR_DEVICE_OP_TYPE_LE)) {
5756  BTRMGRLOG_ERROR ("Pre Check Discovery State Rejected !!!\n");
5757  return BTRMGR_RESULT_GENERIC_FAILURE;
5758  }
5759 
5760  enBTRCoreLeProp lenBTRCoreLeProp = enBTRCoreLePropUnknown;
5761 
5762  switch(aenLeProperty) {
5763  case BTRMGR_LE_PROP_UUID:
5764  lenBTRCoreLeProp = enBTRCoreLePropGUUID;
5765  break;
5766  case BTRMGR_LE_PROP_PRIMARY:
5767  lenBTRCoreLeProp = enBTRCoreLePropGPrimary;
5768  break;
5769  case BTRMGR_LE_PROP_DEVICE:
5770  lenBTRCoreLeProp = enBTRCoreLePropGDevice;
5771  break;
5772  case BTRMGR_LE_PROP_SERVICE:
5773  lenBTRCoreLeProp = enBTRCoreLePropGService;
5774  break;
5775  case BTRMGR_LE_PROP_VALUE:
5776  lenBTRCoreLeProp = enBTRCoreLePropGValue;
5777  break;
5778  case BTRMGR_LE_PROP_NOTIFY:
5779  lenBTRCoreLeProp = enBTRCoreLePropGNotifying;
5780  break;
5781  case BTRMGR_LE_PROP_FLAGS:
5782  lenBTRCoreLeProp = enBTRCoreLePropGFlags;
5783  break;
5784  case BTRMGR_LE_PROP_CHAR:
5785  lenBTRCoreLeProp = enBTRCoreLePropGChar;
5786  break;
5787  default:
5788  break;
5789  }
5790 
5791  if (enBTRCoreSuccess != BTRCore_GetLEProperty(ghBTRCoreHdl, ahBTRMgrDevHdl, apBtrPropUuid, lenBTRCoreLeProp, vpPropValue)) {
5792  BTRMGRLOG_ERROR ("Get LE Property %d for Device/UUID %llu/%s Failed!!!\n", lenBTRCoreLeProp, ahBTRMgrDevHdl, apBtrPropUuid);
5793  lenBtrMgrResult = BTRMGR_RESULT_GENERIC_FAILURE;
5794  }
5795 
5796  return lenBtrMgrResult;
5797 }
5798 
5799 
5800 BTRMGR_Result_t
5801 BTRMGR_PerformLeOp (
5802  unsigned char aui8AdapterIdx,
5803  BTRMgrDeviceHandle ahBTRMgrDevHdl,
5804  const char* aBtrLeUuid,
5805  BTRMGR_LeOp_t aLeOpType,
5806  char* aLeOpArg,
5807  char* rOpResult
5808 ) {
5809  BTRMGR_Result_t lenBtrMgrResult = BTRMGR_RESULT_SUCCESS;
5810  BTRMGR_ConnectedDevicesList_t listOfCDevices;
5811  unsigned char isConnected = 0;
5812  unsigned short ui16LoopIdx = 0;
5813  enBTRCoreLeOp aenBTRCoreLeOp = enBTRCoreLeOpUnknown;
5814 
5815 
5816  if (!ghBTRCoreHdl) {
5817  BTRMGRLOG_ERROR ("BTRCore is not Inited\n");
5818  return BTRMGR_RESULT_INIT_FAILED;
5819  }
5820 
5821  if (aui8AdapterIdx > btrMgr_GetAdapterCnt() || !aBtrLeUuid) {
5822  BTRMGRLOG_ERROR ("Input is invalid\n");
5823  return BTRMGR_RESULT_INVALID_INPUT;
5824  }
5825 
5826  if (eBTRMgrSuccess != btrMgr_PreCheckDiscoveryStatus(aui8AdapterIdx, BTRMGR_DEVICE_OP_TYPE_LE)) {
5827  BTRMGRLOG_ERROR ("Pre Check Discovery State Rejected !!!\n");
5828  return BTRMGR_RESULT_GENERIC_FAILURE;
5829  }
5830 
5831  /* Check whether the device is in the Connected list */
5832  if(!BTRMGR_GetConnectedDevices (aui8AdapterIdx, &listOfCDevices)) {
5833  BTRMGRLOG_TRACE ("BTRMGR_GetConnectedDevices is error !!!\n");
5834  } //CID:95101 - Checked return
5835 
5836  for ( ;ui16LoopIdx < listOfCDevices.m_numOfDevices; ui16LoopIdx++) {
5837  if (listOfCDevices.m_deviceProperty[ui16LoopIdx].m_deviceHandle == ahBTRMgrDevHdl) {
5838  isConnected = listOfCDevices.m_deviceProperty[ui16LoopIdx].m_isConnected;
5839  break;
5840  }
5841  }
5842 
5843  if (!isConnected) {
5844 #if 0
5845  //TODO: Check if ahBTRMgrDevHdl corresponds to the current adapter
5846  BTRMGRLOG_ERROR ("LE Device %lld is not connected to perform LE Op!!!\n", ahBTRMgrDevHdl);
5847  return BTRMGR_RESULT_GENERIC_FAILURE;
5848 #endif
5849  }
5850 
5851 
5852  switch (aLeOpType) {
5853  case BTRMGR_LE_OP_READY:
5854  aenBTRCoreLeOp = enBTRCoreLeOpGReady;
5855  break;
5856  case BTRMGR_LE_OP_READ_VALUE:
5857  aenBTRCoreLeOp = enBTRCoreLeOpGReadValue;
5858  break;
5859  case BTRMGR_LE_OP_WRITE_VALUE:
5860  aenBTRCoreLeOp = enBTRCoreLeOpGWriteValue;
5861  break;
5862  case BTRMGR_LE_OP_START_NOTIFY:
5863  aenBTRCoreLeOp = enBTRCoreLeOpGStartNotify;
5864  break;
5865  case BTRMGR_LE_OP_STOP_NOTIFY:
5866  aenBTRCoreLeOp = enBTRCoreLeOpGStopNotify;
5867  break;
5868  case BTRMGR_LE_OP_UNKNOWN:
5869  default:
5870  aenBTRCoreLeOp = enBTRCoreLeOpGReady;
5871  break;
5872  }
5873 
5874  if (enBTRCoreSuccess != BTRCore_PerformLEOp (ghBTRCoreHdl, ahBTRMgrDevHdl, aBtrLeUuid, aenBTRCoreLeOp, aLeOpArg, rOpResult)) {
5875  BTRMGRLOG_ERROR ("Perform LE Op %d for device %llu Failed!!!\n", aLeOpType, ahBTRMgrDevHdl);
5876  lenBtrMgrResult = BTRMGR_RESULT_GENERIC_FAILURE;
5877  }
5878 
5879  return lenBtrMgrResult;
5880 }
5881 
5882 
5883 BTRMGR_Result_t
5884 BTRMGR_LE_StartAdvertisement (
5885  unsigned char aui8AdapterIdx,
5886  BTRMGR_LeCustomAdvertisement_t* pstBTMGR_LeCustomAdvt
5887 ) {
5888  BTRMGR_Result_t lenBtrMgrResult = BTRMGR_RESULT_SUCCESS;
5889 
5890  char *lAdvtType = "peripheral";
5891  int lLenServiceUUID = 0;
5892  int lComcastFlagType = 0;
5893  int lLenManfData = 0;
5894  unsigned short lManfId = 0;
5895  unsigned char laDeviceDetails[BTRMGR_DEVICE_COUNT_MAX] = {'\0'};
5896  unsigned char lManfType;
5897 
5898  /* Parse the adv data */
5899 
5900  /* Set advertisement type */
5901  BTRCore_SetAdvertisementType(ghBTRCoreHdl, lAdvtType);
5902 
5903  /* Parse and set the services supported by the device */
5904  lLenServiceUUID = (int)pstBTMGR_LeCustomAdvt->len_comcastflags;
5905 
5906  lComcastFlagType = (int)pstBTMGR_LeCustomAdvt->type_comcastflags;
5907  lLenServiceUUID -= 1;
5908 
5909  if ((2 == lComcastFlagType) || (3 == lComcastFlagType)) { /* TODO use macro/enum */
5910  char lUUID[10];
5911  unsigned short lu16UUID = ((unsigned short)pstBTMGR_LeCustomAdvt->deviceInfo_UUID_HI << 8) | (unsigned short)pstBTMGR_LeCustomAdvt->deviceInfo_UUID_LO;
5912  snprintf(lUUID, sizeof(lUUID), "%x", lu16UUID);
5913  if (enBTRCoreSuccess != BTRCore_SetServiceUUIDs(ghBTRCoreHdl, lUUID)) {
5914  lenBtrMgrResult = BTRMGR_RESULT_INVALID_INPUT;
5915  }
5916 
5917  lu16UUID = ((unsigned short)pstBTMGR_LeCustomAdvt->rdk_diag_UUID_HI << 8) | (unsigned short)pstBTMGR_LeCustomAdvt->rdk_diag_UUID_LO;
5918  snprintf(lUUID, sizeof(lUUID), "%x", lu16UUID);
5919  if (enBTRCoreSuccess != BTRCore_SetServiceUUIDs(ghBTRCoreHdl, lUUID)) {
5920  lenBtrMgrResult = BTRMGR_RESULT_INVALID_INPUT;
5921  }
5922  }
5923 
5924  /* Parse and set the manufacturer specific data for the device */
5925  lLenManfData = (int)pstBTMGR_LeCustomAdvt->len_manuf;
5926  BTRMGRLOG_INFO("Length of manf data is %d \n", lLenManfData);
5927 
5928  lManfType = pstBTMGR_LeCustomAdvt->type_manuf;
5929  lLenManfData -= sizeof(lManfType);
5930 
5931  lManfId = ((unsigned short)pstBTMGR_LeCustomAdvt->company_HI << 8) | ((unsigned short)pstBTMGR_LeCustomAdvt->company_LO);
5932  lLenManfData -= sizeof(lManfId);
5933  BTRMGRLOG_INFO("manf id is %d \n", lManfId);
5934 
5935  int index = 0;
5936  laDeviceDetails[index + 1] = pstBTMGR_LeCustomAdvt->device_model & 0xF;
5937  laDeviceDetails[index] = (pstBTMGR_LeCustomAdvt->device_model >> 8) & 0xF;
5938  index += sizeof(pstBTMGR_LeCustomAdvt->device_model);
5939 
5940  for (int count = 0; count < BTRMGR_DEVICE_MAC_LEN; count++) {
5941  laDeviceDetails[index] = pstBTMGR_LeCustomAdvt->device_mac[count];
5942  index += 1;
5943  }
5944 
5945  BTRCore_SetManufacturerData(ghBTRCoreHdl, lManfId, laDeviceDetails, lLenManfData);
5946 
5947  /* Set the Tx Power */
5948  BTRCore_SetEnableTxPower(ghBTRCoreHdl, TRUE);
5949 
5950  gIsAdvertisementSet = TRUE;
5951 
5952  /* Add standard advertisement Gatt Info */
5953  //btrMgr_AddStandardAdvGattInfo();
5954 
5955  /* Start advertising */
5956  if (!ghBTRCoreHdl) {
5957  BTRMGRLOG_ERROR("BTRCore is not Inited\n");
5958  lenBtrMgrResult = BTRMGR_RESULT_INIT_FAILED;
5959  }
5960  else if (FALSE == gIsAdvertisementSet) {
5961  BTRMGRLOG_ERROR("Advertisement data has not been set\n");
5962  lenBtrMgrResult = BTRMGR_RESULT_GENERIC_FAILURE;
5963  }
5964  else if (TRUE == gIsDeviceAdvertising) {
5965  BTRMGRLOG_ERROR("Device is already advertising\n");
5966  lenBtrMgrResult = BTRMGR_RESULT_GENERIC_FAILURE;
5967  }
5968  else {
5969  /* start advertisement */
5970  if (enBTRCoreSuccess != BTRCore_StartAdvertisement(ghBTRCoreHdl)) {
5971  BTRMGRLOG_ERROR("Starting advertisement has failed\n");
5972  lenBtrMgrResult = BTRMGR_RESULT_GENERIC_FAILURE;
5973  }
5974  else {
5975  BTRMGRLOG_INFO("Device is advertising\n");
5976  gIsDeviceAdvertising = TRUE;
5977  }
5978  }
5979 
5980  return lenBtrMgrResult;
5981 }
5982 
5983 BTRMGR_Result_t
5984 BTRMGR_LE_StopAdvertisement (
5985  unsigned char aui8AdapterIdx
5986 ) {
5987  BTRMGR_Result_t lenBtrMgrResult = BTRMGR_RESULT_SUCCESS;
5988 
5989  if (!ghBTRCoreHdl) {
5990  BTRMGRLOG_ERROR("BTRCore is not Inited\n");
5991  lenBtrMgrResult = BTRMGR_RESULT_INIT_FAILED;
5992  }
5993  else if (FALSE == gIsDeviceAdvertising) {
5994  BTRMGRLOG_ERROR("Device is not advertising yet\n");
5995  lenBtrMgrResult = BTRMGR_RESULT_GENERIC_FAILURE;
5996  }
5997  else {
5998  /* stop advertisement */
5999  BTRMGRLOG_INFO("Stopping advertisement\n");
6000  if (enBTRCoreSuccess != BTRCore_StopAdvertisement(ghBTRCoreHdl)) {
6001  BTRMGRLOG_ERROR("Stopping advertisement has failed\n");
6002  lenBtrMgrResult = BTRMGR_RESULT_GENERIC_FAILURE;
6003  }
6004  gIsDeviceAdvertising = FALSE;
6005  }
6006 
6007  return lenBtrMgrResult;
6008 }
6009 
6010 BTRMGR_Result_t
6011 BTRMGR_LE_GetPropertyValue (
6012  unsigned char aui8AdapterIdx,
6013  char* aUUID,
6014  char* aValue,
6015  BTRMGR_LeProperty_t aElement
6016 ) {
6017  BTRMGR_Result_t lenBtrMgrResult = BTRMGR_RESULT_SUCCESS;
6018  char lPropValue[BTRMGR_MAX_STR_LEN] = "";
6019 
6020  if (!ghBTRCoreHdl) {
6021  BTRMGRLOG_ERROR("BTRCore is not Inited\n");
6022  lenBtrMgrResult = BTRMGR_RESULT_INIT_FAILED;
6023  }
6024  else if (FALSE == gIsDeviceAdvertising) {
6025  BTRMGRLOG_ERROR("Device is not advertising yet\n");
6026  lenBtrMgrResult = BTRMGR_RESULT_GENERIC_FAILURE;
6027  }
6028  else {
6029  if (enBTRCoreSuccess != BTRCore_GetPropertyValue(ghBTRCoreHdl, aUUID, lPropValue, aElement)) {
6030  BTRMGRLOG_ERROR("Getting property value has failed\n");
6031  lenBtrMgrResult = BTRMGR_RESULT_GENERIC_FAILURE;
6032  }
6033  else {
6034  strncpy(aValue, lPropValue, (BTRMGR_MAX_STR_LEN - 1));
6035  }
6036  }
6037 
6038  return lenBtrMgrResult;
6039 }
6040 
6041 BTRMGR_Result_t
6042 BTRMGR_LE_SetServiceUUIDs (
6043  unsigned char aui8AdapterIdx,
6044  char* aUUID
6045 ) {
6046  BTRMGR_Result_t lenBtrMgrResult = BTRMGR_RESULT_SUCCESS;
6047 
6048 
6049  if (enBTRCoreSuccess != BTRCore_SetServiceUUIDs(ghBTRCoreHdl, aUUID)) {
6050  lenBtrMgrResult = BTRMGR_RESULT_INVALID_INPUT;
6051  }
6052 
6053  return lenBtrMgrResult;
6054 }
6055 
6056 BTRMGR_Result_t
6057 BTRMGR_LE_SetServiceInfo (
6058  unsigned char aui8AdapterIdx,
6059  char* aUUID,
6060  unsigned char aServiceType
6061 ) {
6062  BTRMGR_Result_t lenBtrMgrResult = BTRMGR_RESULT_SUCCESS;
6063 
6064  if (enBTRCoreSuccess != BTRCore_SetServiceInfo(ghBTRCoreHdl, aUUID, (BOOLEAN)aServiceType)) {
6065  BTRMGRLOG_ERROR("Could not add service info\n");
6066  lenBtrMgrResult = BTRMGR_RESULT_GENERIC_FAILURE;
6067  }
6068 
6069  return lenBtrMgrResult;
6070 }
6071 
6072 BTRMGR_Result_t
6073 BTRMGR_LE_SetGattInfo (
6074  unsigned char aui8AdapterIdx,
6075  char* aParentUUID,
6076  char* aCharUUID,
6077  unsigned short aFlags,
6078  char* aValue,
6079  BTRMGR_LeProperty_t aElement
6080 ) {
6081  BTRMGR_Result_t lenBtrMgrResult = BTRMGR_RESULT_SUCCESS;
6082 
6083  if (enBTRCoreSuccess != BTRCore_SetGattInfo(ghBTRCoreHdl, aParentUUID, aCharUUID, aFlags, aValue, aElement)) {
6084  BTRMGRLOG_ERROR("Could not add gatt info\n");
6085  lenBtrMgrResult = BTRMGR_RESULT_GENERIC_FAILURE;
6086  }
6087 
6088  return lenBtrMgrResult;
6089 }
6090 
6091 BTRMGR_Result_t
6092 BTRMGR_LE_SetGattPropertyValue (
6093  unsigned char aui8AdapterIdx,
6094  char* aUUID,
6095  char* aValue,
6096  BTRMGR_LeProperty_t aElement
6097 ) {
6098  BTRMGR_Result_t lenBtrMgrResult = BTRMGR_RESULT_SUCCESS;
6099 
6100  if (!ghBTRCoreHdl) {
6101  BTRMGRLOG_ERROR("BTRCore is not Inited\n");
6102  lenBtrMgrResult = BTRMGR_RESULT_INIT_FAILED;
6103  }
6104  else if (FALSE == gIsDeviceAdvertising) {
6105  BTRMGRLOG_ERROR("Device is not advertising yet\n");
6106  lenBtrMgrResult = BTRMGR_RESULT_GENERIC_FAILURE;
6107  }
6108  else {
6109  BTRMGRLOG_DEBUG("Value is %s\n", aValue);
6110 
6111 #if 1
6112  if (enBTRCoreSuccess != BTRCore_SetPropertyValue(ghBTRCoreHdl, aUUID, aValue, aElement)) {
6113  BTRMGRLOG_ERROR("Setting property value has failed\n");
6114  lenBtrMgrResult = BTRMGR_RESULT_GENERIC_FAILURE;
6115  }
6116 #else
6117  BTRCore_PerformLEOp
6118 #endif
6119  }
6120 
6121  return lenBtrMgrResult;
6122 }
6123 
6124 
6125 BTRMGR_Result_t
6126 BTRMGR_SysDiagInfo(
6127  unsigned char aui8AdapterIdx,
6128  char *apDiagElement,
6129  char *apValue,
6130  BTRMGR_LeOp_t aOpType
6131 ) {
6132  BTRMGR_Result_t lenBtrMgrResult = BTRMGR_RESULT_SUCCESS;
6133  int lenDiagElement = 0;
6134  char lPropValue[BTRMGR_LE_STR_LEN_MAX] = {'\0'}; //CID:135225 - Overrurn
6135 
6136  if (!ghBTRCoreHdl) {
6137  BTRMGRLOG_ERROR("BTRCore is not Inited\n");
6138  return BTRMGR_RESULT_INIT_FAILED;
6139  }
6140 
6141  if (aui8AdapterIdx > btrMgr_GetAdapterCnt() || !apDiagElement) {
6142  BTRMGRLOG_ERROR("Input is invalid\n");
6143  return BTRMGR_RESULT_INVALID_INPUT;
6144  }
6145 
6146  lenDiagElement = btrMgr_MapUUIDtoDiagElement(apDiagElement);
6147 
6148  if ((BTRMGR_SYS_DIAG_BEGIN < (BTRMGR_SysDiagChar_t)lenDiagElement) && (BTRMGR_SYS_DIAG_END > (BTRMGR_SysDiagChar_t)lenDiagElement)) {
6149  if (BTRMGR_LE_OP_READ_VALUE == aOpType) {
6150  if (eBTRMgrSuccess != BTRMGR_SysDiag_GetData(ghBTRMgrSdHdl, lenDiagElement, lPropValue)) {
6151  BTRMGRLOG_ERROR("Could not get diagnostic data\n");
6152  lenBtrMgrResult = BTRMGR_RESULT_GENERIC_FAILURE;
6153  }
6154  else {
6155  strncpy(apValue, lPropValue, BTRMGR_MAX_STR_LEN - 1);
6156  }
6157  }
6158  }
6159  else if ((BTRMGR_SYSDIAG_COLUMBO_BEGIN < (BTRMGR_ColumboChar_t)lenDiagElement) && (BTRMGR_SYSDIAG_COLUMBO_END > (BTRMGR_ColumboChar_t)lenDiagElement)) {
6160  if (BTRMGR_LE_OP_READ_VALUE == aOpType) {
6161  if (eBTRMgrSuccess != BTRMGR_Columbo_GetData(lenDiagElement, lPropValue)) {
6162  BTRMGRLOG_ERROR("Could not get diagnostic data\n");
6163  lenBtrMgrResult = BTRMGR_RESULT_GENERIC_FAILURE;
6164  }
6165  else {
6166  strncpy(apValue, lPropValue, BTRMGR_MAX_STR_LEN - 1);
6167  }
6168  }
6169  else if (BTRMGR_LE_OP_WRITE_VALUE == aOpType) {
6170  if (eBTRMgrSuccess != BTRMGR_Columbo_SetData(lenDiagElement, lPropValue)) {
6171  BTRMGRLOG_ERROR("Could not get diagnostic data\n");
6172  lenBtrMgrResult = BTRMGR_RESULT_GENERIC_FAILURE;
6173  }
6174  }
6175  }
6176  else if ((BTRMGR_LE_ONBRDG_BEGIN < (BTRMGR_LeOnboardingChar_t)lenDiagElement) && (BTRMGR_LE_ONBRDG_END > (BTRMGR_LeOnboardingChar_t)lenDiagElement)) {
6177  if (BTRMGR_LE_OP_READ_VALUE == aOpType) {
6178  if (eBTRMgrSuccess != BTRMGR_LeOnboarding_GetData(lenDiagElement, lPropValue)) {
6179  BTRMGRLOG_ERROR("Could not get diagnostic data\n");
6180  lenBtrMgrResult = BTRMGR_RESULT_GENERIC_FAILURE;
6181  }
6182  else {
6183  strncpy(apValue, lPropValue, BTRMGR_MAX_STR_LEN - 1);
6184  }
6185  }
6186  else if (BTRMGR_LE_OP_WRITE_VALUE == aOpType) {
6187  if (eBTRMgrSuccess != BTRMGR_LeOnboarding_SetData(lenDiagElement, apValue)) {
6188  BTRMGRLOG_ERROR("Could not set diagnostic data\n");
6189  lenBtrMgrResult = BTRMGR_RESULT_GENERIC_FAILURE;
6190  }
6191  else {
6192 
6193  }
6194  }
6195  }
6196  else {
6197  lenBtrMgrResult = BTRMGR_RESULT_GENERIC_FAILURE;
6198  }
6199 
6200 
6201  return lenBtrMgrResult;
6202 }
6203 
6204 BTRMGR_Result_t
6205 BTRMGR_ConnectToWifi(
6206  unsigned char aui8AdapterIdx,
6207  char* apSSID,
6208  char* apPassword,
6209  int aSecMode
6210 ) {
6211  BTRMGR_Result_t lenBtrMgrResult = BTRMGR_RESULT_SUCCESS;
6212 
6213  if (!ghBTRCoreHdl || !ghBTRMgrSdHdl) {
6214  BTRMGRLOG_ERROR("BTRCore is not Inited\n");
6215  return BTRMGR_RESULT_INIT_FAILED;
6216  }
6217 
6218  if (aui8AdapterIdx > btrMgr_GetAdapterCnt()) {
6219  BTRMGRLOG_ERROR("Input is invalid\n");
6220  return BTRMGR_RESULT_INVALID_INPUT;
6221  }
6222 
6223  lenBtrMgrResult = BTRMGR_SysDiag_ConnectToWifi(ghBTRMgrSdHdl, apSSID, apPassword, aSecMode);
6224 
6225  return lenBtrMgrResult;
6226 }
6227 
6228 // Outgoing callbacks Registration Interfaces
6229 BTRMGR_Result_t
6230 BTRMGR_RegisterEventCallback (
6231  BTRMGR_EventCallback afpcBBTRMgrEventOut
6232 ) {
6233  BTRMGR_Result_t lenBtrMgrResult = BTRMGR_RESULT_SUCCESS;
6234 
6235  if (!afpcBBTRMgrEventOut) {
6236  BTRMGRLOG_ERROR ("Input is invalid\n");
6237  return BTRMGR_RESULT_INVALID_INPUT;
6238  }
6239 
6240  gfpcBBTRMgrEventOut = afpcBBTRMgrEventOut;
6241  BTRMGRLOG_INFO ("BTRMGR_RegisterEventCallback : Success\n");
6242 
6243  return lenBtrMgrResult;
6244 }
6245 
6246 
6247 /* Local Op Threads Prototypes */
6248 static gpointer
6249 btrMgr_g_main_loop_Task (
6250  gpointer appvMainLoop
6251 ) {
6252  GMainLoop* pMainLoop = (GMainLoop*)appvMainLoop;
6253  if (!pMainLoop) {
6254  BTRMGRLOG_INFO ("GMainLoop Error - In arguments Exiting\n");
6255  return NULL;
6256  }
6257 
6258  BTRMGRLOG_INFO ("GMainLoop Running - %p - %p\n", pMainLoop, appvMainLoop);
6259  g_main_loop_run (pMainLoop);
6260 
6261  return appvMainLoop;
6262 }
6263 
6264 
6265 /* Incoming Callbacks */
6266 static gboolean
6267 btrMgr_DiscoveryHoldOffTimerCb (
6268  gpointer gptr
6269 ) {
6270  unsigned char lui8AdapterIdx = 0;
6271 
6272  BTRMGRLOG_DEBUG ("CB context Invoked for btrMgr_DiscoveryHoldOffTimerCb || TimeOutReference - %u\n", gTimeOutRef);
6273 
6274  if (gptr) {
6275  lui8AdapterIdx = *(unsigned char*)gptr;
6276  } else {
6277  BTRMGRLOG_WARN ("CB context received NULL arg!\n");
6278  }
6279 
6280  gTimeOutRef = 0;
6281 
6282  if (btrMgr_PostCheckDiscoveryStatus (lui8AdapterIdx, BTRMGR_DEVICE_OP_TYPE_UNKNOWN) != eBTRMgrSuccess) {
6283  BTRMGRLOG_ERROR ("Post Check Disc Status Failed!\n");
6284  }
6285 
6286  return FALSE;
6287 }
6288 
6289 
6290 static gboolean
6291 btrMgr_ConnPwrStChangeTimerCb (
6292  gpointer gptr
6293 ) {
6294  unsigned char lui8AdapterIdx = 0;
6295 
6296  BTRMGRLOG_DEBUG ("CB context Invoked for btrMgr_ConnPwrStChangeTimerCb || TimeOutReference - %u\n", gConnPwrStChangeTimeOutRef);
6297 
6298  if (gptr) {
6299  lui8AdapterIdx = *(unsigned char*)gptr;
6300  } else {
6301  BTRMGRLOG_WARN ("CB context received NULL arg!\n");
6302  }
6303 
6304  gConnPwrStChangeTimeOutRef = 0;
6305 
6306  if (BTRMGR_StartAudioStreamingOut_StartUp(lui8AdapterIdx, BTRMGR_DEVICE_OP_TYPE_AUDIO_OUTPUT) != BTRMGR_RESULT_SUCCESS) {
6307  BTRMGRLOG_ERROR ("ConnPwrStChange - BTRMGR_StartAudioStreamingOut_StartUp Failed!\n");
6308  }
6309 
6310  return FALSE;
6311 }
6312 
6313 
6314 static eBTRMgrRet
6315 btrMgr_ACDataReadyCb (
6316  void* apvAcDataBuf,
6317  unsigned int aui32AcDataLen,
6318  void* apvUserData
6319 ) {
6320  eBTRMgrRet leBtrMgrAcRet = eBTRMgrSuccess;
6321  stBTRMgrStreamingInfo* lstBTRMgrStrmInfo = (stBTRMgrStreamingInfo*)apvUserData;
6322 
6323  if (lstBTRMgrStrmInfo) {
6324  if ((leBtrMgrAcRet = BTRMgr_SO_SendBuffer(lstBTRMgrStrmInfo->hBTRMgrSoHdl, apvAcDataBuf, aui32AcDataLen)) != eBTRMgrSuccess) {
6325  BTRMGRLOG_ERROR ("cbBufferReady: BTRMgr_SO_SendBuffer FAILED\n");
6326  }
6327  lstBTRMgrStrmInfo->bytesWritten += aui32AcDataLen;
6328  } //CID:23337 - Forward null
6329 
6330  return leBtrMgrAcRet;
6331 }
6332 
6333 
6334 static eBTRMgrRet
6335 btrMgr_ACStatusCb (
6336  stBTRMgrMediaStatus* apstBtrMgrAcStatus,
6337  void* apvUserData
6338 ) {
6339  eBTRMgrRet leBtrMgrAcRet = eBTRMgrSuccess;
6340  stBTRMgrStreamingInfo* lpstBTRMgrStrmInfo = (stBTRMgrStreamingInfo*)apvUserData;
6341 
6342  if (lpstBTRMgrStrmInfo && apstBtrMgrAcStatus) {
6343  stBTRMgrMediaStatus lstBtrMgrSoStatus;
6344 
6345  //TODO; Dont just memcpy from AC Status to SO Status, map it correctly in the future.
6346  BTRMGRLOG_WARN ("STATUS CHANGED\n");
6347  memcpy(&lstBtrMgrSoStatus, apstBtrMgrAcStatus, sizeof(stBTRMgrMediaStatus));
6348  if ((leBtrMgrAcRet = BTRMgr_SO_SetStatus(lpstBTRMgrStrmInfo->hBTRMgrSoHdl, &lstBtrMgrSoStatus)) != eBTRMgrSuccess) {
6349  BTRMGRLOG_ERROR ("BTRMgr_SO_SetStatus FAILED = %d\n", leBtrMgrAcRet);
6350  }
6351  }
6352 
6353  return leBtrMgrAcRet;
6354 }
6355 
6356 
6357 static eBTRMgrRet
6358 btrMgr_SOStatusCb (
6359  stBTRMgrMediaStatus* apstBtrMgrSoStatus,
6360  void* apvUserData
6361 ) {
6362  eBTRMgrRet leBtrMgrSoRet = eBTRMgrSuccess;
6363  stBTRMgrStreamingInfo* lpstBTRMgrStrmInfo = (stBTRMgrStreamingInfo*)apvUserData;
6364 
6365  if (lpstBTRMgrStrmInfo && apstBtrMgrSoStatus) {
6366  BTRMGRLOG_DEBUG ("Entering\n");
6367 
6368  //TODO: Not happy that we are doing in the context of the callback.
6369  // If possible move to a task thread
6370  //TODO: Rather than giving up on Streaming Out altogether, think about a retry implementation
6371  if (apstBtrMgrSoStatus->eBtrMgrState == eBTRMgrStateError) {
6372  if (ghBTRMgrDevHdlCurStreaming && lpstBTRMgrStrmInfo->hBTRMgrSoHdl) { /* Connected device. AC extablished; Release and Disconnect it */
6373  BTRMGRLOG_ERROR ("Error - ghBTRMgrDevHdlCurStreaming = %lld\n", ghBTRMgrDevHdlCurStreaming);
6374  if (ghBTRMgrDevHdlCurStreaming) { /* The streaming is happening; stop it */
6375 #if 0
6376  //TODO: DONT ENABLE Just a Reference of what we are trying to acheive
6377  if (BTRMGR_StopAudioStreamingOut(0, ghBTRMgrDevHdlCurStreaming) != BTRMGR_RESULT_SUCCESS) {
6378  BTRMGRLOG_ERROR ("Streamout is failed to stop\n");
6379  leBtrMgrSoRet = eBTRMgrFailure;
6380  }
6381 #endif
6382  }
6383  }
6384  }
6385  }
6386 
6387  return leBtrMgrSoRet;
6388 }
6389 
6390 
6391 static eBTRMgrRet
6392 btrMgr_SIStatusCb (
6393  stBTRMgrMediaStatus* apstBtrMgrSiStatus,
6394  void* apvUserData
6395 ) {
6396  eBTRMgrRet leBtrMgrSiRet = eBTRMgrSuccess;
6397  stBTRMgrStreamingInfo* lpstBTRMgrStrmInfo = (stBTRMgrStreamingInfo*)apvUserData;
6398 
6399  if (lpstBTRMgrStrmInfo && apstBtrMgrSiStatus) {
6400  BTRMGRLOG_DEBUG ("Entering\n");
6401 
6402  //TODO: Not happy that we are doing in the context of the callback.
6403  // If possible move to a task thread
6404  //TODO: Rather than giving up on Streaming In altogether, think about a retry implementation
6405  if (apstBtrMgrSiStatus->eBtrMgrState == eBTRMgrStateError) {
6406  if (ghBTRMgrDevHdlCurStreaming && lpstBTRMgrStrmInfo->hBTRMgrSiHdl) { /* Connected device. AC extablished; Release and Disconnect it */
6407  BTRMGRLOG_ERROR ("Error - ghBTRMgrDevHdlCurStreaming = %lld\n", ghBTRMgrDevHdlCurStreaming);
6408  if (ghBTRMgrDevHdlCurStreaming) { /* The streaming is happening; stop it */
6409 #if 0
6410  //TODO: DONT ENABLE Just a Reference of what we are trying to acheive
6411  if (BTRMGR_StopAudioStreamingIn(0, ghBTRMgrDevHdlCurStreaming) != BTRMGR_RESULT_SUCCESS) {
6412  BTRMGRLOG_ERROR ("Streamin is failed to stop\n");
6413  leBtrMgrSiRet = eBTRMgrFailure;
6414  }
6415 #endif
6416  }
6417  }
6418  }
6419  }
6420 
6421  return leBtrMgrSiRet;
6422 }
6423 
6424 
6425 static eBTRMgrRet
6426 btrMgr_SDStatusCb (
6427  stBTRMgrSysDiagStatus* apstBtrMgrSdStatus,
6428  void* apvUserData
6429 ) {
6430  eBTRMgrRet leBtrMgrSdRet = eBTRMgrFailure;
6431 
6432  if ((apstBtrMgrSdStatus != NULL) &&
6433  (gIsAudOutStartupInProgress != BTRMGR_STARTUP_AUD_INPROGRESS) &&
6434  (apstBtrMgrSdStatus->enSysDiagChar == BTRMGR_SYS_DIAG_POWERSTATE) &&
6435  !strncmp(apstBtrMgrSdStatus->pcSysDiagRes, BTRMGR_SYS_DIAG_PWRST_ON, strlen(BTRMGR_SYS_DIAG_PWRST_ON))) {
6436 
6437  gConnPwrStChTimeOutCbData = 0; // TODO: Change when this entire file is made re-entrant
6438  if ((gConnPwrStChangeTimeOutRef = g_timeout_add_seconds (BTRMGR_DEVCONN_PWRST_CHANGE_TIME, btrMgr_ConnPwrStChangeTimerCb, (gpointer)&gConnPwrStChTimeOutCbData)) != 0)
6439  leBtrMgrSdRet = eBTRMgrSuccess;
6440  }
6441 
6442  return leBtrMgrSdRet;
6443 }
6444 
6445 
6446 static enBTRCoreRet
6447 btrMgr_DeviceStatusCb (
6448  stBTRCoreDevStatusCBInfo* p_StatusCB,
6449  void* apvUserData
6450 ) {
6451  enBTRCoreRet lenBtrCoreRet = enBTRCoreSuccess;
6452  BTRMGR_EventMessage_t lstEventMessage;
6453  BTRMGR_DeviceType_t lBtrMgrDevType = BTRMGR_DEVICE_TYPE_UNKNOWN;
6454 
6455 
6456  memset (&lstEventMessage, 0, sizeof(lstEventMessage));
6457 
6458  BTRMGRLOG_INFO ("Received status callback\n");
6459 
6460  if (p_StatusCB) {
6461 
6462  lBtrMgrDevType = btrMgr_MapDeviceTypeFromCore(p_StatusCB->eDeviceClass);
6463  BTRMGRLOG_INFO (" Received status callback device type %d PrevState %d State %d\n",lBtrMgrDevType, p_StatusCB->eDevicePrevState, p_StatusCB->eDeviceCurrState);
6464 
6465  if (!gIsHidGamePadEnabled &&
6466  (lBtrMgrDevType == BTRMGR_DEVICE_TYPE_HID_GAMEPAD)) {
6467  BTRMGRLOG_WARN ("Rejecting status callback - BTR HID Gamepad is currently Disabled!\n");
6468  return lenBtrCoreRet;
6469  }
6470 
6471  switch (p_StatusCB->eDeviceCurrState) {
6472  case enBTRCoreDevStPaired:
6473  /* Post this event only for HID Devices and Audio-In Devices */
6474  if ((p_StatusCB->eDeviceType == enBTRCoreHID) ||
6475  (p_StatusCB->eDeviceType == enBTRCoreMobileAudioIn) ||
6476  (p_StatusCB->eDeviceType == enBTRCorePCAudioIn)) {
6477 
6478  btrMgr_GetDiscoveredDevInfo (p_StatusCB->deviceId, &lstEventMessage.m_discoveredDevice);
6479 
6480  lstEventMessage.m_discoveredDevice.m_deviceHandle = p_StatusCB->deviceId;
6481  lstEventMessage.m_discoveredDevice.m_deviceType = (p_StatusCB->eDeviceType == enBTRCoreHID) ? BTRMGR_DEVICE_TYPE_HID : lBtrMgrDevType;
6482  lstEventMessage.m_discoveredDevice.m_isPairedDevice = p_StatusCB->isPaired;
6483  lstEventMessage.m_discoveredDevice.m_ui32DevClassBtSpec = p_StatusCB->ui32DevClassBtSpec;
6484  strncpy(lstEventMessage.m_discoveredDevice.m_name, p_StatusCB->deviceName,
6485  strlen(p_StatusCB->deviceName) < BTRMGR_NAME_LEN_MAX ? strlen (p_StatusCB->deviceName) : BTRMGR_NAME_LEN_MAX - 1);
6486  strncpy(lstEventMessage.m_discoveredDevice.m_deviceAddress, p_StatusCB->deviceAddress,
6487  strlen(p_StatusCB->deviceAddress) < BTRMGR_NAME_LEN_MAX ? strlen (p_StatusCB->deviceAddress) : BTRMGR_NAME_LEN_MAX - 1);
6488 
6489 
6490  lstEventMessage.m_eventType = BTRMGR_EVENT_DEVICE_PAIRING_COMPLETE;
6491  if (gfpcBBTRMgrEventOut) {
6492  gfpcBBTRMgrEventOut(lstEventMessage); /* Post a callback */
6493  }
6494 
6495  if (p_StatusCB->eDeviceType == enBTRCoreHID) {
6496  BTRMGR_GetPairedDevices (gDefaultAdapterContext.adapter_number, &gListOfPairedDevices);
6497  }
6498  }
6499  break;
6500  case enBTRCoreDevStInitialized:
6501  break;
6502  case enBTRCoreDevStConnecting:
6503  break;
6504  case enBTRCoreDevStConnected: /* notify user device back */
6505  if (enBTRCoreDevStLost == p_StatusCB->eDevicePrevState || enBTRCoreDevStPaired == p_StatusCB->eDevicePrevState) {
6506  if (gIsAudOutStartupInProgress != BTRMGR_STARTUP_AUD_INPROGRESS) {
6507  unsigned char doPostCheck = 0;
6508  btrMgr_MapDevstatusInfoToEventInfo ((void*)p_StatusCB, &lstEventMessage, BTRMGR_EVENT_DEVICE_FOUND);
6509 
6510  if ((lstEventMessage.m_pairedDevice.m_deviceType == BTRMGR_DEVICE_TYPE_WEARABLE_HEADSET) ||
6511  (lstEventMessage.m_pairedDevice.m_deviceType == BTRMGR_DEVICE_TYPE_HANDSFREE) ||
6512  (lstEventMessage.m_pairedDevice.m_deviceType == BTRMGR_DEVICE_TYPE_LOUDSPEAKER) ||
6513  (lstEventMessage.m_pairedDevice.m_deviceType == BTRMGR_DEVICE_TYPE_HEADPHONES) ||
6514  (lstEventMessage.m_pairedDevice.m_deviceType == BTRMGR_DEVICE_TYPE_PORTABLE_AUDIO) ||
6515  (lstEventMessage.m_pairedDevice.m_deviceType == BTRMGR_DEVICE_TYPE_CAR_AUDIO) ||
6516  (lstEventMessage.m_pairedDevice.m_deviceType == BTRMGR_DEVICE_TYPE_HIFI_AUDIO_DEVICE) ){
6517 
6518  if (lstEventMessage.m_pairedDevice.m_isLastConnectedDevice) {
6519  btrMgr_PreCheckDiscoveryStatus (0, BTRMGR_DEVICE_OP_TYPE_AUDIO_OUTPUT);
6520  doPostCheck = 1;
6521  }
6522  }
6523  else if ((lstEventMessage.m_pairedDevice.m_deviceType == BTRMGR_DEVICE_TYPE_HID) ||
6524  (lstEventMessage.m_pairedDevice.m_deviceType == BTRMGR_DEVICE_TYPE_HID_GAMEPAD)) {
6525  lstEventMessage.m_pairedDevice.m_deviceType = BTRMGR_DEVICE_TYPE_HID ;
6526  btrMgr_SetDevConnected(lstEventMessage.m_pairedDevice.m_deviceHandle, 1);
6527  }
6528 
6529  if (gfpcBBTRMgrEventOut) {
6530  gfpcBBTRMgrEventOut(lstEventMessage); /* Post a callback */
6531  }
6532 
6533  if (doPostCheck) {
6534  btrMgr_PostCheckDiscoveryStatus (0, BTRMGR_DEVICE_OP_TYPE_AUDIO_OUTPUT);
6535  }
6536  }
6537  }
6538  else if (enBTRCoreDevStInitialized != p_StatusCB->eDevicePrevState) {
6539  btrMgr_MapDevstatusInfoToEventInfo ((void*)p_StatusCB, &lstEventMessage, BTRMGR_EVENT_DEVICE_CONNECTION_COMPLETE);
6540  lstEventMessage.m_pairedDevice.m_isConnected = 1;
6541 
6542  if ((lstEventMessage.m_pairedDevice.m_deviceType != BTRMGR_DEVICE_TYPE_WEARABLE_HEADSET) &&
6543  (lstEventMessage.m_pairedDevice.m_deviceType != BTRMGR_DEVICE_TYPE_HANDSFREE) &&
6544  (lstEventMessage.m_pairedDevice.m_deviceType != BTRMGR_DEVICE_TYPE_LOUDSPEAKER) &&
6545  (lstEventMessage.m_pairedDevice.m_deviceType != BTRMGR_DEVICE_TYPE_HEADPHONES) &&
6546  (lstEventMessage.m_pairedDevice.m_deviceType != BTRMGR_DEVICE_TYPE_PORTABLE_AUDIO) &&
6547  (lstEventMessage.m_pairedDevice.m_deviceType != BTRMGR_DEVICE_TYPE_CAR_AUDIO) &&
6548  (lstEventMessage.m_pairedDevice.m_deviceType != BTRMGR_DEVICE_TYPE_HIFI_AUDIO_DEVICE)) {
6549 
6550  /* Update the flag as the Device is Connected */
6551  if ((lstEventMessage.m_pairedDevice.m_deviceType == BTRMGR_DEVICE_TYPE_HID) ||
6552  (lstEventMessage.m_pairedDevice.m_deviceType == BTRMGR_DEVICE_TYPE_HID_GAMEPAD)) {
6553  lstEventMessage.m_pairedDevice.m_deviceType = BTRMGR_DEVICE_TYPE_HID;
6554  BTRMGRLOG_WARN ("\n Sending Event for HID ");
6555  btrMgr_SetDevConnected(lstEventMessage.m_pairedDevice.m_deviceHandle, 1);
6556  }
6557  else if (lstEventMessage.m_pairedDevice.m_deviceType != BTRMGR_DEVICE_TYPE_TILE) {
6558  btrMgr_SetDevConnected(lstEventMessage.m_pairedDevice.m_deviceHandle, 1);
6559  ghBTRMgrDevHdlLastConnected = lstEventMessage.m_pairedDevice.m_deviceHandle;
6560  }
6561 
6562 
6563  if (gfpcBBTRMgrEventOut) {
6564  gfpcBBTRMgrEventOut(lstEventMessage); /* Post a callback */
6565  }
6566  }
6567  }
6568  break;
6569  case enBTRCoreDevStDisconnected:
6570  if (enBTRCoreDevStConnecting != p_StatusCB->eDevicePrevState) {
6571  btrMgr_MapDevstatusInfoToEventInfo ((void*)p_StatusCB, &lstEventMessage, BTRMGR_EVENT_DEVICE_DISCONNECT_COMPLETE);
6572  /* external modules like thunder,servicemanager yet to define
6573  * HID sub types hence type is sending as BTRMGR_DEVICE_TYPE_HID in events
6574  */
6575  if (lstEventMessage.m_pairedDevice.m_deviceType == BTRMGR_DEVICE_TYPE_HID_GAMEPAD)
6576  lstEventMessage.m_pairedDevice.m_deviceType = BTRMGR_DEVICE_TYPE_HID;
6577 
6578  if (gfpcBBTRMgrEventOut) {
6579  gfpcBBTRMgrEventOut(lstEventMessage); /* Post a callback */
6580  }
6581 
6582  BTRMGRLOG_INFO ("lstEventMessage.m_pairedDevice.m_deviceType = %d\n", lstEventMessage.m_pairedDevice.m_deviceType);
6583  if (lstEventMessage.m_pairedDevice.m_deviceType == BTRMGR_DEVICE_TYPE_TILE) {
6584  /* update the flags as the LE device is NOT Connected */
6585  gIsLeDeviceConnected = 0;
6586  }
6587  else if ((lstEventMessage.m_pairedDevice.m_deviceType == BTRMGR_DEVICE_TYPE_HID) ||
6588  (lstEventMessage.m_pairedDevice.m_deviceType == BTRMGR_DEVICE_TYPE_HID_GAMEPAD)) {
6589  btrMgr_SetDevConnected(lstEventMessage.m_pairedDevice.m_deviceHandle, 0);
6590  }
6591  else if ((ghBTRMgrDevHdlCurStreaming != 0) && (ghBTRMgrDevHdlCurStreaming == p_StatusCB->deviceId)) {
6592  /* update the flags as the device is NOT Connected */
6593  btrMgr_SetDevConnected(lstEventMessage.m_pairedDevice.m_deviceHandle, 0);
6594 
6595  if (lstEventMessage.m_pairedDevice.m_deviceType == BTRMGR_DEVICE_TYPE_SMARTPHONE ||
6596  lstEventMessage.m_pairedDevice.m_deviceType == BTRMGR_DEVICE_TYPE_TABLET) {
6597  /* Stop the playback which already stopped internally but to free up the memory */
6598  if(!BTRMGR_StopAudioStreamingIn(0, ghBTRMgrDevHdlCurStreaming))
6599  {
6600  BTRMGRLOG_ERROR ("BTRMGR_StopAudioStreamingIn error \n "); //CID:41286 - Checked return
6601  }
6602  ghBTRMgrDevHdlLastConnected = 0;
6603  }
6604  else {
6605  /* Stop the playback which already stopped internally but to free up the memory */
6606  if (BTRMGR_RESULT_SUCCESS != BTRMGR_StopAudioStreamingOut(0, ghBTRMgrDevHdlCurStreaming)) {
6607  BTRMGRLOG_ERROR ("BTRMGR_StopAudioStreamingOut error \n "); //CID:41354 - Checked return
6608  }
6609  }
6610  }
6611  else if ((btrMgr_IsDevConnected(lstEventMessage.m_pairedDevice.m_deviceHandle) == 1) &&
6612  (ghBTRMgrDevHdlLastConnected == lstEventMessage.m_pairedDevice.m_deviceHandle)) {
6613 
6614  if (lstEventMessage.m_pairedDevice.m_deviceType == BTRMGR_DEVICE_TYPE_SMARTPHONE ||
6615  lstEventMessage.m_pairedDevice.m_deviceType == BTRMGR_DEVICE_TYPE_TABLET) {
6616  ghBTRMgrDevHdlLastConnected = 0;
6617  }
6618  else {
6619  //TODO: Add what to do for other device types
6620  }
6621  }
6622  }
6623  break;
6624  case enBTRCoreDevStLost:
6625  if( !gIsUserInitiated ) {
6626 
6627  btrMgr_MapDevstatusInfoToEventInfo ((void*)p_StatusCB, &lstEventMessage, BTRMGR_EVENT_DEVICE_OUT_OF_RANGE);
6628  if ((lstEventMessage.m_pairedDevice.m_deviceType == BTRMGR_DEVICE_TYPE_WEARABLE_HEADSET) ||
6629  (lstEventMessage.m_pairedDevice.m_deviceType == BTRMGR_DEVICE_TYPE_HANDSFREE) ||
6630  (lstEventMessage.m_pairedDevice.m_deviceType == BTRMGR_DEVICE_TYPE_LOUDSPEAKER) ||
6631  (lstEventMessage.m_pairedDevice.m_deviceType == BTRMGR_DEVICE_TYPE_HEADPHONES) ||
6632  (lstEventMessage.m_pairedDevice.m_deviceType == BTRMGR_DEVICE_TYPE_PORTABLE_AUDIO) ||
6633  (lstEventMessage.m_pairedDevice.m_deviceType == BTRMGR_DEVICE_TYPE_CAR_AUDIO) ||
6634  (lstEventMessage.m_pairedDevice.m_deviceType == BTRMGR_DEVICE_TYPE_HIFI_AUDIO_DEVICE)) {
6635 
6636  btrMgr_PreCheckDiscoveryStatus (0, BTRMGR_DEVICE_OP_TYPE_AUDIO_OUTPUT);
6637 
6638  if (gfpcBBTRMgrEventOut) {
6639  gfpcBBTRMgrEventOut(lstEventMessage); /* Post a callback */
6640  }
6641 
6642  if ((ghBTRMgrDevHdlCurStreaming != 0) && (ghBTRMgrDevHdlCurStreaming == p_StatusCB->deviceId)) {
6643  /* update the flags as the device is NOT Connected */
6644  btrMgr_SetDevConnected(lstEventMessage.m_pairedDevice.m_deviceHandle, 0);
6645 
6646  BTRMGRLOG_INFO ("lstEventMessage.m_pairedDevice.m_deviceType = %d\n", lstEventMessage.m_pairedDevice.m_deviceType);
6647  if (lstEventMessage.m_pairedDevice.m_deviceType == BTRMGR_DEVICE_TYPE_SMARTPHONE ||
6648  lstEventMessage.m_pairedDevice.m_deviceType == BTRMGR_DEVICE_TYPE_TABLET) {
6649  /* Stop the playback which already stopped internally but to free up the memory */
6650  BTRMGR_StopAudioStreamingIn(0, ghBTRMgrDevHdlCurStreaming);
6651  ghBTRMgrDevHdlLastConnected = 0;
6652  }
6653  else {
6654  /* Stop the playback which already stopped internally but to free up the memory */
6655  if (BTRMGR_RESULT_SUCCESS != BTRMGR_StopAudioStreamingOut (0, ghBTRMgrDevHdlCurStreaming)) {
6656  BTRMGRLOG_ERROR ("BTRMGR_StopAudioStreamingOut error \n "); //CID:41354 - Checked return
6657  }
6658  }
6659  }
6660  btrMgr_PostCheckDiscoveryStatus (0, BTRMGR_DEVICE_OP_TYPE_AUDIO_OUTPUT);
6661  }
6662  }
6663  gIsUserInitiated = 0;
6664  break;
6665  case enBTRCoreDevStPlaying:
6666  if (btrMgr_MapDeviceTypeFromCore(p_StatusCB->eDeviceClass) == BTRMGR_DEVICE_TYPE_SMARTPHONE ||
6667  btrMgr_MapDeviceTypeFromCore(p_StatusCB->eDeviceClass) == BTRMGR_DEVICE_TYPE_TABLET) {
6668  btrMgr_MapDevstatusInfoToEventInfo ((void*)p_StatusCB, &lstEventMessage, BTRMGR_EVENT_RECEIVED_EXTERNAL_PLAYBACK_REQUEST);
6669 
6670  if (gfpcBBTRMgrEventOut) {
6671  gfpcBBTRMgrEventOut(lstEventMessage); /* Post a callback */
6672  }
6673  }
6674  break;
6675  case enBTRCoreDevStOpReady:
6676  if (btrMgr_MapDeviceTypeFromCore(p_StatusCB->eDeviceClass) == BTRMGR_DEVICE_TYPE_TILE) {
6677  memset(lstEventMessage.m_deviceOpInfo.m_deviceAddress, '\0', BTRMGR_NAME_LEN_MAX);
6678  memset(lstEventMessage.m_deviceOpInfo.m_name, '\0', BTRMGR_NAME_LEN_MAX);
6679  memset(lstEventMessage.m_deviceOpInfo.m_uuid, '\0', BTRMGR_MAX_STR_LEN);
6680  btrMgr_MapDevstatusInfoToEventInfo ((void*)p_StatusCB, &lstEventMessage, BTRMGR_EVENT_DEVICE_OP_READY);
6681  //Not a big fan of devOpResponse. We should think of a better way to do this
6682  memset(lstEventMessage.m_deviceOpInfo.m_notifyData, '\0', BTRMGR_MAX_DEV_OP_DATA_LEN);
6683  strncpy(lstEventMessage.m_deviceOpInfo.m_notifyData, p_StatusCB->devOpResponse,
6684  strlen(p_StatusCB->devOpResponse) < BTRMGR_MAX_DEV_OP_DATA_LEN ? strlen(p_StatusCB->devOpResponse) : BTRMGR_MAX_DEV_OP_DATA_LEN - 1);
6685 
6686  /* Post a callback */
6687  if (gfpcBBTRMgrEventOut) {
6688  gfpcBBTRMgrEventOut(lstEventMessage);
6689  }
6690  }
6691  break;
6692  case enBTRCoreDevStOpInfo:
6693  if (btrMgr_MapDeviceTypeFromCore(p_StatusCB->eDeviceClass) == BTRMGR_DEVICE_TYPE_TILE) {
6694  memset(lstEventMessage.m_deviceOpInfo.m_deviceAddress, '\0', BTRMGR_NAME_LEN_MAX);
6695  memset(lstEventMessage.m_deviceOpInfo.m_name, '\0', BTRMGR_NAME_LEN_MAX);
6696  memset(lstEventMessage.m_deviceOpInfo.m_uuid, '\0', BTRMGR_MAX_STR_LEN);
6697  btrMgr_MapDevstatusInfoToEventInfo ((void*)p_StatusCB, &lstEventMessage, BTRMGR_EVENT_DEVICE_OP_INFORMATION);
6698  //Not a big fan of devOpResponse. We should think of a better way to do this
6699  memset(lstEventMessage.m_deviceOpInfo.m_notifyData, '\0', BTRMGR_MAX_DEV_OP_DATA_LEN);
6700  strncpy(lstEventMessage.m_deviceOpInfo.m_notifyData, p_StatusCB->devOpResponse,
6701  strlen(p_StatusCB->devOpResponse) < BTRMGR_MAX_DEV_OP_DATA_LEN ? strlen(p_StatusCB->devOpResponse) : BTRMGR_MAX_DEV_OP_DATA_LEN - 1);
6702 
6703  /* Post a callback */
6704  if (gfpcBBTRMgrEventOut) {
6705  gfpcBBTRMgrEventOut(lstEventMessage);
6706  }
6707  }
6708  else if (BTRMGR_LE_OP_READ_VALUE == (BTRMGR_LeOp_t)p_StatusCB->eCoreLeOper) {
6709  btrMgr_MapDevstatusInfoToEventInfo((void*)p_StatusCB, &lstEventMessage, BTRMGR_EVENT_DEVICE_OP_INFORMATION);
6710  /* Post a callback */
6711  if (gfpcBBTRMgrEventOut) {
6712  gfpcBBTRMgrEventOut(lstEventMessage);
6713  }
6714 
6715  /* Max 10 sec timeout - Polled at 100ms second interval */
6716  {
6717  unsigned int ui32sleepIdx = 100;
6718 
6719  do {
6720  usleep(100000);
6721  } while ((gEventRespReceived == 0) && (--ui32sleepIdx));
6722 
6723  }
6724 
6725  strncpy(p_StatusCB->devOpResponse, gLeReadOpResponse, BTRMGR_MAX_STR_LEN - 1);
6726  }
6727  else if(BTRMGR_LE_OP_WRITE_VALUE == (BTRMGR_LeOp_t)p_StatusCB->eCoreLeOper) {
6728  btrMgr_MapDevstatusInfoToEventInfo((void*)p_StatusCB, &lstEventMessage, BTRMGR_EVENT_DEVICE_OP_INFORMATION);
6729  memset(lstEventMessage.m_deviceOpInfo.m_writeData, '\0', BTRMGR_MAX_DEV_OP_DATA_LEN);
6730  strncpy(lstEventMessage.m_deviceOpInfo.m_writeData, p_StatusCB->devOpResponse,
6731  strlen(p_StatusCB->devOpResponse) < BTRMGR_MAX_DEV_OP_DATA_LEN ? strlen(p_StatusCB->devOpResponse) : BTRMGR_MAX_DEV_OP_DATA_LEN - 1);
6732 
6733  /* Post a callback */
6734  if (gfpcBBTRMgrEventOut) {
6735  gfpcBBTRMgrEventOut(lstEventMessage);
6736  }
6737  }
6738  else {
6739  }
6740  break;
6741  default:
6742  break;
6743  }
6744  }
6745 
6746  return lenBtrCoreRet;
6747 }
6748 
6749 
6750 static enBTRCoreRet
6751 btrMgr_DeviceDiscoveryCb (
6752  stBTRCoreDiscoveryCBInfo* astBTRCoreDiscoveryCbInfo,
6753  void* apvUserData
6754 ) {
6755  enBTRCoreRet lenBtrCoreRet = enBTRCoreSuccess;
6756 
6757  BTRMGRLOG_TRACE ("callback type = %d\n", astBTRCoreDiscoveryCbInfo->type);
6758 
6759  if (astBTRCoreDiscoveryCbInfo->type == enBTRCoreOpTypeDevice) {
6760  BTRMGR_DiscoveryHandle_t* ldiscoveryHdl = NULL;
6761 
6762  if ((ldiscoveryHdl = btrMgr_GetDiscoveryInProgress()) || (astBTRCoreDiscoveryCbInfo->device.bFound == FALSE)) { /* Not a big fan of this */
6763  if (ldiscoveryHdl &&
6764  (btrMgr_GetDiscoveryDeviceType(ldiscoveryHdl) == BTRMGR_DEVICE_OP_TYPE_AUDIO_OUTPUT)) {
6765  // Acceptable hack for DELIA-39526
6766  // We would have already reported a list of discovered devices to XRE/Client of BTRMgr if
6767  // they have requested for the same. But this list will be invalidated by the Resume and if
6768  // a Pairing Op is requested based on this stale information it will fail, but we will not end up
6769  // in a loop repeating the same sequence of events as we understand that on the first resume
6770  // Bluez/BTRCore will correctly give us the device Name. But if we get a new Audio-Out device which exhibits the
6771  // same behavior then we will repeat this again. As we do the above only for Audio-Out devices
6772  // non-Audio-Out devices cannot trigger this logic. So we will perform a focussed Audio-Out internal rescan
6773  if (((astBTRCoreDiscoveryCbInfo->device.enDeviceType == enBTRCore_DC_WearableHeadset) ||
6774  (astBTRCoreDiscoveryCbInfo->device.enDeviceType == enBTRCore_DC_Loudspeaker) ||
6775  (astBTRCoreDiscoveryCbInfo->device.enDeviceType == enBTRCore_DC_PortableAudio) ||
6776  (astBTRCoreDiscoveryCbInfo->device.enDeviceType == enBTRCore_DC_CarAudio) ||
6777  (astBTRCoreDiscoveryCbInfo->device.enDeviceType == enBTRCore_DC_HIFIAudioDevice) ||
6778  (astBTRCoreDiscoveryCbInfo->device.enDeviceType == enBTRCore_DC_Headphones)) &&
6779  (strlen(astBTRCoreDiscoveryCbInfo->device.pcDeviceName) == strlen(astBTRCoreDiscoveryCbInfo->device.pcDeviceAddress)) &&
6780  btrMgr_IsDevNameSameAsAddress(astBTRCoreDiscoveryCbInfo->device.pcDeviceName, astBTRCoreDiscoveryCbInfo->device.pcDeviceAddress, strlen(astBTRCoreDiscoveryCbInfo->device.pcDeviceName)) &&
6781  !btrMgr_CheckIfDevicePrevDetected(astBTRCoreDiscoveryCbInfo->device.tDeviceId)) {
6782 
6783  BTRMGR_DiscoveredDevicesList_t lstDiscDevices;
6784  eBTRMgrRet lenBtrMgrRet = eBTRMgrFailure;
6785  BTRMGR_Result_t lenBtrMgrResult = BTRMGR_RESULT_GENERIC_FAILURE;
6786 
6787  gIsDiscoveryOpInternal = TRUE;
6788  lenBtrMgrRet = btrMgr_PauseDeviceDiscovery(0, ldiscoveryHdl);
6789  BTRMGRLOG_WARN ("Called btrMgr_PauseDeviceDiscovery = %d\n", lenBtrMgrRet);
6790 
6791  lenBtrMgrResult = BTRMGR_GetDiscoveredDevices_Internal(0, &lstDiscDevices);
6792  BTRMGRLOG_WARN ("Stored BTRMGR_GetDiscoveredDevices_Internal = %d\n", lenBtrMgrResult);
6793 
6794  lenBtrMgrRet = btrMgr_ResumeDeviceDiscovery(0, ldiscoveryHdl);
6795  BTRMGRLOG_WARN ("Called btrMgr_ResumeDeviceDiscovery = %d\n", lenBtrMgrRet);
6796  }
6797  else {
6798  BTRMGR_EventMessage_t lstEventMessage;
6799  memset (&lstEventMessage, 0, sizeof(lstEventMessage));
6800 
6801  gIsDiscoveryOpInternal = FALSE;
6802  btrMgr_MapDevstatusInfoToEventInfo ((void*)&astBTRCoreDiscoveryCbInfo->device, &lstEventMessage, BTRMGR_EVENT_DEVICE_DISCOVERY_UPDATE);
6803 
6804  if (gfpcBBTRMgrEventOut) {
6805  gfpcBBTRMgrEventOut(lstEventMessage); /* Post a callback */
6806  }
6807  }
6808  }
6809  else {
6810  BTRMGR_EventMessage_t lstEventMessage;
6811  memset (&lstEventMessage, 0, sizeof(lstEventMessage));
6812 
6813  if (!gIsHidGamePadEnabled &&
6814  (astBTRCoreDiscoveryCbInfo->device.enDeviceType == enBTRCore_DC_HID_GamePad)) {
6815  BTRMGRLOG_WARN ("BTR HID Gamepad is currently Disabled!\n");
6816  return lenBtrCoreRet;
6817  }
6818 
6819  btrMgr_MapDevstatusInfoToEventInfo ((void*)&astBTRCoreDiscoveryCbInfo->device, &lstEventMessage, BTRMGR_EVENT_DEVICE_DISCOVERY_UPDATE);
6820 
6821  if (gfpcBBTRMgrEventOut) {
6822  gfpcBBTRMgrEventOut(lstEventMessage); /* Post a callback */
6823  }
6824  }
6825  }
6826  }
6827  else if (astBTRCoreDiscoveryCbInfo->type == enBTRCoreOpTypeAdapter) {
6828  BTRMGRLOG_INFO ("adapter number = %d, discoverable = %d, discovering = %d\n",
6829  astBTRCoreDiscoveryCbInfo->adapter.adapter_number,
6830  astBTRCoreDiscoveryCbInfo->adapter.discoverable,
6831  astBTRCoreDiscoveryCbInfo->adapter.bDiscovering);
6832 
6833  gIsAdapterDiscovering = astBTRCoreDiscoveryCbInfo->adapter.bDiscovering;
6834 
6835 #if 0
6836  if (gfpcBBTRMgrEventOut && (gIsDiscoveryOpInternal == FALSE)) {
6837  BTRMGR_EventMessage_t lstEventMessage;
6838  memset (&lstEventMessage, 0, sizeof(lstEventMessage));
6839 
6840  lstEventMessage.m_adapterIndex = astBTRCoreDiscoveryCbInfo->adapter.adapter_number;
6841  if (astBTRCoreDiscoveryCbInfo->adapter.bDiscovering) {
6842  lstEventMessage.m_eventType = BTRMGR_EVENT_DEVICE_DISCOVERY_STARTED;
6843  }
6844  else {
6845  lstEventMessage.m_eventType = BTRMGR_EVENT_DEVICE_DISCOVERY_COMPLETE;
6846  }
6847 
6848  gfpcBBTRMgrEventOut(lstEventMessage); /* Post a callback */
6849  }
6850 #endif
6851 
6852  }
6853 
6854  return lenBtrCoreRet;
6855 }
6856 
6857 
6858 static enBTRCoreRet
6859 btrMgr_ConnectionInIntimationCb (
6860  stBTRCoreConnCBInfo* apstConnCbInfo,
6861  int* api32ConnInIntimResp,
6862  void* apvUserData
6863 ) {
6864  enBTRCoreRet lenBtrCoreRet = enBTRCoreSuccess;
6865  BTRMGR_Result_t lenBtrMgrResult = BTRMGR_RESULT_SUCCESS;
6866  eBTRMgrRet lenBtrMgrRet = eBTRMgrSuccess;
6867  BTRMGR_DeviceType_t lBtrMgrDevType = BTRMGR_DEVICE_TYPE_UNKNOWN;
6868  BTRMGR_Events_t lBtMgrOutEvent = -1;
6869  unsigned char lui8AdapterIdx = 0;
6870  BTRMGR_EventMessage_t lstEventMessage;
6871 
6872  if (!apstConnCbInfo) {
6873  BTRMGRLOG_ERROR ("Invaliid argument\n");
6874  return enBTRCoreInvalidArg;
6875  }
6876 
6877  lBtrMgrDevType = btrMgr_MapDeviceTypeFromCore(apstConnCbInfo->stFoundDevice.enDeviceType);
6878  if(! ((BTRMGR_DEVICE_TYPE_HID == lBtrMgrDevType) || (BTRMGR_DEVICE_TYPE_HID_GAMEPAD == lBtrMgrDevType ))) {
6879  if (!gIsAudioInEnabled) {
6880  BTRMGRLOG_WARN ("Incoming Connection Rejected - BTR AudioIn is currently Disabled!\n");
6881  *api32ConnInIntimResp = 0;
6882  return lenBtrCoreRet;
6883  }
6884  }
6885 
6886  lenBtrMgrRet = btrMgr_PreCheckDiscoveryStatus(lui8AdapterIdx, lBtrMgrDevType);
6887 
6888  if (eBTRMgrSuccess != lenBtrMgrRet) {
6889  BTRMGRLOG_ERROR ("Pre Check Discovery State Rejected !!!\n");
6890  return enBTRCoreFailure;
6891  }
6892 
6893  if (apstConnCbInfo->ui32devPassKey) {
6894  BTRMGRLOG_WARN ("Incoming Connection passkey = %06d\n", apstConnCbInfo->ui32devPassKey);
6895  }
6896 
6897  memset (&lstEventMessage, 0, sizeof(lstEventMessage));
6898  btrMgr_MapDevstatusInfoToEventInfo ((void*)apstConnCbInfo, &lstEventMessage, BTRMGR_EVENT_RECEIVED_EXTERNAL_PAIR_REQUEST);
6899 
6900  /* We mustn't need this conditional check; We must always reset the globals before invoking the Callbacks. But as per code review comments, resetting it only for HID */
6901  if ((BTRMGR_DEVICE_TYPE_HID == lBtrMgrDevType) || (BTRMGR_DEVICE_TYPE_HID_GAMEPAD == lBtrMgrDevType)) {
6902  gEventRespReceived = 0;
6903  gAcceptConnection = 0;
6904  }
6905 
6906  if (gfpcBBTRMgrEventOut) {
6907  gfpcBBTRMgrEventOut(lstEventMessage); /* Post a callback */
6908  }
6909 
6910  /* Used for PIN DISPLAY request */
6911  if (!apstConnCbInfo->ucIsReqConfirmation) {
6912  BTRMGRLOG_WARN ("This paring request does not require a confirmation BUT it might need you to enter the PIN at the specified device\n");
6913  /* Set the return to true; just in case */
6914  *api32ConnInIntimResp = 1;
6915  btrMgr_PostCheckDiscoveryStatus (lui8AdapterIdx, lBtrMgrDevType);
6916  return lenBtrCoreRet;
6917  }
6918 
6919  /* Max 25 sec timeout - Polled at 500ms second interval */
6920  {
6921  unsigned int ui32sleepIdx = 50;
6922 
6923  do {
6924  usleep(500000);
6925  } while ((gEventRespReceived == 0) && (--ui32sleepIdx));
6926 
6927  }
6928 
6929  BTRMGRLOG_ERROR ("you picked %d\n", gAcceptConnection);
6930  if (gEventRespReceived && gAcceptConnection == 1) {
6931  BTRMGRLOG_ERROR ("Pin-Passkey accepted\n");
6932  gAcceptConnection = 0; //reset variabhle for the next connection
6933  *api32ConnInIntimResp = 1;
6934  }
6935  else {
6936  BTRMGRLOG_ERROR ("Pin-Passkey Rejected\n");
6937  gAcceptConnection = 0; //reset variabhle for the next connection
6938  *api32ConnInIntimResp = 0;
6939  }
6940 
6941  gEventRespReceived = 0;
6942 
6943  if (*api32ConnInIntimResp == 1) {
6944  BTRMGRLOG_INFO ("Paired Successfully\n");
6945  lenBtrMgrResult = BTRMGR_RESULT_SUCCESS;
6946  lBtMgrOutEvent = BTRMGR_EVENT_DEVICE_PAIRING_COMPLETE;
6947  }
6948  else {
6949  BTRMGRLOG_ERROR ("Failed to pair a device\n");
6950  lenBtrMgrResult = BTRMGR_RESULT_GENERIC_FAILURE;
6951  lBtMgrOutEvent = BTRMGR_EVENT_DEVICE_PAIRING_FAILED;
6952  }
6953 
6954 
6955  lstEventMessage.m_adapterIndex = lui8AdapterIdx;
6956  lstEventMessage.m_eventType = lBtMgrOutEvent;
6957 
6958  if (gfpcBBTRMgrEventOut) {
6959  gfpcBBTRMgrEventOut(lstEventMessage); /* Post a callback */
6960  }
6961 
6962  btrMgr_PostCheckDiscoveryStatus (lui8AdapterIdx, lBtrMgrDevType);
6963 
6964  (void)lenBtrMgrResult;
6965 
6966  return lenBtrCoreRet;
6967 }
6968 
6969 
6970 static enBTRCoreRet
6971 btrMgr_ConnectionInAuthenticationCb (
6972  stBTRCoreConnCBInfo* apstConnCbInfo,
6973  int* api32ConnInAuthResp,
6974  void* apvUserData
6975 ) {
6976  enBTRCoreRet lenBtrCoreRet = enBTRCoreSuccess;
6977  eBTRMgrRet lenBtrMgrRet = eBTRMgrSuccess;
6978  BTRMGR_DeviceType_t lBtrMgrDevType = BTRMGR_DEVICE_TYPE_UNKNOWN;
6979  unsigned char lui8AdapterIdx = 0;
6980 
6981 
6982  if (!apstConnCbInfo) {
6983  BTRMGRLOG_ERROR ("Invaliid argument\n");
6984  return enBTRCoreInvalidArg;
6985  }
6986 
6987  lBtrMgrDevType = btrMgr_MapDeviceTypeFromCore(apstConnCbInfo->stKnownDevice.enDeviceType);
6988  /* Move this check into DeviceClass scope? */
6989  lenBtrMgrRet = btrMgr_PreCheckDiscoveryStatus(lui8AdapterIdx, lBtrMgrDevType);
6990 
6991  if (eBTRMgrSuccess != lenBtrMgrRet) {
6992  BTRMGRLOG_ERROR ("Pre Check Discovery State Rejected !!!\n");
6993  return enBTRCoreFailure;
6994  }
6995 
6996 
6997  if (apstConnCbInfo->stKnownDevice.enDeviceType == enBTRCore_DC_SmartPhone ||
6998  apstConnCbInfo->stKnownDevice.enDeviceType == enBTRCore_DC_Tablet) {
6999 
7000  if (!gIsAudioInEnabled) {
7001  BTRMGRLOG_WARN ("Incoming Connection Rejected - BTR AudioIn is currently Disabled!\n");
7002  *api32ConnInAuthResp = 0;
7003  btrMgr_PostCheckDiscoveryStatus (lui8AdapterIdx, lBtrMgrDevType);
7004  return lenBtrCoreRet;
7005  }
7006 
7007  BTRMGRLOG_WARN ("Incoming Connection from BT SmartPhone/Tablet\n");
7008 
7009  if (apstConnCbInfo->stKnownDevice.tDeviceId != ghBTRMgrDevHdlLastConnected) {
7010  BTRMGR_EventMessage_t lstEventMessage;
7011 
7012  memset (&lstEventMessage, 0, sizeof(lstEventMessage));
7013  btrMgr_MapDevstatusInfoToEventInfo ((void*)apstConnCbInfo, &lstEventMessage, BTRMGR_EVENT_RECEIVED_EXTERNAL_CONNECT_REQUEST);
7014 
7015  if (gfpcBBTRMgrEventOut) {
7016  gfpcBBTRMgrEventOut(lstEventMessage); /* Post a callback */
7017  }
7018 
7019  /* PairedList updation is necessary for Connect event than Disconnect event */
7020  BTRMGR_GetPairedDevices (lstEventMessage.m_adapterIndex, &gListOfPairedDevices);
7021 
7022 
7023  { /* Max 25 sec timeout - Polled at 500ms second interval */
7024  unsigned int ui32sleepIdx = 50;
7025 
7026  do {
7027  usleep(500000);
7028  } while ((gEventRespReceived == 0) && (--ui32sleepIdx));
7029  }
7030 
7031 
7032  if (gEventRespReceived == 1) {
7033  BTRMGRLOG_ERROR ("you picked %d\n", gAcceptConnection);
7034  if (gAcceptConnection == 1) {
7035  BTRMGRLOG_WARN ("Incoming Connection accepted\n");
7036 
7037  if (ghBTRMgrDevHdlLastConnected) {
7038  BTRMGRLOG_DEBUG ("Disconnecting from previous AudioIn connection(%llu)!\n", ghBTRMgrDevHdlLastConnected);
7039 
7040  if (BTRMGR_RESULT_SUCCESS != BTRMGR_DisconnectFromDevice(0, ghBTRMgrDevHdlLastConnected)) {
7041  BTRMGRLOG_ERROR ("Failed to Disconnect from previous AudioIn connection(%llu)!\n", ghBTRMgrDevHdlLastConnected);
7042  //return lenBtrCoreRet;
7043  }
7044  }
7045 
7046  ghBTRMgrDevHdlLastConnected = lstEventMessage.m_externalDevice.m_deviceHandle;
7047  }
7048  else {
7049  BTRMGRLOG_ERROR ("Incoming Connection denied\n");
7050  }
7051 
7052  *api32ConnInAuthResp = gAcceptConnection;
7053  }
7054  else {
7055  BTRMGRLOG_ERROR ("Incoming Connection Rejected\n");
7056  *api32ConnInAuthResp = 0;
7057  }
7058 
7059  gEventRespReceived = 0;
7060  }
7061  else {
7062  BTRMGRLOG_ERROR ("Incoming Connection From Dev = %lld Status %d LastConnectedDev = %lld\n", apstConnCbInfo->stKnownDevice.tDeviceId, gAcceptConnection, ghBTRMgrDevHdlLastConnected);
7063  *api32ConnInAuthResp = gAcceptConnection;
7064  }
7065  }
7066  else if ((apstConnCbInfo->stKnownDevice.enDeviceType == enBTRCore_DC_WearableHeadset) ||
7067  (apstConnCbInfo->stKnownDevice.enDeviceType == enBTRCore_DC_Loudspeaker) ||
7068  (apstConnCbInfo->stKnownDevice.enDeviceType == enBTRCore_DC_PortableAudio) ||
7069  (apstConnCbInfo->stKnownDevice.enDeviceType == enBTRCore_DC_CarAudio) ||
7070  (apstConnCbInfo->stKnownDevice.enDeviceType == enBTRCore_DC_HIFIAudioDevice) ||
7071  (apstConnCbInfo->stKnownDevice.enDeviceType == enBTRCore_DC_Headphones)) {
7072 
7073  BTRMGRLOG_WARN ("Incoming Connection from BT Speaker/Headset\n");
7074  if (btrMgr_GetDevPaired(apstConnCbInfo->stKnownDevice.tDeviceId) && (apstConnCbInfo->stKnownDevice.tDeviceId == ghBTRMgrDevHdlLastConnected)) {
7075 
7076  BTRMGRLOG_DEBUG ("Paired - Last Connected device...\n");
7077 
7078  if (gIsAudOutStartupInProgress != BTRMGR_STARTUP_AUD_INPROGRESS) {
7079  BTRMGR_EventMessage_t lstEventMessage;
7080 
7081  memset (&lstEventMessage, 0, sizeof(lstEventMessage));
7082  btrMgr_MapDevstatusInfoToEventInfo ((void*)apstConnCbInfo, &lstEventMessage, BTRMGR_EVENT_RECEIVED_EXTERNAL_CONNECT_REQUEST);
7083 
7084  //TODO: Check if XRE wants to bring up a Pop-up or Respond
7085  if (gfpcBBTRMgrEventOut) {
7086  gfpcBBTRMgrEventOut(lstEventMessage); /* Post a callback */
7087  }
7088 
7089 
7090  { /* Max 200msec timeout - Polled at 50ms second interval */
7091  unsigned int ui32sleepIdx = 4;
7092 
7093  do {
7094  usleep(50000);
7095  } while ((gEventRespReceived == 0) && (--ui32sleepIdx));
7096 
7097  gEventRespReceived = 0;
7098  }
7099  }
7100 
7101  BTRMGRLOG_WARN ("Incoming Connection accepted\n");
7102  *api32ConnInAuthResp = 1;
7103  }
7104  else {
7105  BTRMGRLOG_ERROR ("Incoming Connection denied\n");
7106  *api32ConnInAuthResp = 0;
7107  }
7108  }
7109  else if ((apstConnCbInfo->stKnownDevice.enDeviceType == enBTRCore_DC_HID_Keyboard) ||
7110  (apstConnCbInfo->stKnownDevice.enDeviceType == enBTRCore_DC_HID_Mouse) ||
7111  (apstConnCbInfo->stKnownDevice.enDeviceType == enBTRCore_DC_HID_MouseKeyBoard) ||
7112  (apstConnCbInfo->stKnownDevice.enDeviceType == enBTRCore_DC_HID_AudioRemote) ||
7113  (apstConnCbInfo->stKnownDevice.enDeviceType == enBTRCore_DC_HID_Joystick) ||
7114  (apstConnCbInfo->stKnownDevice.enDeviceType == enBTRCore_DC_HID_GamePad)) {
7115 
7116 
7117  if ((!gIsHidGamePadEnabled) && (apstConnCbInfo->stKnownDevice.enDeviceType == enBTRCore_DC_HID_GamePad)) {
7118  BTRMGRLOG_WARN ("Incoming Connection Rejected - BTR GamePad is currently Disabled!\n");
7119  *api32ConnInAuthResp = 0;
7120  btrMgr_PostCheckDiscoveryStatus (lui8AdapterIdx, lBtrMgrDevType);
7121  return lenBtrCoreRet;
7122  }
7123 
7124  BTRMGRLOG_WARN ("Incoming Connection from BT HID device\n");
7125  /* PairedList updation is necessary for Connect event than Disconnect event */
7126  BTRMGR_GetPairedDevices (gDefaultAdapterContext.adapter_number, &gListOfPairedDevices);
7127 
7128  if (btrMgr_GetDevPaired(apstConnCbInfo->stKnownDevice.tDeviceId)) {
7129  BTRMGR_EventMessage_t lstEventMessage;
7130 
7131  memset (&lstEventMessage, 0, sizeof(lstEventMessage));
7132  btrMgr_MapDevstatusInfoToEventInfo ((void*)apstConnCbInfo, &lstEventMessage, BTRMGR_EVENT_RECEIVED_EXTERNAL_CONNECT_REQUEST);
7133 
7134  //TODO: Check if XRE wants to bring up a Pop-up or Respond
7135  if (gfpcBBTRMgrEventOut) {
7136  gfpcBBTRMgrEventOut(lstEventMessage); /* Post a callback */
7137  }
7138 
7139 
7140  { /* Max 2 sec timeout - Polled at 50ms second interval */
7141  unsigned int ui32sleepIdx = 40;
7142 
7143  do {
7144  usleep(50000);
7145  } while ((gEventRespReceived == 0) && (--ui32sleepIdx));
7146 
7147 
7148  if (gEventRespReceived == 0)
7149  *api32ConnInAuthResp = 1;
7150  else
7151  *api32ConnInAuthResp = gAcceptConnection;
7152 
7153 
7154  gEventRespReceived = 0;
7155  }
7156 
7157  BTRMGRLOG_WARN ("Incoming Connection accepted - %d\n", *api32ConnInAuthResp);
7158  }
7159  else {
7160  BTRMGRLOG_ERROR ("Incoming Connection denied\n");
7161  *api32ConnInAuthResp = 0;
7162  }
7163  }
7164  else
7165  {
7166  BTRMGRLOG_ERROR ("Incoming Connection Auth Callback\n");
7167  }
7168 
7169  btrMgr_PostCheckDiscoveryStatus (lui8AdapterIdx, lBtrMgrDevType);
7170 
7171  return lenBtrCoreRet;
7172 }
7173 
7174 
7175 static enBTRCoreRet
7176 btrMgr_MediaStatusCb (
7177  stBTRCoreMediaStatusCBInfo* mediaStatusCB,
7178  void* apvUserData
7179 ) {
7180  enBTRCoreRet lenBtrCoreRet = enBTRCoreSuccess;
7181  BTRMGR_EventMessage_t lstEventMessage;
7182 
7183  memset (&lstEventMessage, 0, sizeof(lstEventMessage));
7184 
7185  BTRMGRLOG_INFO ("Received media status callback\n");
7186 
7187  if (mediaStatusCB) {
7188  stBTRCoreMediaStatusUpdate* mediaStatus = &mediaStatusCB->m_mediaStatusUpdate;
7189 
7190  lstEventMessage.m_mediaInfo.m_deviceHandle = mediaStatusCB->deviceId;
7191  lstEventMessage.m_mediaInfo.m_deviceType = btrMgr_MapDeviceTypeFromCore(mediaStatusCB->eDeviceClass);
7192  strncpy (lstEventMessage.m_mediaInfo.m_name, mediaStatusCB->deviceName, BTRMGR_NAME_LEN_MAX -1);
7193  lstEventMessage.m_mediaInfo.m_name[BTRMGR_NAME_LEN_MAX -1] = '\0'; //CID:136544 - Buffer size warning
7194 
7195  switch (mediaStatus->eBTMediaStUpdate) {
7196  case eBTRCoreMediaTrkStStarted:
7197  lstEventMessage.m_eventType = BTRMGR_EVENT_MEDIA_TRACK_STARTED;
7198  gMediaPlaybackStPrev = lstEventMessage.m_eventType;
7199  memcpy(&lstEventMessage.m_mediaInfo.m_mediaPositionInfo, &mediaStatus->m_mediaPositionInfo, sizeof(BTRMGR_MediaPositionInfo_t));
7200  break;
7201  case eBTRCoreMediaTrkStPlaying:
7202  lstEventMessage.m_eventType = BTRMGR_EVENT_MEDIA_TRACK_PLAYING;
7203  gMediaPlaybackStPrev = lstEventMessage.m_eventType;
7204  memcpy(&lstEventMessage.m_mediaInfo.m_mediaPositionInfo, &mediaStatus->m_mediaPositionInfo, sizeof(BTRMGR_MediaPositionInfo_t));
7205  break;
7206  case eBTRCoreMediaTrkStPaused:
7207  lstEventMessage.m_eventType = BTRMGR_EVENT_MEDIA_TRACK_PAUSED;
7208  gMediaPlaybackStPrev = lstEventMessage.m_eventType;
7209  memcpy(&lstEventMessage.m_mediaInfo.m_mediaPositionInfo, &mediaStatus->m_mediaPositionInfo, sizeof(BTRMGR_MediaPositionInfo_t));
7210  break;
7211  case eBTRCoreMediaTrkStStopped:
7212  lstEventMessage.m_eventType = BTRMGR_EVENT_MEDIA_TRACK_STOPPED;
7213  gMediaPlaybackStPrev = lstEventMessage.m_eventType;
7214  memcpy(&lstEventMessage.m_mediaInfo.m_mediaPositionInfo, &mediaStatus->m_mediaPositionInfo, sizeof(BTRMGR_MediaPositionInfo_t));
7215  break;
7216  case eBTRCoreMediaTrkPosition:
7217  lstEventMessage.m_eventType = BTRMGR_EVENT_MEDIA_TRACK_POSITION;
7218  gMediaPlaybackStPrev = lstEventMessage.m_eventType;
7219  memcpy(&lstEventMessage.m_mediaInfo.m_mediaPositionInfo, &mediaStatus->m_mediaPositionInfo, sizeof(BTRMGR_MediaPositionInfo_t));
7220  break;
7221  case eBTRCoreMediaTrkStChanged:
7222  lstEventMessage.m_eventType = BTRMGR_EVENT_MEDIA_TRACK_CHANGED;
7223  gMediaPlaybackStPrev = lstEventMessage.m_eventType;
7224  memcpy(&lstEventMessage.m_mediaInfo.m_mediaTrackInfo, &mediaStatus->m_mediaTrackInfo, sizeof(BTRMGR_MediaTrackInfo_t));
7225  break;
7226  case eBTRCoreMediaPlaybackEnded:
7227  lstEventMessage.m_eventType = BTRMGR_EVENT_MEDIA_PLAYBACK_ENDED;
7228  gMediaPlaybackStPrev = lstEventMessage.m_eventType;
7229  break;
7230  case eBTRCoreMediaPlyrName:
7231  lstEventMessage.m_eventType = BTRMGR_EVENT_MEDIA_PLAYER_NAME;
7232  strncpy (lstEventMessage.m_mediaInfo.m_mediaPlayerName, mediaStatus->m_mediaPlayerName, BTRMGR_MAX_STR_LEN -1);
7233  break;
7234  case eBTRCoreMediaPlyrEqlzrStOff:
7235  lstEventMessage.m_eventType = BTRMGR_EVENT_MEDIA_PLAYER_EQUALIZER_OFF;
7236  break;
7237  case eBTRCoreMediaPlyrEqlzrStOn:
7238  lstEventMessage.m_eventType = BTRMGR_EVENT_MEDIA_PLAYER_EQUALIZER_ON;
7239  break;
7240  case eBTRCoreMediaPlyrShflStOff:
7241  lstEventMessage.m_eventType = BTRMGR_EVENT_MEDIA_PLAYER_SHUFFLE_OFF;
7242  break;
7243  case eBTRCoreMediaPlyrShflStAllTracks:
7244  lstEventMessage.m_eventType = BTRMGR_EVENT_MEDIA_PLAYER_SHUFFLE_ALLTRACKS;
7245  break;
7246  case eBTRCoreMediaPlyrShflStGroup:
7247  lstEventMessage.m_eventType = BTRMGR_EVENT_MEDIA_PLAYER_SHUFFLE_GROUP;
7248  break;
7249  case eBTRCoreMediaPlyrRptStOff:
7250  lstEventMessage.m_eventType = BTRMGR_EVENT_MEDIA_PLAYER_REPEAT_OFF;
7251  break;
7252  case eBTRCoreMediaPlyrRptStSingleTrack:
7253  lstEventMessage.m_eventType = BTRMGR_EVENT_MEDIA_PLAYER_REPEAT_SINGLETRACK;
7254  break;
7255  case eBTRCoreMediaPlyrRptStAllTracks:
7256  lstEventMessage.m_eventType = BTRMGR_EVENT_MEDIA_PLAYER_REPEAT_ALLTRACKS;
7257  break;
7258  case eBTRCoreMediaPlyrRptStGroup:
7259  lstEventMessage.m_eventType = BTRMGR_EVENT_MEDIA_PLAYER_REPEAT_GROUP;
7260  break;
7261  case eBTRCoreMediaPlyrVolume:
7262  if ((lstEventMessage.m_mediaInfo.m_deviceType == BTRMGR_DEVICE_TYPE_WEARABLE_HEADSET) ||
7263  (lstEventMessage.m_mediaInfo.m_deviceType == BTRMGR_DEVICE_TYPE_HANDSFREE) ||
7264  (lstEventMessage.m_mediaInfo.m_deviceType == BTRMGR_DEVICE_TYPE_LOUDSPEAKER) ||
7265  (lstEventMessage.m_mediaInfo.m_deviceType == BTRMGR_DEVICE_TYPE_HEADPHONES) ||
7266  (lstEventMessage.m_mediaInfo.m_deviceType == BTRMGR_DEVICE_TYPE_PORTABLE_AUDIO) ||
7267  (lstEventMessage.m_mediaInfo.m_deviceType == BTRMGR_DEVICE_TYPE_CAR_AUDIO) ||
7268  (lstEventMessage.m_mediaInfo.m_deviceType == BTRMGR_DEVICE_TYPE_HIFI_AUDIO_DEVICE)) {
7269 
7270  gboolean lbMuted = FALSE;
7271  unsigned char lui8Volume = BTRMGR_SO_MAX_VOLUME - 1;
7272 
7273 #ifdef RDKTV_PERSIST_VOLUME_SKY
7274  if (btrMgr_GetLastVolume(0, &lui8Volume) == eBTRMgrSuccess) {
7275  }
7276 
7277  if (btrMgr_GetLastMuteState(0, &lbMuted) == eBTRMgrSuccess) {
7278  }
7279 
7280  if (btrMgr_SetLastVolume(0, mediaStatus->m_mediaPlayerVolume) == eBTRMgrSuccess) {
7281  }
7282 #endif
7283  lstEventMessage.m_eventType = BTRMGR_EVENT_DEVICE_MEDIA_STATUS;
7284  lstEventMessage.m_mediaInfo.m_mediaDevStatus.m_ui8mediaDevVolume = mediaStatus->m_mediaPlayerVolume;
7285  lstEventMessage.m_mediaInfo.m_mediaDevStatus.m_ui8mediaDevMute = (unsigned char)lbMuted;
7286  gui8IsSoDevAvrcpSupported = 1; // TODO: Find a better way to do this
7287 
7288  if (mediaStatus->m_mediaPlayerVolume > lui8Volume)
7289  lstEventMessage.m_mediaInfo.m_mediaDevStatus.m_enmediaCtrlCmd = BTRMGR_MEDIA_CTRL_VOLUMEUP;
7290  else if (mediaStatus->m_mediaPlayerVolume < lui8Volume)
7291  lstEventMessage.m_mediaInfo.m_mediaDevStatus.m_enmediaCtrlCmd = BTRMGR_MEDIA_CTRL_VOLUMEDOWN;
7292  else
7293  lstEventMessage.m_mediaInfo.m_mediaDevStatus.m_enmediaCtrlCmd = BTRMGR_MEDIA_CTRL_UNKNOWN;
7294 
7295  }
7296  else {
7297  lstEventMessage.m_eventType = BTRMGR_EVENT_MEDIA_PLAYER_VOLUME;
7298  lstEventMessage.m_mediaInfo.m_mediaPlayerVolume = mediaStatus->m_mediaPlayerVolume;
7299  }
7300  break;
7301 
7302  case eBTRCoreMediaElementInScope:
7303  switch (mediaStatus->m_mediaElementInfo.eAVMedElementType) {
7304  case enBTRCoreMedETypeAlbum:
7305  lstEventMessage.m_eventType = BTRMGR_EVENT_MEDIA_ALBUM_INFO;
7306  break;
7307  case enBTRCoreMedETypeArtist:
7308  lstEventMessage.m_eventType = BTRMGR_EVENT_MEDIA_ARTIST_INFO;
7309  break;
7310  case enBTRCoreMedETypeGenre:
7311  lstEventMessage.m_eventType = BTRMGR_EVENT_MEDIA_GENRE_INFO;
7312  break;
7313  case enBTRCoreMedETypeCompilation:
7314  lstEventMessage.m_eventType = BTRMGR_EVENT_MEDIA_COMPILATION_INFO;
7315  break;
7316  case enBTRCoreMedETypePlayList:
7317  lstEventMessage.m_eventType = BTRMGR_EVENT_MEDIA_PLAYLIST_INFO;
7318  break;
7319  case enBTRCoreMedETypeTrackList:
7320  lstEventMessage.m_eventType = BTRMGR_EVENT_MEDIA_TRACKLIST_INFO;
7321  break;
7322  case enBTRCoreMedETypeTrack:
7323  lstEventMessage.m_eventType = BTRMGR_EVENT_MEDIA_TRACK_INFO;
7324  break;
7325  default:
7326  break;
7327  }
7328 
7329  lstEventMessage.m_mediaInfo.m_mediaTrackListInfo.m_numberOfElements = 1;
7330  lstEventMessage.m_mediaInfo.m_mediaTrackListInfo.m_mediaElementInfo[0].m_mediaElementHdl = mediaStatus->m_mediaElementInfo.ui32MediaElementId;
7331 
7332  if ((lstEventMessage.m_mediaInfo.m_mediaTrackListInfo.m_mediaElementInfo[0].m_IsPlayable = mediaStatus->m_mediaElementInfo.bIsPlayable)) {
7333  memcpy (&lstEventMessage.m_mediaInfo.m_mediaTrackListInfo.m_mediaElementInfo[0].m_mediaTrackInfo, &mediaStatus->m_mediaElementInfo.m_mediaTrackInfo, sizeof(BTRMGR_MediaTrackInfo_t));
7334  }
7335  else {
7336  strncpy (lstEventMessage.m_mediaInfo.m_mediaTrackListInfo.m_mediaElementInfo[0].m_mediaElementName, mediaStatus->m_mediaElementInfo.m_mediaElementName, BTRMGR_MAX_STR_LEN -1);
7337  }
7338  break;
7339  case eBTRCoreMediaElementOofScope:
7340  lstEventMessage.m_eventType = BTRMGR_EVENT_MAX;
7341  break;
7342 
7343  default:
7344  break;
7345  }
7346 
7347 
7348  if (gfpcBBTRMgrEventOut) {
7349  gfpcBBTRMgrEventOut(lstEventMessage); /* Post a callback */
7350  }
7351 
7352 
7353  switch (mediaStatus->eBTMediaStUpdate) {
7354  case eBTRCoreMediaTrkStStarted:
7355  break;
7356  case eBTRCoreMediaTrkStPlaying:
7357  break;
7358  case eBTRCoreMediaTrkStPaused:
7359  break;
7360  case eBTRCoreMediaTrkStStopped:
7361  break;
7362  case eBTRCoreMediaTrkPosition:
7363  break;
7364  case eBTRCoreMediaTrkStChanged:
7365  break;
7366  case eBTRCoreMediaPlaybackEnded:
7367  break;
7368  case eBTRCoreMediaPlyrName:
7369  break;
7370  case eBTRCoreMediaPlyrEqlzrStOff:
7371  break;
7372  case eBTRCoreMediaPlyrEqlzrStOn:
7373  break;
7374  case eBTRCoreMediaPlyrShflStOff:
7375  break;
7376  case eBTRCoreMediaPlyrShflStAllTracks:
7377  break;
7378  case eBTRCoreMediaPlyrShflStGroup:
7379  break;
7380  case eBTRCoreMediaPlyrRptStOff:
7381  break;
7382  case eBTRCoreMediaPlyrRptStSingleTrack:
7383  break;
7384  case eBTRCoreMediaPlyrRptStAllTracks:
7385  break;
7386  case eBTRCoreMediaPlyrRptStGroup:
7387  break;
7388  case eBTRCoreMediaPlyrVolume:
7389  {
7390  stBTRMgrMediaStatus lstBtrMgrSiStatus;
7391 
7392  lstBtrMgrSiStatus.eBtrMgrState = eBTRMgrStateUnknown;
7393  lstBtrMgrSiStatus.eBtrMgrSFreq = eBTRMgrSFreqUnknown;
7394  lstBtrMgrSiStatus.eBtrMgrSFmt = eBTRMgrSFmtUnknown;
7395  lstBtrMgrSiStatus.eBtrMgrAChan = eBTRMgrAChanUnknown;
7396  lstBtrMgrSiStatus.ui8Volume = mediaStatus->m_mediaPlayerVolume;
7397 
7398  if (gstBTRMgrStreamingInfo.hBTRMgrSiHdl &&
7399  ((lstEventMessage.m_mediaInfo.m_deviceType == BTRMGR_DEVICE_TYPE_SMARTPHONE) ||
7400  (lstEventMessage.m_mediaInfo.m_deviceType == BTRMGR_DEVICE_TYPE_TABLET))) {
7401  if (BTRMgr_SI_SetStatus(gstBTRMgrStreamingInfo.hBTRMgrSiHdl, &lstBtrMgrSiStatus) != eBTRMgrSuccess) {
7402  BTRMGRLOG_WARN ("BTRMgr_SI_SetStatus FAILED - eBTRCoreMediaPlyrVolume\n");
7403  }
7404  }
7405  }
7406  break;
7407  case eBTRCoreMediaElementInScope:
7408  break;
7409  case eBTRCoreMediaElementOofScope:
7410  break;
7411  default:
7412  break;
7413  }
7414 
7415  }
7416 
7417  return lenBtrCoreRet;
7418 }
7419 
7420 /* End of File */
_stBTRMgrSBCInfo::eBtrMgrSbcSFreq
eBTRMgrSFreq eBtrMgrSbcSFreq
frequency
Definition: btrMgr_mediaTypes.h:115
BTRCore_GetAdapterAddr
enBTRCoreRet BTRCore_GetAdapterAddr(tBTRCoreHandle hBTRCore, unsigned char aui8adapterIdx, char *apui8adapterAddr)
This API gets Address of BT Adapter.
Definition: btrCore.c:3065
_stBTRMgrSBCInfo
Represents the Subband coding (SBC) audio codec information.
Definition: btrMgr_mediaTypes.h:114
BTRMGR_GetMediaCurrentPosition
BTRMGR_Result_t BTRMGR_GetMediaCurrentPosition(unsigned char aui8AdapterIdx, BTRMgrDeviceHandle ahBTRMgrDevHdl, BTRMGR_MediaPositionInfo_t *mediaPositionInfo)
This API fetches the current position and total duration of the media.
Definition: btrMgr.c:5251
_stBTRCoreBTDevice
Definition: btrCore.h:318
BTRCore_SetEnableTxPower
enBTRCoreRet BTRCore_SetEnableTxPower(tBTRCoreHandle hBTRCore, BOOLEAN lTxPower)
This API is used to Enable Tx Power transmission.
Definition: btrCore.c:5454
_stBTRMgrMPEGInfo::ui16MpegBitrate
unsigned short ui16MpegBitrate
bitrate
Definition: btrMgr_mediaTypes.h:136
btrMgr_Types.h
BTRCore_Init
enBTRCoreRet BTRCore_Init(tBTRCoreHandle *phBTRCore)
This API connects to a bus daemon and registers the client with it.
Definition: btrCore.c:2494
stBTRMgrMPEGInfo
struct _stBTRMgrMPEGInfo stBTRMgrMPEGInfo
Represents the MPEG codec details.
BOOLEAN
unsigned char BOOLEAN
DTCP Manager return codes.
Definition: dtcpmgr.h:163
_BTRMGR_DiscoveredDevices_t
Represents the discovered device's details.
Definition: btmgr.h:449
BTRMgr_SO_SetMute
eBTRMgrRet BTRMgr_SO_SetMute(tBTRMgrSoHdl hBTRMgrSoHdl, gboolean Mute)
This API will set the Mute used by this interface.
Definition: btrMgr_streamOut.c:325
BTRMgr_SI_Start
eBTRMgrRet BTRMgr_SI_Start(tBTRMgrSiHdl hBTRMgrSiHdl, int aiInBufMaxSize, stBTRMgrInASettings *apstBtrMgrSiInASettings)
This API uses BTRMgr_SI_GstStart(), starts the pipeline.
Definition: btrMgr_streamIn.c:272
BTRCore_DisableAdapter
enBTRCoreRet BTRCore_DisableAdapter(tBTRCoreHandle hBTRCore, stBTRCoreAdapter *apstBTRCoreAdapter)
This API disables specific adapter.
Definition: btrCore.c:3036
BTRMGR_DeInit
BTRMGR_Result_t BTRMGR_DeInit(void)
This API invokes the deinit function of bluetooth core and persistant interface module.
Definition: btrMgr.c:2455
BTRMGR_SetAdapterName
BTRMGR_Result_t BTRMGR_SetAdapterName(unsigned char aui8AdapterIdx, const char *pNameOfAdapter)
This API is used to set the new name to the bluetooth adapter.
Definition: btrMgr.c:2645
BTRMGR_UnpairDevice
BTRMGR_Result_t BTRMGR_UnpairDevice(unsigned char aui8AdapterIdx, BTRMgrDeviceHandle ahBTRMgrDevHdl)
This API is used to remove the pairing information of the device selected.
Definition: btrMgr.c:3440
_BTRMGR_MediaElementInfo_t
Represents Media Element details.
Definition: btmgr.h:507
BTRCore_GetLEProperty
enBTRCoreRet BTRCore_GetLEProperty(tBTRCoreHandle hBTRCore, tBTRCoreDevId aBTRCoreDevId, const char *apcBTRCoreLEUuid, enBTRCoreLeProp aenBTRCoreLeProp, void *apvBTRCorePropVal)
This API returns the Low energy profile device name and address.
Definition: btrCore.c:5173
BTRCore_GetDeviceDisconnected
enBTRCoreRet BTRCore_GetDeviceDisconnected(tBTRCoreHandle hBTRCore, tBTRCoreDevId aBTRCoreDevId, enBTRCoreDeviceType aenBTRCoreDevType)
This method checks the current device that is disconnected.
Definition: btrCore.c:4111
BTRMGR_RSSIValue_t
enum _BTRMGR_RSSIValue_type_t BTRMGR_RSSIValue_t
Represents the bluetooth signal strength.
btrMgr_mediaTypes.h
BTRCore_AcquireDeviceDataPath
enBTRCoreRet BTRCore_AcquireDeviceDataPath(tBTRCoreHandle hBTRCore, tBTRCoreDevId aBTRCoreDevId, enBTRCoreDeviceType aenBTRCoreDevType, int *aiDataPath, int *aidataReadMTU, int *aidataWriteMTU, unsigned int *apui32Delay)
This API returns the bluetooth device address.
Definition: btrCore.c:4415
BTRCore_GetPropertyValue
enBTRCoreRet BTRCore_GetPropertyValue(tBTRCoreHandle hBTRCore, char *aUUID, char *aValue, enBTRCoreLeProp aElement)
This API is used to Get Property value.
Definition: btrCore.c:5383
_BTRMGR_PersistentData_t
Definition: btrMgr_persistIface.h:77
BTRCore_SetGattInfo
enBTRCoreRet BTRCore_SetGattInfo(tBTRCoreHandle hBTRCore, char *aParentUUID, char *aCharUUID, unsigned short aFlags, char *aValue, enBTRCoreLeProp aElement)
This API is used to Set Gatt Info value.
Definition: btrCore.c:5490
_stBTRMgrMPEGInfo::ui8MpegMpf
unsigned char ui8MpegMpf
mpf
Definition: btrMgr_mediaTypes.h:134
_stBTRMgrInASettings
Represents the audio input settings.
Definition: btrMgr_mediaTypes.h:142
BTRMGR_SetAdapterDiscoverable
BTRMGR_Result_t BTRMGR_SetAdapterDiscoverable(unsigned char aui8AdapterIdx, unsigned char discoverable, int timeout)
This API is to make the adapter discoverable until the given timeout.
Definition: btrMgr.c:2830
BTRMGR_GetMediaTrackInfo
BTRMGR_Result_t BTRMGR_GetMediaTrackInfo(unsigned char aui8AdapterIdx, BTRMgrDeviceHandle ahBTRMgrDevHdl, BTRMGR_MediaTrackInfo_t *mediaTrackInfo)
This API fetches the media track info like title, genre, duration, number of tracks,...
Definition: btrMgr.c:5172
BTRMGR_IsAdapterDiscoverable
BTRMGR_Result_t BTRMGR_IsAdapterDiscoverable(unsigned char aui8AdapterIdx, unsigned char *pDiscoverable)
This API checks the adapter is discoverable or not.
Definition: btrMgr.c:2894
BTRMgr_SI_Init
eBTRMgrRet BTRMgr_SI_Init(tBTRMgrSiHdl *phBTRMgrSiHdl, fPtr_BTRMgr_SI_StatusCb afpcBSiStatus, void *apvUserData)
This API invokes BTRMgr_SI_GstInit() for the stream in initializations.
Definition: btrMgr_streamIn.c:75
_stBTRMgrSBCInfo::ui8SbcSubbands
unsigned char ui8SbcSubbands
subbands
Definition: btrMgr_mediaTypes.h:118
BTRCore_GetListOfScannedDevices
enBTRCoreRet BTRCore_GetListOfScannedDevices(tBTRCoreHandle hBTRCore, stBTRCoreScannedDevicesCount *pListOfScannedDevices)
This API returns the number of devices scanned.
Definition: btrCore.c:3500
BTRMgr_AC_DeInit
eBTRMgrRet BTRMgr_AC_DeInit(tBTRMgrAcHdl hBTRMgrAcHdl)
This API deinitializes the bluetooth manager audio capture interface.
Definition: btrMgr_audioCap.c:465
BTRCore_StartAdvertisement
enBTRCoreRet BTRCore_StartAdvertisement(tBTRCoreHandle hBTRCore)
This API is used to start advertisement registration.
Definition: btrCore.c:5345
BTRMGR_PairDevice
BTRMGR_Result_t BTRMGR_PairDevice(unsigned char aui8AdapterIdx, BTRMgrDeviceHandle ahBTRMgrDevHdl)
This API is used to pair the device that you wish to pair.
Definition: btrMgr.c:3313
BTRCore_StartDiscovery
enBTRCoreRet BTRCore_StartDiscovery(tBTRCoreHandle hBTRCore, const char *pAdapterPath, enBTRCoreDeviceType aenBTRCoreDevType, unsigned int aui32DiscDuration)
This method starts the device discovery session.
Definition: btrCore.c:3392
_stBTRMgrMPEGInfo::ui8MpegLayer
unsigned char ui8MpegLayer
layer
Definition: btrMgr_mediaTypes.h:133
BTRMGR_Result_t
enum _BTRMGR_Result_t BTRMGR_Result_t
Represents the status of the operation.
BTRMGR_DeviceType_t
enum _BTRMGR_DeviceType_t BTRMGR_DeviceType_t
Represents the bluetooth device types.
BTRCore_IsDeviceConnectable
enBTRCoreRet BTRCore_IsDeviceConnectable(tBTRCoreHandle hBTRCore, tBTRCoreDevId aBTRCoreDevId)
This API checks the device is connectable.
Definition: btrCore.c:3864
_BTRMGR_MediaElementListInfo_t
Represents Media Element List.
Definition: btmgr.h:517
btrMgr_streamIn.h
_stBTRMgrSBCInfo::ui16SbcBitrate
unsigned short ui16SbcBitrate
bitrate
Definition: btrMgr_mediaTypes.h:123
BTRMGR_PerformLeOp
BTRMGR_Result_t BTRMGR_PerformLeOp(unsigned char aui8AdapterIdx, BTRMgrDeviceHandle ahBTRMgrDevHdl, const char *aBtrLeUuid, BTRMGR_LeOp_t aLeOpType, char *aLeOpArg, char *rOpResult)
This API performs LE operations on the specified bluetooth adapter.
Definition: btrMgr.c:5801
BTRMGR_Events_t
enum _BTRMGR_Events_t BTRMGR_Events_t
Represents the event status.
BTRCore_SetManufacturerData
enBTRCoreRet BTRCore_SetManufacturerData(tBTRCoreHandle hBTRCore, unsigned short aManfId, unsigned char *aDeviceDetails, int aLenManfData)
This API is used to set manufacturer data.
Definition: btrCore.c:5435
BTRCore_GetAdapterPower
enBTRCoreRet BTRCore_GetAdapterPower(tBTRCoreHandle hBTRCore, const char *pAdapterPath, unsigned char *pAdapterPower)
This API returns the value of org.bluez.Adapter.powered .
Definition: btrCore.c:3325
BTRCore_SetAdapterPower
enBTRCoreRet BTRCore_SetAdapterPower(tBTRCoreHandle hBTRCore, const char *pAdapterPath, unsigned char powerStatus)
This API sets the bluetooth adapter power as ON/OFF.
Definition: btrCore.c:3294
_BTRMGR_LeCustomAdvertisement_t
Structure for the custom advertisement payload.
Definition: btmgr.h:616
BTRMgr_SO_Pause
eBTRMgrRet BTRMgr_SO_Pause(tBTRMgrSoHdl hBTRMgrSoHdl)
This API uses BTRMgr_SO_GstPause() for pausing the current operation.
Definition: btrMgr_streamOut.c:753
btmgr.h
_BTRMGR_DiscoveryHandle_t
Definition: btrMgr.c:90
_stBTRMgrSBCInfo::ui16SbcFrameLen
unsigned short ui16SbcFrameLen
frameLength
Definition: btrMgr_mediaTypes.h:122
stBTRMgrSBCInfo
struct _stBTRMgrSBCInfo stBTRMgrSBCInfo
Represents the Subband coding (SBC) audio codec information.
BTRCore_EnableAdapter
enBTRCoreRet BTRCore_EnableAdapter(tBTRCoreHandle hBTRCore, stBTRCoreAdapter *apstBTRCoreAdapter)
This API enables specific adapter.
Definition: btrCore.c:3005
BTRCore_SelectMediaElement
enBTRCoreRet BTRCore_SelectMediaElement(tBTRCoreHandle hBTRCore, tBTRCoreDevId aBTRCoreDevId, tBTRCoreMediaElementId aBtrMediaElementId, enBTRCoreDeviceType aenBTRCoreDevType, eBTRCoreMedElementType aenBTRCoreMedElementType)
This API performs operation according to the element type selected.
Definition: btrCore.c:4931
BTRMGR_RSSI_NONE
@ BTRMGR_RSSI_NONE
No signal (0 bar)
Definition: btmgr.h:226
_stBTRMgrSBCInfo::ui8SbcAllocMethod
unsigned char ui8SbcAllocMethod
allocation_method
Definition: btrMgr_mediaTypes.h:117
_stBTRCoreMediaTrackInfo
Definition: btrCore.h:387
BTRMGR_DeviceOperationType_t
enum _BTRMGR_DeviceOperationType_t BTRMGR_DeviceOperationType_t
Represents the operation type for bluetooth device.
BTRMGR_GetAdapterPowerStatus
BTRMGR_Result_t BTRMGR_GetAdapterPowerStatus(unsigned char aui8AdapterIdx, unsigned char *pPowerStatus)
This API fetches the power status, either 0 or 1.
Definition: btrMgr.c:2790
BTRMgr_SO_SetVolume
eBTRMgrRet BTRMgr_SO_SetVolume(tBTRMgrSoHdl hBTRMgrSoHdl, unsigned char ui8Volume)
This API will set the current volume used by this interface.
Definition: btrMgr_streamOut.c:277
btrMgr_SysDiag.h
BTRCore_GetAdapterName
enBTRCoreRet BTRCore_GetAdapterName(tBTRCoreHandle hBTRCore, const char *pAdapterPath, char *pAdapterName)
This API gets the name of BT adapter.
Definition: btrCore.c:3261
BTRMGR_MediaControl
BTRMGR_Result_t BTRMGR_MediaControl(unsigned char aui8AdapterIdx, BTRMgrDeviceHandle ahBTRMgrDevHdl, BTRMGR_MediaControlCommand_t mediaCtrlCmd)
This API is used to perform the media control operations.
Definition: btrMgr.c:4680
BTRMgr_AC_GetDefaultSettings
eBTRMgrRet BTRMgr_AC_GetDefaultSettings(tBTRMgrAcHdl hBTRMgrAcHdl, stBTRMgrOutASettings *apstBtrMgrAcOutASettings)
This API will fetch default RMF AudioCapture Settings.
Definition: btrMgr_audioCap.c:580
BTRCore_SetDeviceDataAckTimeout
enBTRCoreRet BTRCore_SetDeviceDataAckTimeout(tBTRCoreHandle hBTRCore, unsigned int aui32AckTOutms)
This API release the bluetooth device address.
Definition: btrCore.c:4532
BTRMGR_StartAudioStreamingOut
BTRMGR_Result_t BTRMGR_StartAudioStreamingOut(unsigned char aui8AdapterIdx, BTRMgrDeviceHandle ahBTRMgrDevHdl, BTRMGR_DeviceOperationType_t streamOutPref)
This API initates the streaming from the device with the selected operation type.
Definition: btrMgr.c:4179
BTRCore_GetVersionInfo
enBTRCoreRet BTRCore_GetVersionInfo(tBTRCoreHandle hBTRCore, char *apcBtVersion)
This API gets BT Version.
Definition: btrCore.c:3356
BTRCore_SetAdapterName
enBTRCoreRet BTRCore_SetAdapterName(tBTRCoreHandle hBTRCore, const char *pAdapterPath, const char *pAdapterName)
This API sets a friendly name to BT adapter.
Definition: btrCore.c:3231
BTRCore_GetMediaPositionInfo
enBTRCoreRet BTRCore_GetMediaPositionInfo(tBTRCoreHandle hBTRCore, tBTRCoreDevId aBTRCoreDevId, enBTRCoreDeviceType aenBTRCoreDevType, stBTRCoreMediaPositionInfo *apstBTMediaPositionInfo)
This API returns the duration and the current position of the media.
Definition: btrCore.c:4820
BTRMGR_StartDeviceDiscovery
BTRMGR_Result_t BTRMGR_StartDeviceDiscovery(unsigned char aui8AdapterIdx, BTRMGR_DeviceOperationType_t aenBTRMgrDevOpT)
This API initiates the scanning process.
Definition: btrMgr.c:3141
BTRMGR_GetLimitBeaconDetection
BTRMGR_Result_t BTRMGR_GetLimitBeaconDetection(unsigned char aui8AdapterIdx, unsigned char *pLimited)
This API Gets Beacon Detection status on the specified bluetooth adapter.
Definition: btrMgr.c:5590
_stBTRMgrSysDiagStatus
Definition: btrMgr_SysDiag.h:66
BTRMgr_SO_Init
eBTRMgrRet BTRMgr_SO_Init(tBTRMgrSoHdl *phBTRMgrSoHdl, fPtr_BTRMgr_SO_StatusCb afpcBSoStatus, void *apvUserData)
This API invokes BTRMgr_SO_GstInit() and also set the state as initialized.
Definition: btrMgr_streamOut.c:77
BTRMgr_SO_Resume
eBTRMgrRet BTRMgr_SO_Resume(tBTRMgrSoHdl hBTRMgrSoHdl)
This API uses BTRMgr_SO_GstResume() to resume the status.
Definition: btrMgr_streamOut.c:783
_BTRMGR_PairedDevicesList_t
Represents the list of paired devices.
Definition: btmgr.h:476
_BTRMGR_DiscoveryFilterHandle_t
Definition: btmgr.h:605
_stBTRMgrMediaStatus
Represents the media file status.
Definition: btrMgr_mediaTypes.h:165
BTRMgr_SI_Stop
eBTRMgrRet BTRMgr_SI_Stop(tBTRMgrSiHdl hBTRMgrSiHdl)
This API uses BTRMgr_SI_GstStop() for closing the pipeline.
Definition: btrMgr_streamIn.c:434
BTRMGR_GetNumberOfAdapters
BTRMGR_Result_t BTRMGR_GetNumberOfAdapters(unsigned char *pNumOfAdapters)
This API returns the number of bluetooth adapters available.
Definition: btrMgr.c:2550
_BTRMGR_MediaDeviceStatus_t
Represents Media Element List.
Definition: btmgr.h:525
BTRMGR_DisconnectFromDevice
BTRMGR_Result_t BTRMGR_DisconnectFromDevice(unsigned char aui8AdapterIdx, BTRMgrDeviceHandle ahBTRMgrDevHdl)
This API terminates the current connection.
Definition: btrMgr.c:3674
BTRCore_GetDeviceMediaInfo
enBTRCoreRet BTRCore_GetDeviceMediaInfo(tBTRCoreHandle hBTRCore, tBTRCoreDevId aBTRCoreDevId, enBTRCoreDeviceType aenBTRCoreDevType, stBTRCoreDevMediaInfo *apstBTRCoreDevMediaInfo)
This API returns current media info that includes the codec info, channel modes, subbands etc.
Definition: btrCore.c:4232
_BTRMGR_PairedDevices_t
Represents the paired devices information.
Definition: btmgr.h:433
BTRMGR_SelectMediaElement
BTRMGR_Result_t BTRMGR_SelectMediaElement(unsigned char aui8AdapterIdx, BTRMgrDeviceHandle ahBTRMgrDevHdl, BTRMgrMediaElementHandle ahBTRMgrMedElementHdl, BTRMGR_MediaElementType_t aMediaElementType)
This API performs operation based on the element type selected.
Definition: btrMgr.c:5444
BTRMgr_SO_SendEOS
eBTRMgrRet BTRMgr_SO_SendEOS(tBTRMgrSoHdl hBTRMgrSoHdl)
This API is used to indicate the End of stream.
Definition: btrMgr_streamOut.c:844
_stBTRMgrMPEGInfo::ui8MpegRfa
unsigned char ui8MpegRfa
rfa
Definition: btrMgr_mediaTypes.h:135
BTRCore_ReleaseDeviceDataPath
enBTRCoreRet BTRCore_ReleaseDeviceDataPath(tBTRCoreHandle hBTRCore, tBTRCoreDevId aBTRCoreDevId, enBTRCoreDeviceType enDeviceType)
This API release the bluetooth device address.
Definition: btrCore.c:4483
BTRCore_GetDeviceTypeClass
enBTRCoreRet BTRCore_GetDeviceTypeClass(tBTRCoreHandle hBTRCore, tBTRCoreDevId aBTRCoreDevId, enBTRCoreDeviceType *apenBTRCoreDevTy, enBTRCoreDeviceClass *apenBTRCoreDevCl)
This API returns current media info that includes the codec info, channel modes, subbands etc.
Definition: btrCore.c:4161
_stBTRCoreDevMediaSbcInfo
Definition: btrCore.h:359
_stBTRCoreDevMediaPcmInfo
Definition: btrCore.h:353
BTRMGR_SetMediaElementActive
BTRMGR_Result_t BTRMGR_SetMediaElementActive(unsigned char aui8AdapterIdx, BTRMgrDeviceHandle ahBTRMgrDevHdl, BTRMgrMediaElementHandle ahBTRMgrMedElementHdl, BTRMGR_MediaElementType_t aMediaElementType)
This API sets the mentioned media element list active/in_scope for further operations on it.
Definition: btrMgr.c:5290
_BTRMGR_ConnectedDevicesList_t
Represents the connected devices list.
Definition: btmgr.h:468
BTRCore_UnregisterAgent
enBTRCoreRet BTRCore_UnregisterAgent(tBTRCoreHandle hBTRCore)
This unregisters the agent that has been previously registered.
Definition: btrCore.c:2836
_stBTRCoreListAdapters
Definition: btrCore.h:261
BTRCore_GetListOfPairedDevices
enBTRCoreRet BTRCore_GetListOfPairedDevices(tBTRCoreHandle hBTRCore, stBTRCorePairedDevicesCount *pListOfDevices)
Gets the paired devices list.
Definition: btrCore.c:3695
BTRMgr_PI_Init
eBTRMgrRet BTRMgr_PI_Init(tBTRMgrPIHdl *hBTRMgrPiHdl)
This API initializes bluetooth manager's persistent storage interface.
Definition: btrMgr_persistIface.c:127
BTRMGR_StartAudioStreamingOut_StartUp
BTRMGR_Result_t BTRMGR_StartAudioStreamingOut_StartUp(unsigned char aui8AdapterIdx, BTRMGR_DeviceOperationType_t aenBTRMgrDevConT)
This API initates the streaming from the device with default operation type.
Definition: btrMgr.c:4100
BTRCore_GetAdapter
enBTRCoreRet BTRCore_GetAdapter(tBTRCoreHandle hBTRCore, stBTRCoreAdapter *apstBTRCoreAdapter)
This API returns the bluetooth adapter path.
Definition: btrCore.c:2926
_stBTRMgrOutASettings
Represents the audio output settings.
Definition: btrMgr_mediaTypes.h:153
BTRMGR_GetAdapterName
BTRMGR_Result_t BTRMGR_GetAdapterName(unsigned char aui8AdapterIdx, char *pNameOfAdapter)
This API fetches the bluetooth adapter name.
Definition: btrMgr.c:2685
BTRMGR_GetDiscoveryStatus
BTRMGR_Result_t BTRMGR_GetDiscoveryStatus(unsigned char aui8AdapterIdx, BTRMGR_DiscoveryStatus_t *isDiscoveryInProgress, BTRMGR_DeviceOperationType_t *aenBTRMgrDevOpT)
This API gives the discovery status.
Definition: btrMgr.c:3195
_BTRMGR_Profile_t
Definition: btrMgr_persistIface.h:85
_stBTRMgrStreamingInfo
Definition: btrMgr.c:63
BTRMGR_StopAudioStreamingIn
BTRMGR_Result_t BTRMGR_StopAudioStreamingIn(unsigned char aui8AdapterIdx, BTRMgrDeviceHandle ahBTRMgrDevHdl)
This API termines the audio streaming.
Definition: btrMgr.c:4530
BTRMgr_SI_SetStatus
eBTRMgrRet BTRMgr_SI_SetStatus(tBTRMgrSiHdl hBTRMgrSiHdl, stBTRMgrMediaStatus *apstBtrMgrSiStatus)
This API will set the current settings used by this interface.
Definition: btrMgr_streamIn.c:216
BTRMGR_StopAudioStreamingOut
BTRMGR_Result_t BTRMGR_StopAudioStreamingOut(unsigned char aui8AdapterIdx, BTRMgrDeviceHandle ahBTRMgrDevHdl)
This API terminates the streaming from the device.
Definition: btrMgr.c:4205
BTRCore_StopAdvertisement
enBTRCoreRet BTRCore_StopAdvertisement(tBTRCoreHandle hBTRCore)
This API is used to stop advertisement registration.
Definition: btrCore.c:5364
BTRCore_SetAdvertisementType
enBTRCoreRet BTRCore_SetAdvertisementType(tBTRCoreHandle hBTRCore, char *aAdvtType)
This API is used to set advertisement type.
Definition: btrCore.c:5403
BTRCore_PairDevice
enBTRCoreRet BTRCore_PairDevice(tBTRCoreHandle hBTRCore, tBTRCoreDevId aBTRCoreDevId)
This API initiates the pairing of the device.
Definition: btrCore.c:3539
BTRMGR_SetDeviceVolumeMute
BTRMGR_Result_t BTRMGR_SetDeviceVolumeMute(unsigned char aui8AdapterIdx, BTRMgrDeviceHandle ahBTRMgrDevHdl, BTRMGR_DeviceOperationType_t deviceOpType, unsigned char aui8Volume, unsigned char aui8Mute)
This API is used to set the media volume and mute data.
Definition: btrMgr.c:5051
BTRCore_GetMediaTrackInfo
enBTRCoreRet BTRCore_GetMediaTrackInfo(tBTRCoreHandle hBTRCore, tBTRCoreDevId aBTRCoreDevId, enBTRCoreDeviceType aenBTRCoreDevType, stBTRCoreMediaTrackInfo *apstBTMediaTrackInfo)
This API is used to retrieve the media track information.
Definition: btrCore.c:4710
_BTRMGR_EventMessage_t
Represents the event message info.
Definition: btmgr.h:576
_stBTRCoreMediaPositionInfo
Definition: btrCore.h:397
_BTRMGR_DiscoveredDevicesList_t
Represents the list of scanned devices.
Definition: btmgr.h:484
BTRCore_DeInit
enBTRCoreRet BTRCore_DeInit(tBTRCoreHandle hBTRCore)
This APi deinitialzes and free BTRCore.
Definition: btrCore.c:2657
BTRMGR_GetDeviceProperties
BTRMGR_Result_t BTRMGR_GetDeviceProperties(unsigned char aui8AdapterIdx, BTRMgrDeviceHandle ahBTRMgrDevHdl, BTRMGR_DevicesProperty_t *pDeviceProperty)
This API returns the device information that includes the device name, mac address,...
Definition: btrMgr.c:3961
_stBTRCoreMediaStatusUpdate
Definition: btrCore.h:415
BTRMGR_MediaControlCommand_t
enum _BTRMGR_MediaControlCommand_t BTRMGR_MediaControlCommand_t
Represents the commands to control the media files.
BTRCore_DisconnectDevice
enBTRCoreRet BTRCore_DisconnectDevice(tBTRCoreHandle hBTRCore, tBTRCoreDevId aBTRCoreDevId, enBTRCoreDeviceType aenBTRCoreDevType)
This method gracefully disconnects all connected profiles and then terminates connection.
Definition: btrCore.c:3993
eBTRMgrRet
enum _eBTRMgrRet eBTRMgrRet
Represents the bluetooth manager return values.
BTRMGR_SetLimitBeaconDetection
BTRMGR_Result_t BTRMGR_SetLimitBeaconDetection(unsigned char aui8AdapterIdx, unsigned char limited)
This API Sets Beacon Detection status on the specified bluetooth adapter.
Definition: btrMgr.c:5619
BTRMGR_GetConnectedDevices
BTRMGR_Result_t BTRMGR_GetConnectedDevices(unsigned char aui8AdapterIdx, BTRMGR_ConnectedDevicesList_t *pConnectedDevices)
This API returns the list of devices connected.
Definition: btrMgr.c:3845
BTRMGR_SetAdapterPowerStatus
BTRMGR_Result_t BTRMGR_SetAdapterPowerStatus(unsigned char aui8AdapterIdx, unsigned char power_status)
This API sets the bluetooth adapter power to ON/OFF.
Definition: btrMgr.c:2728
_BTRMGR_Beacon_PersistentData_t
Definition: btrMgr_persistIface.h:63
_stBTRCoreDevMediaInfo
Definition: btrCore.h:382
_stBTRCoreMediaCtData
Definition: btrCore.h:436
BTRMgr_SI_SendEOS
eBTRMgrRet BTRMgr_SI_SendEOS(tBTRMgrSiHdl hBTRMgrSiHdl)
This API is used to indicate the End of stream.
Definition: btrMgr_streamIn.c:557
BTRMGR_SetAudioInServiceState
BTRMGR_Result_t BTRMGR_SetAudioInServiceState(unsigned char aui8AdapterIdx, unsigned char aui8State)
This API Enable/Disables Audio-In on the specified bluetooth adapter.
Definition: btrMgr.c:5562
BTRMGR_ConnectToDevice
BTRMGR_Result_t BTRMGR_ConnectToDevice(unsigned char aui8AdapterIdx, BTRMgrDeviceHandle ahBTRMgrDevHdl, BTRMGR_DeviceOperationType_t connectAs)
This API connects the device as audio sink/headset/audio src based on the device type specified.
Definition: btrMgr.c:3635
BTRCore_GetMediaElementTrackInfo
enBTRCoreRet BTRCore_GetMediaElementTrackInfo(tBTRCoreHandle hBTRCore, tBTRCoreDevId aBTRCoreDevId, enBTRCoreDeviceType aenBTRCoreDevType, tBTRCoreMediaElementId aBtrMediaElementId, stBTRCoreMediaTrackInfo *apstBTMediaTrackInfo)
This API is used to retrieve the media track information.
Definition: btrCore.c:4763
BTRMgr_AC_Stop
eBTRMgrRet BTRMgr_AC_Stop(tBTRMgrAcHdl hBTRMgrAcHdl)
This function will stop the audio capture.
Definition: btrMgr_audioCap.c:1508
BTRCore_SetAdapterDiscoverable
enBTRCoreRet BTRCore_SetAdapterDiscoverable(tBTRCoreHandle hBTRCore, const char *pAdapterPath, unsigned char discoverable)
This API sets adapter as discoverable.
Definition: btrCore.c:3098
BTRMGR_RSSI_FAIR
@ BTRMGR_RSSI_FAIR
Fair (2 bars)
Definition: btmgr.h:228
BTRMgr_SO_Start
eBTRMgrRet BTRMgr_SO_Start(tBTRMgrSoHdl hBTRMgrSoHdl, stBTRMgrInASettings *apstBtrMgrSoInASettings, stBTRMgrOutASettings *apstBtrMgrSoOutASettings)
This API uses BTRMgr_SO_GstStart(), starts the pipeline.
Definition: btrMgr_streamOut.c:507
BTRCore_SetServiceInfo
enBTRCoreRet BTRCore_SetServiceInfo(tBTRCoreHandle hBTRCore, char *aUUID, BOOLEAN aServiceType)
This API is used to Set Service Info value.
Definition: btrCore.c:5470
BTRCore_GetListOfAdapters
enBTRCoreRet BTRCore_GetListOfAdapters(tBTRCoreHandle hBTRCore, stBTRCoreListAdapters *pstListAdapters)
Returns list of adapter object paths under /org/bluez.
Definition: btrCore.c:2859
BTRMGR_StartAudioStreamingIn
BTRMGR_Result_t BTRMGR_StartAudioStreamingIn(unsigned char aui8AdapterIdx, BTRMgrDeviceHandle ahBTRMgrDevHdl, BTRMGR_DeviceOperationType_t connectAs)
This API starts the audio streaming.
Definition: btrMgr.c:4339
BTRMgr_PI_DeInit
eBTRMgrRet BTRMgr_PI_DeInit(tBTRMgrPIHdl hBTRMgrPiHdl)
This API deinitializes bluetooth manager's persistent storage interface.
Definition: btrMgr_persistIface.c:145
_stBTRCorePairedDevicesCount
Definition: btrCore.h:338
BTRCore_MediaControl
enBTRCoreRet BTRCore_MediaControl(tBTRCoreHandle hBTRCore, tBTRCoreDevId aBTRCoreDevId, enBTRCoreDeviceType aenBTRCoreDevType, enBTRCoreMediaCtrl aenBTRCoreMediaCtrl, stBTRCoreMediaCtData *apstBTRCoreMediaCData)
This API is used to perform media control operations like play, pause, NExt, Previous,...
Definition: btrCore.c:4555
BTRCore_SetMediaElementActive
enBTRCoreRet BTRCore_SetMediaElementActive(tBTRCoreHandle hBTRCore, tBTRCoreDevId aBTRCoreDevId, tBTRCoreMediaElementId aBtrMediaElementId, enBTRCoreDeviceType aenBTRCoreDevType, eBTRCoreMedElementType aeBTRCoreMedElementType)
This API sets the mentioned media list active/in_scope at the lower to allow further operations on th...
Definition: btrCore.c:5104
BTRCore_GetAdapterDiscoverableStatus
enBTRCoreRet BTRCore_GetAdapterDiscoverableStatus(tBTRCoreHandle hBTRCore, const char *pAdapterPath, unsigned char *pDiscoverable)
This API checks whether the discovery is in progress or not.
Definition: btrCore.c:3163
btrMgr_streamOut.h
BTRCore_RegisterAgent
enBTRCoreRet BTRCore_RegisterAgent(tBTRCoreHandle hBTRCore, int iBTRCapMode)
This API registers an agent handler.
Definition: btrCore.c:2803
BTRMGR_ResetAdapter
BTRMGR_Result_t BTRMGR_ResetAdapter(unsigned char aui8AdapterIdx)
This API is designed to reset the bluetooth adapter.
Definition: btrMgr.c:2589
BTRCore_SetPropertyValue
enBTRCoreRet BTRCore_SetPropertyValue(tBTRCoreHandle hBTRCore, char *aUUID, char *aValue, enBTRCoreLeProp aElement)
This API is used to Set Property value.
Definition: btrCore.c:5520
btrMgr_persistIface.h
_stBTRMgrSBCInfo::ui8SbcMaxBitpool
unsigned char ui8SbcMaxBitpool
max_bitpool
Definition: btrMgr_mediaTypes.h:121
_stBTRMgrPCMInfo
Represents the PCM codec details.
Definition: btrMgr_mediaTypes.h:103
_stBTRMgrSBCInfo::ui8SbcBlockLength
unsigned char ui8SbcBlockLength
block_length
Definition: btrMgr_mediaTypes.h:119
BTRMgr_SO_Stop
eBTRMgrRet BTRMgr_SO_Stop(tBTRMgrSoHdl hBTRMgrSoHdl)
This API uses BTRMgr_SO_GstStop() for closing the pipeline.
Definition: btrMgr_streamOut.c:721
BTRMgr_SO_SetStatus
eBTRMgrRet BTRMgr_SO_SetStatus(tBTRMgrSoHdl hBTRMgrSoHdl, stBTRMgrMediaStatus *apstBtrMgrSoStatus)
This API will set the current settings used by this interface.
Definition: btrMgr_streamOut.c:221
BTRMGR_GetDiscoveredDevices
BTRMGR_Result_t BTRMGR_GetDiscoveredDevices(unsigned char aui8AdapterIdx, BTRMGR_DiscoveredDevicesList_t *pDiscoveredDevices)
This API fetches the list of devices scanned.
Definition: btrMgr.c:3226
BTRCore_UnPairDevice
enBTRCoreRet BTRCore_UnPairDevice(tBTRCoreHandle hBTRCore, tBTRCoreDevId aBTRCoreDevId)
This API removes the remote device object at the given path.
Definition: btrCore.c:3630
_BTRMGR_DevicesProperty_t
Represents the property of the device.
Definition: btmgr.h:400
_stBTRMgrMPEGInfo
Represents the MPEG codec details.
Definition: btrMgr_mediaTypes.h:129
_stBTRMgrSBCInfo::ui8SbcMinBitpool
unsigned char ui8SbcMinBitpool
min_bitpool
Definition: btrMgr_mediaTypes.h:120
BTRMgr_SO_GetEstimatedInABufSize
eBTRMgrRet BTRMgr_SO_GetEstimatedInABufSize(tBTRMgrSoHdl hBTRMgrSoHdl, stBTRMgrInASettings *apstBtrMgrSoInASettings, stBTRMgrOutASettings *apstBtrMgrSoOutASettings)
This API fetches the maximum transmission rate.
Definition: btrMgr_streamOut.c:368
BTRCore_PerformLEOp
enBTRCoreRet BTRCore_PerformLEOp(tBTRCoreHandle hBTRCore, tBTRCoreDevId aBTRCoreDevId, const char *apcBTRCoreLEUuid, enBTRCoreLeOp aenBTRCoreLeOp, char *apLeOpArg, char *rpLeOpRes)
This API is used to perform read, write, notify operations on LE devices.
Definition: btrCore.c:5262
_stBTRCoreDevStatusCBInfo
Definition: btrCore.h:273
BTRMGR_GetPairedDevices
BTRMGR_Result_t BTRMGR_GetPairedDevices(unsigned char aui8AdapterIdx, BTRMGR_PairedDevicesList_t *pPairedDevices)
This API returns the list of devices paired.
Definition: btrMgr.c:3556
BTRMGR_GetDeviceVolumeMute
BTRMGR_Result_t BTRMGR_GetDeviceVolumeMute(unsigned char aui8AdapterIdx, BTRMgrDeviceHandle ahBTRMgrDevHdl, BTRMGR_DeviceOperationType_t deviceOpType, unsigned char *pui8Volume, unsigned char *pui8Mute)
This API is used to fetch the media volume and mute data.
Definition: btrMgr.c:4966
BTRMGR_RSSI_GOOD
@ BTRMGR_RSSI_GOOD
Good (3 bars)
Definition: btmgr.h:229
_stBTRMgrSBCInfo::eBtrMgrSbcAChan
eBTRMgrAChan eBtrMgrSbcAChan
channel_mode
Definition: btrMgr_mediaTypes.h:116
BTRMGR_GetMediaElementList
BTRMGR_Result_t BTRMGR_GetMediaElementList(unsigned char aui8AdapterIdx, BTRMgrDeviceHandle ahBTRMgrDevHdl, BTRMgrMediaElementHandle ahBTRMgrMedElementHdl, unsigned short aui16MediaElementStartIdx, unsigned short aui16MediaElementEndIdx, unsigned char abMediaElementListDepth, BTRMGR_MediaElementType_t aMediaElementType, BTRMGR_MediaElementListInfo_t *aMediaElementListInfo)
This API gets the media element list.
Definition: btrMgr.c:5362
BTRMGR_LeProperty_t
enum _BTRMGR_LeProperty_t BTRMGR_LeProperty_t
Represents LE properties.
BTRMGR_StopDeviceDiscovery
BTRMGR_Result_t BTRMGR_StopDeviceDiscovery(unsigned char aui8AdapterIdx, BTRMGR_DeviceOperationType_t aenBTRMgrDevOpT)
This API terminates the scanning process.
Definition: btrMgr.c:3169
BTRMGR_GetMediaElementTrackInfo
BTRMGR_Result_t BTRMGR_GetMediaElementTrackInfo(unsigned char aui8AdapterIdx, BTRMgrDeviceHandle ahBTRMgrDevHdl, BTRMgrMediaElementHandle ahBTRMgrMedElementHdl, BTRMGR_MediaTrackInfo_t *mediaTrackInfo)
This API fetches the media track info like title, genre, duration, number of tracks,...
Definition: btrMgr.c:5210
_stBTRCoreMediaElementInfoList
Definition: btrCore.h:410
BTRCore_SetServiceUUIDs
enBTRCoreRet BTRCore_SetServiceUUIDs(tBTRCoreHandle hBTRCore, char *aUUID)
This API is used to set service UUIDs.
Definition: btrCore.c:5419
_stBTRCoreScannedDevicesCount
Definition: btrCore.h:333
BTRMgr_PI_AddProfile
eBTRMgrRet BTRMgr_PI_AddProfile(tBTRMgrPIHdl hBTRMgrPiHdl, BTRMGR_Profile_t *persistProfile)
This API adds a single bluetooth profile to json file.
Definition: btrMgr_persistIface.c:476
BTRMgr_PI_RemoveProfile
eBTRMgrRet BTRMgr_PI_RemoveProfile(tBTRMgrPIHdl hBTRMgrPiHdl, BTRMGR_Profile_t *persistProfile)
This API removes a single bluetooth profile from json file.
Definition: btrMgr_persistIface.c:622
_stBTRMgrMPEGInfo::eBtrMgrMpegSFreq
eBTRMgrSFreq eBtrMgrMpegSFreq
frequency
Definition: btrMgr_mediaTypes.h:130
BTRMGR_IsAudioStreamingIn
BTRMGR_Result_t BTRMGR_IsAudioStreamingIn(unsigned char aui8AdapterIdx, unsigned char *pStreamingStatus)
This API returns the audio streaming status.
Definition: btrMgr.c:4574
BTRMgr_SI_DeInit
eBTRMgrRet BTRMgr_SI_DeInit(tBTRMgrSiHdl hBTRMgrSiHdl)
This API invokes BTRMgr_SI_GstDeInit() for the deinitializations.
Definition: btrMgr_streamIn.c:121
BTRCore_GetMediaElementList
enBTRCoreRet BTRCore_GetMediaElementList(tBTRCoreHandle hBTRCore, tBTRCoreDevId aBTRCoreDevId, tBTRCoreMediaElementId aBtrMediaElementId, unsigned short aui16BtrMedElementStartIdx, unsigned short aui16BtrMedElementEndIdx, enBTRCoreDeviceType aenBTRCoreDevType, eBTRCoreMedElementType aenBTRCoreMedElementType, stBTRCoreMediaElementInfoList *apstMediaElementListInfo)
This API returns the mentioned media list.
Definition: btrCore.c:5030
BTRMgr_AC_Init
eBTRMgrRet BTRMgr_AC_Init(tBTRMgrAcHdl *phBTRMgrAcHdl, tBTRMgrAcType api8BTRMgrAcType)
This API initializes the bluetooth manager audio capture interface.
Definition: btrMgr_audioCap.c:357
BTRMgr_AC_Start
eBTRMgrRet BTRMgr_AC_Start(tBTRMgrAcHdl hBTRMgrAcHdl, stBTRMgrOutASettings *apstBtrMgrAcOutASettings, fPtr_BTRMgr_AC_DataReadyCb afpcBBtrMgrAcDataReady, fPtr_BTRMgr_AC_StatusCb afpcBBtrMgrAcStatus, void *apvUserData)
This function will start the Audio capture with the default capture settings.
Definition: btrMgr_audioCap.c:1159
BTRMGR_StreamOut_Type_t
enum _BTRMGR_StreamOut_Type_t BTRMGR_StreamOut_Type_t
Represents the stream output types.
BTRMGR_GetDeviceTypeAsString
const char * BTRMGR_GetDeviceTypeAsString(BTRMGR_DeviceType_t type)
This API fetches the Device name of the media.
Definition: btrMgr.c:5515
_stBTRCoreMediaStatusCBInfo
Definition: btrCore.h:428
_BTRMGR_EventResponse_t
Represents the event response.
Definition: btmgr.h:591
BTRCore_SetAdapterDiscoverableTimeout
enBTRCoreRet BTRCore_SetAdapterDiscoverableTimeout(tBTRCoreHandle hBTRCore, const char *pAdapterPath, unsigned short timeout)
This API sets how long the adapter is discoverable.
Definition: btrCore.c:3130
BTRCore_GetDeviceConnected
enBTRCoreRet BTRCore_GetDeviceConnected(tBTRCoreHandle hBTRCore, tBTRCoreDevId aBTRCoreDevId, enBTRCoreDeviceType aenBTRCoreDevType)
This method checks the current device that is connected.
Definition: btrCore.c:4061
_stBTRCoreDiscoveryCBInfo
Definition: btrCore.h:459
BTRMGR_RSSI_POOR
@ BTRMGR_RSSI_POOR
Poor (1 bar)
Definition: btmgr.h:227
BTRMGR_SetEventResponse
BTRMGR_Result_t BTRMGR_SetEventResponse(unsigned char aui8AdapterIdx, BTRMGR_EventResponse_t *apstBTRMgrEvtRsp)
This API handles the events received.
Definition: btrMgr.c:4602
BTRMgr_SO_SendBuffer
eBTRMgrRet BTRMgr_SO_SendBuffer(tBTRMgrSoHdl hBTRMgrSoHdl, char *pcInBuf, int aiInBufSize)
Invokes BTRMgr_SO_GstSendBuffer() to add the buffer to the queue.
Definition: btrMgr_streamOut.c:813
_BTRMGR_MediaPositionInfo_t
Represents the media position info.
Definition: btmgr.h:359
_BTRMGR_ConnectedDevice_t
Represents the details of device connected.
Definition: btmgr.h:418
rdk_logger_init
rdk_Error rdk_logger_init(const char *debugConfigFile)
Initialize the logger. Sets up the environment variable storage by parsing debug configuration file t...
Definition: rdk_logger_init.c:57
_stBTRCoreMediaElementInfo
Definition: btrCore.h:402
BTRMGR_SetAudioStreamingOutType
BTRMGR_Result_t BTRMGR_SetAudioStreamingOutType(unsigned char aui8AdapterIdx, BTRMGR_StreamOut_Type_t aenCurrentSoType)
This API is to set the audio type as primary or secondary.
Definition: btrMgr.c:4287
BTRMgr_SO_DeInit
eBTRMgrRet BTRMgr_SO_DeInit(tBTRMgrSoHdl hBTRMgrSoHdl)
This API invokes BTRMgr_SO_GstDeInit() for the deinitializations.
Definition: btrMgr_streamOut.c:125
_stBTRCoreConnCBInfo
Definition: btrCore.h:343
btrMgr_audioCap.h
_BTRMGR_MediaTrackInfo_t
Represents the media track info.
Definition: btmgr.h:346
_stBTRMgrMPEGInfo::eBtrMgrMpegAChan
eBTRMgrAChan eBtrMgrMpegAChan
channel_mode
Definition: btrMgr_mediaTypes.h:131
_stBTRMgrMPEGInfo::ui8MpegCrc
unsigned char ui8MpegCrc
crc
Definition: btrMgr_mediaTypes.h:132
BTRMGR_LeOp_t
enum _BTRMGR_LeOp_t BTRMGR_LeOp_t
Represents the Low energy operations.
TRUE
#define TRUE
Defines for TRUE/FALSE/ENABLE flags.
Definition: wifi_common_hal.h:199
BTRCore_ConnectDevice
enBTRCoreRet BTRCore_ConnectDevice(tBTRCoreHandle hBTRCore, tBTRCoreDevId aBTRCoreDevId, enBTRCoreDeviceType aenBTRCoreDevType)
This method connect any profiles the remote device supports.
Definition: btrCore.c:3921
BTRMGR_SetHidGamePadServiceState
BTRMGR_Result_t BTRMGR_SetHidGamePadServiceState(unsigned char aui8AdapterIdx, unsigned char aui8State)
This API Enable/Disables Hid GamePad on the specified bluetooth adapter.
Definition: btrMgr.c:5576
BTRMGR_Init
BTRMGR_Result_t BTRMGR_Init(void)
This API initializes the bluetooth manager.
Definition: btrMgr.c:2295
_stBTRCoreDevMediaMpegInfo
Definition: btrCore.h:371
BTRMGR_DiscoveryStatus_t
enum _BTRMGR_DiscoveryStatus_t BTRMGR_DiscoveryStatus_t
Represents the bluetooth Discovery Status.
BTRMGR_IsAudioStreamingOut
BTRMGR_Result_t BTRMGR_IsAudioStreamingOut(unsigned char aui8AdapterIdx, unsigned char *pStreamingStatus)
This API returns the stream out status.
Definition: btrMgr.c:4252
BTRMgr_PI_GetAllProfiles
eBTRMgrRet BTRMgr_PI_GetAllProfiles(tBTRMgrPIHdl hBTRMgrPiHdl, BTRMGR_PersistentData_t *persistentData)
This API reads all bluetooth profiles from json file and saves to BTRMGR_PersistentData_t structure.
Definition: btrMgr_persistIface.c:370
BTRMgr_SO_GetVolume
eBTRMgrRet BTRMgr_SO_GetVolume(tBTRMgrSoHdl hBTRMgrSoHdl, unsigned char *ui8Volume)
This API will fetches the current volume used by this interface.
Definition: btrMgr_streamOut.c:298
_stBTRCoreAdapter
Definition: btrCore.h:306
BTRMgr_SO_GetMute
eBTRMgrRet BTRMgr_SO_GetMute(tBTRMgrSoHdl hBTRMgrSoHdl, gboolean *Mute)
This API will fetches the Mute used by this interface.
Definition: btrMgr_streamOut.c:343
BTRMGR_MediaElementType_t
enum _BTRMGR_MediaElementType_t BTRMGR_MediaElementType_t
Represents Media Element Types.
BTRCore_StopDiscovery
enBTRCoreRet BTRCore_StopDiscovery(tBTRCoreHandle hBTRCore, const char *pAdapterPath, enBTRCoreDeviceType aenBTRCoreDevType)
This method will cancel any previous StartDiscovery transaction.
Definition: btrCore.c:3459
btrMgr_LEOnboarding.h
BTRMGR_RSSI_EXCELLENT
@ BTRMGR_RSSI_EXCELLENT
Excellent (4 bars)
Definition: btmgr.h:230