--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/khronosfws/openmax_al/src/radio/xaradioitf.c Tue Aug 31 15:43:02 2010 +0300
@@ -0,0 +1,711 @@
+/*
+* 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 <string.h>
+#include "xaradioitf.h"
+#include "xaradioitfadaptation.h"
+#include "xathreadsafety.h"
+
+#define FREQINTERVAL 200000
+
+/**
+ * XARadioItfImpl* GetImpl(XARadioItf self)
+ * Description: Validated interface pointer and cast it to implementations pointer.
+ **/
+static XARadioItfImpl* GetImpl(XARadioItf self)
+{
+ if(self)
+ {
+ XARadioItfImpl *impl = (XARadioItfImpl*)(*self);
+ if(impl && impl == impl->self)
+ {
+ return impl;
+ }
+ }
+ return NULL;
+}
+
+/**
+ * Base interface XARadioItf implementation
+ */
+
+/**
+ * XAresult XARadioItfImpl_SetFreqRange(XARadioItf self, XAuint8 range)
+ * Description: Sets the frequency range. Asynchronous – xaRadioCallback() callback with
+ * XA_RADIO_EVENT_FREQUENCY_RANGE_CHANGED event is used for notifying of the result.
+ **/
+XAresult XARadioItfImpl_SetFreqRange(XARadioItf self, XAuint8 range)
+{
+ XAresult ret = XA_RESULT_PARAMETER_INVALID;
+ XAboolean isSupported = XA_BOOLEAN_FALSE;
+ XARadioItfImpl* impl = GetImpl(self);
+
+ DEBUG_API("->XARadioItfImpl_SetFreqRange");
+ XA_IMPL_THREAD_SAFETY_ENTRY(XATSRadio);
+
+ if(!impl)
+ {
+ XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
+ /* invalid parameter */
+ DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
+ DEBUG_API("<-XARadioItfImpl_SetFreqRange");
+
+ return ret;
+ }
+
+ ret = XARadioItfAdapt_IsFreqRangeSupported(range, &isSupported);
+
+ if ( ret == XA_RESULT_SUCCESS && isSupported == XA_BOOLEAN_TRUE )
+ {
+ ret = XARadioItfAdapt_SetFreqRange((XAAdaptationMMFCtx*)impl->adapCtx, range);
+ }
+ else if (!isSupported)
+ {
+ ret = XA_RESULT_PARAMETER_INVALID;
+ }
+
+ XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
+ DEBUG_API("<-XARadioItfImpl_SetFreqRange");
+ return ret;
+}
+
+/**
+ * XAresult XARadioItfImpl_GetFreqRange(XARadioItf self, XAuint8 * pRange)
+ * Description: Gets the current frequency range.
+ **/
+XAresult XARadioItfImpl_GetFreqRange(XARadioItf self, XAuint8 * pRange)
+{
+ XAresult ret = XA_RESULT_SUCCESS;
+ XARadioItfImpl* impl = GetImpl(self);
+ DEBUG_API("->XARadioItfImpl_GetFreqRange");
+
+ if(!impl || !pRange)
+ {
+ XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
+ /* invalid parameter */
+ DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
+ DEBUG_API("<-XARadioItfImpl_GetFreqRange");
+ return XA_RESULT_PARAMETER_INVALID;
+ }
+
+ ret = XARadioItfAdapt_GetFreqRange(pRange);
+
+ DEBUG_API("<-XARadioItfImpl_GetFreqRange");
+ return ret;
+}
+
+/**
+ * XAresult XARadioItfImpl_IsFreqRangeSupported(XARadioItf self,
+ * XAuint8 range,
+ * XAboolean * pSupported)
+ * Description: Queries if the given frequency range is supported.
+ **/
+XAresult XARadioItfImpl_IsFreqRangeSupported(XARadioItf self,
+ XAuint8 range,
+ XAboolean * pSupported)
+{
+ XAresult ret = XA_RESULT_SUCCESS;
+ XARadioItfImpl* impl = GetImpl(self);
+ DEBUG_API("->XARadioItfImpl_IsFreqRangeSupported");
+ XA_IMPL_THREAD_SAFETY_ENTRY(XATSRadio);
+
+ if(!impl || !pSupported)
+ {
+ XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
+ /* invalid parameter */
+ DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
+ DEBUG_API("<-XARadioItfImpl_IsFreqRangeSupported");
+ return XA_RESULT_PARAMETER_INVALID;
+ }
+
+ ret = XARadioItfAdapt_IsFreqRangeSupported( range, pSupported );
+
+ XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
+ DEBUG_API("<-XARadioItfImpl_IsFreqRangeSupported");
+ return ret;
+}
+
+
+/**
+ * XAresult XARadioItfImpl_GetFreqRangeProperties(XARadioItf self,
+ * XAuint8 range,
+ * XAuint32 * pMinFreq,
+ * XAuint32 * pMaxFreq,
+ * XAuint32 * pFreqInterval)
+ * Description: Returns the minimum and maximum supported frequencies and the
+ * modulation of the given frequency range.
+ **/
+XAresult XARadioItfImpl_GetFreqRangeProperties(XARadioItf self,
+ XAuint8 range,
+ XAuint32 * pMinFreq,
+ XAuint32 * pMaxFreq,
+ XAuint32 * pFreqInterval)
+{
+ XAresult ret = XA_RESULT_SUCCESS;
+ XARadioItfImpl* impl = GetImpl(self);
+
+ DEBUG_API("->XARadioItfImpl_GetFreqRangeProperties");
+
+ if(!impl || !pMinFreq || !pMaxFreq || !pFreqInterval)
+ {
+ /* invalid parameter */
+ DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
+ DEBUG_API("<-XARadioItfImpl_GetFreqRangeProperties");
+ return XA_RESULT_PARAMETER_INVALID;
+ }
+
+ ret = XARadioItfAdapt_GetFreqRangeProperties( (XAAdaptationMMFCtx*)impl->adapCtx,
+ range, pMinFreq, pMaxFreq );
+ if (ret == XA_RESULT_SUCCESS)
+ {
+ *pFreqInterval = FREQINTERVAL;
+ }
+
+ DEBUG_API("<-XARadioItfImpl_GetFreqRangeProperties");
+ return ret;
+}
+
+/**
+ * XAresult XARadioItfImpl_SetFrequency(XARadioItf self, XAuint32 freq)
+ * Description: Sets the frequency asynchronously – xaRadioCallback() callback
+ * with XA_RADIO_EVENT_FREQUENCY_CHANGED event is used for notifying
+ * of the result. The implementation rounds the given value to the
+ * nearest supported one. See pFreqInterval parameter of
+ * GetFreqRangeProperties() method.
+ **/
+XAresult XARadioItfImpl_SetFrequency(XARadioItf self, XAuint32 freq)
+{
+ XAresult ret = XA_RESULT_SUCCESS;
+ XAuint8 range = 1; // Default to EuroAmerica
+ XAuint32 minFreq;
+ XAuint32 maxFreq;
+ XAuint32 freqInterval;
+
+ XARadioItfImpl* impl = GetImpl(self);
+ DEBUG_API("->XARadioItfImpl_SetFrequency");
+ XA_IMPL_THREAD_SAFETY_ENTRY(XATSRadio);
+
+ if(!impl)
+ {
+ XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
+ DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
+ DEBUG_API("<-XARadioItfImpl_SetFrequency");
+ return XA_RESULT_PARAMETER_INVALID;
+ }
+
+ // Check for valid entries:
+ ret = XARadioItfImpl_GetFreqRangeProperties(self, range, &minFreq, &maxFreq, &freqInterval);
+ if (ret != XA_RESULT_SUCCESS)
+ {
+ XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
+ DEBUG_API("<-XARadioItfImpl_SetFrequency");
+ return ret;
+ }
+
+ if ( (freq < minFreq) || (freq > maxFreq) )
+ {
+ XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
+ DEBUG_API("<-XARadioItfImpl_SetFrequency");
+ return XA_RESULT_PARAMETER_INVALID;
+ }
+
+ ret = XARadioItfAdapt_SetFrequency( (XAAdaptationMMFCtx*)impl->adapCtx, freq );
+
+ XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
+ DEBUG_API("<-XARadioItfImpl_SetFrequency");
+ return ret;
+}
+
+/**
+ * XAresult XARadioItfImpl_CancelSetFrequency(XARadioItf self)
+ * Description: Cancels an outstanding SetFrequency() request. The method
+ * blocks while canceling the outstanding request. Has not effect
+ * if no set frequency operation is ongoing.
+ **/
+XAresult XARadioItfImpl_CancelSetFrequency(XARadioItf self)
+
+{
+ XAresult ret = XA_RESULT_SUCCESS;
+ XARadioItfImpl* impl = GetImpl(self);
+ DEBUG_API("->XARadioItfImpl_CancelSetFrequency");
+ XA_IMPL_THREAD_SAFETY_ENTRY(XATSRadio);
+
+ if(!impl)
+ {
+ XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
+ /* invalid parameter */
+ DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
+ DEBUG_API("<-XARadioItfImpl_CancelSetFrequency");
+ return XA_RESULT_PARAMETER_INVALID;
+ }
+
+ ret = XARadioItfAdapt_CancelSetFrequency();
+
+ XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
+ DEBUG_API("<-XARadioItfImpl_CancelSetFrequency");
+ return ret;
+}
+
+/**
+ * XAresult XARadioItfImpl_GetFrequency(XARadioItf self, XAuint32 * pFreq)
+ * Description: Gets the current frequency.
+ **/
+XAresult XARadioItfImpl_GetFrequency(XARadioItf self, XAuint32 * pFreq)
+{
+ XAresult ret = XA_RESULT_SUCCESS;
+ XARadioItfImpl* impl = GetImpl(self);
+ DEBUG_API("->XARadioItfImpl_GetFrequency");
+ XA_IMPL_THREAD_SAFETY_ENTRY(XATSRadio);
+
+ if(!impl || !pFreq)
+ {
+ XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
+ /* invalid parameter */
+ DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
+ DEBUG_API("<-XARadioItfImpl_GetFrequency");
+ return XA_RESULT_PARAMETER_INVALID;
+ }
+
+ ret = XARadioItfAdapt_GetFrequency(pFreq);
+
+ XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
+ DEBUG_API("<-XARadioItfImpl_GetFrequency");
+ return ret;
+}
+
+/**
+ * XAresult XARadioItfImpl_SetSquelch(XARadioItf self, XAboolean squelch)
+ * Description: Toggles the squelch (muting in frequencies without broadcast).
+ **/
+XAresult XARadioItfImpl_SetSquelch(XARadioItf self, XAboolean squelch)
+{
+ XAresult ret = XA_RESULT_SUCCESS;
+ XARadioItfImpl* impl = GetImpl(self);
+ DEBUG_API("->XARadioItfImpl_SetSquelch");
+ XA_IMPL_THREAD_SAFETY_ENTRY(XATSRadio);
+
+ if(!impl)
+ {
+ XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
+ /* invalid parameter */
+ DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
+ DEBUG_API("<-XARadioItfImpl_SetSquelch");
+ return XA_RESULT_PARAMETER_INVALID;
+ }
+
+ if (impl->squelch != squelch)
+ {
+ ret = XARadioItfAdapt_SetSquelch( squelch );
+ if ( ret == XA_RESULT_SUCCESS )
+ {
+ impl->squelch = squelch;
+ }
+ }
+
+ XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
+ DEBUG_API("<-XARadioItfImpl_SetSquelch");
+ return ret;
+}
+
+/**
+ * XAresult XARadioItfImpl_GetSquelch(XARadioItf self, XAboolean * pSquelch)
+ * Description: Queries the squelch setting (muting in frequencies without broadcast).
+ **/
+XAresult XARadioItfImpl_GetSquelch(XARadioItf self, XAboolean * pSquelch)
+{
+ XAresult ret = XA_RESULT_SUCCESS;
+ XARadioItfImpl* impl = GetImpl(self);
+ DEBUG_API("->XARadioItfImpl_GetSquelch");
+ if(!impl || !pSquelch)
+ {
+ DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
+ /* invalid parameter */
+ DEBUG_API("<-XARadioItfImpl_GetSquelch");
+ return XA_RESULT_PARAMETER_INVALID;
+ }
+
+ ret = XARadioItfAdapt_GetSquelch( pSquelch );
+
+ DEBUG_API("<-XARadioItfImpl_GetSquelch");
+ return ret;
+}
+
+/**
+ * XAresult XARadioItfImpl_SetStereoMode(XARadioItf self, XAuint32 mode)
+ * Description: Sets the current stereo mode.
+ **/
+XAresult XARadioItfImpl_SetStereoMode(XARadioItf self, XAuint32 mode)
+{
+ XAresult ret = XA_RESULT_SUCCESS;
+ XARadioItfImpl* impl = GetImpl(self);
+ DEBUG_API("->XARadioItfImpl_SetStereoMode");
+ XA_IMPL_THREAD_SAFETY_ENTRY(XATSRadio);
+
+ if( !impl || mode > XA_STEREOMODE_AUTO )
+ {
+ XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
+ /* invalid parameter */
+ DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
+ DEBUG_API("<-XARadioItfImpl_SetStereoMode");
+ return XA_RESULT_PARAMETER_INVALID;
+ }
+ if ( impl->stereoMode != mode)
+ {
+ ret = XARadioItfAdapt_SetStereoMode( (XAAdaptationMMFCtx*)impl->adapCtx, mode );
+ if ( ret == XA_RESULT_SUCCESS )
+ {
+ impl->stereoMode = mode;
+ }
+ }
+ XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
+ DEBUG_API("<-XARadioItfImpl_SetStereoMode");
+ return ret;
+}
+
+/**
+ * XAresult XARadioItfImpl_GetStereoMode(XARadioItf self, XAuint32 * pMode)
+ * Description: Queries the current stereo mode.
+ **/
+XAresult XARadioItfImpl_GetStereoMode(XARadioItf self, XAuint32 * pMode)
+{
+
+ XAresult ret = XA_RESULT_SUCCESS;
+ XARadioItfImpl* impl = GetImpl(self);
+ DEBUG_API("->XARadioItfImpl_GetStereoMode");
+ if(!impl || !pMode)
+ {
+ DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
+ /* invalid parameter */
+ DEBUG_API("<-XARadioItfImpl_GetStereoMode");
+ return XA_RESULT_PARAMETER_INVALID;
+ }
+
+ ret = XARadioItfAdapt_GetStereoMode( pMode );
+
+ DEBUG_API("<-XARadioItfImpl_GetStereoMode");
+ return ret;
+}
+
+/**
+ * XAresult XARadioItfImpl_GetSignalStrength(XARadioItf self, XAuint32 * pStrength)
+ * Description: Returns the signal strength in per cents.
+ **/
+XAresult XARadioItfImpl_GetSignalStrength(XARadioItf self, XAuint32 * pStrength)
+{
+ XAresult ret = XA_RESULT_SUCCESS;
+ XARadioItfImpl* impl = GetImpl(self);
+ DEBUG_API("->XARadioItfImpl_GetSignalStrength");
+ XA_IMPL_THREAD_SAFETY_ENTRY(XATSRadio);
+
+ if(!impl || !pStrength)
+ {
+ XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
+ /* invalid parameter */
+ DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
+ DEBUG_API("<-XARadioItfImpl_GetSignalStrength");
+ return XA_RESULT_PARAMETER_INVALID;
+ }
+
+ ret = XARadioItfAdapt_GetSignalStrength( pStrength );
+
+ XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
+ DEBUG_API("<-XARadioItfImpl_GetSignalStrength");
+ return ret;
+}
+
+/**
+ * XAresult XARadioItfImpl_Seek(XARadioItf self, XAboolean upwards)
+ * Description: Starts the seek from the current frequency to the given direction.
+ * Asynchronous – xaRadioCallback() callback with XA_RADIO_EVENT_SEEK_COMPLETED
+ * event is used for notifying of the result. If the end of the tuner’s
+ * frequency band is reached before a signal was found, the scan continues
+ * from the other end until a signal is found or the original frequency is reached.
+ **/
+XAresult XARadioItfImpl_Seek(XARadioItf self, XAboolean upwards)
+{
+ XAresult ret = XA_RESULT_SUCCESS;
+ XARadioItfImpl* impl = GetImpl(self);
+ DEBUG_API("->XARadioItfImpl_Seek");
+ XA_IMPL_THREAD_SAFETY_ENTRY(XATSRadio);
+
+ if(!impl)
+ {
+ XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
+ /* invalid parameter */
+ DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
+ DEBUG_API("<-XARadioItfImpl_Seek");
+ return XA_RESULT_PARAMETER_INVALID;
+ }
+
+ ret = XARadioItfAdapt_Seek( (XAAdaptationMMFCtx*)impl->adapCtx, upwards );
+
+ XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
+ DEBUG_API("<-XARadioItfImpl_Seek");
+ return ret;
+}
+
+/**
+ * XAresult XARadioItfImpl_StopSeeking(XARadioItf self)
+ * Description: Cancels an outstanding seek request. The method blocks while canceling
+ * the outstanding request. After cancellation, the frequency is the one
+ * where seeking stopped. Has not effect if no seek operation is ongoing.
+ **/
+XAresult XARadioItfImpl_StopSeeking(XARadioItf self)
+{
+ XAresult ret = XA_RESULT_SUCCESS;
+ XARadioItfImpl* impl = GetImpl(self);
+ DEBUG_API("->XARadioItfImpl_StopSeeking");
+ XA_IMPL_THREAD_SAFETY_ENTRY(XATSRadio);
+
+ if(!impl)
+ {
+ /* invalid parameter */
+ XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
+ DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
+ DEBUG_API("<-XARadioItfImpl_StopSeeking");
+ return XA_RESULT_PARAMETER_INVALID;
+ }
+
+ XARadioItfAdapt_StopSeeking( (XAAdaptationMMFCtx*)impl->adapCtx );
+
+ XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);
+ DEBUG_API("<-XARadioItfImpl_StopSeeking");
+ return ret;
+}
+
+/**
+ * XAresult XARadioItfImpl_GetNumberOfPresets(XARadioItf self, XAuint32 * pNumPresets)
+ * Description: Returns the number of preset slots the device has for storing the presets.
+ **/
+XAresult XARadioItfImpl_GetNumberOfPresets(XARadioItf self, XAuint32 * pNumPresets)
+{
+ XAresult ret = XA_RESULT_FEATURE_UNSUPPORTED;
+
+ DEBUG_API("->XARadioItfImpl_GetNumberOfPresets");
+
+ return ret;
+}
+
+/**
+ * XAresult XARadioItfImpl_SetPreset(XARadioItf self,
+ * XAuint32 preset,
+ * XAuint32 freq,
+ * XAuint8 range,
+ * XAuint32 mode,
+ * const XAchar * name)
+ * Description: Sets the preset.
+ **/
+XAresult XARadioItfImpl_SetPreset(XARadioItf self,
+ XAuint32 preset,
+ XAuint32 freq,
+ XAuint8 range,
+ XAuint32 mode,
+ const XAchar * name)
+{
+ XAresult ret = XA_RESULT_FEATURE_UNSUPPORTED;
+
+ return ret;
+}
+
+/**
+ * XAresult XARadioItfImpl_GetPreset(XARadioItf self,
+ * XAuint32 preset,
+ * XAuint32 * pFreq,
+ * XAuint8 * pRange,
+ * XAuint32 * pMode,
+ * XAchar * pName,
+ * XAuint16 * pNameLength)
+ * Description: Gets the settings stored into a preset.
+ **/
+XAresult XARadioItfImpl_GetPreset(XARadioItf self,
+ XAuint32 preset,
+ XAuint32 * pFreq,
+ XAuint8 * pRange,
+ XAuint32 * pMode,
+ XAchar * pName,
+ XAuint16 * pNameLength)
+{
+
+ XAresult ret = XA_RESULT_FEATURE_UNSUPPORTED;
+
+ DEBUG_API("<-XARadioItfImpl_GetPreset");
+ return ret;
+}
+
+/**
+ * XAresult XARadioItfImpl_RegisterRadioCallback(XARadioItf self,
+ * xaRadioCallback callback,
+ * void * pContext)
+ * Description: Sets or clears the xaRadioCallback.
+ **/
+XAresult XARadioItfImpl_RegisterRadioCallback(XARadioItf self,
+ xaRadioCallback callback,
+ void * pContext)
+{
+ XAresult ret = XA_RESULT_SUCCESS;
+ XARadioItfImpl* impl = GetImpl(self);
+ DEBUG_API("->XARadioItfImpl_RegisterRadioCallback");
+
+ if(!impl)
+ {
+ DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");
+ /* invalid parameter */
+ DEBUG_API("<-XARadioItfImpl_RegisterRadioCallback");
+ return XA_RESULT_PARAMETER_INVALID;
+ }
+
+ impl->callback = callback;
+ impl->context = pContext;
+ impl->cbPtrToSelf = self;
+
+ DEBUG_API("<-XARadioItfImpl_RegisterRadioCallback");
+ return ret;
+}
+
+/**
+ * XARadioItfImpl -specific methods
+ **/
+
+/**
+ * XARadioItfImplImpl* XARadioItfImpl_Create()
+ * Description: Allocate and initialize RadioItfImpl
+ **/
+XARadioItfImpl* XARadioItfImpl_Create(XAAdaptationBaseCtx *adapCtx)
+{
+
+ XARadioItfImpl *self = (XARadioItfImpl*)
+ calloc(1,sizeof(XARadioItfImpl));
+
+ DEBUG_API("->XARadioItfImpl_Create");
+
+ if(self)
+ {
+ /* init itf default implementation */
+ self->itf.SetFreqRange = XARadioItfImpl_SetFreqRange;
+ self->itf.GetFreqRange = XARadioItfImpl_GetFreqRange;
+ self->itf.IsFreqRangeSupported = XARadioItfImpl_IsFreqRangeSupported;
+ self->itf.GetFreqRangeProperties = XARadioItfImpl_GetFreqRangeProperties;
+ self->itf.SetFrequency = XARadioItfImpl_SetFrequency;
+ self->itf.CancelSetFrequency = XARadioItfImpl_CancelSetFrequency;
+ self->itf.GetFrequency = XARadioItfImpl_GetFrequency;
+ self->itf.SetSquelch = XARadioItfImpl_SetSquelch;
+ self->itf.GetSquelch = XARadioItfImpl_GetSquelch;
+ self->itf.SetStereoMode = XARadioItfImpl_SetStereoMode;
+ self->itf.GetStereoMode = XARadioItfImpl_GetStereoMode;
+ self->itf.GetSignalStrength = XARadioItfImpl_GetSignalStrength;
+ self->itf.Seek = XARadioItfImpl_Seek;
+ self->itf.StopSeeking = XARadioItfImpl_StopSeeking;
+ self->itf.RegisterRadioCallback = XARadioItfImpl_RegisterRadioCallback;
+
+ /* init variables */
+
+ self->squelch = XA_BOOLEAN_FALSE;
+ self->stereoMode = XA_STEREOMODE_STEREO;
+ self->callback = NULL;
+ self->context = NULL;
+ self->cbPtrToSelf = NULL;
+ self->adapCtx = adapCtx;
+
+ XAAdaptationBase_AddEventHandler( adapCtx, &XARadioItfImpl_AdaptCb, XA_RADIOITFEVENTS, self );
+
+ self->self = self;
+ }
+
+ DEBUG_API("<-XARadioItfImpl_Create");
+ return self;
+}
+
+/**
+ * void XARadioItfImpl_Free(XARadioItfImpl* self)
+ * Description: Free all resources reserved at XARadioItfImpl_Create
+ **/
+void XARadioItfImpl_Free(XARadioItfImpl* self)
+{
+ DEBUG_API("->XARadioItfImpl_Free");
+ XA_IMPL_THREAD_SAFETY_ENTRY_FOR_VOID_FUNCTIONS(XATSRadio);
+ XAAdaptationBase_RemoveEventHandler( self->adapCtx, &XARadioItfImpl_AdaptCb );
+
+ XARadioItfAdapt_Free();
+ assert(self==self->self);
+ free(self);
+
+ XA_IMPL_THREAD_SAFETY_EXIT_FOR_VOID_FUNCTIONS(XATSRadio);
+ DEBUG_API("<-XARadioItfImpl_Free");
+}
+
+/* void XARadioItfimpl_AdaptCb( void *pHandlerCtx, XAAdaptEvent *event )
+ * Description: Event handler for adaptation events
+ */
+void XARadioItfImpl_AdaptCb( void *pHandlerCtx, XAAdaptEvent *event )
+{
+ XARadioItfImpl* impl =(XARadioItfImpl*)pHandlerCtx;
+ XAuint32 eventData = 0;
+ XAboolean eventBoolean = XA_BOOLEAN_FALSE;
+
+ DEBUG_API("->XARadioItfimpl_AdaptCb");
+
+ if(!impl)
+ {
+ DEBUG_ERR("XARadioItfImpl_AdaptCb, invalid context pointer!");
+ DEBUG_API("<-XARadioItfImpl_AdaptCb");
+ return;
+ }
+ assert(event);
+
+ if( event->eventid == XA_ADAPT_RADIO_FREQUENCY_CHANGED && impl->callback )
+ {
+ DEBUG_API("Frequency changed in adaptation");
+ eventData = *(XAuint32*)event->data;
+ impl->callback( impl->cbPtrToSelf, impl->context, XA_RADIO_EVENT_FREQUENCY_CHANGED, eventData, eventBoolean );
+ }
+
+ else if( event->eventid == XA_ADAPT_RADIO_FREQUENCY_RANGE_CHANGED && impl->callback )
+ {
+ DEBUG_API("Frequency range changed in adaptation");
+
+ impl->callback( impl->cbPtrToSelf, impl->context, XA_RADIO_EVENT_FREQUENCY_RANGE_CHANGED, eventData, eventBoolean );
+ }
+
+ else if( event->eventid == XA_ADAPT_RADIO_SEEK_COMPLETE && impl->callback )
+ {
+ DEBUG_API("Seek complete in adaptation");
+ eventBoolean = *(XAboolean*)event->data;
+ impl->callback( impl->cbPtrToSelf, impl->context, XA_RADIO_EVENT_SEEK_COMPLETED, eventData, eventBoolean );
+ }
+
+ else if( event->eventid == XA_ADAPT_RADIO_STEREO_STATUS_CHANGED && impl->callback )
+ {
+ DEBUG_API("Stereo status change in adaptation");
+ eventBoolean = *(XAboolean*)event->data;
+ impl->callback( impl->cbPtrToSelf, impl->context, XA_RADIO_EVENT_STEREO_STATUS_CHANGED, eventData, eventBoolean );
+ }
+
+ else if( event->eventid == XA_ADAPT_RADIO_SIGNAL_STRENGTH_CHANGED && impl->callback )
+ {
+ DEBUG_API("Signal Strength Change in adaptation");
+ impl->callback( impl->cbPtrToSelf, impl->context, XA_RADIO_EVENT_SIGNAL_STRENGTH_CHANGED, eventData, eventBoolean );
+ }
+ else
+ {
+ /* do nothing */
+ }
+ DEBUG_API("<-XARadioItfimpl_AdaptCb");
+}
+