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 <stdio.h>

    19 #include <stdlib.h>

    20 #include <assert.h>

    21 

    22 #include "xaobjectitf.h"

    23 

    24 /**

    25  * Base interface XAObjectItf implementation

    26  */

    27 XAresult XAObjectItfImpl_Realize(XAObjectItf self, XAboolean async)

    28 {

    29     XAObjectItfImpl* pObjImp = (XAObjectItfImpl*)(*self);

    30     XAresult retval = XA_RESULT_SUCCESS;

    31 

    32     DEBUG_API("->XAObjectItfImpl_Realize");

    33     if( !pObjImp || pObjImp != pObjImp->self)

    34     {

    35         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

    36         DEBUG_API("<-XAObjectItfImpl_Realize");

    37         /* invalid parameter */

    38         return XA_RESULT_PARAMETER_INVALID;

    39     }

    40 

    41     if( async )

    42     {

    43         /* invoke asynchronously */

    44         if( !pObjImp->callBack )

    45         {

    46             retval = XA_RESULT_PARAMETER_INVALID;

    47         }

    48         else

    49         {

    50             /* check if another async operation is processed */

    51             if(pObjImp->asyncOngoing)

    52             {

    53                 /* abort ongoing operation */

    54                 XAImpl_CancelThread(pObjImp->asyncThr);

    55             }

    56             pObjImp->asyncOngoing = XA_BOOLEAN_TRUE;

    57             if(XAImpl_StartThread(pObjImp->asyncThr, NULL,

    58                     XAObjectItfImpl_AsyncRealize,(void*)(self)))

    59             {

    60                 pObjImp->asyncOngoing = XA_BOOLEAN_FALSE;

    61                 retval = XA_RESULT_RESOURCE_ERROR;

    62             }

    63             else

    64             {

    65                 retval = XA_RESULT_SUCCESS;

    66             }

    67         }

    68     }

    69     else

    70     {

    71         /* Check if the object is in unrealized state */

    72         if(pObjImp->state != XA_OBJECT_STATE_UNREALIZED)

    73         {

    74             DEBUG_ERR("XA_RESULT_PRECONDITIONS_VIOLATED");

    75             DEBUG_API("<-XAObjectItfImpl_Realize");

    76             return XA_RESULT_PRECONDITIONS_VIOLATED;

    77         }

    78         /* invoke synchronously */

    79         if( pObjImp->DoRealizeImpl )

    80         {

    81             retval = pObjImp->DoRealizeImpl(self);

    82         }

    83     }

    84     DEBUG_API("<-XAObjectItfImpl_Realize");

    85     return retval;

    86 }

    87 

    88 XAresult XAObjectItfImpl_Resume(XAObjectItf self, XAboolean async)

    89 {

    90     XAresult retval = XA_RESULT_SUCCESS;

    91     XAObjectItfImpl* pObjImp = (XAObjectItfImpl*)(*self);

    92     DEBUG_API("->XAObjectItfImpl_Resume");

    93 

    94     if( !pObjImp || pObjImp != pObjImp->self )

    95     {

    96         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

    97         DEBUG_API("<-XAObjectItfImpl_Resume");

    98         /* invalid parameter */

    99         return XA_RESULT_PARAMETER_INVALID;

   100     }

   101     if( async )

   102     {

   103         /* invoke asynchronously */

   104         if( !pObjImp->callBack )

   105         {

   106             retval = XA_RESULT_PARAMETER_INVALID;

   107         }

   108         else

   109         {

   110             /* check if another async operation is processed */

   111             if(pObjImp->asyncOngoing)

   112             {

   113                 /* abort ongoing operation */

   114                 XAImpl_CancelThread(pObjImp->asyncThr);

   115             }

   116             pObjImp->asyncOngoing = XA_BOOLEAN_TRUE;

   117             if(XAImpl_StartThread(pObjImp->asyncThr, NULL,

   118                     XAObjectItfImpl_AsyncResume,(void*)(self)))

   119             {

   120                 pObjImp->asyncOngoing = XA_BOOLEAN_FALSE;

   121                 retval = XA_RESULT_RESOURCE_ERROR;

   122             }

   123             else

   124             {

   125                 retval = XA_RESULT_SUCCESS;

   126             }

   127         }

   128     }

   129     else

   130     {

   131         /* invoke synchronously */

   132         if( pObjImp->DoResumeImpl )

   133         {

   134             retval = pObjImp->DoResumeImpl(self);

   135         }

   136     }

   137     DEBUG_API("<-XAObjectItfImpl_Resume");

   138     return retval;

   139 }

   140 

   141 XAresult XAObjectItfImpl_GetState(XAObjectItf self, XAuint32 *pState)

   142 {

   143     XAObjectItfImpl* pObjImp = (XAObjectItfImpl*)(*self);

   144     DEBUG_API("->XAObjectItfImpl_GetState");

   145     if( !pObjImp || pObjImp != pObjImp->self || !pState )

   146     {

   147         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   148         DEBUG_API("<-XAObjectItfImpl_GetState");

   149         /* invalid parameter */

   150         return XA_RESULT_PARAMETER_INVALID;

   151     }

   152     *pState = pObjImp->state;

   153 

   154     DEBUG_API("<-XAObjectItfImpl_GetState");

   155     return XA_RESULT_SUCCESS;

   156 }

   157 

   158 XAresult XAObjectItfImpl_GetInterface(XAObjectItf self, const XAInterfaceID iid,

   159                                        void *pInterface)

   160 {

   161     XAObjectItfImpl* pObjImp = (XAObjectItfImpl*)(*self);

   162     XAObjItfMapEntry *mapEntry = NULL;

   163     DEBUG_API("->XAObjectItfImpl_GetInterface");

   164 

   165     if( !pObjImp || pObjImp != pObjImp->self || !pInterface || !iid )

   166     {

   167         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   168         DEBUG_API("<-XAObjectItfImpl_GetInterface");

   169         /* invalid parameter */

   170         return XA_RESULT_PARAMETER_INVALID;

   171     }

   172 

   173     if(pObjImp->state != XA_OBJECT_STATE_REALIZED)

   174     {

   175         DEBUG_ERR("XA_RESULT_PRECONDITIONS_VIOLATED");

   176         DEBUG_API("<-XAObjectItfImpl_GetInterface");

   177         /*state is not correct */

   178         return XA_RESULT_PRECONDITIONS_VIOLATED;

   179     }

   180 

   181     mapEntry = XAObjectItfImpl_GetItfEntry(self, iid);

   182     if( mapEntry && mapEntry->pItf )

   183     {

   184         *(void**)pInterface = &(mapEntry->pItf);

   185         DEBUG_API("<-XAObjectItfImpl_GetInterface");

   186         return XA_RESULT_SUCCESS;

   187     }

   188     else

   189     {

   190         DEBUG_ERR("XA_RESULT_FEATURE_UNSUPPORTED");

   191         DEBUG_API("<-XAObjectItfImpl_GetInterface");

   192         return XA_RESULT_FEATURE_UNSUPPORTED;

   193     }

   194 }

   195 

   196 

   197 XAresult XAObjectItfImpl_RegisterCallback(XAObjectItf self,

   198                                        xaObjectCallback callback,

   199                                        void *pContext)

   200 {

   201     XAObjectItfImpl* pObjImp = (XAObjectItfImpl*)(*self);

   202     DEBUG_API("->XAObjectItfImpl_RegisterCallback");

   203 

   204     if( !pObjImp || pObjImp != pObjImp->self )

   205     {

   206         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   207         DEBUG_API("<-XAObjectItfImpl_RegisterCallback");

   208         /* invalid parameter */

   209         return XA_RESULT_PARAMETER_INVALID;

   210     }

   211     pObjImp->callBack = callback;

   212     pObjImp->context = pContext;

   213     pObjImp->cbPtrToSelf = self;

   214 

   215     DEBUG_API("<-XAObjectItfImpl_RegisterCallback");

   216     return XA_RESULT_SUCCESS;

   217 }

   218 

   219 void XAObjectItfImpl_AbortAsyncOperation(XAObjectItf self)

   220 {

   221     XAObjectItfImpl* pObjImp = (XAObjectItfImpl*)(*self);

   222     DEBUG_API("->XAObjectItfImpl_AbortAsyncOperation");

   223 

   224     if( pObjImp &&

   225        (pObjImp == pObjImp->self) &&

   226         pObjImp->callBack &&

   227         pObjImp->asyncOngoing )

   228     {

   229         /* abort ongoing operation */

   230         XAImpl_CancelThread(pObjImp->asyncThr);

   231     }

   232 

   233     DEBUG_API("<-XAObjectItfImpl_AbortAsyncOperation");

   234 }

   235 

   236 void XAObjectItfImpl_Destroy(XAObjectItf self)

   237 {

   238     XAObjectItfImpl* pObjImp = (XAObjectItfImpl*)(*self);

   239     DEBUG_API("->XAObjectItfImpl_Destroy");

   240 

   241     if( pObjImp && pObjImp == pObjImp->self )

   242     {

   243         if( pObjImp->asyncOngoing )

   244         {

   245             /* abort ongoing operation */

   246             XAImpl_CancelThread(pObjImp->asyncThr);

   247         }

   248         /* free object specific resources */

   249         if( pObjImp->FreeResourcesImpl )

   250         {

   251             pObjImp->FreeResourcesImpl(self);

   252         }

   253         free(pObjImp->interfaceMap);

   254         XAImpl_DeleteThreadHandle(pObjImp->asyncThr);

   255         free(pObjImp);

   256     }

   257 

   258     DEBUG_API("<-XAObjectItfImpl_Destroy");

   259 }

   260 

   261 XAresult XAObjectItfImpl_SetPriority(XAObjectItf self, XAint32 priority,

   262                                   XAboolean preemptable)

   263 {

   264     XAObjectItfImpl* pObjImp = (XAObjectItfImpl*)(*self);

   265     DEBUG_API("->XAObjectItfImpl_SetPriority");

   266 

   267     if( !pObjImp || pObjImp != pObjImp->self )

   268     {

   269         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   270         DEBUG_API("<-XAObjectItfImpl_SetPriority");

   271         /* invalid parameter */

   272         return XA_RESULT_PARAMETER_INVALID;

   273     }

   274     pObjImp->priority = priority;

   275     pObjImp->preemptable = preemptable;

   276 

   277     DEBUG_API("<-XAObjectItfImpl_SetPriority");

   278     return XA_RESULT_SUCCESS;

   279 }

   280 

   281 XAresult XAObjectItfImpl_GetPriority(XAObjectItf self, XAint32 *pPriority,

   282                                   XAboolean *pPreemptable)

   283 {

   284     XAObjectItfImpl* pObjImp = (XAObjectItfImpl*)(*self);

   285     DEBUG_API("->XAObjectItfImpl_GetPriority");

   286 

   287     if( !pObjImp || pObjImp != pObjImp->self )

   288     {

   289         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   290         DEBUG_API("<-XAObjectItfImpl_GetPriority");

   291         /* invalid parameter */

   292         return XA_RESULT_PARAMETER_INVALID;

   293     }

   294     *pPriority = pObjImp->priority;

   295     *pPreemptable = pObjImp->preemptable;

   296 

   297     DEBUG_API("<-XAObjectItfImpl_GetPriority");

   298     return XA_RESULT_SUCCESS;

   299 }

   300 

   301 XAresult XAObjectItfImpl_SetLossOfControlInterfaces(XAObjectItf self,

   302                                               XAint16 numInterfaces,

   303                                               XAInterfaceID *pInterfaceIDs,

   304                                               XAboolean enabled)

   305 {

   306     XAObjectItfImpl* pObjImp = (XAObjectItfImpl*)(*self);

   307     XAint32 itfIndex = 0;

   308     XAObjItfMapEntry *mapEntry = NULL;

   309     DEBUG_API("->XAObjectItfImpl_SetLossOfControlInterfaces");

   310 

   311     if( !pObjImp || pObjImp != pObjImp->self || !pInterfaceIDs )

   312     {

   313         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   314         DEBUG_API("<-XAObjectItfImpl_SetLossOfControlInterfaces");

   315         /* invalid parameter */

   316         return XA_RESULT_PARAMETER_INVALID;

   317     }

   318     if( pInterfaceIDs )

   319     {

   320         for(itfIndex = 0; itfIndex < numInterfaces; itfIndex++)

   321         {

   322             mapEntry = XAObjectItfImpl_GetItfEntry(self, pInterfaceIDs[itfIndex]);

   323             if( mapEntry )

   324             {

   325                 mapEntry->locEnabled = enabled;

   326             }

   327         }

   328     }

   329 

   330     DEBUG_API("<-XAObjectItfImpl_SetLossOfControlInterfaces");

   331     return XA_RESULT_SUCCESS;

   332 }

   333 

   334 /**

   335  * XAObjectItfImpl -specific methods

   336  **/

   337 

   338 /*

   339  * Allocate and init new object itf instance

   340  */

   341 XAresult XAObjectItfImpl_Init(XAObjectItfImpl* self,

   342                               XAuint32 itfCount,

   343                               const XAInterfaceID** itfIIDs,

   344                               xaDoRealizeImpl doRealizeImpl,

   345                               xaDoResumeImpl doResumeImpl,

   346                               xaFreeResourcesImpl freeResourcesImpl)

   347 {

   348     XAuint32 i = 0;

   349     DEBUG_API("->XAObjectItfImpl_Init");

   350 

   351     assert( self && itfIIDs && doRealizeImpl && doResumeImpl && freeResourcesImpl );

   352 

   353     self->interfaceMap =

   354        (XAObjItfMapEntry*)calloc(itfCount, sizeof(XAObjItfMapEntry));

   355     if( !self->interfaceMap )

   356     {

   357         free(self);

   358         DEBUG_ERR("XA_RESULT_MEMORY_FAILURE");

   359         DEBUG_API("<-XAObjectItfImpl_Init");

   360         return XA_RESULT_MEMORY_FAILURE;

   361     }

   362     if( XAImpl_CreateThreadHandle(&(self->asyncThr)) != XA_RESULT_SUCCESS )

   363     {

   364         free(self);

   365         DEBUG_ERR("XA_RESULT_MEMORY_FAILURE");

   366         DEBUG_API("<-XAObjectItfImpl_Init");

   367         return XA_RESULT_MEMORY_FAILURE;

   368     }

   369     for(i=0;i<itfCount;i++)

   370     {

   371         self->interfaceMap[i].mapIdx = i;

   372         self->interfaceMap[i].iid = *(itfIIDs[i]);

   373         self->interfaceMap[i].pItf = NULL;

   374         self->interfaceMap[i].locEnabled = XA_BOOLEAN_FALSE;

   375         self->interfaceMap[i].required = XA_BOOLEAN_FALSE;

   376         self->interfaceMap[i].isDynamic = XA_BOOLEAN_FALSE;

   377     }

   378     self->interfaceMap[0].pItf = self;

   379     self->interfaceMap[0].required = XA_BOOLEAN_TRUE;

   380 

   381     self->interfaceCount = itfCount;

   382     self->priority = XA_PRIORITY_NORMAL;

   383     self->preemptable = XA_BOOLEAN_FALSE;

   384     self->state = XA_OBJECT_STATE_UNREALIZED;

   385     self->callBack = NULL;

   386     self->context = NULL;

   387     self->asyncOngoing = XA_BOOLEAN_FALSE;

   388     self->cbPtrToSelf = NULL;

   389 

   390     self->DoRealizeImpl = doRealizeImpl;

   391     self->DoResumeImpl = doResumeImpl;

   392     self->FreeResourcesImpl = freeResourcesImpl;

   393 

   394     /* init itf default implementation */

   395     self->itf.Realize = XAObjectItfImpl_Realize;

   396     self->itf.Resume = XAObjectItfImpl_Resume;

   397     self->itf.GetState = XAObjectItfImpl_GetState;

   398     self->itf.GetInterface = XAObjectItfImpl_GetInterface;

   399     self->itf.RegisterCallback = XAObjectItfImpl_RegisterCallback;

   400     self->itf.AbortAsyncOperation = XAObjectItfImpl_AbortAsyncOperation;

   401     self->itf.Destroy = XAObjectItfImpl_Destroy;

   402     self->itf.SetPriority = XAObjectItfImpl_SetPriority;

   403     self->itf.GetPriority = XAObjectItfImpl_GetPriority;

   404     self->itf.SetLossOfControlInterfaces  = XAObjectItfImpl_SetLossOfControlInterfaces;

   405     self->self = self;

   406 

   407     DEBUG_API("<-XAObjectItfImpl_Init");

   408     return XA_RESULT_SUCCESS;

   409 }

   410 

   411 /*

   412  * Asynchronous invocation of Realize

   413  */

   414 void* XAObjectItfImpl_AsyncRealize(void* args)

   415 {

   416     XAresult retval = XA_RESULT_SUCCESS;

   417     XAObjectItfImpl* pObjImp = (XAObjectItfImpl*)(*(XAObjectItf)(args));

   418     DEBUG_API("->XAObjectItfImpl_AsyncRealize");

   419 

   420     if( pObjImp && pObjImp == pObjImp->self)

   421     {

   422         /* Check if the object is in unrealized state */

   423         if(pObjImp->state != XA_OBJECT_STATE_UNREALIZED)

   424         {

   425             retval = XA_RESULT_PRECONDITIONS_VIOLATED;

   426         }

   427         else if( pObjImp->DoRealizeImpl )

   428         {

   429             retval = pObjImp->DoRealizeImpl((XAObjectItf)(args));

   430         }

   431         if( pObjImp->callBack )

   432         {

   433             pObjImp->callBack(pObjImp->cbPtrToSelf, pObjImp->context,

   434                               XA_OBJECT_EVENT_ASYNC_TERMINATION,

   435                               retval, pObjImp->state, NULL);

   436         }

   437         pObjImp->asyncOngoing = XA_BOOLEAN_FALSE;

   438         XAImpl_ExitThread(pObjImp->asyncThr);

   439     }

   440     else

   441     {

   442         DEBUG_API("XAObjectItfImpl_AsyncRealize: INVALID args");

   443     }

   444     

   445 

   446     DEBUG_API("<-XAObjectItfImpl_AsyncRealize");

   447     return NULL;

   448 }

   449 

   450 

   451 /*

   452  * Asynchronous invocation of Resume

   453  */

   454 void* XAObjectItfImpl_AsyncResume(void* args)

   455 {

   456     XAresult retval = XA_RESULT_SUCCESS;

   457     XAObjectItfImpl* pObjImp = (XAObjectItfImpl*)(*(XAObjectItf)(args));

   458     DEBUG_API("->XAObjectItfImpl_AsyncResume");

   459 

   460     if( pObjImp && pObjImp == pObjImp->self )

   461     {

   462         if( pObjImp->DoResumeImpl )

   463         {

   464             retval = pObjImp->DoResumeImpl((XAObjectItf)(args));

   465         }

   466         if( pObjImp->callBack )

   467         {

   468             pObjImp->callBack(pObjImp->cbPtrToSelf, pObjImp->context,

   469                               XA_OBJECT_EVENT_ASYNC_TERMINATION,

   470                               retval, pObjImp->state, NULL);

   471         }

   472         pObjImp->asyncOngoing = XA_BOOLEAN_FALSE;

   473         XAImpl_ExitThread(pObjImp->asyncThr);

   474     }

   475     else

   476     {

   477         DEBUG_API("XAObjectItfImpl_AsyncResume: INVALID args");

   478     }

   479     

   480 

   481     DEBUG_API("<-XAObjectItfImpl_AsyncResume");

   482     return NULL;

   483 }

   484 

   485 void XAObjectItfImpl_AsyncCleanup(void* args)

   486 {

   487     XAObjectItfImpl* pObjImp = (XAObjectItfImpl*)(*(XAObjectItf)(args));

   488     DEBUG_API("->XAObjectItfImpl_AsyncCleanup");

   489 

   490     if( pObjImp &&

   491        (pObjImp == pObjImp->self) &&

   492         pObjImp->FreeResourcesImpl )

   493     {

   494         pObjImp->FreeResourcesImpl((XAObjectItf)(args));

   495     }

   496     else

   497     {

   498         DEBUG_API("XAObjectItfImpl_AsyncCleanup: INVALID args");

   499     }

   500 

   501     DEBUG_API("<-XAObjectItfImpl_AsyncCleanup");

   502 }

   503 

   504 XAObjItfMapEntry* XAObjectItfImpl_GetItfEntry(const XAObjectItf self,

   505                                               const XAInterfaceID iid)

   506 {

   507     XAuint32 mapIndex = 0;

   508     XAObjectItfImpl* pObjImp = (XAObjectItfImpl*)(*self);

   509     DEBUG_API("->XAObjectItfImpl_GetItfEntry");

   510 

   511     if( pObjImp &&

   512        (pObjImp == pObjImp->self) &&

   513         pObjImp->interfaceMap &&

   514         iid )

   515     {

   516         /* Check interface */

   517         for(mapIndex = 0; mapIndex < pObjImp->interfaceCount; mapIndex++)

   518         {

   519             if(XACommon_EqualIIds(pObjImp->interfaceMap[mapIndex].iid, iid))

   520             {

   521                 DEBUG_API("<-XAObjectItfImpl_GetItfEntry");

   522                 return &(pObjImp->interfaceMap[mapIndex]);

   523             }

   524         }

   525     }

   526 

   527     DEBUG_API("<-XAObjectItfImpl_GetItfEntry");

   528     return NULL;

   529 }

   530