25 /** |
25 /** |
26 * XANokiaLinearVolumeItfImpl* GetImpl(XANokiaLinearVolumeItf self) |
26 * XANokiaLinearVolumeItfImpl* GetImpl(XANokiaLinearVolumeItf self) |
27 * Description: Validated interface pointer and cast it to implementations pointer. |
27 * Description: Validated interface pointer and cast it to implementations pointer. |
28 **/ |
28 **/ |
29 static XANokiaLinearVolumeItfImpl* GetImpl(XANokiaLinearVolumeItf self) |
29 static XANokiaLinearVolumeItfImpl* GetImpl(XANokiaLinearVolumeItf self) |
30 { |
30 { |
31 if(self) |
31 if (self) |
32 { |
32 { |
33 XANokiaLinearVolumeItfImpl* impl = (XANokiaLinearVolumeItfImpl*)(*self); |
33 XANokiaLinearVolumeItfImpl* impl = |
34 if(impl && impl == impl->self) |
34 (XANokiaLinearVolumeItfImpl*) (*self); |
35 { |
35 if (impl && impl == impl->self) |
|
36 { |
36 return impl; |
37 return impl; |
37 } |
38 } |
38 } |
39 } |
39 return NULL; |
40 return NULL; |
40 } |
41 } |
41 |
42 |
42 /** |
43 /** |
43 * XAresult XANokiaLinearVolumeItfImpl_RegisterVolumeCallback(XANokiaLinearVolumeItf self, |
44 * XAresult XANokiaLinearVolumeItfImpl_RegisterVolumeCallback(XANokiaLinearVolumeItf self, |
44 * xaNokiaLinearVolumeCallback callback, |
45 * xaNokiaLinearVolumeCallback callback, |
45 * void * pContext) |
46 * void * pContext) |
46 * Description: Sets or clears the xaVolumeCallback. |
47 * Description: Sets or clears the xaVolumeCallback. |
47 **/ |
48 **/ |
48 XAresult XANokiaLinearVolumeItfImpl_RegisterVolumeCallback(XANokiaLinearVolumeItf self, |
49 XAresult XANokiaLinearVolumeItfImpl_RegisterVolumeCallback( |
49 xaNokiaLinearVolumeCallback callback, |
50 XANokiaLinearVolumeItf self, xaNokiaLinearVolumeCallback callback, |
50 void * pContext) |
51 void * pContext) |
51 { |
52 { |
52 XAresult ret = XA_RESULT_SUCCESS; |
53 XAresult ret = XA_RESULT_SUCCESS; |
53 XANokiaLinearVolumeItfImpl* impl = GetImpl(self); |
54 XANokiaLinearVolumeItfImpl* impl = GetImpl(self); |
54 DEBUG_API("->XANokiaLinearVolumeItfImpl_RegisterVolumeCallback"); |
55 DEBUG_API("->XANokiaLinearVolumeItfImpl_RegisterVolumeCallback"); |
55 |
56 |
56 if(!impl) |
57 if (!impl) |
57 { |
58 { |
58 DEBUG_ERR("XA_RESULT_PARAMETER_INVALID"); |
59 DEBUG_ERR("XA_RESULT_PARAMETER_INVALID"); |
59 /* invalid parameter */ |
60 /* invalid parameter */ |
60 DEBUG_API("<-XANokiaLinearVolumeItfImpl_RegisterVolumeCallback"); |
61 DEBUG_API("<-XANokiaLinearVolumeItfImpl_RegisterVolumeCallback"); |
61 return XA_RESULT_PARAMETER_INVALID; |
62 return XA_RESULT_PARAMETER_INVALID; |
62 } |
63 } |
63 |
64 |
64 impl->callback = callback; |
65 impl->callback = callback; |
65 impl->context = pContext; |
66 impl->context = pContext; |
66 impl->cbPtrToSelf = self; |
67 impl->cbPtrToSelf = self; |
67 |
68 |
68 DEBUG_API("<-XANokiaLinearVolumeItfImpl_RegisterVolumeCallback"); |
69 DEBUG_API("<-XANokiaLinearVolumeItfImpl_RegisterVolumeCallback"); |
69 return ret; |
70 return ret; |
70 } |
71 } |
71 |
72 |
72 /** |
73 /** |
73 * Base interface XANokiaLinearVolumeItf implementation |
74 * Base interface XANokiaLinearVolumeItf implementation |
74 */ |
75 */ |
75 |
76 |
76 /** |
77 /** |
77 * XAresult XANokiaLinearVolumeItfImpl_SetVolumeLevel(XANokiaLinearVolumeItf self, XAuint32 percentage) |
78 * XAresult XANokiaLinearVolumeItfImpl_SetVolumeLevel(XANokiaLinearVolumeItf self, XAuint32 percentage) |
78 * Description: Sets the object's volume level. |
79 * Description: Sets the object's volume level. |
79 **/ |
80 **/ |
80 XAresult XANokiaLinearVolumeItfImpl_SetVolumeLevel(XANokiaLinearVolumeItf self, XAuint32 *percentage) |
81 XAresult XANokiaLinearVolumeItfImpl_SetVolumeLevel( |
81 { |
82 XANokiaLinearVolumeItf self, XAuint32 *percentage) |
|
83 { |
82 XANokiaLinearVolumeItfImpl *impl = GetImpl(self); |
84 XANokiaLinearVolumeItfImpl *impl = GetImpl(self); |
83 XAresult ret = XA_RESULT_SUCCESS; |
85 XAresult ret = XA_RESULT_SUCCESS; |
84 XAuint32 vol = *percentage; |
86 XAuint32 vol = *percentage; |
85 |
87 |
86 DEBUG_API("->XANokiaLinearVolumeItfImpl_SetVolumeLevel"); |
88 DEBUG_API("->XANokiaLinearVolumeItfImpl_SetVolumeLevel"); |
87 |
89 |
88 |
90 if ((!impl) || (vol > MAX_PERCENTAGE_VOLUME)) |
89 if((!impl) || (vol > MAX_PERCENTAGE_VOLUME)) |
91 { |
90 { |
92 DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");DEBUG_API("<-XANokiaLinearVolumeItfImpl_SetVolumeLevel"); |
91 DEBUG_ERR("XA_RESULT_PARAMETER_INVALID"); |
93 /* invalid parameter */ |
92 DEBUG_API("<-XANokiaLinearVolumeItfImpl_SetVolumeLevel"); |
94 return XA_RESULT_PARAMETER_INVALID; |
93 /* invalid parameter */ |
95 } |
94 return XA_RESULT_PARAMETER_INVALID; |
|
95 } |
|
96 |
96 |
97 ret = XAAdaptationBase_ThreadEntry(impl->adapCtx); |
97 ret = XAAdaptationBase_ThreadEntry(impl->adapCtx); |
98 if( ret == XA_RESULT_PARAMETER_INVALID || ret == XA_RESULT_PRECONDITIONS_VIOLATED ) |
98 if (ret == XA_RESULT_SUCCESS) |
99 { |
99 { |
100 DEBUG_API("<-XANokiaLinearVolumeItfImpl_SetVolumeLevel"); |
100 if (impl->adapCtx && impl->adapCtx->fwtype == FWMgrFWMMF) |
101 return ret; |
101 { |
102 } |
102 ret = XANokiaLinearVolumeItfAdapt_SetVolumeLevel( |
103 if(impl->adapCtx->fwtype == FWMgrFWMMF) |
103 (XAAdaptationMMFCtx*) impl->adapCtx, vol); |
104 { |
104 if (ret == XA_RESULT_SUCCESS) |
105 ret = XANokiaLinearVolumeItfAdapt_SetVolumeLevel((XAAdaptationMMFCtx*)impl->adapCtx, vol); |
105 { |
106 } |
106 impl->volumeLevel = vol; |
107 |
107 } |
108 if(ret == XA_RESULT_SUCCESS) |
108 } |
109 { |
109 XAAdaptationBase_ThreadExit(impl->adapCtx); |
110 impl->volumeLevel = vol; |
110 } |
111 } |
|
112 |
|
113 XAAdaptationBase_ThreadExit(impl->adapCtx); |
|
114 DEBUG_API("<-XANokiaLinearVolumeItfImpl_SetVolumeLevel"); |
111 DEBUG_API("<-XANokiaLinearVolumeItfImpl_SetVolumeLevel"); |
115 return ret ; |
112 return ret; |
116 } |
113 } |
117 |
114 |
118 /** |
115 /** |
119 * XAresult XANokiaLinearVolumeItfImpl_GetVolumeLevel(XANokiaLinearVolumeItf self, XAmillibel *pLevel) |
116 * XAresult XANokiaLinearVolumeItfImpl_GetVolumeLevel(XANokiaLinearVolumeItf self, XAmillibel *pLevel) |
120 * Description: Gets the object’s volume level. |
117 * Description: Gets the object’s volume level. |
121 **/ |
118 **/ |
122 XAresult XANokiaLinearVolumeItfImpl_GetVolumeLevel(XANokiaLinearVolumeItf self, XAuint32 *percentage) |
119 XAresult XANokiaLinearVolumeItfImpl_GetVolumeLevel( |
123 { |
120 XANokiaLinearVolumeItf self, XAuint32 *percentage) |
|
121 { |
124 XAresult ret = XA_RESULT_SUCCESS; |
122 XAresult ret = XA_RESULT_SUCCESS; |
125 XANokiaLinearVolumeItfImpl *impl = GetImpl(self); |
123 XANokiaLinearVolumeItfImpl *impl = GetImpl(self); |
126 DEBUG_API("->XANokiaLinearVolumeItfImpl_GetVolumeLevel"); |
124 DEBUG_API("->XANokiaLinearVolumeItfImpl_GetVolumeLevel"); |
127 |
125 |
128 if(!impl || !percentage) |
126 if (!impl || !percentage) |
129 { |
127 { |
130 DEBUG_ERR("XA_RESULT_PARAMETER_INVALID"); |
128 DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");DEBUG_API("<-XANokiaLinearVolumeItfImpl_GetVolumeLevel"); |
131 DEBUG_API("<-XANokiaLinearVolumeItfImpl_GetVolumeLevel"); |
129 /* invalid parameter */ |
132 /* invalid parameter */ |
130 return XA_RESULT_PARAMETER_INVALID; |
133 return XA_RESULT_PARAMETER_INVALID; |
131 } |
134 } |
|
135 |
132 |
136 *percentage = impl->volumeLevel; |
133 *percentage = impl->volumeLevel; |
137 |
134 |
138 DEBUG_API("<-XANokiaLinearVolumeItfImpl_GetVolumeLevel"); |
135 DEBUG_API("<-XANokiaLinearVolumeItfImpl_GetVolumeLevel"); |
139 return ret; |
136 return ret; |
140 } |
137 } |
141 |
138 |
142 /** |
139 /** |
143 * XAresult XANokiaLinearVolumeItfImpl_GetMaxVolumeLevel(XANokiaLinearVolumeItf self, XAmillibel *pMaxLevel) |
140 * XAresult XANokiaLinearVolumeItfImpl_GetMaxVolumeLevel(XANokiaLinearVolumeItf self, XAmillibel *pMaxLevel) |
144 * Description: Gets the maximum supported level. |
141 * Description: Gets the maximum supported level. |
145 **/ |
142 **/ |
146 XAresult XANokiaLinearVolumeItfImpl_GetStepCount(XANokiaLinearVolumeItf self, XAuint32 *pStepCount) |
143 XAresult XANokiaLinearVolumeItfImpl_GetStepCount(XANokiaLinearVolumeItf self, |
147 { |
144 XAuint32 *pStepCount) |
|
145 { |
148 XAresult ret = XA_RESULT_SUCCESS; |
146 XAresult ret = XA_RESULT_SUCCESS; |
149 XANokiaLinearVolumeItfImpl *impl = GetImpl(self); |
147 XANokiaLinearVolumeItfImpl *impl = GetImpl(self); |
150 DEBUG_API("->XANokiaLinearVolumeItfImpl_GetVolumeLevel"); |
148 DEBUG_API("->XANokiaLinearVolumeItfImpl_GetVolumeLevel"); |
151 |
149 |
152 if(!impl || !pStepCount) |
150 if (!impl || !pStepCount) |
153 { |
151 { |
154 DEBUG_ERR("XA_RESULT_PARAMETER_INVALID"); |
152 DEBUG_ERR("XA_RESULT_PARAMETER_INVALID");DEBUG_API("<-XANokiaLinearVolumeItfImpl_GetMaxVolumeLevel"); |
155 DEBUG_API("<-XANokiaLinearVolumeItfImpl_GetMaxVolumeLevel"); |
153 /* invalid parameter */ |
156 /* invalid parameter */ |
154 return XA_RESULT_PARAMETER_INVALID; |
157 return XA_RESULT_PARAMETER_INVALID; |
155 } |
158 } |
|
159 |
156 |
160 ret = XAAdaptationBase_ThreadEntry(impl->adapCtx); |
157 ret = XAAdaptationBase_ThreadEntry(impl->adapCtx); |
161 if( ret == XA_RESULT_PARAMETER_INVALID || ret == XA_RESULT_PRECONDITIONS_VIOLATED ) |
158 if (ret == XA_RESULT_SUCCESS) |
162 { |
159 { |
163 DEBUG_API("<-XANokiaLinearVolumeItfImpl_GetMaxVolumeLevel"); |
160 if (impl->adapCtx && impl->adapCtx->fwtype == FWMgrFWMMF) |
164 return ret; |
161 { |
165 } |
162 ret = XANokiaLinearVolumeItfAdapt_GetStepCount( |
166 if(impl->adapCtx->fwtype == FWMgrFWMMF) |
163 (XAAdaptationMMFCtx*) impl->adapCtx, pStepCount); |
167 { |
164 } |
168 ret = XANokiaLinearVolumeItfAdapt_GetStepCount((XAAdaptationMMFCtx*)impl->adapCtx, pStepCount); |
165 |
169 } |
166 XAAdaptationBase_ThreadExit(impl->adapCtx); |
170 |
167 } |
171 XAAdaptationBase_ThreadExit(impl->adapCtx); |
|
172 DEBUG_API("<-XANokiaLinearVolumeItfImpl_GetMaxVolumeLevel"); |
168 DEBUG_API("<-XANokiaLinearVolumeItfImpl_GetMaxVolumeLevel"); |
173 return ret; |
169 return ret; |
174 } |
170 } |
175 |
171 |
176 XAresult XANokiaLinearVolumeItfImpl_SetCallbackEventsMask(XANokiaLinearVolumeItf self, XAuint32 eventFlags ) |
172 XAresult XANokiaLinearVolumeItfImpl_SetCallbackEventsMask( |
|
173 XANokiaLinearVolumeItf self, XAuint32 eventFlags) |
177 { |
174 { |
178 XAresult ret = XA_RESULT_SUCCESS; |
175 XAresult ret = XA_RESULT_SUCCESS; |
179 XANokiaLinearVolumeItfImpl* impl = GetImpl(self); |
176 XANokiaLinearVolumeItfImpl* impl = GetImpl(self); |
180 DEBUG_API("->XANokiaLinearVolumeItfImpl_SetCallbackEventsMask"); |
177 DEBUG_API("->XANokiaLinearVolumeItfImpl_SetCallbackEventsMask"); |
181 |
178 |
182 if(!impl) |
179 if (!impl) |
183 { |
180 { |
184 DEBUG_ERR("XA_RESULT_PARAMETER_INVALID"); |
181 DEBUG_ERR("XA_RESULT_PARAMETER_INVALID"); |
185 /* invalid parameter */ |
182 /* invalid parameter */ |
186 DEBUG_API("<-XANokiaLinearVolumeItfImpl_SetCallbackEventsMask"); |
183 DEBUG_API("<-XANokiaLinearVolumeItfImpl_SetCallbackEventsMask"); |
187 return XA_RESULT_PARAMETER_INVALID; |
184 return XA_RESULT_PARAMETER_INVALID; |
188 } |
185 } |
189 |
186 |
190 impl->eventFlags = eventFlags; |
187 impl->eventFlags = eventFlags; |
191 |
188 |
192 DEBUG_API("<-XANokiaLinearVolumeItfImpl_SetCallbackEventsMask"); |
189 DEBUG_API("<-XANokiaLinearVolumeItfImpl_SetCallbackEventsMask"); |
193 return ret; |
190 return ret; |
194 } |
191 } |
195 |
192 |
196 XAresult XANokiaLinearVolumeItfImpl_GetCallbackEventsMask(XANokiaLinearVolumeItf self, XAuint32 * pEventFlags) |
193 XAresult XANokiaLinearVolumeItfImpl_GetCallbackEventsMask( |
|
194 XANokiaLinearVolumeItf self, XAuint32 * pEventFlags) |
197 { |
195 { |
198 XAresult ret = XA_RESULT_SUCCESS; |
196 XAresult ret = XA_RESULT_SUCCESS; |
199 XANokiaLinearVolumeItfImpl* impl = GetImpl(self); |
197 XANokiaLinearVolumeItfImpl* impl = GetImpl(self); |
200 DEBUG_API("->XANokiaLinearVolumeItfImpl_GetCallbackEventsMask"); |
198 DEBUG_API("->XANokiaLinearVolumeItfImpl_GetCallbackEventsMask"); |
201 |
199 |
202 if(!impl || !pEventFlags) |
200 if (!impl || !pEventFlags) |
203 { |
201 { |
204 DEBUG_ERR("XA_RESULT_PARAMETER_INVALID"); |
202 DEBUG_ERR("XA_RESULT_PARAMETER_INVALID"); |
205 /* invalid parameter */ |
203 /* invalid parameter */ |
206 DEBUG_API("<-XANokiaLinearVolumeItfImpl_GetCallbackEventsMask"); |
204 DEBUG_API("<-XANokiaLinearVolumeItfImpl_GetCallbackEventsMask"); |
207 return XA_RESULT_PARAMETER_INVALID; |
205 return XA_RESULT_PARAMETER_INVALID; |
208 } |
206 } |
209 |
207 |
210 *pEventFlags = impl->eventFlags; |
208 *pEventFlags = impl->eventFlags; |
211 |
209 |
212 DEBUG_API("<-XANokiaLinearVolumeItfImpl_GetCallbackEventsMask"); |
210 DEBUG_API("<-XANokiaLinearVolumeItfImpl_GetCallbackEventsMask"); |
213 return ret; |
211 return ret; |
214 } |
212 } |
215 |
213 |
216 /** |
214 /** |
217 * XANokiaLinearVolumeItfImpl -specific methods |
215 * XANokiaLinearVolumeItfImpl -specific methods |
218 **/ |
216 **/ |
219 |
217 |
220 /** |
218 /** |
221 * XANokiaLinearVolumeItfImpl* XANokiaLinearVolumeItfImpl_Create() |
219 * XANokiaLinearVolumeItfImpl* XANokiaLinearVolumeItfImpl_Create() |
222 * Description: Allocate and initialize VolumeItfImpl |
220 * Description: Allocate and initialize VolumeItfImpl |
223 **/ |
221 **/ |
224 XANokiaLinearVolumeItfImpl* XANokiaLinearVolumeItfImpl_Create(XAAdaptationBaseCtx *adapCtx ) |
222 XANokiaLinearVolumeItfImpl* XANokiaLinearVolumeItfImpl_Create( |
225 { |
223 XAAdaptationBaseCtx *adapCtx) |
226 XANokiaLinearVolumeItfImpl *self = (XANokiaLinearVolumeItfImpl*) |
224 { |
227 calloc(1,sizeof(XANokiaLinearVolumeItfImpl)); |
225 XANokiaLinearVolumeItfImpl *self = (XANokiaLinearVolumeItfImpl*) calloc( |
|
226 1, sizeof(XANokiaLinearVolumeItfImpl)); |
228 DEBUG_API("->XANokiaLinearVolumeItfImpl_Create"); |
227 DEBUG_API("->XANokiaLinearVolumeItfImpl_Create"); |
229 |
228 |
230 if(self) |
229 if (self) |
231 { |
230 { |
232 /* init itf default implementation */ |
231 /* init itf default implementation */ |
233 self->itf.GetStepCount = XANokiaLinearVolumeItfImpl_GetStepCount; |
232 self->itf.GetStepCount = XANokiaLinearVolumeItfImpl_GetStepCount; |
234 self->itf.GetVolumeLevel = XANokiaLinearVolumeItfImpl_GetVolumeLevel; |
233 self->itf.GetVolumeLevel = XANokiaLinearVolumeItfImpl_GetVolumeLevel; |
235 self->itf.SetVolumeLevel = XANokiaLinearVolumeItfImpl_SetVolumeLevel; |
234 self->itf.SetVolumeLevel = XANokiaLinearVolumeItfImpl_SetVolumeLevel; |
236 self->itf.RegisterVolumeCallback = XANokiaLinearVolumeItfImpl_RegisterVolumeCallback; |
235 self->itf.RegisterVolumeCallback |
237 self->itf.SetCallbackEventsMask = XANokiaLinearVolumeItfImpl_SetCallbackEventsMask; |
236 = XANokiaLinearVolumeItfImpl_RegisterVolumeCallback; |
238 self->itf.GetCallbackEventsMask = XANokiaLinearVolumeItfImpl_GetCallbackEventsMask; |
237 self->itf.SetCallbackEventsMask |
|
238 = XANokiaLinearVolumeItfImpl_SetCallbackEventsMask; |
|
239 self->itf.GetCallbackEventsMask |
|
240 = XANokiaLinearVolumeItfImpl_GetCallbackEventsMask; |
239 /* init variables */ |
241 /* init variables */ |
240 self->volumeLevel = 0; |
242 self->volumeLevel = 0; |
241 |
243 |
242 self->adapCtx = adapCtx; |
244 self->adapCtx = adapCtx; |
243 |
245 |
244 XAAdaptationBase_AddEventHandler( adapCtx, &XANokiaLinearVolumeItfImpl_AdaptCb, XA_NOKIALINEARVOLITFEVENTS, self ); |
246 XAAdaptationBase_AddEventHandler(adapCtx, |
245 |
247 &XANokiaLinearVolumeItfImpl_AdaptCb, |
|
248 XA_NOKIALINEARVOLITFEVENTS, self); |
|
249 |
246 self->self = self; |
250 self->self = self; |
247 } |
251 } |
248 |
252 |
249 DEBUG_API("<-XANokiaLinearVolumeItfImpl_Create"); |
253 DEBUG_API("<-XANokiaLinearVolumeItfImpl_Create"); |
250 return self; |
254 return self; |
251 } |
255 } |
252 |
256 |
253 /** |
257 /** |
254 * void XANokiaLinearVolumeItfImpl_Free(XANokiaLinearVolumeItfImpl* self) |
258 * void XANokiaLinearVolumeItfImpl_Free(XANokiaLinearVolumeItfImpl* self) |
255 * Description: Free all resources reserved at XANokiaLinearVolumeItfImpl_Create |
259 * Description: Free all resources reserved at XANokiaLinearVolumeItfImpl_Create |
256 **/ |
260 **/ |
257 void XANokiaLinearVolumeItfImpl_Free(XANokiaLinearVolumeItfImpl* self) |
261 void XANokiaLinearVolumeItfImpl_Free(XANokiaLinearVolumeItfImpl* self) |
258 { |
262 { |
259 DEBUG_API("->XANokiaLinearVolumeItfImpl_Free"); |
263 DEBUG_API("->XANokiaLinearVolumeItfImpl_Free"); |
260 assert(self==self->self); |
264 assert(self==self->self); |
261 free(self); |
265 free(self); |
262 DEBUG_API("<-XANokiaLinearVolumeItfImpl_Free"); |
266 DEBUG_API("<-XANokiaLinearVolumeItfImpl_Free"); |
263 } |
267 } |
264 |
268 |
265 /* void XANokiaLinearVolumeItfimpl_AdaptCb( void *pHandlerCtx, XAAdaptEvent *event ) |
269 /* void XANokiaLinearVolumeItfimpl_AdaptCb( void *pHandlerCtx, XAAdaptEvent *event ) |
266 * Description: Event handler for adaptation events |
270 * Description: Event handler for adaptation events |
267 */ |
271 */ |
268 void XANokiaLinearVolumeItfImpl_AdaptCb( void *pHandlerCtx, XAAdaptEvent *event ) |
272 void XANokiaLinearVolumeItfImpl_AdaptCb(void *pHandlerCtx, |
269 { |
273 XAAdaptEvent *event) |
270 XANokiaLinearVolumeItfImpl* impl =(XANokiaLinearVolumeItfImpl*)pHandlerCtx; |
274 { |
|
275 XANokiaLinearVolumeItfImpl* impl = |
|
276 (XANokiaLinearVolumeItfImpl*) pHandlerCtx; |
271 XAboolean eventBoolean = XA_BOOLEAN_FALSE; |
277 XAboolean eventBoolean = XA_BOOLEAN_FALSE; |
|
278 |
|
279 DEBUG_API("->XANokiaLinearVolumeItfimpl_AdaptCb"); |
|
280 |
|
281 if (!impl && !event) |
|
282 { |
|
283 DEBUG_ERR("XANokiaLinearVolumeItfImpl_AdaptCb, invalid context pointer!");DEBUG_API("<-XANokiaLinearVolumeItfImpl_AdaptCb"); |
|
284 return; |
|
285 } |
272 |
286 |
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); |
287 assert(event); |
282 |
288 |
283 if( event->eventid == XA_ADAPT_VOLUME_VOLUME_CHANGED && impl->callback ) |
289 if (event->eventid == XA_ADAPT_VOLUME_VOLUME_CHANGED && impl->callback) |
284 { |
290 { |
285 if(XA_NOKIALINEARVOLUME_EVENT_VOLUME_CHANGED & impl->eventFlags) |
291 if (XA_NOKIALINEARVOLUME_EVENT_VOLUME_CHANGED & impl->eventFlags) |
286 { |
292 { |
287 DEBUG_API("Volume level changed in adaptation"); |
293 DEBUG_API("Volume level changed in adaptation"); |
288 impl->callback( impl->cbPtrToSelf, impl->context, XA_NOKIALINEARVOLUME_EVENT_VOLUME_CHANGED, eventBoolean ); |
294 impl->callback(impl->cbPtrToSelf, impl->context, |
|
295 XA_NOKIALINEARVOLUME_EVENT_VOLUME_CHANGED, eventBoolean); |
289 } |
296 } |
290 } |
297 } |
291 else |
298 else |
292 { |
299 { |
293 /* do nothing */ |
300 /* do nothing */ |
294 } |
301 }DEBUG_API("<-XANokiaLinearVolumeItfimpl_AdaptCb"); |
295 DEBUG_API("<-XANokiaLinearVolumeItfimpl_AdaptCb"); |
302 } |
296 } |
|