|
1 /* |
|
2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies). |
|
3 * All rights reserved. |
|
4 * This component and the accompanying materials are made available |
|
5 * under the terms of "Eclipse Public License v1.0" |
|
6 * which accompanies this distribution, and is available |
|
7 * at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
8 * |
|
9 * Initial Contributors: |
|
10 * Nokia Corporation - initial contribution. |
|
11 * |
|
12 * Contributors: |
|
13 * |
|
14 * Description: |
|
15 * |
|
16 */ |
|
17 |
|
18 #include <stdio.h> |
|
19 #include <stdlib.h> |
|
20 #include <assert.h> |
|
21 #include "xardsitf.h" |
|
22 /*#include "XARDSItfAdaptation.h"*/ |
|
23 #include "xathreadsafety.h" |
|
24 |
|
25 /** |
|
26 * XARDSItfImpl* GetImpl(XARDSItf self) |
|
27 * Description: Validated interface pointer and cast it to implementations pointer. |
|
28 **/ |
|
29 static XARDSItfImpl* GetImpl(XARDSItf self) |
|
30 { |
|
31 if(self) |
|
32 { |
|
33 XARDSItfImpl *impl = (XARDSItfImpl*)(*self); |
|
34 if(impl && impl == impl->self) |
|
35 { |
|
36 return impl; |
|
37 } |
|
38 } |
|
39 return NULL; |
|
40 } |
|
41 |
|
42 /** |
|
43 * Base interface XARDSItf implementation |
|
44 */ |
|
45 |
|
46 /** |
|
47 * XAresult XARDSItfImpl_QueryRDSSignal(XARDSItf self, XAboolean * isSignal) |
|
48 * Description: Returns the status of the RDS reception. |
|
49 **/ |
|
50 XAresult XARDSItfImpl_QueryRDSSignal(XARDSItf self, XAboolean * isSignal) |
|
51 { |
|
52 XAresult ret = XA_RESULT_SUCCESS; |
|
53 XARDSItfImpl* impl = GetImpl(self); |
|
54 DEBUG_API("->XARDSItfImpl_QueryRDSSignal"); |
|
55 XA_IMPL_THREAD_SAFETY_ENTRY(XATSRadio); |
|
56 if(!impl || !isSignal) |
|
57 { |
|
58 XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio); |
|
59 DEBUG_ERR("XA_RESULT_PARAMETER_INVALID"); |
|
60 /* invalid parameter */ |
|
61 DEBUG_API("<-XARDSItfImpl_QueryRDSSignal"); |
|
62 return XA_RESULT_PARAMETER_INVALID; |
|
63 } |
|
64 |
|
65 #ifdef _GSTREAMER_BACKEND_ |
|
66 ret = XARDSItfAdapt_QueryRDSSignal(impl->adapCtx, isSignal); |
|
67 #endif |
|
68 XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio); |
|
69 DEBUG_API("<-XARDSItfImpl_QueryRDSSignal"); |
|
70 return ret; |
|
71 } |
|
72 |
|
73 /** |
|
74 * XAresult XARDSItfImpl_GetProgrammeServiceName(XARDSItf self, XAchar * ps) |
|
75 * Description: Gets the current Programme Service name (PS). |
|
76 **/ |
|
77 XAresult XARDSItfImpl_GetProgrammeServiceName(XARDSItf self, XAchar * ps) |
|
78 { |
|
79 XAresult ret = XA_RESULT_SUCCESS; |
|
80 XARDSItfImpl* impl = GetImpl(self); |
|
81 DEBUG_API("->XARDSItfImpl_GetProgrammeServiceName"); |
|
82 if(!impl || !ps) |
|
83 { |
|
84 DEBUG_ERR("XA_RESULT_PARAMETER_INVALID"); |
|
85 /* invalid parameter */ |
|
86 DEBUG_API("<-XARDSItfImpl_GetProgrammeServiceName"); |
|
87 return XA_RESULT_PARAMETER_INVALID; |
|
88 } |
|
89 |
|
90 #ifdef _GSTREAMER_BACKEND_ |
|
91 ret = XARDSItfAdapt_GetProgrammeServiceName(impl->adapCtx, ps); |
|
92 #endif |
|
93 DEBUG_API("<-XARDSItfImpl_GetProgrammeServiceName"); |
|
94 return ret; |
|
95 } |
|
96 |
|
97 /** |
|
98 * XAresult XARDSItfImpl_GetRadioText(XARDSItf self, XAchar * rt) |
|
99 * Description: Gets the current Radio Text (RT). |
|
100 **/ |
|
101 XAresult XARDSItfImpl_GetRadioText(XARDSItf self, XAchar * rt) |
|
102 { |
|
103 XAresult ret = XA_RESULT_SUCCESS; |
|
104 XARDSItfImpl* impl = GetImpl(self); |
|
105 DEBUG_API("->XARDSItfImpl_GetRadioText"); |
|
106 XA_IMPL_THREAD_SAFETY_ENTRY(XATSRadio); |
|
107 |
|
108 if(!impl || !rt) |
|
109 { |
|
110 XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio); |
|
111 DEBUG_ERR("XA_RESULT_PARAMETER_INVALID"); |
|
112 /* invalid parameter */ |
|
113 DEBUG_API("<-XARDSItfImpl_GetRadioText"); |
|
114 return XA_RESULT_PARAMETER_INVALID; |
|
115 } |
|
116 |
|
117 #ifdef _GSTREAMER_BACKEND_ |
|
118 ret = XARDSItfAdapt_GetRadioText(impl->adapCtx, rt); |
|
119 #endif |
|
120 XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio); |
|
121 DEBUG_API("<-XARDSItfImpl_GetRadioText"); |
|
122 return ret; |
|
123 } |
|
124 |
|
125 /** |
|
126 * XAresult XARDSItfImpl_GetRadioTextPlus(XARDSItf self, |
|
127 * XAuint8 contentType, |
|
128 * XAchar * informationElement, |
|
129 * XAchar * descriptor, |
|
130 * XAuint8 * descriptorContentType) |
|
131 * Description: Gets the current Radio Text+ (RT+) information element based |
|
132 * on the given class code. |
|
133 **/ |
|
134 XAresult XARDSItfImpl_GetRadioTextPlus(XARDSItf self, |
|
135 XAuint8 contentType, |
|
136 XAchar * informationElement, |
|
137 XAchar * descriptor, |
|
138 XAuint8 * descriptorContentType) |
|
139 { |
|
140 XAresult ret = XA_RESULT_SUCCESS; |
|
141 XARDSItfImpl* impl = GetImpl(self); |
|
142 DEBUG_API("->XARDSItfImpl_GetRadioTextPlus"); |
|
143 XA_IMPL_THREAD_SAFETY_ENTRY(XATSRadio); |
|
144 |
|
145 if(!impl || contentType < XA_RDSRTPLUS_ITEMTITLE || contentType > XA_RDSRTPLUS_GETDATA |
|
146 || !informationElement || !descriptor || !descriptorContentType) |
|
147 { |
|
148 XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio); |
|
149 DEBUG_ERR("XA_RESULT_PARAMETER_INVALID"); |
|
150 /* invalid parameter */ |
|
151 DEBUG_API("<-XARDSItfImpl_GetRadioTextPlus"); |
|
152 return XA_RESULT_PARAMETER_INVALID; |
|
153 } |
|
154 |
|
155 #ifdef _GSTREAMER_BACKEND_ |
|
156 ret = XARDSItfAdapt_GetRadioTextPlus(impl->adapCtx, contentType, informationElement, |
|
157 descriptor, descriptorContentType); |
|
158 #endif |
|
159 XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio); |
|
160 DEBUG_API("<-XARDSItfImpl_GetRadioTextPlus"); |
|
161 return ret; |
|
162 } |
|
163 |
|
164 /** |
|
165 * XAresult XARDSItfImpl_GetProgrammeType(XARDSItf self, XAuint32 * pty) |
|
166 * Description: Gets the current Programme TYpe (PTY) as short. The |
|
167 * return value zero corresponds to No Programme Type |
|
168 * or to undefined type. Please note that PTYs in RBDS |
|
169 * differ from the ones in RDS. |
|
170 **/ |
|
171 XAresult XARDSItfImpl_GetProgrammeType(XARDSItf self, XAuint32 * pty) |
|
172 { |
|
173 XAresult ret = XA_RESULT_SUCCESS; |
|
174 XARDSItfImpl* impl = GetImpl(self); |
|
175 DEBUG_API("->XARDSItfImpl_GetProgrammeType"); |
|
176 |
|
177 if(!impl || !pty) |
|
178 { |
|
179 DEBUG_ERR("XA_RESULT_PARAMETER_INVALID"); |
|
180 /* invalid parameter */ |
|
181 DEBUG_API("<-XARDSItfImpl_GetProgrammeType"); |
|
182 return XA_RESULT_PARAMETER_INVALID; |
|
183 } |
|
184 |
|
185 #ifdef _GSTREAMER_BACKEND_ |
|
186 ret = XARDSItfAdapt_GetProgrammeType(impl->adapCtx, pty); |
|
187 #endif |
|
188 DEBUG_API("<-XARDSItfImpl_GetProgrammeType"); |
|
189 return ret; |
|
190 } |
|
191 |
|
192 /** |
|
193 * XAresult XARDSItfImpl_GetProgrammeTypeString(XARDSItf self, |
|
194 * XAboolean isLengthMax16, |
|
195 * XAchar * pty) |
|
196 * Description: Gets the current Programme TYpe (PTY) as a String with |
|
197 * the maximum of 8 or 16 characters in English (char set TBD) |
|
198 * as defined in RDS and RBDS specifications. Please note |
|
199 * that PTYs in RBDS differ from the ones in RDS. |
|
200 **/ |
|
201 XAresult XARDSItfImpl_GetProgrammeTypeString(XARDSItf self, |
|
202 XAboolean isLengthMax16, |
|
203 XAchar * pty) |
|
204 { |
|
205 XAresult ret = XA_RESULT_SUCCESS; |
|
206 XARDSItfImpl* impl = GetImpl(self); |
|
207 DEBUG_API("->XARDSItfImpl_GetProgrammeTypeString"); |
|
208 XA_IMPL_THREAD_SAFETY_ENTRY(XATSRadio); |
|
209 |
|
210 if(!impl || !pty) |
|
211 { |
|
212 XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio); |
|
213 DEBUG_ERR("XA_RESULT_PARAMETER_INVALID"); |
|
214 /* invalid parameter */ |
|
215 DEBUG_API("<-XARDSItfImpl_GetProgrammeTypeString"); |
|
216 return XA_RESULT_PARAMETER_INVALID; |
|
217 } |
|
218 |
|
219 #ifdef _GSTREAMER_BACKEND_ |
|
220 ret = XARDSItfAdapt_GetProgrammeTypeString(impl->adapCtx, isLengthMax16, pty); |
|
221 #endif |
|
222 XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio); |
|
223 DEBUG_API("<-XARDSItfImpl_GetProgrammeTypeString"); |
|
224 return ret; |
|
225 } |
|
226 |
|
227 /** |
|
228 * XAresult XARDSItfImpl_GetProgrammeIdentificationCode(XARDSItf self, XAint16 * pi) |
|
229 * Description: Gets the current Programme Identification code (PI). The PI is not |
|
230 * intended for directly displaying to the end user, but instead to |
|
231 * identify uniquely a programme. This can be used to detect that two |
|
232 * frequencies are transmitting the same programme. |
|
233 **/ |
|
234 XAresult XARDSItfImpl_GetProgrammeIdentificationCode(XARDSItf self, XAint16 * pi) |
|
235 { |
|
236 XAresult ret = XA_RESULT_SUCCESS; |
|
237 XARDSItfImpl* impl = GetImpl(self); |
|
238 DEBUG_API("->XARDSItfImpl_GetProgrammeIdentificationCode"); |
|
239 XA_IMPL_THREAD_SAFETY_ENTRY(XATSRadio); |
|
240 |
|
241 if(!impl || !pi) |
|
242 { |
|
243 XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio); |
|
244 DEBUG_ERR("XA_RESULT_PARAMETER_INVALID"); |
|
245 /* invalid parameter */ |
|
246 DEBUG_API("<-XARDSItfImpl_GetProgrammeIdentificationCode"); |
|
247 return XA_RESULT_PARAMETER_INVALID; |
|
248 } |
|
249 |
|
250 #ifdef _GSTREAMER_BACKEND_ |
|
251 ret = XARDSItfAdapt_GetProgrammeIdentificationCode(impl->adapCtx, pi); |
|
252 #endif |
|
253 XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio); |
|
254 DEBUG_API("<-XARDSItfImpl_GetProgrammeIdentificationCode"); |
|
255 return ret; |
|
256 } |
|
257 |
|
258 /** |
|
259 * XAresult XARDSItfImpl_GetClockTime(XARDSItf self, XAtime * dateAndTime) |
|
260 * Description: Gets the current Clock Time and date (CT). |
|
261 **/ |
|
262 XAresult XARDSItfImpl_GetClockTime(XARDSItf self, XAtime * dateAndTime) |
|
263 { |
|
264 XAresult ret = XA_RESULT_SUCCESS; |
|
265 XARDSItfImpl* impl = GetImpl(self); |
|
266 DEBUG_API("->XARDSItfImpl_GetClockTime"); |
|
267 XA_IMPL_THREAD_SAFETY_ENTRY(XATSRadio); |
|
268 |
|
269 if(!impl || !dateAndTime) |
|
270 { |
|
271 XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio); |
|
272 DEBUG_ERR("XA_RESULT_PARAMETER_INVALID"); |
|
273 /* invalid parameter */ |
|
274 DEBUG_API("<-XARDSItfImpl_GetClockTime"); |
|
275 return XA_RESULT_PARAMETER_INVALID; |
|
276 } |
|
277 |
|
278 #ifdef _GSTREAMER_BACKEND_ |
|
279 ret = XARDSItfAdapt_GetClockTime(impl->adapCtx, dateAndTime); |
|
280 #endif |
|
281 XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio); |
|
282 DEBUG_API("<-XARDSItfImpl_GetClockTime"); |
|
283 return ret; |
|
284 } |
|
285 |
|
286 /** |
|
287 * XAresult XARDSItfImpl_GetTrafficAnnouncement(XARDSItf self, XAboolean * ta) |
|
288 * Description: Gets the current status of the Traffic Announcement (TA) switch. |
|
289 **/ |
|
290 XAresult XARDSItfImpl_GetTrafficAnnouncement(XARDSItf self, XAboolean * ta) |
|
291 { |
|
292 XAresult ret = XA_RESULT_SUCCESS; |
|
293 XARDSItfImpl* impl = GetImpl(self); |
|
294 DEBUG_API("->XARDSItfImpl_GetTrafficAnnouncement"); |
|
295 XA_IMPL_THREAD_SAFETY_ENTRY(XATSRadio); |
|
296 |
|
297 if(!impl || !ta) |
|
298 { |
|
299 XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio); |
|
300 DEBUG_ERR("XA_RESULT_PARAMETER_INVALID"); |
|
301 /* invalid parameter */ |
|
302 DEBUG_API("<-XARDSItfImpl_GetTrafficAnnouncement"); |
|
303 return XA_RESULT_PARAMETER_INVALID; |
|
304 } |
|
305 |
|
306 #ifdef _GSTREAMER_BACKEND_ |
|
307 ret = XARDSItfAdapt_GetTrafficAnnouncement(impl->adapCtx, ta); |
|
308 #endif |
|
309 XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio); |
|
310 DEBUG_API("<-XARDSItfImpl_GetTrafficAnnouncement"); |
|
311 return ret; |
|
312 } |
|
313 |
|
314 /** |
|
315 * XAresult XARDSItfImpl_GetTrafficProgramme(XARDSItf self, XAboolean * tp) |
|
316 * Description: Gets the current status of the Traffic Programme (TP) switch. |
|
317 **/ |
|
318 XAresult XARDSItfImpl_GetTrafficProgramme(XARDSItf self, XAboolean * tp) |
|
319 { |
|
320 XAresult ret = XA_RESULT_SUCCESS; |
|
321 XARDSItfImpl* impl = GetImpl(self); |
|
322 DEBUG_API("->XARDSItfImpl_GetTrafficProgramme"); |
|
323 XA_IMPL_THREAD_SAFETY_ENTRY(XATSRadio); |
|
324 |
|
325 if(!impl || !tp) |
|
326 { |
|
327 XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio); |
|
328 DEBUG_ERR("XA_RESULT_PARAMETER_INVALID"); |
|
329 /* invalid parameter */ |
|
330 DEBUG_API("<-XARDSItfImpl_GetTrafficProgramme"); |
|
331 return XA_RESULT_PARAMETER_INVALID; |
|
332 } |
|
333 |
|
334 #ifdef _GSTREAMER_BACKEND_ |
|
335 ret = XARDSItfAdapt_GetTrafficProgramme(impl->adapCtx, tp); |
|
336 #endif |
|
337 XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio); |
|
338 DEBUG_API("<-XARDSItfImpl_GetTrafficProgramme"); |
|
339 return ret; |
|
340 } |
|
341 |
|
342 /** |
|
343 * XAresult XARDSItfImpl_SeekByProgrammeType(XARDSItf self, |
|
344 * XAuint32 pty, |
|
345 * XAboolean upwards) |
|
346 * Description: Seeks for the frequency sending the given Programme TYpe (PTY). |
|
347 * If the end of the tuner’s frequency band is reached before the |
|
348 * given Programme TYpe is found, the scan continues from the other |
|
349 * end until the given Programme TYpe is found or the original frequency |
|
350 * is reached. Asynchronous - tuner callback xaRadioCallback() and |
|
351 * XA_RADIO_EVENT_SEEK_COMPLETED is used for notifying of the result. |
|
352 * StopSeeking() method of XARadioItf can be used to abort an ongoing seek. |
|
353 **/ |
|
354 XAresult XARDSItfImpl_SeekByProgrammeType(XARDSItf self, |
|
355 XAuint32 pty, |
|
356 XAboolean upwards) |
|
357 { |
|
358 XAresult ret = XA_RESULT_SUCCESS; |
|
359 XARDSItfImpl* impl = GetImpl(self); |
|
360 DEBUG_API("->XARDSItfImpl_SeekByProgrammeType"); |
|
361 XA_IMPL_THREAD_SAFETY_ENTRY(XATSRadio); |
|
362 if(!impl || pty > XA_RDSPROGRAMMETYPE_RDSPTY_ALARM) |
|
363 { |
|
364 XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio); |
|
365 DEBUG_ERR("XA_RESULT_PARAMETER_INVALID"); |
|
366 /* invalid parameter */ |
|
367 DEBUG_API("<-XARDSItfImpl_SeekByProgrammeType"); |
|
368 return XA_RESULT_PARAMETER_INVALID; |
|
369 } |
|
370 |
|
371 #ifdef _GSTREAMER_BACKEND_ |
|
372 ret = XARDSItfAdapt_SeekByProgrammeType(impl->adapCtx, pty, upwards); |
|
373 #endif |
|
374 XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio); |
|
375 DEBUG_API("<-XARDSItfImpl_SeekByProgrammeType"); |
|
376 return ret; |
|
377 } |
|
378 |
|
379 /** |
|
380 * XAresult XARDSItfImpl_SeekTrafficAnnouncement(XARDSItf self, XAboolean upwards) |
|
381 * Description: Seeks for a frequency sending Traffic Announcement (TA). If the end |
|
382 * of the tuner’s frequency band is reached before a Traffic Announcement |
|
383 * is found, the scan continues from the other end until a Traffic |
|
384 * Announcement is found or the original frequency is reached. Asynchronous |
|
385 * - tuner callback xaRadioCallback() and XA_RADIO_EVENT_SEEK_COMPLETED |
|
386 * is used for notifying of the result. StopSeeking() method of XARadioItf |
|
387 * can be used to abort an ongoing seek. |
|
388 **/ |
|
389 XAresult XARDSItfImpl_SeekTrafficAnnouncement(XARDSItf self, XAboolean upwards) |
|
390 { |
|
391 XAresult ret = XA_RESULT_SUCCESS; |
|
392 XARDSItfImpl* impl = GetImpl(self); |
|
393 DEBUG_API("->XARDSItfImpl_SeekTrafficAnnouncement"); |
|
394 XA_IMPL_THREAD_SAFETY_ENTRY(XATSRadio); |
|
395 if(!impl) |
|
396 { |
|
397 XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio); |
|
398 DEBUG_ERR("XA_RESULT_PARAMETER_INVALID"); |
|
399 /* invalid parameter */ |
|
400 DEBUG_API("<-XARDSItfImpl_SeekTrafficAnnouncement"); |
|
401 return XA_RESULT_PARAMETER_INVALID; |
|
402 } |
|
403 |
|
404 #ifdef _GSTREAMER_BACKEND_ |
|
405 ret = XARDSItfAdapt_SeekTrafficAnnouncement(impl->adapCtx, upwards); |
|
406 #endif |
|
407 XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio); |
|
408 DEBUG_API("<-XARDSItfImpl_SeekTrafficAnnouncement"); |
|
409 return ret; |
|
410 } |
|
411 |
|
412 /** |
|
413 * XAresult XARDSItfImpl_SeekTrafficProgramme(XARDSItf self, XAboolean upwards) |
|
414 * Description: Seeks for a frequency sending Traffic Programme (TP). If the end |
|
415 * of the tuner’s frequency band is reached before a Traffic Programme |
|
416 * is found, the scan continues from the other end until a Traffic |
|
417 * Programme is found or the original frequency is reached. Asynchronous |
|
418 * - tuner callback xaRadioCallback() and XA_RADIO_EVENT_SEEK_COMPLETED |
|
419 * is used for notifying of the result. StopSeeking() method of XARadioItf |
|
420 * can be used to abort an ongoing seek. |
|
421 **/ |
|
422 XAresult XARDSItfImpl_SeekTrafficProgramme(XARDSItf self, XAboolean upwards) |
|
423 { |
|
424 XAresult ret = XA_RESULT_SUCCESS; |
|
425 XARDSItfImpl* impl = GetImpl(self); |
|
426 DEBUG_API("->XARDSItfImpl_SeekTrafficProgramme"); |
|
427 XA_IMPL_THREAD_SAFETY_ENTRY(XATSRadio); |
|
428 if(!impl) |
|
429 { |
|
430 XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio); |
|
431 DEBUG_ERR("XA_RESULT_PARAMETER_INVALID"); |
|
432 /* invalid parameter */ |
|
433 DEBUG_API("<-XARDSItfImpl_SeekTrafficProgramme"); |
|
434 return XA_RESULT_PARAMETER_INVALID; |
|
435 } |
|
436 |
|
437 #ifdef _GSTREAMER_BACKEND_ |
|
438 ret = XARDSItfAdapt_SeekTrafficProgramme(impl->adapCtx, upwards); |
|
439 #endif |
|
440 XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio); |
|
441 DEBUG_API("<-XARDSItfImpl_SeekTrafficProgramme"); |
|
442 return ret; |
|
443 } |
|
444 |
|
445 /** |
|
446 * XAresult XARDSItfImpl_SetAutomaticSwitching(XARDSItf self, XAboolean automatic) |
|
447 * Description: Sets the automatic switching of the transmitter in the case of a |
|
448 * stronger transmitter with the same PI presence. Based on AF and/or |
|
449 * EON fields. Please note that NOT ALL IMPLEMENTATIONS SUPPORT THIS |
|
450 * FUNCTIONALITY. |
|
451 **/ |
|
452 XAresult XARDSItfImpl_SetAutomaticSwitching(XARDSItf self, XAboolean automatic) |
|
453 { |
|
454 XAresult ret = XA_RESULT_SUCCESS; |
|
455 XARDSItfImpl* impl = GetImpl(self); |
|
456 DEBUG_API("->XARDSItfImpl_SetAutomaticSwitching"); |
|
457 XA_IMPL_THREAD_SAFETY_ENTRY(XATSRadio); |
|
458 if(!impl) |
|
459 { |
|
460 XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio); |
|
461 DEBUG_ERR("XA_RESULT_PARAMETER_INVALID"); |
|
462 /* invalid parameter */ |
|
463 DEBUG_API("<-XARDSItfImpl_SetAutomaticSwitching"); |
|
464 return XA_RESULT_PARAMETER_INVALID; |
|
465 } |
|
466 |
|
467 #ifdef _GSTREAMER_BACKEND_ |
|
468 ret = XARDSItfAdapt_SetAutomaticSwitching(impl->adapCtx, automatic); |
|
469 #endif |
|
470 XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio); |
|
471 DEBUG_API("<-XARDSItfImpl_SetAutomaticSwitching"); |
|
472 return ret; |
|
473 } |
|
474 |
|
475 /** |
|
476 * XAresult XARDSItfImpl_GetAutomaticSwitching(XARDSItf self, XAboolean * automatic) |
|
477 * Description: Gets the mode of the automatic switching of the transmitter in |
|
478 * case of a stronger transmitter with the same PI presence. |
|
479 **/ |
|
480 XAresult XARDSItfImpl_GetAutomaticSwitching(XARDSItf self, XAboolean * automatic) |
|
481 { |
|
482 XAresult ret = XA_RESULT_SUCCESS; |
|
483 XARDSItfImpl* impl = GetImpl(self); |
|
484 DEBUG_API("->XARDSItfImpl_GetAutomaticSwitching"); |
|
485 XA_IMPL_THREAD_SAFETY_ENTRY(XATSRadio); |
|
486 if(!impl || !automatic) |
|
487 { |
|
488 XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio); |
|
489 DEBUG_ERR("XA_RESULT_PARAMETER_INVALID"); |
|
490 /* invalid parameter */ |
|
491 DEBUG_API("<-XARDSItfImpl_GetAutomaticSwitching"); |
|
492 return XA_RESULT_PARAMETER_INVALID; |
|
493 } |
|
494 |
|
495 #ifdef _GSTREAMER_BACKEND_ |
|
496 ret = XARDSItfAdapt_GetAutomaticSwitching(impl->adapCtx, automatic); |
|
497 #endif |
|
498 XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio); |
|
499 DEBUG_API("<-XARDSItfImpl_GetAutomaticSwitching"); |
|
500 return ret; |
|
501 } |
|
502 |
|
503 /** |
|
504 * XAresult XARDSItfImpl_SetAutomaticTrafficAnnouncement(XARDSItf self, XAboolean automatic) |
|
505 * Description: Sets the automatic switching of the program in case of the presence |
|
506 * of Traffic Announcement in another program. Based on TP and TA fields. |
|
507 * Please note that NOT ALL IMPLEMENTATIONS SUPPORT THIS FUNCTIONALITY. |
|
508 **/ |
|
509 XAresult XARDSItfImpl_SetAutomaticTrafficAnnouncement(XARDSItf self, XAboolean automatic) |
|
510 { |
|
511 XAresult ret = XA_RESULT_SUCCESS; |
|
512 XARDSItfImpl* impl = GetImpl(self); |
|
513 DEBUG_API("->XARDSItfImpl_SetAutomaticTrafficAnnouncement"); |
|
514 XA_IMPL_THREAD_SAFETY_ENTRY(XATSRadio); |
|
515 if(!impl) |
|
516 { |
|
517 XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio); |
|
518 DEBUG_ERR("XA_RESULT_PARAMETER_INVALID"); |
|
519 /* invalid parameter */ |
|
520 DEBUG_API("<-XARDSItfImpl_SetAutomaticTrafficAnnouncement"); |
|
521 return XA_RESULT_PARAMETER_INVALID; |
|
522 } |
|
523 |
|
524 #ifdef _GSTREAMER_BACKEND_ |
|
525 ret = XARDSItfAdapt_SetAutomaticTrafficAnnouncement(impl->adapCtx, automatic); |
|
526 #endif |
|
527 XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio); |
|
528 DEBUG_API("<-XARDSItfImpl_SetAutomaticTrafficAnnouncement"); |
|
529 return ret; |
|
530 } |
|
531 |
|
532 /** |
|
533 * XAresult XARDSItfImpl_GetAutomaticTrafficAnnouncement(XARDSItf self, XAboolean * automatic) |
|
534 * Description: Gets the mode of the automatic switching of the program in case of |
|
535 * the presence of Traffic Announcement in another program. Based on |
|
536 * TP and TA fields. |
|
537 **/ |
|
538 XAresult XARDSItfImpl_GetAutomaticTrafficAnnouncement(XARDSItf self, XAboolean * automatic) |
|
539 { |
|
540 XAresult ret = XA_RESULT_SUCCESS; |
|
541 XARDSItfImpl* impl = GetImpl(self); |
|
542 DEBUG_API("->XARDSItfImpl_GetAutomaticTrafficAnnouncement"); |
|
543 XA_IMPL_THREAD_SAFETY_ENTRY(XATSRadio); |
|
544 if(!impl || !automatic) |
|
545 { |
|
546 XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio); |
|
547 DEBUG_ERR("XA_RESULT_PARAMETER_INVALID"); |
|
548 /* invalid parameter */ |
|
549 DEBUG_API("<-XARDSItfImpl_GetAutomaticTrafficAnnouncement"); |
|
550 |
|
551 return XA_RESULT_PARAMETER_INVALID; |
|
552 } |
|
553 |
|
554 #ifdef _GSTREAMER_BACKEND_ |
|
555 ret = XARDSItfAdapt_GetAutomaticTrafficAnnouncement(impl->adapCtx, automatic); |
|
556 #endif |
|
557 XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio); |
|
558 DEBUG_API("<-XARDSItfImpl_GetAutomaticTrafficAnnouncement"); |
|
559 return ret; |
|
560 } |
|
561 |
|
562 /** |
|
563 * XAresult XARDSItfImpl_GetODAGroup(XARDSItf self, |
|
564 * XAint16 AID, |
|
565 * xaGetODAGroupCallback callback, |
|
566 * void * pContext) |
|
567 * Description: Returns asynchronously via callback (xaGetODAGroupCallback()) |
|
568 * the application Group and the message bits concerning the given |
|
569 * ODA (Open Data Application). ODA is a mechanism that a broadcaster |
|
570 * can use to transfer data that is not explicitly specified in the RDS |
|
571 * standard. Open Data Applications are subject to a registration process. |
|
572 * Transmission protocols used by ODAs may be public or private. See RDS |
|
573 * Forum web page (http://www.rds.org.uk/)for details. |
|
574 **/ |
|
575 XAresult XARDSItfImpl_GetODAGroup(XARDSItf self, |
|
576 XAuint16 AID, |
|
577 xaGetODAGroupCallback callback, |
|
578 void * pContext) |
|
579 { |
|
580 XAresult ret = XA_RESULT_SUCCESS; |
|
581 XARDSItfImpl* impl = GetImpl(self); |
|
582 DEBUG_API("->XARDSItfImpl_GetODAGroup"); |
|
583 XA_IMPL_THREAD_SAFETY_ENTRY(XATSRadio); |
|
584 if(!impl) |
|
585 { |
|
586 XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio); |
|
587 DEBUG_ERR("XA_RESULT_PARAMETER_INVALID"); |
|
588 /* invalid parameter */ |
|
589 DEBUG_API("<-XARDSItfImpl_GetODAGroup"); |
|
590 return XA_RESULT_PARAMETER_INVALID; |
|
591 } |
|
592 |
|
593 impl->odaGroupCallback = callback; |
|
594 impl->odaGroupContext = pContext; |
|
595 impl->odaGroupCbPtrToSelf = self; |
|
596 |
|
597 if (callback) |
|
598 { |
|
599 #ifdef _GSTREAMER_BACKEND_ |
|
600 ret = XARDSItfAdapt_GetODAGroup(impl->adapCtx, AID); |
|
601 #endif |
|
602 } |
|
603 |
|
604 XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio); |
|
605 DEBUG_API("<-XARDSItfImpl_GetODAGroup"); |
|
606 |
|
607 return ret; |
|
608 } |
|
609 |
|
610 /** |
|
611 * XAresult XARDSItfImpl_SubscribeODAGroup(XARDSItf self, |
|
612 * XAint16 group, |
|
613 * XAboolean useErrorCorrection) |
|
614 * Description: Subscribes the given ODA group. If the given group was already |
|
615 * subscribed, this call doesn’t do anything. Only new data in groups |
|
616 * that have been subscribed will cause a newODA callback. |
|
617 **/ |
|
618 XAresult XARDSItfImpl_SubscribeODAGroup(XARDSItf self, |
|
619 XAint16 group, |
|
620 XAboolean useErrorCorrection) |
|
621 { |
|
622 XAresult ret = XA_RESULT_SUCCESS; |
|
623 XARDSItfImpl* impl = GetImpl(self); |
|
624 |
|
625 DEBUG_API("->XARDSItfImpl_SubscribeODAGroup"); |
|
626 XA_IMPL_THREAD_SAFETY_ENTRY(XATSRadio); |
|
627 |
|
628 if(!impl) |
|
629 { |
|
630 XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio); |
|
631 DEBUG_ERR("XA_RESULT_PARAMETER_INVALID"); |
|
632 /* invalid parameter */ |
|
633 DEBUG_API("<-XARDSItfImpl_SubscribeODAGroup"); |
|
634 return XA_RESULT_PARAMETER_INVALID; |
|
635 } |
|
636 |
|
637 #ifdef _GSTREAMER_BACKEND_ |
|
638 ret = XARDSItfAdapt_SubscribeODAGroup(impl->adapCtx, group, useErrorCorrection); |
|
639 #endif |
|
640 XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio); |
|
641 DEBUG_API("<-XARDSItfImpl_SubscribeODAGroup"); |
|
642 return ret; |
|
643 } |
|
644 |
|
645 /** |
|
646 * XAresult XARDSItfImpl_UnsubscribeODAGroup(XARDSItf self, XAint16 group) |
|
647 * Description: Unsubscribes the given ODA group. If the given group has not |
|
648 * been subscribed, this doesn’t do anything. Only new data in |
|
649 * groups that have been subscribed will cause a newODA callback. |
|
650 **/ |
|
651 XAresult XARDSItfImpl_UnsubscribeODAGroup(XARDSItf self, XAint16 group) |
|
652 { |
|
653 XAresult ret = XA_RESULT_SUCCESS; |
|
654 XARDSItfImpl* impl = GetImpl(self); |
|
655 |
|
656 DEBUG_API("->XARDSItfImpl_UnsubscribeODAGroup"); |
|
657 XA_IMPL_THREAD_SAFETY_ENTRY(XATSRadio); |
|
658 |
|
659 if(!impl) |
|
660 { |
|
661 XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio); |
|
662 DEBUG_ERR("XA_RESULT_PARAMETER_INVALID"); |
|
663 /* invalid parameter */ |
|
664 DEBUG_API("<-XARDSItfImpl_UnsubscribeODAGroup"); |
|
665 |
|
666 return XA_RESULT_PARAMETER_INVALID; |
|
667 } |
|
668 |
|
669 #ifdef _GSTREAMER_BACKEND_ |
|
670 ret = XARDSItfAdapt_UnsubscribeODAGroup(impl->adapCtx, group); |
|
671 #endif |
|
672 XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio); |
|
673 DEBUG_API("<-XARDSItfImpl_UnsubscribeODAGroup"); |
|
674 return ret; |
|
675 } |
|
676 |
|
677 /** |
|
678 * XAresult XARDSItfImpl_ListODAGroupSubscriptions(XARDSItf self, |
|
679 * XAint16* pGroups, |
|
680 * XAuint32* pLength); |
|
681 * Description: Lists ODA groups that are currently subscribed. |
|
682 **/ |
|
683 XAresult XARDSItfImpl_ListODAGroupSubscriptions(XARDSItf self, |
|
684 XAint16* pGroups, |
|
685 XAuint32* pLength) |
|
686 { |
|
687 XAresult ret = XA_RESULT_SUCCESS; |
|
688 XARDSItfImpl* impl = GetImpl(self); |
|
689 XA_IMPL_THREAD_SAFETY_ENTRY(XATSRadio); |
|
690 DEBUG_API("->XARDSItfImpl_ListODAGroupSubscriptions"); |
|
691 |
|
692 if(!impl || !pLength) |
|
693 { |
|
694 XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio); |
|
695 DEBUG_ERR("XA_RESULT_PARAMETER_INVALID"); |
|
696 /* invalid parameter */ |
|
697 DEBUG_API("<-XARDSItfImpl_ListODAGroupSubscriptions"); |
|
698 return XA_RESULT_PARAMETER_INVALID; |
|
699 } |
|
700 |
|
701 #ifdef _GSTREAMER_BACKEND_ |
|
702 XARDSItfAdapt_ListODAGroupSubscriptions(impl->adapCtx, pGroups, pLength); |
|
703 #endif |
|
704 XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio); |
|
705 DEBUG_API("<-XARDSItfImpl_ListODAGroupSubscriptions"); |
|
706 return ret; |
|
707 } |
|
708 |
|
709 /** |
|
710 * XAresult XARDSItfImpl_RegisterRDSCallback(XARDSItf self, |
|
711 * xaRDSCallback callback, |
|
712 * void * pContext) |
|
713 * Description: Sets or clears the xaNewODADataCallback(). xaNewODADataCallback() |
|
714 * is used tranfer the actual ODA data to the application. |
|
715 **/ |
|
716 XAresult XARDSItfImpl_RegisterRDSCallback(XARDSItf self, |
|
717 xaRDSCallback callback, |
|
718 void * pContext) |
|
719 { |
|
720 XAresult ret = XA_RESULT_SUCCESS; |
|
721 XARDSItfImpl* impl = GetImpl(self); |
|
722 DEBUG_API("->XARDSItfImpl_RegisterRDSCallback"); |
|
723 |
|
724 if(!impl) |
|
725 { |
|
726 DEBUG_ERR("XA_RESULT_PARAMETER_INVALID"); |
|
727 /* invalid parameter */ |
|
728 DEBUG_API("<-XARDSItfImpl_RegisterRDSCallback"); |
|
729 return XA_RESULT_PARAMETER_INVALID; |
|
730 } |
|
731 |
|
732 impl->rdsCallback = callback; |
|
733 impl->rdsContext = pContext; |
|
734 impl->rdsCbPtrToSelf = self; |
|
735 |
|
736 DEBUG_API("<-XARDSItfImpl_RegisterRDSCallback"); |
|
737 return ret; |
|
738 } |
|
739 |
|
740 /** |
|
741 * XAresult XARDSItfImpl_RegisterODADataCallback(XARDSItf self, |
|
742 * xaNewODADataCallback callback, |
|
743 * void * pContext) |
|
744 * Description: Sets or clears the xaRDSCallback(). xaRDSCallback() is used to monitor |
|
745 * changes in RDS fields. |
|
746 **/ |
|
747 XAresult XARDSItfImpl_RegisterODADataCallback(XARDSItf self, |
|
748 xaNewODADataCallback callback, |
|
749 void * pContext) |
|
750 { |
|
751 |
|
752 XAresult ret = XA_RESULT_SUCCESS; |
|
753 XARDSItfImpl* impl = GetImpl(self); |
|
754 DEBUG_API("->XARDSItfImpl_RegisterODADataCallback"); |
|
755 |
|
756 if(!impl) |
|
757 { |
|
758 DEBUG_ERR("XA_RESULT_PARAMETER_INVALID"); |
|
759 /* invalid parameter */ |
|
760 DEBUG_API("<-XARDSItfImpl_RegisterODADataCallback"); |
|
761 return XA_RESULT_PARAMETER_INVALID; |
|
762 } |
|
763 |
|
764 impl->odaDataCallback = callback; |
|
765 impl->odaDataContext = pContext; |
|
766 impl->odaDataCbPtrToSelf = self; |
|
767 |
|
768 DEBUG_API("<-XARDSItfImpl_RegisterODADataCallback"); |
|
769 return ret; |
|
770 } |
|
771 |
|
772 /** |
|
773 * XARDSItfImpl -specific methods |
|
774 **/ |
|
775 #ifdef _GSTREAMER_BACKEND_ |
|
776 |
|
777 /** |
|
778 * XARDSItfImplImpl* XARDSItfImpl_Create() |
|
779 * @return XARDSItfImplImpl* - Pointer to RDSItf interface implementation |
|
780 **/ |
|
781 XARDSItfImpl* XARDSItfImpl_Create(XAAdaptationBaseCtx *adapCtx) |
|
782 { |
|
783 XARDSItfImpl *self = (XARDSItfImpl*) |
|
784 calloc(1,sizeof(XARDSItfImpl)); |
|
785 DEBUG_API("->XARDSItfImpl_Create"); |
|
786 if(self) |
|
787 { |
|
788 /* init itf default implementation */ |
|
789 self->itf.QueryRDSSignal = XARDSItfImpl_QueryRDSSignal; |
|
790 self->itf.GetProgrammeServiceName = XARDSItfImpl_GetProgrammeServiceName; |
|
791 self->itf.GetRadioText = XARDSItfImpl_GetRadioText; |
|
792 self->itf.GetRadioTextPlus = XARDSItfImpl_GetRadioTextPlus; |
|
793 self->itf.GetProgrammeType = XARDSItfImpl_GetProgrammeType; |
|
794 self->itf.GetProgrammeTypeString = XARDSItfImpl_GetProgrammeTypeString; |
|
795 self->itf.GetProgrammeIdentificationCode = XARDSItfImpl_GetProgrammeIdentificationCode; |
|
796 self->itf.GetClockTime = XARDSItfImpl_GetClockTime; |
|
797 self->itf.GetTrafficAnnouncement = XARDSItfImpl_GetTrafficAnnouncement; |
|
798 self->itf.GetTrafficProgramme = XARDSItfImpl_GetTrafficProgramme; |
|
799 self->itf.SeekByProgrammeType = XARDSItfImpl_SeekByProgrammeType; |
|
800 self->itf.SeekTrafficAnnouncement = XARDSItfImpl_SeekTrafficAnnouncement; |
|
801 self->itf.SeekTrafficProgramme = XARDSItfImpl_SeekTrafficProgramme; |
|
802 self->itf.SetAutomaticSwitching = XARDSItfImpl_SetAutomaticSwitching; |
|
803 self->itf.GetAutomaticSwitching = XARDSItfImpl_GetAutomaticSwitching; |
|
804 self->itf.SetAutomaticTrafficAnnouncement = XARDSItfImpl_SetAutomaticTrafficAnnouncement; |
|
805 self->itf.GetAutomaticTrafficAnnouncement = XARDSItfImpl_GetAutomaticTrafficAnnouncement; |
|
806 self->itf.GetODAGroup = XARDSItfImpl_GetODAGroup; |
|
807 self->itf.SubscribeODAGroup = XARDSItfImpl_SubscribeODAGroup; |
|
808 self->itf.UnsubscribeODAGroup = XARDSItfImpl_UnsubscribeODAGroup; |
|
809 self->itf.ListODAGroupSubscriptions = XARDSItfImpl_ListODAGroupSubscriptions; |
|
810 self->itf.RegisterRDSCallback = XARDSItfImpl_RegisterRDSCallback; |
|
811 self->itf.RegisterODADataCallback = XARDSItfImpl_RegisterODADataCallback; |
|
812 |
|
813 /* init variables */ |
|
814 |
|
815 self->odaDataCallback = NULL; |
|
816 self->odaDataContext = NULL; |
|
817 self->odaDataCbPtrToSelf = NULL; |
|
818 self->odaGroupCallback = NULL; |
|
819 self->odaGroupContext = NULL; |
|
820 self->odaGroupCbPtrToSelf = NULL; |
|
821 self->rdsCallback = NULL; |
|
822 self->rdsContext = NULL; |
|
823 self->rdsCbPtrToSelf = NULL; |
|
824 |
|
825 XAAdaptationBase_AddEventHandler( adapCtx, &XARDSItfImpl_AdaptCb, XA_RDSITFEVENTS, self ); |
|
826 |
|
827 self->adapCtx = adapCtx; |
|
828 |
|
829 self->self = self; |
|
830 } |
|
831 |
|
832 DEBUG_API("<-XARDSItfImpl_Create"); |
|
833 return self; |
|
834 } |
|
835 |
|
836 /* void XARDSItfImpl_AdaptCb( void *pHandlerCtx, XAAdaptEvent *event ) |
|
837 * @param void *pHandlerCtx - pointer to cb context (XARadioItfImpl) |
|
838 * @param XAAdaptEvent *event - Event |
|
839 * Description: Event handler for adaptation events |
|
840 */ |
|
841 void XARDSItfImpl_AdaptCb( void *pHandlerCtx, XAAdaptEvent *event ) |
|
842 { |
|
843 XARDSItfImpl* impl =(XARDSItfImpl*)pHandlerCtx; |
|
844 DEBUG_API("->XARDSItfImpl_AdaptCb"); |
|
845 |
|
846 if(!impl) |
|
847 { |
|
848 DEBUG_ERR("XARadioItfImpl_AdaptCb, invalid context pointer!"); |
|
849 DEBUG_API("<-XARDSItfImpl_AdaptCb"); |
|
850 return; |
|
851 } |
|
852 assert(event); |
|
853 |
|
854 if( event->eventid == XA_ADAPT_RDS_GET_ODA_GROUP_DONE && impl->odaGroupCallback ) |
|
855 { |
|
856 /* stubbed (enough for emulation purposes) */ |
|
857 /* XA_BOOLEAN_FALSE and -1 means oda group not found */ |
|
858 impl->odaGroupCallback( (XARadioItf) impl->odaGroupCbPtrToSelf, impl->odaGroupContext, XA_BOOLEAN_FALSE, -1, 0 ); |
|
859 } |
|
860 DEBUG_API("<-XARDSItfImpl_AdaptCb"); |
|
861 } |
|
862 #endif |
|
863 /** |
|
864 * void XARDSItfImpl_Free(XARDSItfImpl* self) |
|
865 * @param XARDSItfImpl* self - |
|
866 **/ |
|
867 void XARDSItfImpl_Free(XARDSItfImpl* self) |
|
868 { |
|
869 DEBUG_API("->XARDSItfImpl_Free"); |
|
870 XA_IMPL_THREAD_SAFETY_ENTRY_FOR_VOID_FUNCTIONS(XATSRadio); |
|
871 assert(self==self->self); |
|
872 #ifdef _GSTREAMER_BACKEND_ |
|
873 XAAdaptationBase_RemoveEventHandler( self->adapCtx, &XARDSItfImpl_AdaptCb ); |
|
874 |
|
875 XARDSItfAdapt_Free(self->adapCtx); |
|
876 #endif |
|
877 free(self); |
|
878 XA_IMPL_THREAD_SAFETY_EXIT_FOR_VOID_FUNCTIONS(XATSRadio); |
|
879 DEBUG_API("<-XARDSItfImpl_Free"); |
|
880 } |
|
881 |