/*
* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:
*
*/
#include <stdio.h>
#include <stdlib.h>
#include <assert.h>
#include "xardsitf.h"
#include "xardsitfadaptation.h"
#include "xathreadsafety.h"
#include "xaadaptationgst.h"
/**
* XARDSItfImpl* GetImpl(XARDSItf self)
* Description: Validated interface pointer and cast it to implementations pointer.
**/
static XARDSItfImpl* GetImpl(XARDSItf self)
{
if(self)
{
XARDSItfImpl *impl = (XARDSItfImpl*)(*self);
if(impl && impl == impl->self)
{
return impl;
}
}
return NULL;
}
/**
* Base interface XARDSItf implementation
*/
/**
* XAresult XARDSItfImpl_QueryRDSSignal(XARDSItf self, XAboolean * isSignal)
* Description: Returns the status of the RDS reception.
**/
XAresult XARDSItfImpl_QueryRDSSignal(XARDSItf self, XAboolean * isSignal)
{
XAresult ret = XA_RESULT_SUCCESS;
XARDSItfImpl* impl = GetImpl(self);
DEBUG_API("->XARDSItfImpl_QueryRDSSignal");
XA_IMPL_THREAD_SAFETY_ENTRY(XATSRadio);
if(!impl || !isSignal)
{
XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
/* invalid parameter */
DEBUG_API("<-XARDSItfImpl_QueryRDSSignal");
return XA_RESULT_PARAMETER_INVALID;
}
ret = XARDSItfAdapt_QueryRDSSignal((XAAdaptationGstCtx*)impl->adapCtx, isSignal);
XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
DEBUG_API("<-XARDSItfImpl_QueryRDSSignal");
return ret;
}
/**
* XAresult XARDSItfImpl_GetProgrammeServiceName(XARDSItf self, XAchar * ps)
* Description: Gets the current Programme Service name (PS).
**/
XAresult XARDSItfImpl_GetProgrammeServiceName(XARDSItf self, XAchar * ps)
{
XAresult ret = XA_RESULT_SUCCESS;
XARDSItfImpl* impl = GetImpl(self);
DEBUG_API("->XARDSItfImpl_GetProgrammeServiceName");
if(!impl || !ps)
{
DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
/* invalid parameter */
DEBUG_API("<-XARDSItfImpl_GetProgrammeServiceName");
return XA_RESULT_PARAMETER_INVALID;
}
ret = XARDSItfAdapt_GetProgrammeServiceName((XAAdaptationGstCtx*)impl->adapCtx, ps);
DEBUG_API("<-XARDSItfImpl_GetProgrammeServiceName");
return ret;
}
/**
* XAresult XARDSItfImpl_GetRadioText(XARDSItf self, XAchar * rt)
* Description: Gets the current Radio Text (RT).
**/
XAresult XARDSItfImpl_GetRadioText(XARDSItf self, XAchar * rt)
{
XAresult ret = XA_RESULT_SUCCESS;
XARDSItfImpl* impl = GetImpl(self);
DEBUG_API("->XARDSItfImpl_GetRadioText");
XA_IMPL_THREAD_SAFETY_ENTRY(XATSRadio);
if(!impl || !rt)
{
XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
/* invalid parameter */
DEBUG_API("<-XARDSItfImpl_GetRadioText");
return XA_RESULT_PARAMETER_INVALID;
}
ret = XARDSItfAdapt_GetRadioText((XAAdaptationGstCtx*)impl->adapCtx, rt);
XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
DEBUG_API("<-XARDSItfImpl_GetRadioText");
return ret;
}
/**
* XAresult XARDSItfImpl_GetRadioTextPlus(XARDSItf self,
* XAuint8 contentType,
* XAchar * informationElement,
* XAchar * descriptor,
* XAuint8 * descriptorContentType)
* Description: Gets the current Radio Text+ (RT+) information element based
* on the given class code.
**/
XAresult XARDSItfImpl_GetRadioTextPlus(XARDSItf self,
XAuint8 contentType,
XAchar * informationElement,
XAchar * descriptor,
XAuint8 * descriptorContentType)
{
XAresult ret = XA_RESULT_SUCCESS;
XARDSItfImpl* impl = GetImpl(self);
DEBUG_API("->XARDSItfImpl_GetRadioTextPlus");
XA_IMPL_THREAD_SAFETY_ENTRY(XATSRadio);
if(!impl || contentType < XA_RDSRTPLUS_ITEMTITLE || contentType > XA_RDSRTPLUS_GETDATA
|| !informationElement || !descriptor || !descriptorContentType)
{
XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
/* invalid parameter */
DEBUG_API("<-XARDSItfImpl_GetRadioTextPlus");
return XA_RESULT_PARAMETER_INVALID;
}
ret = XARDSItfAdapt_GetRadioTextPlus((XAAdaptationGstCtx*)impl->adapCtx, contentType, informationElement,
descriptor, descriptorContentType);
XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
DEBUG_API("<-XARDSItfImpl_GetRadioTextPlus");
return ret;
}
/**
* XAresult XARDSItfImpl_GetProgrammeType(XARDSItf self, XAuint32 * pty)
* Description: Gets the current Programme TYpe (PTY) as short. The
* return value zero corresponds to No Programme Type
* or to undefined type. Please note that PTYs in RBDS
* differ from the ones in RDS.
**/
XAresult XARDSItfImpl_GetProgrammeType(XARDSItf self, XAuint32 * pty)
{
XAresult ret = XA_RESULT_SUCCESS;
XARDSItfImpl* impl = GetImpl(self);
DEBUG_API("->XARDSItfImpl_GetProgrammeType");
if(!impl || !pty)
{
DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
/* invalid parameter */
DEBUG_API("<-XARDSItfImpl_GetProgrammeType");
return XA_RESULT_PARAMETER_INVALID;
}
ret = XARDSItfAdapt_GetProgrammeType((XAAdaptationGstCtx*)impl->adapCtx, pty);
DEBUG_API("<-XARDSItfImpl_GetProgrammeType");
return ret;
}
/**
* XAresult XARDSItfImpl_GetProgrammeTypeString(XARDSItf self,
* XAboolean isLengthMax16,
* XAchar * pty)
* Description: Gets the current Programme TYpe (PTY) as a String with
* the maximum of 8 or 16 characters in English (char set TBD)
* as defined in RDS and RBDS specifications. Please note
* that PTYs in RBDS differ from the ones in RDS.
**/
XAresult XARDSItfImpl_GetProgrammeTypeString(XARDSItf self,
XAboolean isLengthMax16,
XAchar * pty)
{
XAresult ret = XA_RESULT_SUCCESS;
XARDSItfImpl* impl = GetImpl(self);
DEBUG_API("->XARDSItfImpl_GetProgrammeTypeString");
XA_IMPL_THREAD_SAFETY_ENTRY(XATSRadio);
if(!impl || !pty)
{
XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
/* invalid parameter */
DEBUG_API("<-XARDSItfImpl_GetProgrammeTypeString");
return XA_RESULT_PARAMETER_INVALID;
}
ret = XARDSItfAdapt_GetProgrammeTypeString((XAAdaptationGstCtx*)impl->adapCtx, isLengthMax16, pty);
XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
DEBUG_API("<-XARDSItfImpl_GetProgrammeTypeString");
return ret;
}
/**
* XAresult XARDSItfImpl_GetProgrammeIdentificationCode(XARDSItf self, XAint16 * pi)
* Description: Gets the current Programme Identification code (PI). The PI is not
* intended for directly displaying to the end user, but instead to
* identify uniquely a programme. This can be used to detect that two
* frequencies are transmitting the same programme.
**/
XAresult XARDSItfImpl_GetProgrammeIdentificationCode(XARDSItf self, XAint16 * pi)
{
XAresult ret = XA_RESULT_SUCCESS;
XARDSItfImpl* impl = GetImpl(self);
DEBUG_API("->XARDSItfImpl_GetProgrammeIdentificationCode");
XA_IMPL_THREAD_SAFETY_ENTRY(XATSRadio);
if(!impl || !pi)
{
XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
/* invalid parameter */
DEBUG_API("<-XARDSItfImpl_GetProgrammeIdentificationCode");
return XA_RESULT_PARAMETER_INVALID;
}
ret = XARDSItfAdapt_GetProgrammeIdentificationCode((XAAdaptationGstCtx*)impl->adapCtx, pi);
XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
DEBUG_API("<-XARDSItfImpl_GetProgrammeIdentificationCode");
return ret;
}
/**
* XAresult XARDSItfImpl_GetClockTime(XARDSItf self, XAtime * dateAndTime)
* Description: Gets the current Clock Time and date (CT).
**/
XAresult XARDSItfImpl_GetClockTime(XARDSItf self, XAtime * dateAndTime)
{
XAresult ret = XA_RESULT_SUCCESS;
XARDSItfImpl* impl = GetImpl(self);
DEBUG_API("->XARDSItfImpl_GetClockTime");
XA_IMPL_THREAD_SAFETY_ENTRY(XATSRadio);
if(!impl || !dateAndTime)
{
XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
/* invalid parameter */
DEBUG_API("<-XARDSItfImpl_GetClockTime");
return XA_RESULT_PARAMETER_INVALID;
}
ret = XARDSItfAdapt_GetClockTime((XAAdaptationGstCtx*)impl->adapCtx, dateAndTime);
XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
DEBUG_API("<-XARDSItfImpl_GetClockTime");
return ret;
}
/**
* XAresult XARDSItfImpl_GetTrafficAnnouncement(XARDSItf self, XAboolean * ta)
* Description: Gets the current status of the Traffic Announcement (TA) switch.
**/
XAresult XARDSItfImpl_GetTrafficAnnouncement(XARDSItf self, XAboolean * ta)
{
XAresult ret = XA_RESULT_SUCCESS;
XARDSItfImpl* impl = GetImpl(self);
DEBUG_API("->XARDSItfImpl_GetTrafficAnnouncement");
XA_IMPL_THREAD_SAFETY_ENTRY(XATSRadio);
if(!impl || !ta)
{
XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
/* invalid parameter */
DEBUG_API("<-XARDSItfImpl_GetTrafficAnnouncement");
return XA_RESULT_PARAMETER_INVALID;
}
ret = XARDSItfAdapt_GetTrafficAnnouncement((XAAdaptationGstCtx*)impl->adapCtx, ta);
XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
DEBUG_API("<-XARDSItfImpl_GetTrafficAnnouncement");
return ret;
}
/**
* XAresult XARDSItfImpl_GetTrafficProgramme(XARDSItf self, XAboolean * tp)
* Description: Gets the current status of the Traffic Programme (TP) switch.
**/
XAresult XARDSItfImpl_GetTrafficProgramme(XARDSItf self, XAboolean * tp)
{
XAresult ret = XA_RESULT_SUCCESS;
XARDSItfImpl* impl = GetImpl(self);
DEBUG_API("->XARDSItfImpl_GetTrafficProgramme");
XA_IMPL_THREAD_SAFETY_ENTRY(XATSRadio);
if(!impl || !tp)
{
XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
/* invalid parameter */
DEBUG_API("<-XARDSItfImpl_GetTrafficProgramme");
return XA_RESULT_PARAMETER_INVALID;
}
ret = XARDSItfAdapt_GetTrafficProgramme((XAAdaptationGstCtx*)impl->adapCtx, tp);
XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
DEBUG_API("<-XARDSItfImpl_GetTrafficProgramme");
return ret;
}
/**
* XAresult XARDSItfImpl_SeekByProgrammeType(XARDSItf self,
* XAuint32 pty,
* XAboolean upwards)
* Description: Seeks for the frequency sending the given Programme TYpe (PTY).
* If the end of the tuner’s frequency band is reached before the
* given Programme TYpe is found, the scan continues from the other
* end until the given Programme TYpe is found or the original frequency
* is reached. Asynchronous - tuner callback xaRadioCallback() and
* XA_RADIO_EVENT_SEEK_COMPLETED is used for notifying of the result.
* StopSeeking() method of XARadioItf can be used to abort an ongoing seek.
**/
XAresult XARDSItfImpl_SeekByProgrammeType(XARDSItf self,
XAuint32 pty,
XAboolean upwards)
{
XAresult ret = XA_RESULT_SUCCESS;
XARDSItfImpl* impl = GetImpl(self);
DEBUG_API("->XARDSItfImpl_SeekByProgrammeType");
XA_IMPL_THREAD_SAFETY_ENTRY(XATSRadio);
if(!impl || pty > XA_RDSPROGRAMMETYPE_RDSPTY_ALARM)
{
XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
/* invalid parameter */
DEBUG_API("<-XARDSItfImpl_SeekByProgrammeType");
return XA_RESULT_PARAMETER_INVALID;
}
ret = XARDSItfAdapt_SeekByProgrammeType((XAAdaptationGstCtx*)impl->adapCtx, pty, upwards);
XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
DEBUG_API("<-XARDSItfImpl_SeekByProgrammeType");
return ret;
}
/**
* XAresult XARDSItfImpl_SeekTrafficAnnouncement(XARDSItf self, XAboolean upwards)
* Description: Seeks for a frequency sending Traffic Announcement (TA). If the end
* of the tuner’s frequency band is reached before a Traffic Announcement
* is found, the scan continues from the other end until a Traffic
* Announcement is found or the original frequency is reached. Asynchronous
* - tuner callback xaRadioCallback() and XA_RADIO_EVENT_SEEK_COMPLETED
* is used for notifying of the result. StopSeeking() method of XARadioItf
* can be used to abort an ongoing seek.
**/
XAresult XARDSItfImpl_SeekTrafficAnnouncement(XARDSItf self, XAboolean upwards)
{
XAresult ret = XA_RESULT_SUCCESS;
XARDSItfImpl* impl = GetImpl(self);
DEBUG_API("->XARDSItfImpl_SeekTrafficAnnouncement");
XA_IMPL_THREAD_SAFETY_ENTRY(XATSRadio);
if(!impl)
{
XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
/* invalid parameter */
DEBUG_API("<-XARDSItfImpl_SeekTrafficAnnouncement");
return XA_RESULT_PARAMETER_INVALID;
}
ret = XARDSItfAdapt_SeekTrafficAnnouncement((XAAdaptationGstCtx*)impl->adapCtx, upwards);
XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
DEBUG_API("<-XARDSItfImpl_SeekTrafficAnnouncement");
return ret;
}
/**
* XAresult XARDSItfImpl_SeekTrafficProgramme(XARDSItf self, XAboolean upwards)
* Description: Seeks for a frequency sending Traffic Programme (TP). If the end
* of the tuner’s frequency band is reached before a Traffic Programme
* is found, the scan continues from the other end until a Traffic
* Programme is found or the original frequency is reached. Asynchronous
* - tuner callback xaRadioCallback() and XA_RADIO_EVENT_SEEK_COMPLETED
* is used for notifying of the result. StopSeeking() method of XARadioItf
* can be used to abort an ongoing seek.
**/
XAresult XARDSItfImpl_SeekTrafficProgramme(XARDSItf self, XAboolean upwards)
{
XAresult ret = XA_RESULT_SUCCESS;
XARDSItfImpl* impl = GetImpl(self);
DEBUG_API("->XARDSItfImpl_SeekTrafficProgramme");
XA_IMPL_THREAD_SAFETY_ENTRY(XATSRadio);
if(!impl)
{
XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
/* invalid parameter */
DEBUG_API("<-XARDSItfImpl_SeekTrafficProgramme");
return XA_RESULT_PARAMETER_INVALID;
}
ret = XARDSItfAdapt_SeekTrafficProgramme((XAAdaptationGstCtx*)impl->adapCtx, upwards);
XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
DEBUG_API("<-XARDSItfImpl_SeekTrafficProgramme");
return ret;
}
/**
* XAresult XARDSItfImpl_SetAutomaticSwitching(XARDSItf self, XAboolean automatic)
* Description: Sets the automatic switching of the transmitter in the case of a
* stronger transmitter with the same PI presence. Based on AF and/or
* EON fields. Please note that NOT ALL IMPLEMENTATIONS SUPPORT THIS
* FUNCTIONALITY.
**/
XAresult XARDSItfImpl_SetAutomaticSwitching(XARDSItf self, XAboolean automatic)
{
XAresult ret = XA_RESULT_SUCCESS;
XARDSItfImpl* impl = GetImpl(self);
DEBUG_API("->XARDSItfImpl_SetAutomaticSwitching");
XA_IMPL_THREAD_SAFETY_ENTRY(XATSRadio);
if(!impl)
{
XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
/* invalid parameter */
DEBUG_API("<-XARDSItfImpl_SetAutomaticSwitching");
return XA_RESULT_PARAMETER_INVALID;
}
ret = XARDSItfAdapt_SetAutomaticSwitching((XAAdaptationGstCtx*)impl->adapCtx, automatic);
XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
DEBUG_API("<-XARDSItfImpl_SetAutomaticSwitching");
return ret;
}
/**
* XAresult XARDSItfImpl_GetAutomaticSwitching(XARDSItf self, XAboolean * automatic)
* Description: Gets the mode of the automatic switching of the transmitter in
* case of a stronger transmitter with the same PI presence.
**/
XAresult XARDSItfImpl_GetAutomaticSwitching(XARDSItf self, XAboolean * automatic)
{
XAresult ret = XA_RESULT_SUCCESS;
XARDSItfImpl* impl = GetImpl(self);
DEBUG_API("->XARDSItfImpl_GetAutomaticSwitching");
XA_IMPL_THREAD_SAFETY_ENTRY(XATSRadio);
if(!impl || !automatic)
{
XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
/* invalid parameter */
DEBUG_API("<-XARDSItfImpl_GetAutomaticSwitching");
return XA_RESULT_PARAMETER_INVALID;
}
ret = XARDSItfAdapt_GetAutomaticSwitching((XAAdaptationGstCtx*)impl->adapCtx, automatic);
XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
DEBUG_API("<-XARDSItfImpl_GetAutomaticSwitching");
return ret;
}
/**
* XAresult XARDSItfImpl_SetAutomaticTrafficAnnouncement(XARDSItf self, XAboolean automatic)
* Description: Sets the automatic switching of the program in case of the presence
* of Traffic Announcement in another program. Based on TP and TA fields.
* Please note that NOT ALL IMPLEMENTATIONS SUPPORT THIS FUNCTIONALITY.
**/
XAresult XARDSItfImpl_SetAutomaticTrafficAnnouncement(XARDSItf self, XAboolean automatic)
{
XAresult ret = XA_RESULT_SUCCESS;
XARDSItfImpl* impl = GetImpl(self);
DEBUG_API("->XARDSItfImpl_SetAutomaticTrafficAnnouncement");
XA_IMPL_THREAD_SAFETY_ENTRY(XATSRadio);
if(!impl)
{
XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
/* invalid parameter */
DEBUG_API("<-XARDSItfImpl_SetAutomaticTrafficAnnouncement");
return XA_RESULT_PARAMETER_INVALID;
}
ret = XARDSItfAdapt_SetAutomaticTrafficAnnouncement((XAAdaptationGstCtx*)impl->adapCtx, automatic);
XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
DEBUG_API("<-XARDSItfImpl_SetAutomaticTrafficAnnouncement");
return ret;
}
/**
* XAresult XARDSItfImpl_GetAutomaticTrafficAnnouncement(XARDSItf self, XAboolean * automatic)
* Description: Gets the mode of the automatic switching of the program in case of
* the presence of Traffic Announcement in another program. Based on
* TP and TA fields.
**/
XAresult XARDSItfImpl_GetAutomaticTrafficAnnouncement(XARDSItf self, XAboolean * automatic)
{
XAresult ret = XA_RESULT_SUCCESS;
XARDSItfImpl* impl = GetImpl(self);
DEBUG_API("->XARDSItfImpl_GetAutomaticTrafficAnnouncement");
XA_IMPL_THREAD_SAFETY_ENTRY(XATSRadio);
if(!impl || !automatic)
{
XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
/* invalid parameter */
DEBUG_API("<-XARDSItfImpl_GetAutomaticTrafficAnnouncement");
return XA_RESULT_PARAMETER_INVALID;
}
ret = XARDSItfAdapt_GetAutomaticTrafficAnnouncement((XAAdaptationGstCtx*)impl->adapCtx, automatic);
XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
DEBUG_API("<-XARDSItfImpl_GetAutomaticTrafficAnnouncement");
return ret;
}
/**
* XAresult XARDSItfImpl_GetODAGroup(XARDSItf self,
* XAint16 AID,
* xaGetODAGroupCallback callback,
* void * pContext)
* Description: Returns asynchronously via callback (xaGetODAGroupCallback())
* the application Group and the message bits concerning the given
* ODA (Open Data Application). ODA is a mechanism that a broadcaster
* can use to transfer data that is not explicitly specified in the RDS
* standard. Open Data Applications are subject to a registration process.
* Transmission protocols used by ODAs may be public or private. See RDS
* Forum web page (http://www.rds.org.uk/)for details.
**/
XAresult XARDSItfImpl_GetODAGroup(XARDSItf self,
XAuint16 AID,
xaGetODAGroupCallback callback,
void * pContext)
{
XAresult ret = XA_RESULT_SUCCESS;
XARDSItfImpl* impl = GetImpl(self);
DEBUG_API("->XARDSItfImpl_GetODAGroup");
XA_IMPL_THREAD_SAFETY_ENTRY(XATSRadio);
if(!impl)
{
XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
/* invalid parameter */
DEBUG_API("<-XARDSItfImpl_GetODAGroup");
return XA_RESULT_PARAMETER_INVALID;
}
impl->odaGroupCallback = callback;
impl->odaGroupContext = pContext;
impl->odaGroupCbPtrToSelf = self;
if (callback)
{
ret = XARDSItfAdapt_GetODAGroup((XAAdaptationGstCtx*)impl->adapCtx, AID);
}
XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
DEBUG_API("<-XARDSItfImpl_GetODAGroup");
return ret;
}
/**
* XAresult XARDSItfImpl_SubscribeODAGroup(XARDSItf self,
* XAint16 group,
* XAboolean useErrorCorrection)
* Description: Subscribes the given ODA group. If the given group was already
* subscribed, this call doesn’t do anything. Only new data in groups
* that have been subscribed will cause a newODA callback.
**/
XAresult XARDSItfImpl_SubscribeODAGroup(XARDSItf self,
XAint16 group,
XAboolean useErrorCorrection)
{
XAresult ret = XA_RESULT_SUCCESS;
XARDSItfImpl* impl = GetImpl(self);
DEBUG_API("->XARDSItfImpl_SubscribeODAGroup");
XA_IMPL_THREAD_SAFETY_ENTRY(XATSRadio);
if(!impl)
{
XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
/* invalid parameter */
DEBUG_API("<-XARDSItfImpl_SubscribeODAGroup");
return XA_RESULT_PARAMETER_INVALID;
}
ret = XARDSItfAdapt_SubscribeODAGroup((XAAdaptationGstCtx*)impl->adapCtx, group, useErrorCorrection);
XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
DEBUG_API("<-XARDSItfImpl_SubscribeODAGroup");
return ret;
}
/**
* XAresult XARDSItfImpl_UnsubscribeODAGroup(XARDSItf self, XAint16 group)
* Description: Unsubscribes the given ODA group. If the given group has not
* been subscribed, this doesn’t do anything. Only new data in
* groups that have been subscribed will cause a newODA callback.
**/
XAresult XARDSItfImpl_UnsubscribeODAGroup(XARDSItf self, XAint16 group)
{
XAresult ret = XA_RESULT_SUCCESS;
XARDSItfImpl* impl = GetImpl(self);
DEBUG_API("->XARDSItfImpl_UnsubscribeODAGroup");
XA_IMPL_THREAD_SAFETY_ENTRY(XATSRadio);
if(!impl)
{
XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
/* invalid parameter */
DEBUG_API("<-XARDSItfImpl_UnsubscribeODAGroup");
return XA_RESULT_PARAMETER_INVALID;
}
ret = XARDSItfAdapt_UnsubscribeODAGroup((XAAdaptationGstCtx*)impl->adapCtx, group);
XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
DEBUG_API("<-XARDSItfImpl_UnsubscribeODAGroup");
return ret;
}
/**
* XAresult XARDSItfImpl_ListODAGroupSubscriptions(XARDSItf self,
* XAint16* pGroups,
* XAuint32* pLength);
* Description: Lists ODA groups that are currently subscribed.
**/
XAresult XARDSItfImpl_ListODAGroupSubscriptions(XARDSItf self,
XAint16* pGroups,
XAuint32* pLength)
{
XAresult ret = XA_RESULT_SUCCESS;
XARDSItfImpl* impl = GetImpl(self);
XA_IMPL_THREAD_SAFETY_ENTRY(XATSRadio);
DEBUG_API("->XARDSItfImpl_ListODAGroupSubscriptions");
if(!impl || !pLength)
{
XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
/* invalid parameter */
DEBUG_API("<-XARDSItfImpl_ListODAGroupSubscriptions");
return XA_RESULT_PARAMETER_INVALID;
}
XARDSItfAdapt_ListODAGroupSubscriptions((XAAdaptationGstCtx*)impl->adapCtx, pGroups, pLength);
XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
DEBUG_API("<-XARDSItfImpl_ListODAGroupSubscriptions");
return ret;
}
/**
* XAresult XARDSItfImpl_RegisterRDSCallback(XARDSItf self,
* xaRDSCallback callback,
* void * pContext)
* Description: Sets or clears the xaNewODADataCallback(). xaNewODADataCallback()
* is used tranfer the actual ODA data to the application.
**/
XAresult XARDSItfImpl_RegisterRDSCallback(XARDSItf self,
xaRDSCallback callback,
void * pContext)
{
XAresult ret = XA_RESULT_SUCCESS;
XARDSItfImpl* impl = GetImpl(self);
DEBUG_API("->XARDSItfImpl_RegisterRDSCallback");
if(!impl)
{
DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
/* invalid parameter */
DEBUG_API("<-XARDSItfImpl_RegisterRDSCallback");
return XA_RESULT_PARAMETER_INVALID;
}
impl->rdsCallback = callback;
impl->rdsContext = pContext;
impl->rdsCbPtrToSelf = self;
DEBUG_API("<-XARDSItfImpl_RegisterRDSCallback");
return ret;
}
/**
* XAresult XARDSItfImpl_RegisterODADataCallback(XARDSItf self,
* xaNewODADataCallback callback,
* void * pContext)
* Description: Sets or clears the xaRDSCallback(). xaRDSCallback() is used to monitor
* changes in RDS fields.
**/
XAresult XARDSItfImpl_RegisterODADataCallback(XARDSItf self,
xaNewODADataCallback callback,
void * pContext)
{
XAresult ret = XA_RESULT_SUCCESS;
XARDSItfImpl* impl = GetImpl(self);
DEBUG_API("->XARDSItfImpl_RegisterODADataCallback");
if(!impl)
{
DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
/* invalid parameter */
DEBUG_API("<-XARDSItfImpl_RegisterODADataCallback");
return XA_RESULT_PARAMETER_INVALID;
}
impl->odaDataCallback = callback;
impl->odaDataContext = pContext;
impl->odaDataCbPtrToSelf = self;
DEBUG_API("<-XARDSItfImpl_RegisterODADataCallback");
return ret;
}
/**
* XARDSItfImpl -specific methods
**/
/**
* XARDSItfImplImpl* XARDSItfImpl_Create()
* @return XARDSItfImplImpl* - Pointer to RDSItf interface implementation
**/
XARDSItfImpl* XARDSItfImpl_Create(XAAdaptationBaseCtx *adapCtx)
{
XARDSItfImpl *self = (XARDSItfImpl*)
calloc(1,sizeof(XARDSItfImpl));
DEBUG_API("->XARDSItfImpl_Create");
if(self)
{
/* init itf default implementation */
self->itf.QueryRDSSignal = XARDSItfImpl_QueryRDSSignal;
self->itf.GetProgrammeServiceName = XARDSItfImpl_GetProgrammeServiceName;
self->itf.GetRadioText = XARDSItfImpl_GetRadioText;
self->itf.GetRadioTextPlus = XARDSItfImpl_GetRadioTextPlus;
self->itf.GetProgrammeType = XARDSItfImpl_GetProgrammeType;
self->itf.GetProgrammeTypeString = XARDSItfImpl_GetProgrammeTypeString;
self->itf.GetProgrammeIdentificationCode = XARDSItfImpl_GetProgrammeIdentificationCode;
self->itf.GetClockTime = XARDSItfImpl_GetClockTime;
self->itf.GetTrafficAnnouncement = XARDSItfImpl_GetTrafficAnnouncement;
self->itf.GetTrafficProgramme = XARDSItfImpl_GetTrafficProgramme;
self->itf.SeekByProgrammeType = XARDSItfImpl_SeekByProgrammeType;
self->itf.SeekTrafficAnnouncement = XARDSItfImpl_SeekTrafficAnnouncement;
self->itf.SeekTrafficProgramme = XARDSItfImpl_SeekTrafficProgramme;
self->itf.SetAutomaticSwitching = XARDSItfImpl_SetAutomaticSwitching;
self->itf.GetAutomaticSwitching = XARDSItfImpl_GetAutomaticSwitching;
self->itf.SetAutomaticTrafficAnnouncement = XARDSItfImpl_SetAutomaticTrafficAnnouncement;
self->itf.GetAutomaticTrafficAnnouncement = XARDSItfImpl_GetAutomaticTrafficAnnouncement;
self->itf.GetODAGroup = XARDSItfImpl_GetODAGroup;
self->itf.SubscribeODAGroup = XARDSItfImpl_SubscribeODAGroup;
self->itf.UnsubscribeODAGroup = XARDSItfImpl_UnsubscribeODAGroup;
self->itf.ListODAGroupSubscriptions = XARDSItfImpl_ListODAGroupSubscriptions;
self->itf.RegisterRDSCallback = XARDSItfImpl_RegisterRDSCallback;
self->itf.RegisterODADataCallback = XARDSItfImpl_RegisterODADataCallback;
/* init variables */
self->odaDataCallback = NULL;
self->odaDataContext = NULL;
self->odaDataCbPtrToSelf = NULL;
self->odaGroupCallback = NULL;
self->odaGroupContext = NULL;
self->odaGroupCbPtrToSelf = NULL;
self->rdsCallback = NULL;
self->rdsContext = NULL;
self->rdsCbPtrToSelf = NULL;
XAAdaptationBase_AddEventHandler( adapCtx, &XARDSItfImpl_AdaptCb, XA_RDSITFEVENTS, self );
self->adapCtx = adapCtx;
self->self = self;
}
DEBUG_API("<-XARDSItfImpl_Create");
return self;
}
/* void XARDSItfImpl_AdaptCb( void *pHandlerCtx, XAAdaptEvent *event )
* @param void *pHandlerCtx - pointer to cb context (XARadioItfImpl)
* @param XAAdaptEvent *event - Event
* Description: Event handler for adaptation events
*/
void XARDSItfImpl_AdaptCb( void *pHandlerCtx, XAAdaptEvent *event )
{
XARDSItfImpl* impl =(XARDSItfImpl*)pHandlerCtx;
DEBUG_API("->XARDSItfImpl_AdaptCb");
if(!impl)
{
DEBUG_ERR("XARadioItfImpl_AdaptCb, invalid context pointer!");
DEBUG_API("<-XARDSItfImpl_AdaptCb");
return;
}
assert(event);
if( event->eventid == XA_ADAPT_RDS_GET_ODA_GROUP_DONE && impl->odaGroupCallback )
{
/* stubbed (enough for emulation purposes) */
/* XA_BOOLEAN_FALSE and -1 means oda group not found */
impl->odaGroupCallback( (XARadioItf) impl->odaGroupCbPtrToSelf, impl->odaGroupContext, XA_BOOLEAN_FALSE, -1, 0 );
}
DEBUG_API("<-XARDSItfImpl_AdaptCb");
}
/**
* void XARDSItfImpl_Free(XARDSItfImpl* self)
* @param XARDSItfImpl* self -
**/
void XARDSItfImpl_Free(XARDSItfImpl* self)
{
DEBUG_API("->XARDSItfImpl_Free");
XA_IMPL_THREAD_SAFETY_ENTRY_FOR_VOID_FUNCTIONS(XATSRadio);
assert(self==self->self);
XAAdaptationBase_RemoveEventHandler( self->adapCtx, &XARDSItfImpl_AdaptCb );
XARDSItfAdapt_Free(self->adapCtx);
free(self);
XA_IMPL_THREAD_SAFETY_EXIT_FOR_VOID_FUNCTIONS(XATSRadio);
DEBUG_API("<-XARDSItfImpl_Free");
}