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 "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 = (XANokiaLinearVolumeItfImpl*)(*self);

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

    35         {

    36             return impl;

    37         }

    38     }

    39     return NULL;

    40 }

    41 

    42 /**

    43  * XAresult XANokiaLinearVolumeItfImpl_RegisterVolumeCallback(XANokiaLinearVolumeItf self,

    44  *                                               xaNokiaLinearVolumeCallback callback,

    45  *                                               void * pContext)

    46  * Description: Sets or clears the xaVolumeCallback.

    47  **/

    48 XAresult XANokiaLinearVolumeItfImpl_RegisterVolumeCallback(XANokiaLinearVolumeItf self,

    49                                               xaNokiaLinearVolumeCallback callback,

    50                                               void * pContext)

    51 {

    52     XAresult ret = XA_RESULT_SUCCESS;

    53     XANokiaLinearVolumeItfImpl* impl = GetImpl(self);

    54     DEBUG_API("->XANokiaLinearVolumeItfImpl_RegisterVolumeCallback");

    55 

    56     if(!impl)

    57     {

    58         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

    59         /* invalid parameter */

    60         DEBUG_API("<-XANokiaLinearVolumeItfImpl_RegisterVolumeCallback");

    61         return XA_RESULT_PARAMETER_INVALID;

    62     }

    63 

    64     impl->callback = callback;

    65     impl->context = pContext;

    66     impl->cbPtrToSelf = self;

    67 

    68     DEBUG_API("<-XANokiaLinearVolumeItfImpl_RegisterVolumeCallback");

    69     return ret;

    70 }

    71 

    72 /**

    73  * Base interface XANokiaLinearVolumeItf implementation

    74  */

    75 

    76 /**

    77  * XAresult XANokiaLinearVolumeItfImpl_SetVolumeLevel(XANokiaLinearVolumeItf self, XAuint32 percentage)

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

    79  **/

    80 XAresult XANokiaLinearVolumeItfImpl_SetVolumeLevel(XANokiaLinearVolumeItf self, XAuint32 *percentage)

    81 {

    82     XANokiaLinearVolumeItfImpl *impl = GetImpl(self);

    83     XAresult ret = XA_RESULT_SUCCESS;     

    84     XAuint32 vol = *percentage;

    85     

    86     DEBUG_API("->XANokiaLinearVolumeItfImpl_SetVolumeLevel");

    87 

    88   

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

    90     {

    91         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

    92         DEBUG_API("<-XANokiaLinearVolumeItfImpl_SetVolumeLevel");

    93         /* invalid parameter */

    94         return XA_RESULT_PARAMETER_INVALID;

    95     }

    96 

    97     ret = XAAdaptationBase_ThreadEntry(impl->adapCtx);

    98     if( ret == XA_RESULT_PARAMETER_INVALID || ret == XA_RESULT_PRECONDITIONS_VIOLATED )

    99     {

   100         DEBUG_API("<-XANokiaLinearVolumeItfImpl_SetVolumeLevel");

   101         return ret;

   102     }

   103     if(impl->adapCtx->fwtype == FWMgrFWMMF)

   104         {

   105         ret = XANokiaLinearVolumeItfAdapt_SetVolumeLevel((XAAdaptationMMFCtx*)impl->adapCtx,  vol);

   106         }

   107 

   108     if(ret == XA_RESULT_SUCCESS)

   109     {

   110         impl->volumeLevel = vol;

   111     }

   112 

   113     XAAdaptationBase_ThreadExit(impl->adapCtx);

   114     DEBUG_API("<-XANokiaLinearVolumeItfImpl_SetVolumeLevel");

   115     return ret ;

   116 }

   117 

   118 /**

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

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

   121  **/

   122 XAresult XANokiaLinearVolumeItfImpl_GetVolumeLevel(XANokiaLinearVolumeItf self, XAuint32 *percentage)

   123 {

   124     XAresult ret = XA_RESULT_SUCCESS;

   125     XANokiaLinearVolumeItfImpl *impl = GetImpl(self);

   126     DEBUG_API("->XANokiaLinearVolumeItfImpl_GetVolumeLevel");

   127 

   128     if(!impl || !percentage)

   129     {

   130         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   131         DEBUG_API("<-XANokiaLinearVolumeItfImpl_GetVolumeLevel");

   132         /* invalid parameter */

   133         return XA_RESULT_PARAMETER_INVALID;

   134     }

   135 

   136     *percentage = impl->volumeLevel;

   137 

   138     DEBUG_API("<-XANokiaLinearVolumeItfImpl_GetVolumeLevel");

   139     return ret;

   140 }

   141 

   142 /**

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

   144  * Description: Gets the maximum supported level.

   145  **/

   146 XAresult XANokiaLinearVolumeItfImpl_GetStepCount(XANokiaLinearVolumeItf  self, XAuint32 *pStepCount)

   147 {

   148     XAresult ret = XA_RESULT_SUCCESS;

   149     XANokiaLinearVolumeItfImpl *impl = GetImpl(self);

   150     DEBUG_API("->XANokiaLinearVolumeItfImpl_GetVolumeLevel");

   151 

   152     if(!impl || !pStepCount)

   153     {

   154         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   155         DEBUG_API("<-XANokiaLinearVolumeItfImpl_GetMaxVolumeLevel");

   156         /* invalid parameter */

   157         return XA_RESULT_PARAMETER_INVALID;

   158     }

   159 

   160     ret = XAAdaptationBase_ThreadEntry(impl->adapCtx);

   161     if( ret == XA_RESULT_PARAMETER_INVALID || ret == XA_RESULT_PRECONDITIONS_VIOLATED )

   162     {

   163         DEBUG_API("<-XANokiaLinearVolumeItfImpl_GetMaxVolumeLevel");

   164         return ret;

   165     }

   166     if(impl->adapCtx->fwtype == FWMgrFWMMF)

   167         {

   168         ret = XANokiaLinearVolumeItfAdapt_GetStepCount((XAAdaptationMMFCtx*)impl->adapCtx, pStepCount);

   169         }

   170 

   171     XAAdaptationBase_ThreadExit(impl->adapCtx);

   172     DEBUG_API("<-XANokiaLinearVolumeItfImpl_GetMaxVolumeLevel");

   173     return ret;

   174 }

   175 

   176 XAresult XANokiaLinearVolumeItfImpl_SetCallbackEventsMask(XANokiaLinearVolumeItf self, XAuint32 eventFlags )

   177     {

   178     XAresult ret = XA_RESULT_SUCCESS;

   179     XANokiaLinearVolumeItfImpl* impl = GetImpl(self);

   180     DEBUG_API("->XANokiaLinearVolumeItfImpl_SetCallbackEventsMask");

   181 

   182     if(!impl)

   183     {

   184         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   185         /* invalid parameter */

   186         DEBUG_API("<-XANokiaLinearVolumeItfImpl_SetCallbackEventsMask");

   187         return XA_RESULT_PARAMETER_INVALID;

   188     }

   189 

   190     impl->eventFlags = eventFlags;

   191 

   192     DEBUG_API("<-XANokiaLinearVolumeItfImpl_SetCallbackEventsMask");

   193     return ret;    

   194     }

   195 

   196 XAresult XANokiaLinearVolumeItfImpl_GetCallbackEventsMask(XANokiaLinearVolumeItf self, XAuint32 * pEventFlags)

   197     {

   198     XAresult ret = XA_RESULT_SUCCESS;

   199     XANokiaLinearVolumeItfImpl* impl = GetImpl(self);

   200     DEBUG_API("->XANokiaLinearVolumeItfImpl_GetCallbackEventsMask");

   201 

   202     if(!impl || !pEventFlags)

   203     {

   204         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   205         /* invalid parameter */

   206         DEBUG_API("<-XANokiaLinearVolumeItfImpl_GetCallbackEventsMask");

   207         return XA_RESULT_PARAMETER_INVALID;

   208     }

   209 

   210     *pEventFlags = impl->eventFlags;

   211 

   212     DEBUG_API("<-XANokiaLinearVolumeItfImpl_GetCallbackEventsMask");

   213     return ret;    

   214     }

   215 

   216 /**

   217  * XANokiaLinearVolumeItfImpl -specific methods

   218  **/

   219 

   220 /**

   221  * XANokiaLinearVolumeItfImpl* XANokiaLinearVolumeItfImpl_Create()

   222  * Description: Allocate and initialize VolumeItfImpl

   223  **/

   224 XANokiaLinearVolumeItfImpl* XANokiaLinearVolumeItfImpl_Create(XAAdaptationBaseCtx *adapCtx )

   225 {

   226     XANokiaLinearVolumeItfImpl *self = (XANokiaLinearVolumeItfImpl*)

   227         calloc(1,sizeof(XANokiaLinearVolumeItfImpl));

   228     DEBUG_API("->XANokiaLinearVolumeItfImpl_Create");

   229 

   230     if(self)

   231     {

   232         /* init itf default implementation */

   233         self->itf.GetStepCount = XANokiaLinearVolumeItfImpl_GetStepCount;

   234         self->itf.GetVolumeLevel = XANokiaLinearVolumeItfImpl_GetVolumeLevel;

   235         self->itf.SetVolumeLevel = XANokiaLinearVolumeItfImpl_SetVolumeLevel;

   236        	self->itf.RegisterVolumeCallback = XANokiaLinearVolumeItfImpl_RegisterVolumeCallback;        

   237        	self->itf.SetCallbackEventsMask = XANokiaLinearVolumeItfImpl_SetCallbackEventsMask;

   238        	self->itf.GetCallbackEventsMask = XANokiaLinearVolumeItfImpl_GetCallbackEventsMask;

   239         /* init variables */

   240         self->volumeLevel = 0;

   241 

   242         self->adapCtx = adapCtx;

   243 

   244         XAAdaptationBase_AddEventHandler( adapCtx, &XANokiaLinearVolumeItfImpl_AdaptCb, XA_NOKIALINEARVOLITFEVENTS, self );

   245         

   246         self->self = self;

   247     }

   248 

   249     DEBUG_API("<-XANokiaLinearVolumeItfImpl_Create");

   250     return self;

   251 }

   252 

   253 /**

   254  * void XANokiaLinearVolumeItfImpl_Free(XANokiaLinearVolumeItfImpl* self)

   255  * Description: Free all resources reserved at XANokiaLinearVolumeItfImpl_Create

   256  **/

   257 void XANokiaLinearVolumeItfImpl_Free(XANokiaLinearVolumeItfImpl* self)

   258 {

   259     DEBUG_API("->XANokiaLinearVolumeItfImpl_Free");

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

   261     free(self);

   262     DEBUG_API("<-XANokiaLinearVolumeItfImpl_Free");

   263 }

   264 

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

   266  * Description: Event handler for adaptation events

   267  */

   268 void XANokiaLinearVolumeItfImpl_AdaptCb( void *pHandlerCtx, XAAdaptEvent *event )

   269 {

   270     XANokiaLinearVolumeItfImpl* impl =(XANokiaLinearVolumeItfImpl*)pHandlerCtx;

   271     XAboolean eventBoolean = XA_BOOLEAN_FALSE;

   272     

   273     DEBUG_API("->XANokiaLinearVolumeItfimpl_AdaptCb");

   274 

   275     if(!impl)

   276     {

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

   278         DEBUG_API("<-XANokiaLinearVolumeItfImpl_AdaptCb");

   279         return;

   280     }

   281     assert(event);

   282 

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

   284     {

   285         if(XA_NOKIALINEARVOLUME_EVENT_VOLUME_CHANGED & impl->eventFlags)

   286             {

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

   288             impl->callback( impl->cbPtrToSelf, impl->context, XA_NOKIALINEARVOLUME_EVENT_VOLUME_CHANGED, eventBoolean );

   289             }

   290     }       

   291     else

   292     {

   293         /* do nothing */

   294     }

   295     DEBUG_API("<-XANokiaLinearVolumeItfimpl_AdaptCb");

   296 }