/*

* 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");    

    if ((range == XA_FREQRANGE_FMEUROAMERICA) || (range == XA_FREQRANGE_FMJAPAN)) 

        {	

 			*pSupported = XA_BOOLEAN_TRUE;   

 		}

 		else

 			*pSupported = XA_BOOLEAN_FALSE;

    DEBUG_API("<-XARadioItfAdapt_IsFreqRangeSupported");

    return ret;

}

/*

 * XAresult XARadioItfAdapt_GetFreqRangeProperties(XAAdaptationMMFCtx *bCtx,

 *                                                 XAuint8 range,

 *                                                 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_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)

{

    XAresult ret = XA_RESULT_SUCCESS;          

   	DEBUG_API("->XARadioItfAdapt_Seek");	    

    mmf_set_radio_adapt_context(cmmfradiobackendengine_init(), bCtx);     	

		station_seek(cmmfradiobackendengine_init(), upwards);   				

    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 );

   	}   

}