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 "XAAdaptation.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( XAAdaptationBaseCtx *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(XAAdaptationBaseCtx *bCtx, XAuint32 freq);

    76 

    77 

    78 /*

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

    80  */

    81 XAresult XARDSItfAdapt_QueryRDSSignal(XAAdaptationBaseCtx *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(XAAdaptationBaseCtx *bCtx, XAchar * ps)

   108  */

   109 XAresult XARDSItfAdapt_GetProgrammeServiceName(XAAdaptationBaseCtx *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(XAAdaptationBaseCtx *bCtx, XAchar * rt)

   140  */

   141 XAresult XARDSItfAdapt_GetRadioText(XAAdaptationBaseCtx *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(XAAdaptationBaseCtx *bCtx,

   171  *                                         XAuint8 contentType,

   172  *                                         XAchar * informationElement,

   173  *                                         XAchar * descriptor,

   174  *                                         XAuint8 * descriptorContentType)

   175  */

   176 XAresult XARDSItfAdapt_GetRadioTextPlus(XAAdaptationBaseCtx *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(XAAdaptationBaseCtx *bCtx, XAuint32 * pty)

   202  */

   203 XAresult XARDSItfAdapt_GetProgrammeType(XAAdaptationBaseCtx *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(XAAdaptationBaseCtx *bCtx,

   233  *                                               XAboolean isLengthMax16,

   234  *                                               XAchar * pty)

   235  *

   236  */

   237 XAresult XARDSItfAdapt_GetProgrammeTypeString(XAAdaptationBaseCtx *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(XAAdaptationBaseCtx *bCtx, XAint16 * pi)

   279  */

   280 XAresult XARDSItfAdapt_GetProgrammeIdentificationCode(XAAdaptationBaseCtx *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(XAAdaptationBaseCtx *bCtx, XAtime * dateAndTime)

   310  */

   311 XAresult XARDSItfAdapt_GetClockTime(XAAdaptationBaseCtx *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(XAAdaptationBaseCtx *bCtx, XAboolean * ta)

   341  */

   342 XAresult XARDSItfAdapt_GetTrafficAnnouncement(XAAdaptationBaseCtx *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(XAAdaptationBaseCtx *bCtx, XAboolean * tp)

   372  */

   373 XAresult XARDSItfAdapt_GetTrafficProgramme(XAAdaptationBaseCtx *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(XAAdaptationBaseCtx *bCtx,

   403  *                                            XAuint32 pty,

   404  *                                            XAboolean upwards)

   405  */

   406 XAresult XARDSItfAdapt_SeekByProgrammeType(XAAdaptationBaseCtx *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(XAAdaptationBaseCtx *bCtx, XAboolean upwards)

   455  */

   456 XAresult XARDSItfAdapt_SeekTrafficAnnouncement(XAAdaptationBaseCtx *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(XAAdaptationBaseCtx *bCtx, XAboolean upwards)

   496  */

   497 XAresult XARDSItfAdapt_SeekTrafficProgramme(XAAdaptationBaseCtx *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     XAAdaptationBaseCtx *bCtx = (XAAdaptationBaseCtx*)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, &event );

   561     }

   562     mCtx->state = XA_RADIO_IDLE;

   563 

   564     DEBUG_API("<-XARDSItfAdapt_AsyncSeek");

   565     pthread_exit(NULL);

   566 }

   567 

   568 /*

   569  * XAresult XARDSItfAdapt_SetAutomaticSwitching(XAAdaptationBaseCtx *bCtx, XAboolean automatic)

   570  */

   571 XAresult XARDSItfAdapt_SetAutomaticSwitching(XAAdaptationBaseCtx *bCtx, XAboolean automatic)

   572 {

   573     XAresult ret = XA_RESULT_SUCCESS;

   574     DEBUG_API("->XARDSItfAdapt_SetAutomaticSwitching");

   575 

   576     if(!bCtx)

   577     {

   578         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   579         DEBUG_API("<-XARDSItfAdapt_SetAutomaticSwitching");

   580         return XA_RESULT_PARAMETER_INVALID;

   581     }

   582 

   583     ret = XA_RESULT_FEATURE_UNSUPPORTED;

   584 

   585     DEBUG_API("<-XARDSItfAdapt_SetAutomaticSwitching");

   586     return ret;

   587 }

   588 

   589 /*

   590  * XAresult XARDSItfAdapt_GetAutomaticSwitching(XAAdaptationBaseCtx *bCtx, XAboolean * automatic)

   591  */

   592 XAresult XARDSItfAdapt_GetAutomaticSwitching(XAAdaptationBaseCtx *bCtx, XAboolean * automatic)

   593 {

   594     XAresult ret = XA_RESULT_SUCCESS;

   595     DEBUG_API("->XARDSItfAdapt_GetAutomaticSwitching");

   596 

   597     if(!bCtx || !automatic)

   598     {

   599         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   600         DEBUG_API("<-XARDSItfAdapt_GetAutomaticSwitching");

   601         return XA_RESULT_PARAMETER_INVALID;

   602     }

   603 

   604     /* Feature not supported */

   605     *automatic = XA_BOOLEAN_FALSE;

   606 

   607     DEBUG_API("<-XARDSItfAdapt_GetAutomaticSwitching");

   608     return ret;

   609 }

   610 

   611 /*

   612  * XAresult XARDSItfAdapt_SetAutomaticTrafficAnnouncement(XAAdaptationBaseCtx *bCtx, XAboolean automatic)

   613  */

   614 XAresult XARDSItfAdapt_SetAutomaticTrafficAnnouncement(XAAdaptationBaseCtx *bCtx, XAboolean automatic)

   615 {

   616     XAresult ret = XA_RESULT_SUCCESS;

   617     DEBUG_API("->XARDSItfAdapt_SetAutomaticTrafficAnnouncement");

   618     if(!bCtx)

   619     {

   620         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   621         DEBUG_API("<-XARDSItfAdapt_SetAutomaticTrafficAnnouncement");

   622         return XA_RESULT_PARAMETER_INVALID;

   623     }

   624 

   625     ret = XA_RESULT_FEATURE_UNSUPPORTED;

   626 

   627     DEBUG_API("<-XARDSItfAdapt_SetAutomaticTrafficAnnouncement");

   628     return ret;

   629 }

   630 

   631 /*

   632  * XAresult XARDSItfAdapt_GetAutomaticTrafficAnnouncement(XAAdaptationBaseCtx *bCtx, XAboolean * automatic)

   633  */

   634 XAresult XARDSItfAdapt_GetAutomaticTrafficAnnouncement(XAAdaptationBaseCtx *bCtx, XAboolean * automatic)

   635 {

   636     XAresult ret = XA_RESULT_SUCCESS;

   637     DEBUG_API("->XARDSItfAdapt_GetAutomaticTrafficAnnouncement");

   638 

   639     if(!bCtx || !automatic)

   640     {

   641         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   642         DEBUG_API("<-XARDSItfAdapt_GetAutomaticTrafficAnnouncement");

   643         return XA_RESULT_PARAMETER_INVALID;

   644     }

   645 

   646     *automatic = XA_BOOLEAN_FALSE;

   647 

   648     DEBUG_API("<-XARDSItfAdapt_GetAutomaticTrafficAnnouncement");

   649     return ret;

   650 }

   651 

   652 /*

   653  * XAresult XARDSItfAdapt_GetODAGroup(XAAdaptationBaseCtx *bCtx,

   654  *                                    XAint16 AID)

   655  */

   656 XAresult XARDSItfAdapt_GetODAGroup(XAAdaptationBaseCtx *bCtx, XAint16 AID)

   657 {

   658     XAresult ret = XA_RESULT_SUCCESS;

   659     int pt_ret=0;

   660     XARadioAdaptationCtx* mCtx=NULL;

   661     DEBUG_API("->XARDSItfAdapt_GetODAGroup");

   662 

   663     if(!bCtx)

   664     {

   665         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   666         DEBUG_API("<-XARDSItfAdapt_GetODAGroup");

   667         return XA_RESULT_PARAMETER_INVALID;

   668     }

   669 

   670     mCtx = (XARadioAdaptationCtx*) bCtx;

   671 

   672     if (mCtx->rdsState != XA_RADIO_RDS_IDLE)

   673     {

   674       //  pthread_cancel(mCtx->rdsEmulationThread);

   675         mCtx->rdsState = XA_RADIO_RDS_IDLE;

   676         DEBUG_INFO("Previous getodagroup async call cancelled")

   677     }

   678 

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

   680 

   681     if(pt_ret)

   682     {

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

   684         DEBUG_API("<-XARDSItfAdapt_GetODAGroup");

   685         return XA_RESULT_INTERNAL_ERROR;

   686     }

   687 

   688     DEBUG_API("<-XARDSItfAdapt_GetODAGroup");

   689     return ret;

   690 }

   691 

   692 /*

   693  * void * XARDSItfAdapt_AsyncGetODAGroup(void* args)

   694  */

   695 void * XARDSItfAdapt_AsyncGetODAGroup(void* args)

   696 {

   697     XARadioAdaptationCtx* mCtx = (XARadioAdaptationCtx*)args;

   698 

   699     DEBUG_API("->XARDSItfAdapt_AsyncGetODAGroup");

   700     mCtx->rdsState = XA_RADIO_RDS_GETTING_ODA_GROUP;

   701 

   702     DEBUG_INFO("Get oda group async wait")

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

   704 

   705     /* Send event */

   706     {

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

   708         XAAdaptationBase_SendAdaptEvents(args, &event );

   709     }

   710     mCtx->rdsState = XA_RADIO_RDS_IDLE;

   711     DEBUG_API("<-XARDSItfAdapt_AsyncGetODAGroup");

   712     pthread_exit(NULL);

   713 }

   714 

   715 /*

   716  * XAresult XARDSItfAdapt_SubscribeODAGroup(XAAdaptationBaseCtx *bCtx,

   717  *                                          XAint16 group,

   718  *                                          XAboolean useErrorCorrection)

   719  */

   720 XAresult XARDSItfAdapt_SubscribeODAGroup(XAAdaptationBaseCtx *bCtx,

   721                                         XAint16 group,

   722                                         XAboolean useErrorCorrection)

   723 {

   724     XAresult ret = XA_RESULT_SUCCESS;

   725     XAuint8 index=0;

   726     XAboolean groupFound = XA_BOOLEAN_FALSE;

   727     DEBUG_API("->XARDSItfAdapt_SubscribeODAGroup");

   728 

   729     if(!bCtx)

   730     {

   731         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   732         DEBUG_API("<-XARDSItfAdapt_SubscribeODAGroup");

   733         return XA_RESULT_PARAMETER_INVALID;

   734     }

   735 

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

   737     if (subscribedODAGroupCount < MAX_ODA_GROUP_SUBSCRIPTIONS)

   738     {

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

   740         {

   741             if (subscribedODAGroups[index] == group)

   742             {

   743                 groupFound = XA_BOOLEAN_TRUE;

   744             }

   745         }

   746         if (!groupFound)

   747         {

   748             subscribedODAGroups[subscribedODAGroupCount] = group;

   749             subscribedODAGroupCount++;

   750         }

   751     }

   752     else

   753     {

   754         DEBUG_ERR("XA_RESULT_INTERNAL_ERROR");

   755         DEBUG_API("<-XARDSItfAdapt_SubscribeODAGroup");

   756         return XA_RESULT_INTERNAL_ERROR;

   757     }

   758 

   759     DEBUG_API("<-XARDSItfAdapt_SubscribeODAGroup");

   760     return ret;

   761 }

   762 

   763 /*

   764  * XAresult XARDSItfAdapt_UnsubscribeODAGroup(XAAdaptationBaseCtx *bCtx, XAint16 group)

   765  */

   766 XAresult XARDSItfAdapt_UnsubscribeODAGroup(XAAdaptationBaseCtx *bCtx, XAint16 group)

   767 {

   768     XAresult ret = XA_RESULT_SUCCESS;

   769     XAuint8 index=0;

   770     DEBUG_API("->XARDSItfAdapt_UnsubscribeODAGroup");

   771 

   772     if(!bCtx)

   773     {

   774         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   775         DEBUG_API("<-XARDSItfAdapt_UnsubscribeODAGroup");

   776         return XA_RESULT_PARAMETER_INVALID;

   777     }

   778 

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

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

   781     {

   782         if (subscribedODAGroups[index] == group)

   783         {

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

   785             subscribedODAGroupCount--;

   786         }

   787     }

   788 

   789     DEBUG_API("<-XARDSItfAdapt_UnsubscribeODAGroup");

   790     return ret;

   791 }

   792 

   793 /*

   794  * XAresult XARDSItfAdapt_ListODAGroupSubscriptions(XAAdaptationBaseCtx *bCtx,

   795  *                                                  XAint16* pGroups,

   796  *                                                  XAuint32* pLength)

   797  */

   798 XAresult XARDSItfAdapt_ListODAGroupSubscriptions(XAAdaptationBaseCtx *bCtx,

   799                                                 XAint16* pGroups,

   800                                                 XAuint32* pLength)

   801 {

   802     XAresult ret = XA_RESULT_SUCCESS;

   803     XAuint8 index=0;

   804     DEBUG_API("->XARDSItfAdapt_ListODAGroupSubscriptions");

   805 

   806     if(!bCtx || !pLength)

   807     {

   808         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   809         DEBUG_API("<-XARDSItfAdapt_ListODAGroupSubscriptions");

   810         return XA_RESULT_PARAMETER_INVALID;

   811     }

   812 

   813     if (!pGroups)

   814     {

   815         *pLength = subscribedODAGroupCount;

   816     }

   817     else

   818     {

   819         if (*pLength < subscribedODAGroupCount)

   820         {

   821             ret = XA_RESULT_BUFFER_INSUFFICIENT;

   822         }

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

   824         {

   825             pGroups[index] = subscribedODAGroups[index];

   826         }

   827     }

   828 

   829     DEBUG_API("<-XARDSItfAdapt_ListODAGroupSubscriptions");

   830     return ret;

   831 }

   832 

   833 /*

   834  * const RDSData* GetCurrentRdsData( XAAdaptationBaseCtx *bCtx )

   835  */

   836 const RDSData* GetCurrentRdsData( XAAdaptationBaseCtx *bCtx )

   837 {

   838     XAuint8 index=0;

   839     XARadioAdaptationCtx* mCtx = (XARadioAdaptationCtx*) bCtx;

   840 

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

   842     {

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

   844         {

   845             DEBUG_API("<-GetCurrentRdsData");

   846             return &(rdsData[index]);

   847         }

   848     }

   849     DEBUG_API("<-GetCurrentRdsData");

   850     return NULL;

   851 }

   852 

   853 

   854 /*

   855  * void XARDSItfAdapt_Free(XAAdaptationBaseCtx *bCtx)

   856  */

   857 void XARDSItfAdapt_Free(XAAdaptationBaseCtx *bCtx)

   858 {

   859     XARadioAdaptationCtx* mCtx = (XARadioAdaptationCtx*) bCtx;

   860     DEBUG_API("->XARDSItfAdapt_Free");

   861 

   862     if (mCtx->state != XA_RADIO_IDLE)

   863     {

   864        // pthread_cancel(mCtx->emulationThread);

   865         mCtx->state = XA_RADIO_IDLE;

   866     }

   867 

   868     if (mCtx->rdsState != XA_RADIO_RDS_IDLE)

   869     {

   870       //  pthread_cancel(mCtx->rdsEmulationThread);

   871         mCtx->rdsState = XA_RADIO_RDS_IDLE;

   872     }

   873 

   874     DEBUG_API("<-XARDSItfAdapt_Free");

   875 }