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 "xanvolumeextitf.h"

    23 #include "xanokiavolumeextitfadaptationmmf.h"

    24 

    25 /**

    26  * XANokiaVolumeExtItfImpl* GetImpl(XANokiaVolumeExtItf self)

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

    28  **/

    29 static XANokiaVolumeExtItfImpl* GetImpl(XANokiaVolumeExtItf self)

    30 {

    31     if(self)

    32     {

    33         XANokiaVolumeExtItfImpl* impl = (XANokiaVolumeExtItfImpl*)(*self);

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

    35         {

    36             return impl;

    37         }

    38     }

    39     return NULL;

    40 }

    41 

    42 /**

    43  * XAresult XANokiaVolumeExtItfImpl_RegisterVolumeCallback(XANokiaVolumeExtItf self,

    44  *                                               xaNokiaVolumeExtCallback callback,

    45  *                                               void * pContext)

    46  * Description: Sets or clears the xaVolumeCallback.

    47  **/

    48 XAresult XANokiaVolumeExtItfImpl_RegisterVolumeCallback(XANokiaVolumeExtItf self,

    49                                               xaNokiaVolumeExtCallback callback,

    50                                               void * pContext)

    51 {

    52     XAresult ret = XA_RESULT_SUCCESS;

    53     XANokiaVolumeExtItfImpl* impl = GetImpl(self);

    54     DEBUG_API("->XANokiaVolumeExtItfImpl_RegisterVolumeCallback");

    55 

    56     if(!impl)

    57     {

    58         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

    59         /* invalid parameter */

    60         DEBUG_API("<-XANokiaVolumeExtItfImpl_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("<-XANokiaVolumeExtItfImpl_RegisterVolumeCallback");

    69     return ret;

    70 }

    71 

    72 /**

    73  * Base interface XANokiaVolumeExtItf implementation

    74  */

    75 

    76 /**

    77  * XAresult XANokiaVolumeExtItfImpl_SetVolumeLevel(XANokiaVolumeExtItf self, XAmillibel level)

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

    79  **/

    80 XAresult XANokiaVolumeExtItfImpl_SetVolumeLevel(XANokiaVolumeExtItf self, XAmillibel level)

    81 {

    82     XANokiaVolumeExtItfImpl *impl = GetImpl(self);

    83     XAresult ret = XA_RESULT_SUCCESS;

    84 

    85     XAmillibel maximumLevel = 0; 

    86  

    87     DEBUG_API("->XANokiaVolumeExtItfImpl_SetVolumeLevel");

    88 

    89     /* check maximum volume level */

    90   	if(XANokiaVolumeExtItfImpl_GetMaxVolumeLevel(self, &maximumLevel) != XA_RESULT_SUCCESS)

    91    	{

    92         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

    93         DEBUG_API("<-XANokiaVolumeExtItfImpl_SetVolumeLevel");

    94         /* cannot solve maximum volume level */

    95         return XA_RESULT_PARAMETER_INVALID;

    96    	}

    97     

    98     if(!impl || level > maximumLevel)

    99     {

   100         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   101         DEBUG_API("<-XANokiaVolumeExtItfImpl_SetVolumeLevel");

   102         /* invalid parameter */

   103         return XA_RESULT_PARAMETER_INVALID;

   104     }

   105 

   106     impl->volumeLevel = level;

   107 

   108     DEBUG_API("<-XANokiaVolumeExtItfImpl_SetVolumeLevel");

   109     return ret ;

   110 }

   111 

   112 /**

   113  * XAresult XANokiaVolumeExtItfImpl_GetVolumeLevel(XANokiaVolumeExtItf self, XAmillibel *pLevel)

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

   115  **/

   116 XAresult XANokiaVolumeExtItfImpl_GetVolumeLevel(XANokiaVolumeExtItf self, XAmillibel *pLevel)

   117 {

   118     XAresult ret = XA_RESULT_SUCCESS;

   119     XANokiaVolumeExtItfImpl *impl = GetImpl(self);

   120     DEBUG_API("->XANokiaVolumeExtItfImpl_GetVolumeLevel");

   121 

   122     if(!impl || !pLevel)

   123     {

   124         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   125         DEBUG_API("<-XANokiaVolumeExtItfImpl_GetVolumeLevel");

   126         /* invalid parameter */

   127         return XA_RESULT_PARAMETER_INVALID;

   128     }

   129 

   130     *pLevel = impl->volumeLevel;

   131 

   132     DEBUG_API("<-XANokiaVolumeExtItfImpl_GetVolumeLevel");

   133     return ret;

   134 }

   135 

   136 /**

   137  * XAresult XANokiaVolumeExtItfImpl_GetMaxVolumeLevel(XANokiaVolumeExtItf  self, XAmillibel *pMaxLevel)

   138  * Description: Gets the maximum supported level.

   139  **/

   140 XAresult XANokiaVolumeExtItfImpl_GetMaxVolumeLevel(XANokiaVolumeExtItf  self, XAmillibel *pMaxLevel)

   141 {

   142     XAresult ret = XA_RESULT_SUCCESS;

   143     XANokiaVolumeExtItfImpl *impl = GetImpl(self);

   144     DEBUG_API("->XANokiaVolumeExtItfImpl_GetVolumeLevel");

   145 

   146     if(!impl || !pMaxLevel)

   147     {

   148         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   149         DEBUG_API("<-XANokiaVolumeExtItfImpl_GetMaxVolumeLevel");

   150         /* invalid parameter */

   151         return XA_RESULT_PARAMETER_INVALID;

   152     }

   153 

   154     *pMaxLevel = MAX_SUPPORT_VOLUME_LEVEL;

   155     

   156     DEBUG_API("<-XANokiaVolumeExtItfImpl_GetMaxVolumeLevel");

   157     return ret;

   158 }

   159 

   160 /**

   161  * XAresult XANokiaVolumeExtItfImpl_SetMute(XANokiaVolumeExtItf self, XAboolean mute)

   162  * Description: Mutes or unmutes the object.

   163  **/

   164 XAresult XANokiaVolumeExtItfImpl_SetMute(XANokiaVolumeExtItf self, XAboolean mute)

   165 {

   166     XAresult ret = XA_RESULT_SUCCESS;

   167     XANokiaVolumeExtItfImpl *impl = GetImpl(self);

   168     DEBUG_API("->XANokiaVolumeExtItfImpl_SetMute");

   169 

   170     if(!impl)

   171     {

   172         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   173         DEBUG_API("<-XANokiaVolumeExtItfImpl_SetMute");

   174         /* invalid parameter */

   175         return XA_RESULT_PARAMETER_INVALID;

   176     }

   177 

   178     ret = XAAdaptationBase_ThreadEntry(impl->adapCtx);

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

   180     {

   181         DEBUG_API("<-XANokiaVolumeExtItfImpl_SetMute");

   182         return ret;

   183     }

   184     /* check is mute state changed */

   185     if(mute != impl->mute)

   186     {

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

   188         {

   189         ret = XANokiaVolumeExtItfAdapt_SetMute((XAAdaptationMMFCtx*)impl->adapCtx,  mute);

   190         }

   191 

   192         if(ret == XA_RESULT_SUCCESS)

   193         {

   194             impl->mute = mute;

   195         }

   196     }

   197 

   198     XAAdaptationBase_ThreadExit(impl->adapCtx);

   199     DEBUG_API("<-XANokiaVolumeExtItfImpl_SetMute");

   200     return ret;

   201 }

   202 

   203 /**

   204  * XAresult XANokiaVolumeExtItfImpl_GetMute(XANokiaVolumeExtItf self, XAboolean *pMute)

   205  * Description: Retrieves the object's state.

   206  **/

   207 XAresult XANokiaVolumeExtItfImpl_GetMute(XANokiaVolumeExtItf self, XAboolean *pMute)

   208 {

   209     XAresult ret = XA_RESULT_SUCCESS;

   210     XANokiaVolumeExtItfImpl *impl = GetImpl(self);

   211     DEBUG_API("->XANokiaVolumeExtItfImpl_GetMute");

   212 

   213     if(!impl || !pMute)

   214     {

   215         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   216         DEBUG_API("<-XANokiaVolumeExtItfImpl_GetMute");

   217         /* invalid parameter */

   218         return XA_RESULT_PARAMETER_INVALID;

   219     }

   220 

   221     *pMute = impl->mute;

   222 

   223     DEBUG_API("<-XANokiaVolumeExtItfImpl_GetMute");

   224     return ret;

   225 }

   226 

   227 /**

   228  * XAresult XANokiaVolumeExtItfImpl_EnableStereoPosition(XANokiaVolumeExtItf self, XAboolean enable)

   229  * Description: Enables or disables the stereo positioning effect.

   230  **/

   231 XAresult XANokiaVolumeExtItfImpl_EnableStereoPosition(XANokiaVolumeExtItf self, XAboolean enable)

   232 {

   233     XAresult ret = XA_RESULT_SUCCESS;

   234     XANokiaVolumeExtItfImpl *impl = GetImpl(self);

   235     DEBUG_API("->XANokiaVolumeExtItfImpl_EnableStereoPosition");

   236 

   237     if(!impl)

   238     {

   239         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   240         DEBUG_API("<-XANokiaVolumeExtItfImpl_EnableStereoPosition");

   241         /* invalid parameter */

   242         return XA_RESULT_PARAMETER_INVALID;

   243     }

   244 

   245     ret = XAAdaptationBase_ThreadEntry(impl->adapCtx);

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

   247     {

   248         DEBUG_API("<-XANokiaVolumeExtItfImpl_EnableStereoPosition");

   249         return ret;

   250     }

   251     /* Check is stereo position state changed */

   252     if(enable != impl->enableStereoPos)

   253     {

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

   255         {

   256         ret = XANokiaVolumeExtItfAdapt_EnableStereoPosition((XAAdaptationMMFCtx*)impl->adapCtx,

   257                                                     enable);

   258         }

   259 

   260         if(ret == XA_RESULT_SUCCESS)

   261         {

   262             impl->enableStereoPos = enable;

   263         }

   264     }

   265 

   266     XAAdaptationBase_ThreadExit(impl->adapCtx);

   267     DEBUG_API("<-XANokiaVolumeExtItfImpl_EnableStereoPosition");

   268     return ret;

   269 }

   270 

   271 /**

   272  * XAresult XANokiaVolumeExtItfImpl_IsEnabledStereoPosition(XANokiaVolumeExtItf self,

   273  *                                                  XAboolean *pEnable)

   274  * Description: Returns the enabled state of the stereo positioning effect.

   275  **/

   276 XAresult XANokiaVolumeExtItfImpl_IsEnabledStereoPosition(XANokiaVolumeExtItf self,

   277                                                  XAboolean *pEnable)

   278 {

   279     XAresult ret = XA_RESULT_SUCCESS;

   280     XANokiaVolumeExtItfImpl *impl = GetImpl(self);

   281     DEBUG_API("->XANokiaVolumeExtItfImpl_IsEnabledStereoPosition");

   282 

   283     if(!impl || !pEnable)

   284     {

   285         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   286         DEBUG_API("<-XANokiaVolumeExtItfImpl_IsEnabledStereoPosition");

   287         /* invalid parameter */

   288         return XA_RESULT_PARAMETER_INVALID;

   289     }

   290 

   291     *pEnable = impl->enableStereoPos;

   292 

   293     DEBUG_API("<-XANokiaVolumeExtItfImpl_IsEnabledStereoPosition");

   294     return ret;

   295 }

   296 

   297 /**

   298  * XAresult XANokiaVolumeExtItfImpl_SetStereoPosition(XANokiaVolumeExtItf self,

   299  *                                            XApermille stereoPosition)

   300  * Description: Sets the stereo position of the object.

   301  **/

   302 XAresult XANokiaVolumeExtItfImpl_SetStereoPosition(XANokiaVolumeExtItf self,

   303                                            XApermille stereoPosition)

   304 {

   305     XAresult ret = XA_RESULT_SUCCESS;

   306     XANokiaVolumeExtItfImpl *impl = GetImpl(self);

   307     DEBUG_API("->XANokiaVolumeExtItfImpl_SetStereoPosition");

   308 

   309     if(!impl || (stereoPosition < STEREO_POSITION_LEFT) ||

   310         (stereoPosition > STEREO_POSITION_RIGHT))

   311     {

   312         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   313         DEBUG_API("<-XANokiaVolumeExtItfImpl_SetStereoPosition");

   314         /* invalid parameter */

   315         return XA_RESULT_PARAMETER_INVALID;

   316     }

   317 

   318     impl->stereoPosition = stereoPosition;

   319 

   320     ret = XAAdaptationBase_ThreadEntry(impl->adapCtx);

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

   322     {

   323         DEBUG_API("<-XANokiaVolumeExtItfImpl_SetStereoPosition");

   324         return ret;

   325     }

   326     /* check is stereo position effect enabled if is then handle effect */

   327     if(impl->enableStereoPos)

   328     {

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

   330         {

   331         ret = XANokiaVolumeExtItfAdapt_SetStereoPosition((XAAdaptationMMFCtx*)impl->adapCtx,

   332                                                  stereoPosition);

   333         

   334         }

   335     }

   336 

   337     XAAdaptationBase_ThreadExit(impl->adapCtx);

   338     DEBUG_API("<-XANokiaVolumeExtItfImpl_SetStereoPosition");

   339     return ret;

   340 }

   341 

   342 /**

   343  * XAresult XANokiaVolumeExtItfImpl_GetStereoPosition(XANokiaVolumeExtItf self,

   344  *                                            XApermille *pStereoPosition)

   345  * Description: Gets the object’s stereo position setting.

   346  **/

   347 XAresult XANokiaVolumeExtItfImpl_GetStereoPosition(XANokiaVolumeExtItf self,

   348                                            XApermille *pStereoPosition)

   349 {

   350     XAresult ret = XA_RESULT_SUCCESS;

   351     XANokiaVolumeExtItfImpl *impl = GetImpl(self);

   352     DEBUG_API("->XANokiaVolumeExtItfImpl_GetStereoPosition");

   353 

   354     if(!impl || !pStereoPosition)

   355     {

   356         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   357         DEBUG_API("<-XANokiaVolumeExtItfImpl_GetStereoPosition");

   358         /* invalid parameter */

   359         return XA_RESULT_PARAMETER_INVALID;

   360     }

   361 

   362     *pStereoPosition = impl->stereoPosition;

   363 

   364     DEBUG_API("<-XANokiaVolumeExtItfImpl_GetStereoPosition");

   365     return ret;

   366 }

   367 

   368 XAresult XANokiaVolumeExtItfImpl_SetCallbackEventsMask(XANokiaVolumeExtItf self, XAuint32 eventFlags )

   369     {

   370     XAresult ret = XA_RESULT_SUCCESS;

   371     XANokiaVolumeExtItfImpl* impl = GetImpl(self);

   372     DEBUG_API("->XANokiaVolumeExtItfImpl_SetCallbackEventsMask");

   373 

   374     if(!impl)

   375     {

   376         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   377         /* invalid parameter */

   378         DEBUG_API("<-XANokiaVolumeExtItfImpl_SetCallbackEventsMask");

   379         return XA_RESULT_PARAMETER_INVALID;

   380     }

   381 

   382     impl->eventFlags = eventFlags;

   383 

   384     DEBUG_API("<-XANokiaVolumeExtItfImpl_SetCallbackEventsMask");

   385     return ret;    

   386     }

   387 

   388 XAresult XANokiaVolumeExtItfImpl_GetCallbackEventsMask(XANokiaVolumeExtItf self, XAuint32 * pEventFlags)

   389     {

   390     XAresult ret = XA_RESULT_SUCCESS;

   391     XANokiaVolumeExtItfImpl* impl = GetImpl(self);

   392     DEBUG_API("->XANokiaVolumeExtItfImpl_GetCallbackEventsMask");

   393 

   394     if(!impl || !pEventFlags)

   395     {

   396         DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");

   397         /* invalid parameter */

   398         DEBUG_API("<-XANokiaVolumeExtItfImpl_GetCallbackEventsMask");

   399         return XA_RESULT_PARAMETER_INVALID;

   400     }

   401 

   402     *pEventFlags = impl->eventFlags;

   403 

   404     DEBUG_API("<-XANokiaVolumeExtItfImpl_GetCallbackEventsMask");

   405     return ret;    

   406     }

   407 

   408 

   409 /**

   410  * XANokiaVolumeExtItfImpl -specific methods

   411  **/

   412 

   413 /**

   414  * XANokiaVolumeExtItfImpl* XANokiaVolumeExtItfImpl_Create()

   415  * Description: Allocate and initialize VolumeItfImpl

   416  **/

   417 XANokiaVolumeExtItfImpl* XANokiaVolumeExtItfImpl_Create(XAAdaptationBaseCtx *adapCtx )

   418 {

   419     XANokiaVolumeExtItfImpl *self = (XANokiaVolumeExtItfImpl*)

   420         calloc(1,sizeof(XANokiaVolumeExtItfImpl));

   421     DEBUG_API("->XANokiaVolumeExtItfImpl_Create");

   422 

   423     if(self)

   424     {

   425         /* init itf default implementation */

   426         self->itf.EnableStereoPosition = XANokiaVolumeExtItfImpl_EnableStereoPosition;

   427         self->itf.GetMaxVolumeLevel = XANokiaVolumeExtItfImpl_GetMaxVolumeLevel;

   428         self->itf.GetMute = XANokiaVolumeExtItfImpl_GetMute;

   429         self->itf.GetStereoPosition = XANokiaVolumeExtItfImpl_GetStereoPosition;

   430         self->itf.GetVolumeLevel = XANokiaVolumeExtItfImpl_GetVolumeLevel;

   431         self->itf.IsEnabledStereoPosition = XANokiaVolumeExtItfImpl_IsEnabledStereoPosition;

   432         self->itf.SetMute = XANokiaVolumeExtItfImpl_SetMute;

   433         self->itf.SetStereoPosition = XANokiaVolumeExtItfImpl_SetStereoPosition;

   434         self->itf.SetVolumeLevel = XANokiaVolumeExtItfImpl_SetVolumeLevel;

   435        	self->itf.RegisterVolumeCallback = XANokiaVolumeExtItfImpl_RegisterVolumeCallback;

   436        	self->itf.SetCallbackEventsMask = XANokiaVolumeExtItfImpl_SetCallbackEventsMask;

   437        	self->itf.GetCallbackEventsMask = XANokiaVolumeExtItfImpl_GetCallbackEventsMask;

   438 

   439         /* init variables */

   440         self->volumeLevel = 0;

   441         self->mute = XA_BOOLEAN_FALSE;

   442         self->enableStereoPos = XA_BOOLEAN_FALSE;

   443         self->stereoPosition = STEREO_POSITION_CENTER;

   444 

   445         self->adapCtx = adapCtx;

   446 

   447         XAAdaptationBase_AddEventHandler(adapCtx, &XANokiaVolumeExtItfImpl_AdaptCb, XA_NOKIAEXTVOLITFEVENTS, self );

   448         

   449         self->self = self;

   450     }

   451 

   452     DEBUG_API("<-XANokiaVolumeExtItfImpl_Create");

   453     return self;

   454 }

   455 

   456 /**

   457  * void XANokiaVolumeExtItfImpl_Free(XANokiaVolumeExtItfImpl* self)

   458  * Description: Free all resources reserved at XANokiaVolumeExtItfImpl_Create

   459  **/

   460 void XANokiaVolumeExtItfImpl_Free(XANokiaVolumeExtItfImpl* self)

   461 {

   462     DEBUG_API("->XANokiaVolumeExtItfImpl_Free");

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

   464     free(self);

   465     DEBUG_API("<-XANokiaVolumeExtItfImpl_Free");

   466 }

   467 

   468 /* void XANokiaVolumeExtItfimpl_AdaptCb( void *pHandlerCtx, XAAdaptEvent *event )

   469  * Description: Event handler for adaptation events

   470  */

   471 void XANokiaVolumeExtItfImpl_AdaptCb( void *pHandlerCtx, XAAdaptEvent *event )

   472 {

   473     XANokiaVolumeExtItfImpl* impl =(XANokiaVolumeExtItfImpl*)pHandlerCtx;

   474     XAboolean eventBoolean = XA_BOOLEAN_FALSE;

   475     

   476     DEBUG_API("->XANokiaVolumeExtItfimpl_AdaptCb");

   477 

   478     if(!impl)

   479     {

   480         DEBUG_ERR("XANokiaVolumeExtItfImpl_AdaptCb, invalid context pointer!");

   481         DEBUG_API("<-XANokiaVolumeExtItfImpl_AdaptCb");

   482         return;

   483     }

   484     assert(event);

   485     

   486     if( event->eventid == XA_ADAPT_VOLUME_MUTE_CHANGED && impl->callback )

   487     {

   488         if(impl->eventFlags & XA_NOKIAVOLUMEEXT_EVENT_MUTE_CHANGED)

   489             {

   490             DEBUG_API("Mute Status  changed in adaptation");

   491             eventBoolean = *(XAboolean*)event->data;    

   492             impl->callback( impl->cbPtrToSelf, impl->context, XA_NOKIAVOLUMEEXT_EVENT_MUTE_CHANGED, eventBoolean  );

   493             }

   494     }

   495        

   496     else if (event->eventid == XA_ADAPT_VOLUME_VOLUME_CHANGED)

   497     {

   498         if(impl->eventFlags & XA_NOKIAVOLUMEEXT_EVENT_VOLUME_CHANGED)

   499             {

   500             DEBUG_API("Volume Status  changed in adaptation");

   501             eventBoolean = *(XAboolean*)event->data;    

   502             impl->callback( impl->cbPtrToSelf, impl->context, XA_NOKIAVOLUMEEXT_EVENT_VOLUME_CHANGED, eventBoolean  );

   503             }

   504     }

   505     else if (event->eventid == XA_ADAPT_VULOME_STEREOPOSITION_CHANGED)

   506     {

   507         if(impl->eventFlags & XA_NOKIAVOLUMEEXT_EVENT_STEREO_POSITION_CHANGED)

   508             {

   509             DEBUG_API("StereoPosituin Status  changed in adaptation");

   510             eventBoolean = *(XAboolean*)event->data;    

   511             impl->callback( impl->cbPtrToSelf, impl->context, XA_NOKIAVOLUMEEXT_EVENT_STEREO_POSITION_CHANGED, eventBoolean  );

   512             }

   513     }

   514     

   515     DEBUG_API("<-XANokiaVolumeExtItfimpl_AdaptCb");

   516 }