/*

* 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:

*

*

*/

#include <stdio.h>

#include <stdlib.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;

    }

    if (ret != XA_RESULT_SUCCESS)

    {

    	XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);

    	return ret;

    if ( (freq < minFreq) || (freq > maxFreq) )

    {

    	XA_IMPL_THREAD_SAFETY_EXIT(XATSRadio);

    	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)

    {

        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.

 **/

{

    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,