/*

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