--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/khronosfws/openmax_al/src/mmf_adaptation/xaradioitfadaptation.c Wed Jun 23 18:47:10 2010 +0300
@@ -0,0 +1,324 @@
+/*
+* 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 <unistd.h>
+#include "xadebug.h"
+#include "xaadaptationmmf.h"
+#include "xaradioitfadaptation.h"
+#include "xaradioadaptctx.h"
+#include "cmmfradiobackendengine.h"
+
+/*
+ * XAresult XARadioItfAdapt_SetFreqRange(XAAdaptationMMFCtx *bCtx, XAuint8 range)
+ */
+XAresult XARadioItfAdapt_SetFreqRange(XAAdaptationMMFCtx *bCtx, XAuint8 range)
+{
+ XAresult ret = XA_RESULT_SUCCESS;
+ DEBUG_API("->XARadioItfAdapt_SetFreqRange");
+ mmf_set_radio_adapt_context(cmmfradiobackendengine_init(), bCtx);
+ set_freq_range(cmmfradiobackendengine_init(), range);
+ DEBUG_API("<-XARadioItfAdapt_SetFreqRange");
+ return ret;
+}
+
+/*
+ * XAresult XARadioItfAdapt_GetFreqRange(XAuint8 * pFreqRange)
+ *
+ */
+XAresult XARadioItfAdapt_GetFreqRange(XAuint8 * pFreqRange)
+{
+ XAresult res = XA_RESULT_SUCCESS;
+ DEBUG_API("->XARadioItfAdapt_GetFreqRange");
+ res = get_freq_range(cmmfradiobackendengine_init(), pFreqRange);
+ DEBUG_API("<-XARadioItfAdapt_GetFreqRange");
+ return res;
+}
+
+/*
+ * XAresult XARadioItfAdapt_IsFreqRangeSupported(XAuint8 range,
+ * XAboolean * pSupported)
+ */
+XAresult XARadioItfAdapt_IsFreqRangeSupported(XAuint8 range,
+ XAboolean * pSupported)
+{
+ XAresult ret = XA_RESULT_SUCCESS;
+ DEBUG_API("->XARadioItfAdapt_IsFreqRangeSupported");
+ *pSupported = XA_BOOLEAN_TRUE; // No radio utility API for this, set to true automatically.
+ DEBUG_API("<-XARadioItfAdapt_IsFreqRangeSupported");
+ return ret;
+}
+
+/*
+ * XAresult XARadioItfAdapt_GetFreqRangeProperties(XAAdaptationMMFCtx *bCtx,
+ * XAuint8 * pRange,
+ * XAuint32 * pMinFreq,
+ * XAuint32 * pMaxFreq)
+ */
+XAresult XARadioItfAdapt_GetFreqRangeProperties(XAAdaptationMMFCtx *bCtx,
+ XAuint8 range,
+ XAuint32 * pMinFreq,
+ XAuint32 * pMaxFreq)
+{
+ XAresult res = XA_RESULT_SUCCESS;
+ DEBUG_API("->XARadioItfAdapt_GetFreqRangeProperties");
+ mmf_set_radio_adapt_context(cmmfradiobackendengine_init(), bCtx);
+ res = get_freq_range_properties(cmmfradiobackendengine_init(), range, pMinFreq, pMaxFreq);
+ DEBUG_API("<-XARadioItfAdapt_GetFreqRangeProperties");
+ return res;
+}
+
+/*
+ * XAresult XARadioItfAdapt_SetFrequency(XAAdaptationMMFCtx *bCtx, XAuint32 freq)
+ */
+XAresult XARadioItfAdapt_SetFrequency(XAAdaptationMMFCtx *bCtx, XAuint32 freq)
+{
+ XAresult ret = XA_RESULT_SUCCESS;
+ DEBUG_API("->XARadioItfAdapt_SetFrequency");
+ mmf_set_radio_adapt_context(cmmfradiobackendengine_init(), bCtx);
+ set_frequency(cmmfradiobackendengine_init(), freq);
+ DEBUG_API("<-XARadioItfAdapt_SetFrequency");
+ return ret;
+}
+
+
+/*
+ * XAresult XARadioItfAdapt_GetFrequency(XAAdaptationMMFCtx *bCtx,
+ * XAuint32* pFrequency)
+ */
+XAresult XARadioItfAdapt_GetFrequency(XAuint32* pFrequency)
+{
+ XAresult ret = XA_RESULT_SUCCESS;
+ DEBUG_API("->XARadioItfAdapt_GetFrequency");
+ ret = get_frequency(cmmfradiobackendengine_init(), pFrequency);
+ DEBUG_API("<-XARadioItfAdapt_GetFrequency");
+ return ret;
+}
+
+
+/*
+ * XAresult XARadioItfAdapt_CancelSetFrequency()
+ */
+XAresult XARadioItfAdapt_CancelSetFrequency()
+{
+ XAresult ret = XA_RESULT_SUCCESS;
+ DEBUG_API("->XARadioItfAdapt_CancelSetFrequency");
+ cancel_set_frequency(cmmfradiobackendengine_init());
+ DEBUG_API("<-XARadioItfAdapt_CancelSetFrequency");
+ return ret;
+}
+
+/*
+ * XAresult XARadioItfAdapt_CancelStationSeek()
+ */
+XAresult XARadioItfAdapt_CancelStationSeek()
+{
+ XAresult ret = XA_RESULT_SUCCESS;
+ DEBUG_API("->XARadioItfAdapt_CancelStationSeek");
+ cancel_station_seek(cmmfradiobackendengine_init());
+ DEBUG_API("<-XARadioItfAdapt_CancelStationSeek");
+ return ret;
+}
+
+/*
+ * XAresult XARadioItfAdapt_SetSquelch(XAboolean squelch)
+ */
+XAresult XARadioItfAdapt_SetSquelch(XAboolean squelch)
+{
+ XAresult ret = XA_RESULT_FEATURE_UNSUPPORTED;
+ DEBUG_API("->XARadioItfAdapt_SetSquelch");
+ return ret;
+}
+
+/*
+ * XAresult XARadioItfAdapt_GetSquelch(XAboolean *squelch)
+ */
+XAresult XARadioItfAdapt_GetSquelch(XAboolean* squelch)
+{
+ XAresult ret = XA_RESULT_FEATURE_UNSUPPORTED;
+ DEBUG_API("->XARadioItfAdapt_GetSquelch");
+ return ret;
+}
+
+/*
+ * XAresult XARadioItfAdapt_SetStereoMode(XAAdaptationMMFCtx *bCtx, XAuint32 mode)
+ */
+XAresult XARadioItfAdapt_SetStereoMode(XAAdaptationMMFCtx *bCtx, XAuint32 mode)
+{
+ XAresult res = XA_RESULT_SUCCESS;
+ DEBUG_API("->XARadioItfAdapt_SetStereoMode");
+ mmf_set_radio_adapt_context(cmmfradiobackendengine_init(), bCtx);
+ res = set_stereo_mode(cmmfradiobackendengine_init(), mode);
+ DEBUG_API("<-XARadioItfAdapt_SetStereoMode");
+ return res;
+}
+
+/*
+ * XAresult XARadioItfAdapt_GetSignalStrength(XAuint32 * pStrength)
+ */
+XAresult XARadioItfAdapt_GetSignalStrength(XAuint32 * pStrength)
+{
+ XAresult ret = XA_RESULT_SUCCESS;
+ DEBUG_API("->XARadioItfAdapt_GetSignalStrength");
+ ret = get_signal_strength(cmmfradiobackendengine_init(), pStrength);
+ DEBUG_API("<-XARadioItfAdapt_GetSignalStrength");
+ return ret;
+}
+
+/*
+ * XAresult XARadioItfAdapt_Seek(XAAdaptationMMFCtx *bCtx, XAboolean upwards)
+ */
+XAresult XARadioItfAdapt_Seek(XAAdaptationMMFCtx *bCtx, XAboolean upwards)
+{
+ XAboolean direction;
+ XAresult ret = XA_RESULT_SUCCESS;
+ if (!upwards)
+ direction = XA_BOOLEAN_FALSE;
+ else
+ direction = XA_BOOLEAN_TRUE;
+ DEBUG_API("->XARadioItfAdapt_Seek");
+ mmf_set_radio_adapt_context(cmmfradiobackendengine_init(), bCtx);
+ station_seek(cmmfradiobackendengine_init(), direction);
+ DEBUG_API("<-XARadioItfAdapt_Seek");
+ return ret;
+}
+
+/*
+ * void XARadioItfAdapt_StopSeeking(XAAdaptationMMFCtx *bCtx)
+ */
+void XARadioItfAdapt_StopSeeking(XAAdaptationMMFCtx *bCtx)
+{
+ DEBUG_API("->XARadioItfAdapt_StopSeeking");
+ mmf_set_radio_adapt_context(cmmfradiobackendengine_init(), bCtx);
+ cancel_station_seek(cmmfradiobackendengine_init());
+ DEBUG_API("<-XARadioItfAdapt_StopSeeking");
+}
+
+/*
+ * XAresult XARadioItfAdapt_GetStereoMode(XAuint32 * pMode)
+ */
+XAresult XARadioItfAdapt_GetStereoMode(XAuint32 * pMode)
+{
+ XAresult ret = XA_RESULT_SUCCESS;
+ DEBUG_API("->XARadioItfAdapt_GetStereoMode");
+ ret = get_stereo_mode(cmmfradiobackendengine_init(), pMode);
+ DEBUG_API("<-XARadioItfAdapt_GetStereoMode");
+ return ret;
+}
+
+/*
+ * void XARadioItfAdapt_Free()
+ */
+void XARadioItfAdapt_Free()
+{
+ DEBUG_API("->XARadioItfAdapt_Free");
+
+}
+
+void XARadioItfAdapt_SeekComplete(XAAdaptationBaseCtx *ctx, TInt aError, TInt aFrequency)
+{
+ XAAdaptEvent event = {XA_RADIOITFEVENTS, XA_ADAPT_RADIO_SEEK_COMPLETE,1,0};
+ if (ctx)
+ {
+ if (aError)
+ {
+ event.data = &aError;
+ }
+ else
+ {
+ event.data = &aFrequency;
+ }
+
+ XAAdaptationBase_SendAdaptEvents(ctx, &event );
+ }
+}
+
+void XARadioItfAdapt_FrequencyChange(XAAdaptationBaseCtx *ctx, TInt aFrequency)
+{
+ // Currently: Bug in FM Radio Utility: SetFrequency calls this callback as well as SetFrequencyComplete
+ // (So client will end up getting 2 events on a SetFrequency call)
+ XAuint32 freq = aFrequency;
+ XAAdaptEvent event = {XA_RADIOITFEVENTS, XA_ADAPT_RADIO_FREQUENCY_CHANGED,1,0};
+ if (ctx)
+ {
+ event.data = &freq;
+ XAAdaptationBase_SendAdaptEvents(ctx, &event );
+ }
+}
+
+void XARadioItfAdapt_FrequencyRangeChange(XAAdaptationBaseCtx* ctx, TInt aFreqRangeChange)
+{
+ // Currently: Bug in FM Radio Utility: SetFrequencyRange triggers this callback as well as SetFrequencyRangeComplete
+
+ /* XAAdaptEvent event = {XA_RADIOITFEVENTS, XA_ADAPT_RADIO_FREQUENCY_RANGE_CHANGED,1,0};
+ if (baseCtx)
+ {
+ event.data = &aFreqRangeChange;
+ XAAdaptationBase_SendAdaptEvents(&baseCtx->baseObj, &event );
+ }
+ */
+}
+
+void XARadioItfAdapt_SetFrequencyComplete(XAAdaptationBaseCtx *ctx, TInt aError, TInt aFrequency)
+{
+ // Currently: Qt API has no event for SetFrequencyComplete, so must use this one:
+ XAAdaptEvent event = {XA_RADIOITFEVENTS, XA_ADAPT_RADIO_FREQUENCY_CHANGED,1,0};
+ XAuint32 freq = aFrequency;
+ if (ctx)
+ {
+ if (!aError)
+ {
+ event.data = &freq;
+ }
+ else
+ {
+ event.data = &aError;
+ }
+ XAAdaptationBase_SendAdaptEvents(ctx, &event );
+ }
+}
+
+void XARadioItfAdapt_SetFrequencyRangeComplete(XAAdaptationBaseCtx *ctx, TInt aError)
+{
+ XAAdaptEvent event = {XA_RADIOITFEVENTS, XA_ADAPT_RADIO_FREQUENCY_RANGE_CHANGED,1,0};
+ if (ctx)
+ {
+ event.data = &aError;
+ XAAdaptationBase_SendAdaptEvents(ctx, &event );
+ }
+}
+
+void XARadioItfAdapt_StereoStatusChange(XAAdaptationBaseCtx *ctx, XAboolean aStereoStatus)
+{
+ XAAdaptEvent event = {XA_RADIOITFEVENTS, XA_ADAPT_RADIO_STEREO_STATUS_CHANGED,1,0};
+ DEBUG_INFO_A1("XARadioItfAdapt_StereoStatusChange to: %s", aStereoStatus);
+ if (ctx)
+ {
+ event.data = &aStereoStatus;
+ XAAdaptationBase_SendAdaptEvents(ctx, &event );
+ }
+}
+
+void XARadioItfAdapt_SignalStrengthChange(XAAdaptationBaseCtx *ctx, TInt aSignalStrength)
+{
+ XAAdaptEvent event = {XA_RADIOITFEVENTS, XA_ADAPT_RADIO_SIGNAL_STRENGTH_CHANGED,1,0};
+ DEBUG_INFO_A1("XARadioItfAdapt_SignalStrengthChange to: %s", aSignalStrength);
+ if (ctx)
+ {
+ event.data = &aSignalStrength;
+ XAAdaptationBase_SendAdaptEvents(ctx, &event );
+ }
+}