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: Nokia Linear Volume Interface Implementation

    15  *

    16  */

    17 

    18 #include <stdio.h>

    19 #include <stdlib.h>

    20 #include <assert.h>

    21 

    22 #include "xanlinearvolumeitf.h"

    23 #include "xanokialinearvolumeitfadaptationmmf.h"

    24 

    25 /**

    26  * XANokiaLinearVolumeItfImpl* GetImpl(XANokiaLinearVolumeItf self)

    27  * Description: Validated interface pointer and cast it to implementations pointer.

    28  **/

    29 static XANokiaLinearVolumeItfImpl* GetImpl(XANokiaLinearVolumeItf self)

    30     {

    31     if (self)

    32         {

    33         XANokiaLinearVolumeItfImpl* impl =

    34                 (XANokiaLinearVolumeItfImpl*) (*self);

    35         if (impl && impl == impl->self)

    36             {

    37             return impl;

    38             }

    39         }

    40     return NULL;

    41     }

    42 

    43 /**

    44  * XAresult XANokiaLinearVolumeItfImpl_RegisterVolumeCallback(XANokiaLinearVolumeItf self,

    45  *                                               xaNokiaLinearVolumeCallback callback,

    46  *                                               void * pContext)

    47  * Description: Sets or clears the xaVolumeCallback.

    48  **/

    49 XAresult XANokiaLinearVolumeItfImpl_RegisterVolumeCallback(

    50         XANokiaLinearVolumeItf self, xaNokiaLinearVolumeCallback callback,

    51         void * pContext)

    52     {

    53     XAresult ret = XA_RESULT_SUCCESS;

    54     XANokiaLinearVolumeItfImpl* impl = GetImpl(self);

    55     DEBUG_API("->XANokiaLinearVolumeItfImpl_RegisterVolumeCallback");

    56 

    57     if (!impl)

    58         {

    59         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

    60         /* invalid parameter */

    61         DEBUG_API("<-XANokiaLinearVolumeItfImpl_RegisterVolumeCallback");

    62         return XA_RESULT_PARAMETER_INVALID;

    63         }

    64 

    65     impl->callback = callback;

    66     impl->context = pContext;

    67     impl->cbPtrToSelf = self;

    68 

    69     DEBUG_API("<-XANokiaLinearVolumeItfImpl_RegisterVolumeCallback");

    70     return ret;

    71     }

    72 

    73 /**

    74  * Base interface XANokiaLinearVolumeItf implementation

    75  */

    76 

    77 /**

    78  * XAresult XANokiaLinearVolumeItfImpl_SetVolumeLevel(XANokiaLinearVolumeItf self, XAuint32 percentage)

    79  * Description: Sets the object's volume level.

    80  **/

    81 XAresult XANokiaLinearVolumeItfImpl_SetVolumeLevel(

    82         XANokiaLinearVolumeItf self, XAuint32 *percentage)

    83     {

    84     XANokiaLinearVolumeItfImpl *impl = GetImpl(self);

    85     XAresult ret = XA_RESULT_SUCCESS;

    86     XAuint32 vol = *percentage;

    87 

    88     DEBUG_API("->XANokiaLinearVolumeItfImpl_SetVolumeLevel");

    89 

    90     if ((!impl) || (vol > MAX_PERCENTAGE_VOLUME))

    91         {

    92         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

    93         DEBUG_API("<-XANokiaLinearVolumeItfImpl_SetVolumeLevel");

    94         /* invalid parameter */

    95         return XA_RESULT_PARAMETER_INVALID;

    96         }

    97 

    98     ret = XAAdaptationBase_ThreadEntry(impl->adapCtx);

    99     if (ret == XA_RESULT_SUCCESS)

   100         {

   101         if (impl->adapCtx && impl->adapCtx->fwtype == FWMgrFWMMF)

   102             {

   103             ret = XANokiaLinearVolumeItfAdapt_SetVolumeLevel(

   104                     (XAAdaptationMMFCtx*) impl->adapCtx, vol);

   105             if (ret == XA_RESULT_SUCCESS)

   106                 {

   107                 impl->volumeLevel = vol;

   108                 }

   109             }

   110         XAAdaptationBase_ThreadExit(impl->adapCtx);

   111         }

   112     DEBUG_API("<-XANokiaLinearVolumeItfImpl_SetVolumeLevel");

   113     return ret;

   114     }

   115 

   116 /**

   117  * XAresult XANokiaLinearVolumeItfImpl_GetVolumeLevel(XANokiaLinearVolumeItf self, XAmillibel *pLevel)

   118  * Description: Gets the object’s volume level.

   119  **/

   120 XAresult XANokiaLinearVolumeItfImpl_GetVolumeLevel(

   121         XANokiaLinearVolumeItf self, XAuint32 *percentage)

   122     {

   123     XAresult ret = XA_RESULT_SUCCESS;

   124     XANokiaLinearVolumeItfImpl *impl = GetImpl(self);

   125     DEBUG_API("->XANokiaLinearVolumeItfImpl_GetVolumeLevel");

   126 

   127     if (!impl || !percentage)

   128         {

   129         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   130         DEBUG_API("<-XANokiaLinearVolumeItfImpl_GetVolumeLevel");

   131         /* invalid parameter */

   132         return XA_RESULT_PARAMETER_INVALID;

   133         }

   134 

   135     ret = XAAdaptationBase_ThreadEntry(impl->adapCtx);

   136     if (ret == XA_RESULT_SUCCESS)

   137         {

   138         if (impl->adapCtx && impl->adapCtx->fwtype == FWMgrFWMMF)

   139             {

   140             ret = XANokiaLinearVolumeItfAdapt_GetVolumeLevel(

   141                     (XAAdaptationMMFCtx*) impl->adapCtx, percentage);

   142             if (ret == XA_RESULT_SUCCESS)

   143                 {

   144                 impl->volumeLevel = *percentage;

   145                 }

   146             }

   147         XAAdaptationBase_ThreadExit(impl->adapCtx);

   148         }

   149 

   150     DEBUG_API("<-XANokiaLinearVolumeItfImpl_GetVolumeLevel");

   151     return ret;

   152     }

   153 

   154 /**

   155  * XAresult XANokiaLinearVolumeItfImpl_GetMaxVolumeLevel(XANokiaLinearVolumeItf  self, XAmillibel *pMaxLevel)

   156  * Description: Gets the maximum supported level.

   157  **/

   158 XAresult XANokiaLinearVolumeItfImpl_GetStepCount(XANokiaLinearVolumeItf self,

   159         XAuint32 *pStepCount)

   160     {

   161     XAresult ret = XA_RESULT_SUCCESS;

   162     XANokiaLinearVolumeItfImpl *impl = GetImpl(self);

   163     DEBUG_API("->XANokiaLinearVolumeItfImpl_GetVolumeLevel");

   164 

   165     if (!impl || !pStepCount)

   166         {

   167         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   168         DEBUG_API("<-XANokiaLinearVolumeItfImpl_GetMaxVolumeLevel");

   169         /* invalid parameter */

   170         return XA_RESULT_PARAMETER_INVALID;

   171         }

   172 

   173     ret = XAAdaptationBase_ThreadEntry(impl->adapCtx);

   174     if (ret == XA_RESULT_SUCCESS)

   175         {

   176         if (impl->adapCtx && impl->adapCtx->fwtype == FWMgrFWMMF)

   177             {

   178             ret = XANokiaLinearVolumeItfAdapt_GetStepCount(

   179                     (XAAdaptationMMFCtx*) impl->adapCtx, pStepCount);

   180             }

   181     

   182         XAAdaptationBase_ThreadExit(impl->adapCtx);

   183         }

   184     DEBUG_API("<-XANokiaLinearVolumeItfImpl_GetMaxVolumeLevel");

   185     return ret;

   186     }

   187 

   188 XAresult XANokiaLinearVolumeItfImpl_SetCallbackEventsMask(

   189         XANokiaLinearVolumeItf self, XAuint32 eventFlags)

   190     {

   191     XAresult ret = XA_RESULT_SUCCESS;

   192     XANokiaLinearVolumeItfImpl* impl = GetImpl(self);

   193     DEBUG_API("->XANokiaLinearVolumeItfImpl_SetCallbackEventsMask");

   194 

   195     if (!impl)

   196         {

   197         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   198         /* invalid parameter */

   199         DEBUG_API("<-XANokiaLinearVolumeItfImpl_SetCallbackEventsMask");

   200         return XA_RESULT_PARAMETER_INVALID;

   201         }

   202 

   203     impl->eventFlags = eventFlags;

   204 

   205     DEBUG_API("<-XANokiaLinearVolumeItfImpl_SetCallbackEventsMask");

   206     return ret;

   207     }

   208 

   209 XAresult XANokiaLinearVolumeItfImpl_GetCallbackEventsMask(

   210         XANokiaLinearVolumeItf self, XAuint32 * pEventFlags)

   211     {

   212     XAresult ret = XA_RESULT_SUCCESS;

   213     XANokiaLinearVolumeItfImpl* impl = GetImpl(self);

   214     DEBUG_API("->XANokiaLinearVolumeItfImpl_GetCallbackEventsMask");

   215 

   216     if (!impl || !pEventFlags)

   217         {

   218         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   219         /* invalid parameter */

   220         DEBUG_API("<-XANokiaLinearVolumeItfImpl_GetCallbackEventsMask");

   221         return XA_RESULT_PARAMETER_INVALID;

   222         }

   223 

   224     *pEventFlags = impl->eventFlags;

   225 

   226     DEBUG_API("<-XANokiaLinearVolumeItfImpl_GetCallbackEventsMask");

   227     return ret;

   228     }

   229 

   230 /**

   231  * XANokiaLinearVolumeItfImpl -specific methods

   232  **/

   233 

   234 /**

   235  * XANokiaLinearVolumeItfImpl* XANokiaLinearVolumeItfImpl_Create()

   236  * Description: Allocate and initialize VolumeItfImpl

   237  **/

   238 XANokiaLinearVolumeItfImpl* XANokiaLinearVolumeItfImpl_Create(

   239         XAAdaptationBaseCtx *adapCtx)

   240     {

   241     XANokiaLinearVolumeItfImpl *self = (XANokiaLinearVolumeItfImpl*) calloc(

   242             1, sizeof(XANokiaLinearVolumeItfImpl));

   243     DEBUG_API("->XANokiaLinearVolumeItfImpl_Create");

   244 

   245     if (self)

   246         {

   247         /* init itf default implementation */

   248         self->itf.GetStepCount = XANokiaLinearVolumeItfImpl_GetStepCount;

   249         self->itf.GetVolumeLevel = XANokiaLinearVolumeItfImpl_GetVolumeLevel;

   250         self->itf.SetVolumeLevel = XANokiaLinearVolumeItfImpl_SetVolumeLevel;

   251         self->itf.RegisterVolumeCallback

   252                 = XANokiaLinearVolumeItfImpl_RegisterVolumeCallback;

   253         self->itf.SetCallbackEventsMask

   254                 = XANokiaLinearVolumeItfImpl_SetCallbackEventsMask;

   255         self->itf.GetCallbackEventsMask

   256                 = XANokiaLinearVolumeItfImpl_GetCallbackEventsMask;

   257         /* init variables */

   258         self->volumeLevel = 0;

   259 

   260         self->adapCtx = adapCtx;

   261 

   262         XAAdaptationBase_AddEventHandler(adapCtx,

   263                 &XANokiaLinearVolumeItfImpl_AdaptCb,

   264                 XA_NOKIALINEARVOLITFEVENTS, self);

   265 

   266         self->self = self;

   267         }

   268 

   269     DEBUG_API("<-XANokiaLinearVolumeItfImpl_Create");

   270     return self;

   271     }

   272 

   273 /**

   274  * void XANokiaLinearVolumeItfImpl_Free(XANokiaLinearVolumeItfImpl* self)

   275  * Description: Free all resources reserved at XANokiaLinearVolumeItfImpl_Create

   276  **/

   277 void XANokiaLinearVolumeItfImpl_Free(XANokiaLinearVolumeItfImpl* self)

   278     {

   279     DEBUG_API("->XANokiaLinearVolumeItfImpl_Free");

   280     assert(self==self->self);

   281     free(self);

   282     DEBUG_API("<-XANokiaLinearVolumeItfImpl_Free");

   283     }

   284 

   285 /* void XANokiaLinearVolumeItfimpl_AdaptCb( void *pHandlerCtx, XAAdaptEvent *event )

   286  * Description: Event handler for adaptation events

   287  */

   288 void XANokiaLinearVolumeItfImpl_AdaptCb(void *pHandlerCtx,

   289         XAAdaptEvent *event)

   290     {

   291     XANokiaLinearVolumeItfImpl* impl =

   292             (XANokiaLinearVolumeItfImpl*) pHandlerCtx;

   293     XAboolean eventBoolean = XA_BOOLEAN_FALSE;

   294 

   295     DEBUG_API("->XANokiaLinearVolumeItfimpl_AdaptCb");

   296 

   297     if (!impl || !event)

   298         {

   299         DEBUG_ERR("XANokiaLinearVolumeItfImpl_AdaptCb, invalid context pointer!");

   300         DEBUG_API("<-XANokiaLinearVolumeItfImpl_AdaptCb");

   301         return;

   302         }

   303     

   304     if (event->eventid == XA_ADAPT_VOLUME_VOLUME_CHANGED && impl->callback)

   305         {

   306         if (XA_NOKIALINEARVOLUME_EVENT_VOLUME_CHANGED & impl->eventFlags)

   307             {

   308             DEBUG_API("Volume level changed in adaptation");

   309             impl->callback(impl->cbPtrToSelf, impl->context,

   310                     XA_NOKIALINEARVOLUME_EVENT_VOLUME_CHANGED, eventBoolean);

   311             }

   312         }

   313     DEBUG_API("<-XANokiaLinearVolumeItfimpl_AdaptCb");

   314     }