1 /*

     2 * Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description: 

    15 *

    16 */

    17 

    18 #include <unistd.h>

    19 #include <time.h>

    20 #include <string.h>

    21 

    22 #include "xaadaptationgst.h"

    23 #include "xaradioadaptctx.h"

    24 #include "xardsitfadaptation.h"

    25 #include "xaradioitfadaptation.h"

    26 

    27 /* emulated device data and constraints */

    28 

    29 #define NUM_OF_CHANNELS 2

    30 #define MAX_PS_STRING_LENGHT 17

    31 #define MAX_RT_STRING_LENGHT 129

    32 #define MAX_ODA_GROUP_SUBSCRIPTIONS 100

    33 #define MAX_PTY_STRING_SHORT_LENGHT 17

    34 #define MAX_PTY_STRING_LONG_LENGHT 33

    35 #define NONE_STRING_LENGHT 4

    36 

    37 /* emulated rds data structure */

    38 typedef struct

    39 {

    40     XAuint32 frequency;

    41     XAchar *progServiceName;

    42     XAchar *radioText;

    43     XAuint32 programmeType;

    44     XAchar *ptyStringShort;

    45     XAchar *ptyStringLong;

    46     XAint16 programmeID;

    47     XAboolean trafficAnnouncement;

    48     XAboolean trafficProgramme;

    49 } RDSData;

    50 

    51 #define TRAFFIC_PROGRAMME_CHANNEL 0

    52 #define TRAFFIC_ANNOUNCEMENT_CHANNEL 0

    53 #define POPMUSIC_CHANNEL 1

    54 

    55 /* emulated rds data from channels */

    56 static const RDSData rdsData[NUM_OF_CHANNELS] = {

    57         {88500000, (XAchar *)"Traffic", (XAchar *)"All your traffic needs", XA_RDSPROGRAMMETYPE_RDSPTY_NONE,

    58             (XAchar *)"None", (XAchar *)"None", 0x0001, XA_BOOLEAN_TRUE, XA_BOOLEAN_TRUE },

    59         {89300000, (XAchar *)"Popular", (XAchar *)"For the populous", XA_RDSPROGRAMMETYPE_RDSPTY_POPMUSIC,

    60             (XAchar *)"Pop music", (XAchar *)"Pop music for the masses", 0x0002, XA_BOOLEAN_FALSE, XA_BOOLEAN_FALSE }

    61 };

    62 

    63 static const XAchar* noneString = (XAchar *)"None";

    64 

    65 static XAint16 subscribedODAGroups[MAX_ODA_GROUP_SUBSCRIPTIONS];

    66 static XAuint16 subscribedODAGroupCount = 0;

    67 

    68 static XAuint32 freqSetAfterSeek;

    69 

    70 const RDSData* GetCurrentRdsData( XAAdaptationGstCtx *bCtx );

    71 void * XARDSItfAdapt_AsyncSeek(void* args);

    72 void * XARDSItfAdapt_AsyncGetODAGroup(void* args);

    73 

    74 /* exposing radio itf adaptation internal function here */

    75 XAresult XARadioItfAdapt_SyncSetFrequency(XAAdaptationGstCtx *bCtx, XAuint32 freq);

    76 

    77 

    78 /*

    79  * XAresult XARDSItfAdapt_QueryRDSSignal(XAAdaptationGstCtx *bCtx, XAboolean * isSignal)

    80  */

    81 XAresult XARDSItfAdapt_QueryRDSSignal(XAAdaptationGstCtx *bCtx, XAboolean * isSignal)

    82 {

    83     XAresult ret = XA_RESULT_SUCCESS;

    84     DEBUG_API("->XARDSItfAdapt_QueryRDSSignal");

    85 

    86     if(!bCtx || !isSignal)

    87     {

    88         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

    89         DEBUG_API("<-XARDSItfAdapt_QueryRDSSignal");

    90         return XA_RESULT_PARAMETER_INVALID;

    91     }

    92 

    93     if (GetCurrentRdsData(bCtx))

    94     {

    95         *isSignal = XA_BOOLEAN_TRUE;

    96     }

    97     else

    98     {

    99         *isSignal = XA_BOOLEAN_FALSE;

   100     }

   101 

   102     DEBUG_API("<-XARDSItfAdapt_QueryRDSSignal");

   103     return ret;

   104 }

   105 

   106 /*

   107  * XAresult XARDSItfAdapt_GetProgrammeServiceName(XAAdaptationGstCtx *bCtx, XAchar * ps)

   108  */

   109 XAresult XARDSItfAdapt_GetProgrammeServiceName(XAAdaptationGstCtx *bCtx, XAchar * ps)

   110 {

   111     XAresult ret = XA_RESULT_SUCCESS;

   112     const RDSData* data;

   113     DEBUG_API("->XARDSItfAdapt_GetProgrammeServiceName");

   114 

   115 

   116     if(!bCtx || !ps)

   117     {

   118         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   119         DEBUG_API("<-XARDSItfAdapt_GetProgrammeServiceName");

   120         return XA_RESULT_PARAMETER_INVALID;

   121     }

   122 

   123     data = GetCurrentRdsData( bCtx );

   124 

   125     if (data)

   126     {

   127         strncpy( (char *)ps, (char *)data->progServiceName, MAX_PS_STRING_LENGHT );

   128     }

   129     else

   130     {

   131         *ps = 0;

   132     }

   133 

   134     DEBUG_API("<-XARDSItfAdapt_GetProgrammeServiceName");

   135     return ret;

   136 }

   137 

   138 /*

   139  * XAresult XARDSItfAdapt_GetRadioText(XAAdaptationGstCtx *bCtx, XAchar * rt)

   140  */

   141 XAresult XARDSItfAdapt_GetRadioText(XAAdaptationGstCtx *bCtx, XAchar * rt)

   142 {

   143     XAresult ret = XA_RESULT_SUCCESS;

   144     const RDSData* data;

   145     DEBUG_API("->XARDSItfAdapt_GetRadioText");

   146 

   147     if(!bCtx || !rt)

   148     {

   149         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   150         DEBUG_API("<-XARDSItfAdapt_GetRadioText");

   151         return XA_RESULT_PARAMETER_INVALID;

   152     }

   153 

   154     data = GetCurrentRdsData( bCtx );

   155 

   156     if (data)

   157     {

   158         strncpy( (char *)rt, (char *)data->radioText, MAX_RT_STRING_LENGHT );

   159     }

   160     else

   161     {

   162         *rt = 0;

   163     }

   164 

   165     DEBUG_API("<-XARDSItfAdapt_GetRadioText");

   166     return ret;

   167 }

   168 

   169 /*

   170  * XAresult XARDSItfAdapt_GetRadioTextPlus(XAAdaptationGstCtx *bCtx,

   171  *                                         XAuint8 contentType,

   172  *                                         XAchar * informationElement,

   173  *                                         XAchar * descriptor,

   174  *                                         XAuint8 * descriptorContentType)

   175  */

   176 XAresult XARDSItfAdapt_GetRadioTextPlus(XAAdaptationGstCtx *bCtx,

   177                                         XAuint8 contentType,

   178                                         XAchar * informationElement,

   179                                         XAchar * descriptor,

   180                                         XAuint8 * descriptorContentType)

   181 {

   182     XAresult ret = XA_RESULT_SUCCESS;

   183     DEBUG_API("->XARDSItfAdapt_GetRadioTextPlus");

   184 

   185     if(!bCtx || contentType < XA_RDSRTPLUS_ITEMTITLE || contentType > XA_RDSRTPLUS_GETDATA

   186             || !informationElement || !descriptor || !descriptorContentType)

   187     {

   188         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   189         DEBUG_API("<-XARDSItfAdapt_GetRadioTextPlus");

   190         return XA_RESULT_PARAMETER_INVALID;

   191     }

   192 

   193     *informationElement = 0;

   194     *descriptorContentType = 0;

   195 

   196     DEBUG_API("<-XARDSItfAdapt_GetRadioTextPlus");

   197     return ret;

   198 }

   199 

   200 /*

   201  * XAresult XARDSItfAdapt_GetProgrammeType(XAAdaptationGstCtx *bCtx, XAuint32 * pty)

   202  */

   203 XAresult XARDSItfAdapt_GetProgrammeType(XAAdaptationGstCtx *bCtx, XAuint32 * pty)

   204 {

   205     XAresult ret = XA_RESULT_SUCCESS;

   206     const RDSData* data;

   207     DEBUG_API("->XARDSItfAdapt_GetProgrammeType");

   208 

   209     if(!bCtx || !pty)

   210     {

   211         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   212         DEBUG_API("<-XARDSItfAdapt_GetProgrammeType");

   213         return XA_RESULT_PARAMETER_INVALID;

   214     }

   215 

   216     data = GetCurrentRdsData( bCtx );

   217 

   218     if (data)

   219     {

   220         *pty = data->programmeType;

   221     }

   222     else

   223     {

   224         *pty = 0;

   225     }

   226 

   227     DEBUG_API("<-XARDSItfAdapt_GetProgrammeType");

   228     return ret;

   229 }

   230 

   231 /*

   232  * XAresult XARDSItfAdapt_GetProgrammeTypeString(XAAdaptationGstCtx *bCtx,

   233  *                                               XAboolean isLengthMax16,

   234  *                                               XAchar * pty)

   235  *

   236  */

   237 XAresult XARDSItfAdapt_GetProgrammeTypeString(XAAdaptationGstCtx *bCtx,

   238                                              XAboolean isLengthMax16,

   239                                              XAchar * pty)

   240 {

   241     XAresult ret = XA_RESULT_SUCCESS;

   242     const RDSData* data;

   243     DEBUG_API("->XARDSItfAdapt_GetProgrammeTypeString");

   244 

   245     if(!bCtx || !pty)

   246     {

   247         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   248         DEBUG_API("<-XARDSItfAdapt_GetProgrammeTypeString");

   249         return XA_RESULT_PARAMETER_INVALID;

   250     }

   251 

   252     data = GetCurrentRdsData( bCtx );

   253 

   254     if (data)

   255     {

   256         if (isLengthMax16)

   257         {

   258             DEBUG_API_A1("Programme type string %s", data->ptyStringLong);

   259             strncpy( (char *)pty, (char *)data->ptyStringLong, MAX_PTY_STRING_LONG_LENGHT );

   260         }

   261         else

   262         {

   263             DEBUG_API_A1("Programme type string %s", data->ptyStringShort);

   264             strncpy( (char *)pty, (char *)data->ptyStringShort, MAX_PTY_STRING_SHORT_LENGHT );

   265         }

   266     }

   267     else

   268     {

   269         DEBUG_API_A1("Programme type string %s", noneString);

   270         strncpy( (char *)pty, (char *)noneString, NONE_STRING_LENGHT );

   271     }

   272 

   273     DEBUG_API("<-XARDSItfAdapt_GetProgrammeTypeString");

   274     return ret;

   275 }

   276 

   277 /*

   278  * XAresult XARDSItfAdapt_GetProgrammeIdentificationCode(XAAdaptationGstCtx *bCtx, XAint16 * pi)

   279  */

   280 XAresult XARDSItfAdapt_GetProgrammeIdentificationCode(XAAdaptationGstCtx *bCtx, XAint16 * pi)

   281 {

   282     XAresult ret = XA_RESULT_SUCCESS;

   283     const RDSData* data;

   284     DEBUG_API("->XARDSItfAdapt_GetProgrammeIdentificationCode");

   285 

   286     if(!bCtx || !pi)

   287     {

   288         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   289         DEBUG_API("<-XARDSItfAdapt_GetProgrammeIdentificationCode");

   290         return XA_RESULT_PARAMETER_INVALID;

   291     }

   292 

   293     data = GetCurrentRdsData( bCtx );

   294 

   295     if (data)

   296     {

   297         *pi = data->programmeID;

   298     }

   299     else

   300     {

   301         *pi = 0;

   302     }

   303 

   304     DEBUG_API("<-XARDSItfAdapt_GetProgrammeIdentificationCode");

   305     return ret;

   306 }

   307 

   308 /*

   309  * XAresult XARDSItfAdapt_GetClockTime(XAAdaptationGstCtx *bCtx, XAtime * dateAndTime)

   310  */

   311 XAresult XARDSItfAdapt_GetClockTime(XAAdaptationGstCtx *bCtx, XAtime * dateAndTime)

   312 {

   313     XAresult ret = XA_RESULT_SUCCESS;

   314     time_t timeRet=0;

   315     DEBUG_API("->XARDSItfAdapt_GetClockTime");

   316 

   317     if(!bCtx || !dateAndTime)

   318     {

   319         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   320         DEBUG_API("<-XARDSItfAdapt_GetClockTime");

   321         return XA_RESULT_PARAMETER_INVALID;

   322     }

   323 

   324     timeRet = time(NULL);

   325 

   326     if (timeRet == -1) /* could not get time for some reason */

   327     {

   328         ret = XA_RESULT_INTERNAL_ERROR;

   329     }

   330     else

   331     {

   332         *dateAndTime = timeRet;

   333     }

   334 

   335     DEBUG_API("<-XARDSItfAdapt_GetClockTime");

   336     return ret;

   337 }

   338 

   339 /*

   340  * XAresult XARDSItfAdapt_GetTrafficAnnouncement(XAAdaptationGstCtx *bCtx, XAboolean * ta)

   341  */

   342 XAresult XARDSItfAdapt_GetTrafficAnnouncement(XAAdaptationGstCtx *bCtx, XAboolean * ta)

   343 {

   344     XAresult ret = XA_RESULT_SUCCESS;

   345     const RDSData* data;

   346     DEBUG_API("->XARDSItfAdapt_GetTrafficAnnouncement");

   347 

   348     if(!bCtx || !ta)

   349     {

   350         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   351         DEBUG_API("<-XARDSItfAdapt_GetTrafficAnnouncement");

   352         return XA_RESULT_PARAMETER_INVALID;

   353     }

   354 

   355     data = GetCurrentRdsData( bCtx );

   356 

   357     if (data)

   358     {

   359         *ta = data->trafficAnnouncement;

   360     }

   361     else

   362     {

   363         *ta = XA_BOOLEAN_FALSE;

   364     }

   365 

   366     DEBUG_API("<-XARDSItfAdapt_GetTrafficAnnouncement");

   367     return ret;

   368 }

   369 

   370 /*

   371  * XAresult XARDSItfAdapt_GetTrafficProgramme(XAAdaptationGstCtx *bCtx, XAboolean * tp)

   372  */

   373 XAresult XARDSItfAdapt_GetTrafficProgramme(XAAdaptationGstCtx *bCtx, XAboolean * tp)

   374 {

   375     XAresult ret = XA_RESULT_SUCCESS;

   376     const RDSData* data;

   377     DEBUG_API("->XARDSItfAdapt_GetTrafficProgramme");

   378 

   379     if(!bCtx || !tp)

   380     {

   381         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   382         DEBUG_API("<-XARDSItfAdapt_GetTrafficProgramme");

   383         return XA_RESULT_PARAMETER_INVALID;

   384     }

   385 

   386     data = GetCurrentRdsData( bCtx );

   387 

   388     if (data)

   389     {

   390         *tp = data->trafficProgramme;

   391     }

   392     else

   393     {

   394         *tp = XA_BOOLEAN_FALSE;

   395     }

   396 

   397     DEBUG_API("<-XARDSItfAdapt_GetTrafficProgramme");

   398     return ret;

   399 }

   400 

   401 /*

   402  * XAresult XARDSItfAdapt_SeekByProgrammeType(XAAdaptationGstCtx *bCtx,

   403  *                                            XAuint32 pty,

   404  *                                            XAboolean upwards)

   405  */

   406 XAresult XARDSItfAdapt_SeekByProgrammeType(XAAdaptationGstCtx *bCtx,

   407                                            XAuint32 pty,

   408                                            XAboolean upwards)

   409 {

   410     XAresult ret = XA_RESULT_SUCCESS;

   411     int pt_ret=0;

   412     XARadioAdaptationCtx* mCtx = NULL;

   413     DEBUG_API("->XARDSItfAdapt_SeekByProgrammeType");

   414 

   415     if(!bCtx)

   416     {

   417         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   418         DEBUG_API("<-XARDSItfAdapt_SeekByProgrammeType");

   419         return XA_RESULT_PARAMETER_INVALID;

   420     }

   421 

   422     mCtx = (XARadioAdaptationCtx*) bCtx;

   423 

   424     if (mCtx->state != XA_RADIO_IDLE)

   425     {

   426       //  pthread_cancel(mCtx->emulationThread);

   427         mCtx->state = XA_RADIO_IDLE;

   428     }

   429 

   430     if (pty == XA_RDSPROGRAMMETYPE_RDSPTY_POPMUSIC)

   431     {

   432         freqSetAfterSeek = rdsData[POPMUSIC_CHANNEL].frequency;

   433     }

   434     else

   435     {

   436         freqSetAfterSeek = mCtx->frequency;

   437     }

   438 

   439     mCtx->state = XA_RADIO_SEEKING;

   440     pt_ret = pthread_create(&(mCtx->emulationThread), NULL, (XARDSItfAdapt_AsyncSeek),(void*)bCtx);

   441 

   442     if(pt_ret)

   443     {

   444         DEBUG_ERR_A1("could not create thread!! (%d)",ret);

   445         DEBUG_API("<-XARDSItfAdapt_SeekByProgrammeType");

   446         return XA_RESULT_INTERNAL_ERROR;

   447     }

   448 

   449     DEBUG_API("<-XARDSItfAdapt_SeekByProgrammeType");

   450     return ret;

   451 }

   452 

   453 /*

   454  * XAresult XARDSItfAdapt_SeekTrafficAnnouncement(XAAdaptationGstCtx *bCtx, XAboolean upwards)

   455  */

   456 XAresult XARDSItfAdapt_SeekTrafficAnnouncement(XAAdaptationGstCtx *bCtx, XAboolean upwards)

   457 {

   458     XAresult ret = XA_RESULT_SUCCESS;

   459     int pt_ret=0;

   460     XARadioAdaptationCtx* mCtx = NULL;

   461     DEBUG_API("->XARDSItfAdapt_SeekTrafficAnnouncement");

   462 

   463     if(!bCtx)

   464     {

   465         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   466         DEBUG_API("<-XARDSItfAdapt_SeekTrafficAnnouncement");

   467         return XA_RESULT_PARAMETER_INVALID;

   468     }

   469 

   470     mCtx = (XARadioAdaptationCtx*) bCtx;

   471 

   472     if (mCtx->state != XA_RADIO_IDLE)

   473     {

   474      //   pthread_cancel(mCtx->emulationThread);

   475         mCtx->state = XA_RADIO_IDLE;

   476     }

   477 

   478     freqSetAfterSeek = rdsData[TRAFFIC_ANNOUNCEMENT_CHANNEL].frequency;

   479 

   480     mCtx->state = XA_RADIO_SEEKING;

   481     pt_ret = pthread_create(&(mCtx->emulationThread), NULL, (XARDSItfAdapt_AsyncSeek),(void*)bCtx);

   482 

   483     if(pt_ret)

   484     {

   485         DEBUG_ERR_A1("could not create thread!! (%d)",ret);

   486         DEBUG_API("<-XARDSItfAdapt_SeekTrafficAnnouncement");

   487         return XA_RESULT_INTERNAL_ERROR;

   488     }

   489 

   490     DEBUG_API("<-XARDSItfAdapt_SeekTrafficAnnouncement");

   491     return ret;

   492 }

   493 

   494 /*

   495  * XAresult XARDSItfAdapt_SeekTrafficProgramme(XAAdaptationGstCtx *bCtx, XAboolean upwards)

   496  */

   497 XAresult XARDSItfAdapt_SeekTrafficProgramme(XAAdaptationGstCtx *bCtx, XAboolean upwards)

   498 {

   499     XAresult ret = XA_RESULT_SUCCESS;

   500     int pt_ret=0;

   501     XARadioAdaptationCtx* mCtx = NULL;

   502     DEBUG_API("->XARDSItfAdapt_SeekTrafficProgramme");

   503 

   504     if(!bCtx)

   505     {

   506         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   507         DEBUG_API("<-XARDSItfAdapt_SeekTrafficProgramme");

   508         return XA_RESULT_PARAMETER_INVALID;

   509     }

   510 

   511     mCtx = (XARadioAdaptationCtx*) bCtx;

   512 

   513     if (mCtx->state != XA_RADIO_IDLE)

   514     {

   515       //  pthread_cancel(mCtx->emulationThread);

   516         mCtx->state = XA_RADIO_IDLE;

   517     }

   518 

   519     freqSetAfterSeek = rdsData[TRAFFIC_PROGRAMME_CHANNEL].frequency;

   520 

   521     mCtx->state = XA_RADIO_SEEKING;

   522     pt_ret = pthread_create(&(mCtx->emulationThread), NULL, (XARDSItfAdapt_AsyncSeek),(void*)bCtx);

   523 

   524     if(pt_ret)

   525     {

   526         DEBUG_ERR_A1("could not create thread!! (%d)",ret);

   527         DEBUG_API("<-XARDSItfAdapt_SeekTrafficProgramme");

   528         return XA_RESULT_INTERNAL_ERROR;

   529     }

   530 

   531     DEBUG_API("<-XARDSItfAdapt_SeekTrafficProgramme");

   532     return ret;

   533 }

   534 

   535 /*

   536  * void * XARadioItfAdapt_AsyncSeek(void* args)

   537  */

   538 void * XARDSItfAdapt_AsyncSeek(void* args)

   539 {

   540     XAresult ret = XA_RESULT_SUCCESS;

   541     XAAdaptationGstCtx *bCtx = (XAAdaptationGstCtx*)args;

   542 

   543     XARadioAdaptationCtx* mCtx = (XARadioAdaptationCtx*) bCtx;

   544 

   545     DEBUG_API("->XARDSItfAdapt_AsyncSeek");

   546 

   547     usleep(100000); /* 1/10 seconds */

   548 

   549     DEBUG_INFO("Seek done!");

   550 

   551     ret = XARadioItfAdapt_SyncSetFrequency( bCtx, freqSetAfterSeek );

   552     if (ret != XA_RESULT_SUCCESS)

   553     {

   554         DEBUG_ERR("XARadioItfAdapt_SyncSetFrequency FAILED");

   555     }

   556 

   557     /* Send event to RadioItf */

   558     {

   559         XAAdaptEvent event = {XA_RADIOITFEVENTS, XA_ADAPT_RADIO_SEEK_COMPLETE, 0, NULL };

   560         XAAdaptationBase_SendAdaptEvents(&bCtx->baseObj, &event );

   561     }

   562     mCtx->state = XA_RADIO_IDLE;

   563 

   564     DEBUG_API("<-XARDSItfAdapt_AsyncSeek");

   565     pthread_exit(NULL);

   566     return NULL;

   567 }

   568 

   569 /*

   570  * XAresult XARDSItfAdapt_SetAutomaticSwitching(XAAdaptationGstCtx *bCtx, XAboolean automatic)

   571  */

   572 XAresult XARDSItfAdapt_SetAutomaticSwitching(XAAdaptationGstCtx *bCtx, XAboolean automatic)

   573 {

   574     XAresult ret = XA_RESULT_SUCCESS;

   575     DEBUG_API("->XARDSItfAdapt_SetAutomaticSwitching");

   576 

   577     if(!bCtx)

   578     {

   579         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   580         DEBUG_API("<-XARDSItfAdapt_SetAutomaticSwitching");

   581         return XA_RESULT_PARAMETER_INVALID;

   582     }

   583 

   584     ret = XA_RESULT_FEATURE_UNSUPPORTED;

   585 

   586     DEBUG_API("<-XARDSItfAdapt_SetAutomaticSwitching");

   587     return ret;

   588 }

   589 

   590 /*

   591  * XAresult XARDSItfAdapt_GetAutomaticSwitching(XAAdaptationGstCtx *bCtx, XAboolean * automatic)

   592  */

   593 XAresult XARDSItfAdapt_GetAutomaticSwitching(XAAdaptationGstCtx *bCtx, XAboolean * automatic)

   594 {

   595     XAresult ret = XA_RESULT_SUCCESS;

   596     DEBUG_API("->XARDSItfAdapt_GetAutomaticSwitching");

   597 

   598     if(!bCtx || !automatic)

   599     {

   600         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   601         DEBUG_API("<-XARDSItfAdapt_GetAutomaticSwitching");

   602         return XA_RESULT_PARAMETER_INVALID;

   603     }

   604 

   605     /* Feature not supported */

   606     *automatic = XA_BOOLEAN_FALSE;

   607 

   608     DEBUG_API("<-XARDSItfAdapt_GetAutomaticSwitching");

   609     return ret;

   610 }

   611 

   612 /*

   613  * XAresult XARDSItfAdapt_SetAutomaticTrafficAnnouncement(XAAdaptationGstCtx *bCtx, XAboolean automatic)

   614  */

   615 XAresult XARDSItfAdapt_SetAutomaticTrafficAnnouncement(XAAdaptationGstCtx *bCtx, XAboolean automatic)

   616 {

   617     XAresult ret = XA_RESULT_SUCCESS;

   618     DEBUG_API("->XARDSItfAdapt_SetAutomaticTrafficAnnouncement");

   619     if(!bCtx)

   620     {

   621         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   622         DEBUG_API("<-XARDSItfAdapt_SetAutomaticTrafficAnnouncement");

   623         return XA_RESULT_PARAMETER_INVALID;

   624     }

   625 

   626     ret = XA_RESULT_FEATURE_UNSUPPORTED;

   627 

   628     DEBUG_API("<-XARDSItfAdapt_SetAutomaticTrafficAnnouncement");

   629     return ret;

   630 }

   631 

   632 /*

   633  * XAresult XARDSItfAdapt_GetAutomaticTrafficAnnouncement(XAAdaptationGstCtx *bCtx, XAboolean * automatic)

   634  */

   635 XAresult XARDSItfAdapt_GetAutomaticTrafficAnnouncement(XAAdaptationGstCtx *bCtx, XAboolean * automatic)

   636 {

   637     XAresult ret = XA_RESULT_SUCCESS;

   638     DEBUG_API("->XARDSItfAdapt_GetAutomaticTrafficAnnouncement");

   639 

   640     if(!bCtx || !automatic)

   641     {

   642         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   643         DEBUG_API("<-XARDSItfAdapt_GetAutomaticTrafficAnnouncement");

   644         return XA_RESULT_PARAMETER_INVALID;

   645     }

   646 

   647     *automatic = XA_BOOLEAN_FALSE;

   648 

   649     DEBUG_API("<-XARDSItfAdapt_GetAutomaticTrafficAnnouncement");

   650     return ret;

   651 }

   652 

   653 /*

   654  * XAresult XARDSItfAdapt_GetODAGroup(XAAdaptationGstCtx *bCtx,

   655  *                                    XAint16 AID)

   656  */

   657 XAresult XARDSItfAdapt_GetODAGroup(XAAdaptationGstCtx *bCtx, XAint16 AID)

   658 {

   659     XAresult ret = XA_RESULT_SUCCESS;

   660     int pt_ret=0;

   661     XARadioAdaptationCtx* mCtx=NULL;

   662     DEBUG_API("->XARDSItfAdapt_GetODAGroup");

   663 

   664     if(!bCtx)

   665     {

   666         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   667         DEBUG_API("<-XARDSItfAdapt_GetODAGroup");

   668         return XA_RESULT_PARAMETER_INVALID;

   669     }

   670 

   671     mCtx = (XARadioAdaptationCtx*) bCtx;

   672 

   673     if (mCtx->rdsState != XA_RADIO_RDS_IDLE)

   674     {

   675       //  pthread_cancel(mCtx->rdsEmulationThread);

   676         mCtx->rdsState = XA_RADIO_RDS_IDLE;

   677         DEBUG_INFO("Previous getodagroup async call cancelled")

   678     }

   679 

   680     pt_ret = pthread_create(&(mCtx->rdsEmulationThread), NULL, (XARDSItfAdapt_AsyncGetODAGroup),(void*)bCtx);

   681 

   682     if(pt_ret)

   683     {

   684         DEBUG_ERR_A1("could not create thread!! (%d)",ret);

   685         DEBUG_API("<-XARDSItfAdapt_GetODAGroup");

   686         return XA_RESULT_INTERNAL_ERROR;

   687     }

   688 

   689     DEBUG_API("<-XARDSItfAdapt_GetODAGroup");

   690     return ret;

   691 }

   692 

   693 /*

   694  * void * XARDSItfAdapt_AsyncGetODAGroup(void* args)

   695  */

   696 void * XARDSItfAdapt_AsyncGetODAGroup(void* args)

   697 {

   698     XARadioAdaptationCtx* mCtx = (XARadioAdaptationCtx*)args;

   699 

   700     DEBUG_API("->XARDSItfAdapt_AsyncGetODAGroup");

   701     mCtx->rdsState = XA_RADIO_RDS_GETTING_ODA_GROUP;

   702 

   703     DEBUG_INFO("Get oda group async wait")

   704     usleep(100000); /* 1/10 seconds */

   705 

   706     /* Send event */

   707     {

   708         XAAdaptEvent event = {XA_RDSITFEVENTS, XA_ADAPT_RDS_GET_ODA_GROUP_DONE, 0, NULL };

   709         XAAdaptationBase_SendAdaptEvents(args, &event );

   710     }

   711     mCtx->rdsState = XA_RADIO_RDS_IDLE;

   712     DEBUG_API("<-XARDSItfAdapt_AsyncGetODAGroup");

   713     pthread_exit(NULL);

   714     return NULL;

   715 }

   716 

   717 /*

   718  * XAresult XARDSItfAdapt_SubscribeODAGroup(XAAdaptationGstCtx *bCtx,

   719  *                                          XAint16 group,

   720  *                                          XAboolean useErrorCorrection)

   721  */

   722 XAresult XARDSItfAdapt_SubscribeODAGroup(XAAdaptationGstCtx *bCtx,

   723                                         XAint16 group,

   724                                         XAboolean useErrorCorrection)

   725 {

   726     XAresult ret = XA_RESULT_SUCCESS;

   727     XAuint8 index=0;

   728     XAboolean groupFound = XA_BOOLEAN_FALSE;

   729     DEBUG_API("->XARDSItfAdapt_SubscribeODAGroup");

   730 

   731     if(!bCtx)

   732     {

   733         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   734         DEBUG_API("<-XARDSItfAdapt_SubscribeODAGroup");

   735         return XA_RESULT_PARAMETER_INVALID;

   736     }

   737 

   738     /* Look for group in list, if not there add it */

   739     if (subscribedODAGroupCount < MAX_ODA_GROUP_SUBSCRIPTIONS)

   740     {

   741         for (index = 0; index < subscribedODAGroupCount; index++)

   742         {

   743             if (subscribedODAGroups[index] == group)

   744             {

   745                 groupFound = XA_BOOLEAN_TRUE;

   746             }

   747         }

   748         if (!groupFound)

   749         {

   750             subscribedODAGroups[subscribedODAGroupCount] = group;

   751             subscribedODAGroupCount++;

   752         }

   753     }

   754     else

   755     {

   756         DEBUG_ERR("XA_RESULT_INTERNAL_ERROR");

   757         DEBUG_API("<-XARDSItfAdapt_SubscribeODAGroup");

   758         return XA_RESULT_INTERNAL_ERROR;

   759     }

   760 

   761     DEBUG_API("<-XARDSItfAdapt_SubscribeODAGroup");

   762     return ret;

   763 }

   764 

   765 /*

   766  * XAresult XARDSItfAdapt_UnsubscribeODAGroup(XAAdaptationGstCtx *bCtx, XAint16 group)

   767  */

   768 XAresult XARDSItfAdapt_UnsubscribeODAGroup(XAAdaptationGstCtx *bCtx, XAint16 group)

   769 {

   770     XAresult ret = XA_RESULT_SUCCESS;

   771     XAuint8 index=0;

   772     DEBUG_API("->XARDSItfAdapt_UnsubscribeODAGroup");

   773 

   774     if(!bCtx)

   775     {

   776         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   777         DEBUG_API("<-XARDSItfAdapt_UnsubscribeODAGroup");

   778         return XA_RESULT_PARAMETER_INVALID;

   779     }

   780 

   781     /* Look for group in list, if found, remove it */

   782     for (index = 0; index < subscribedODAGroupCount; index++)

   783     {

   784         if (subscribedODAGroups[index] == group)

   785         {

   786             subscribedODAGroups[index] = subscribedODAGroups[subscribedODAGroupCount-1];

   787             subscribedODAGroupCount--;

   788         }

   789     }

   790 

   791     DEBUG_API("<-XARDSItfAdapt_UnsubscribeODAGroup");

   792     return ret;

   793 }

   794 

   795 /*

   796  * XAresult XARDSItfAdapt_ListODAGroupSubscriptions(XAAdaptationGstCtx *bCtx,

   797  *                                                  XAint16* pGroups,

   798  *                                                  XAuint32* pLength)

   799  */

   800 XAresult XARDSItfAdapt_ListODAGroupSubscriptions(XAAdaptationGstCtx *bCtx,

   801                                                 XAint16* pGroups,

   802                                                 XAuint32* pLength)

   803 {

   804     XAresult ret = XA_RESULT_SUCCESS;

   805     XAuint8 index=0;

   806     DEBUG_API("->XARDSItfAdapt_ListODAGroupSubscriptions");

   807 

   808     if(!bCtx || !pLength)

   809     {

   810         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   811         DEBUG_API("<-XARDSItfAdapt_ListODAGroupSubscriptions");

   812         return XA_RESULT_PARAMETER_INVALID;

   813     }

   814 

   815     if (!pGroups)

   816     {

   817         *pLength = subscribedODAGroupCount;

   818     }

   819     else

   820     {

   821         if (*pLength < subscribedODAGroupCount)

   822         {

   823             ret = XA_RESULT_BUFFER_INSUFFICIENT;

   824         }

   825         for (index = 0; index < *pLength; index++)

   826         {

   827             pGroups[index] = subscribedODAGroups[index];

   828         }

   829     }

   830 

   831     DEBUG_API("<-XARDSItfAdapt_ListODAGroupSubscriptions");

   832     return ret;

   833 }

   834 

   835 /*

   836  * const RDSData* GetCurrentRdsData( XAAdaptationGstCtx *bCtx )

   837  */

   838 const RDSData* GetCurrentRdsData( XAAdaptationGstCtx *bCtx )

   839 {

   840     XAuint8 index=0;

   841     XARadioAdaptationCtx* mCtx = (XARadioAdaptationCtx*) bCtx;

   842 

   843     for (index = 0; index < NUM_OF_CHANNELS; index++ )

   844     {

   845         if (rdsData[index].frequency == mCtx->frequency)

   846         {

   847             DEBUG_API("<-GetCurrentRdsData");

   848             return &(rdsData[index]);

   849         }

   850     }

   851     DEBUG_API("<-GetCurrentRdsData");

   852     return NULL;

   853 }

   854 

   855 

   856 /*

   857  * void XARDSItfAdapt_Free(XAAdaptationGstCtx *bCtx)

   858  */

   859 void XARDSItfAdapt_Free(XAAdaptationBaseCtx *bCtx)

   860 {

   861     XARadioAdaptationCtx* mCtx = (XARadioAdaptationCtx*) bCtx;

   862     DEBUG_API("->XARDSItfAdapt_Free");

   863 

   864     if (mCtx->state != XA_RADIO_IDLE)

   865     {

   866        // pthread_cancel(mCtx->emulationThread);

   867         mCtx->state = XA_RADIO_IDLE;

   868     }

   869 

   870     if (mCtx->rdsState != XA_RADIO_RDS_IDLE)

   871     {

   872       //  pthread_cancel(mCtx->rdsEmulationThread);

   873         mCtx->rdsState = XA_RADIO_RDS_IDLE;

   874     }

   875 

   876     DEBUG_API("<-XARDSItfAdapt_Free");

   877 }