81 TInt status(KErrNone); |
81 TInt status(KErrNone); |
82 TInt freqRange(0); |
82 TInt freqRange(0); |
83 status = aItem.GetNextInt(freqRange); |
83 status = aItem.GetNextInt(freqRange); |
84 RET_ERR_IF_ERR(status); |
84 RET_ERR_IF_ERR(status); |
85 |
85 |
86 if (m_PlayItf) |
|
87 { |
|
88 status = (*m_PlayItf)->SetPlayState( |
|
89 m_PlayItf, XA_PLAYSTATE_PLAYING); |
|
90 } |
|
91 else |
|
92 { |
|
93 status = KErrNotFound; |
|
94 return status; |
|
95 } |
|
96 |
|
97 if(m_RadioItf) |
86 if(m_RadioItf) |
98 { |
87 { |
99 status = (*m_RadioItf)->SetFreqRange( |
88 status = (*m_RadioItf)->SetFreqRange( |
100 m_RadioItf, freqRange); |
89 m_RadioItf, freqRange); |
101 } |
90 } |
102 else |
91 else |
103 { |
92 { |
104 status = KErrNotFound; |
93 status = KErrNotFound; |
105 } |
94 } |
106 return status; |
95 return status; |
107 } |
96 } |
108 |
97 |
109 TInt COpenMAXALTestModule::al_radioitf_GetFreqRange( CStifItemParser& aItem ) |
98 TInt COpenMAXALTestModule::al_radioitf_GetFreqRange( CStifItemParser& aItem ) |
110 { |
99 { |
111 TInt status(KErrNone); |
100 TInt status(KErrNone); |
112 XAuint8 freqRange; |
101 XAuint8 freqRange; |
113 TInt expectedRange; |
102 TInt expectedRange; |
114 status = aItem.GetNextInt(expectedRange); |
103 status = aItem.GetNextInt(expectedRange); |
115 RET_ERR_IF_ERR(status); |
104 RET_ERR_IF_ERR(status); |
116 |
105 |
117 if (m_RadioItf) |
106 if (m_RadioItf) |
118 { |
107 { |
119 status = (*m_RadioItf)->GetFreqRange( |
108 status = (*m_RadioItf)->GetFreqRange( |
120 m_RadioItf, &freqRange); |
109 m_RadioItf, &freqRange); |
121 if (!status) |
110 if (!status) |
122 { |
111 { |
123 if (freqRange != (TInt)expectedRange) |
112 if (freqRange != (TInt)expectedRange) |
124 { |
113 { |
125 status = KErrCompletion; |
114 status = KErrCompletion; |
140 XAboolean isSupported; |
129 XAboolean isSupported; |
141 status = aItem.GetNextInt(freqRange); |
130 status = aItem.GetNextInt(freqRange); |
142 if (m_RadioItf) |
131 if (m_RadioItf) |
143 { |
132 { |
144 status = (*m_RadioItf)->IsFreqRangeSupported( |
133 status = (*m_RadioItf)->IsFreqRangeSupported( |
145 m_RadioItf, (XAuint8)freqRange, &isSupported); |
134 m_RadioItf, (XAuint8)freqRange, &isSupported); |
146 if (!isSupported) |
135 if (!isSupported) |
147 status = KErrCompletion; |
136 status = KErrCompletion; |
148 } |
137 } |
149 else |
138 else |
150 { |
139 { |
151 status = KErrNotFound; |
140 status = KErrNotFound; |
152 } |
141 } |
153 return status; |
142 return status; |
154 } |
143 } |
155 |
144 |
156 TInt COpenMAXALTestModule::al_radioitf_GetFreqRangeProperties( CStifItemParser& aItem ) |
145 TInt COpenMAXALTestModule::al_radioitf_GetFreqRangeProperties( CStifItemParser& aItem ) |
157 { |
146 { |
158 TInt status(KErrNone); |
147 TInt status(KErrNone); |
159 TInt range; |
148 TInt range; |
160 status = aItem.GetNextInt(range); |
149 status = aItem.GetNextInt(range); |
161 RET_ERR_IF_ERR(status); |
150 RET_ERR_IF_ERR(status); |
162 TInt expectedMinFreq; |
151 TInt expectedMinFreq; |
163 status = aItem.GetNextInt(expectedMinFreq); |
152 status = aItem.GetNextInt(expectedMinFreq); |
164 RET_ERR_IF_ERR(status); |
153 RET_ERR_IF_ERR(status); |
165 TInt expectedMaxFreq; |
154 TInt expectedMaxFreq; |
166 status = aItem.GetNextInt(expectedMaxFreq); |
155 status = aItem.GetNextInt(expectedMaxFreq); |
167 RET_ERR_IF_ERR(status); |
156 RET_ERR_IF_ERR(status); |
168 TInt expectedFreqInterval; |
157 TInt expectedFreqInterval; |
169 status = aItem.GetNextInt(expectedFreqInterval); |
158 status = aItem.GetNextInt(expectedFreqInterval); |
170 RET_ERR_IF_ERR(status); |
159 RET_ERR_IF_ERR(status); |
171 XAuint32 minFreq; |
160 |
172 XAuint32 maxFreq; |
161 XAuint32 minFreq; |
173 XAuint32 freqInterval; |
162 XAuint32 maxFreq; |
|
163 XAuint32 freqInterval; |
174 |
164 |
175 if (m_RadioItf) |
165 if (m_RadioItf) |
176 { |
166 { |
177 status = (*m_RadioItf)->GetFreqRangeProperties( |
167 status = (*m_RadioItf)->GetFreqRangeProperties( |
178 m_RadioItf, range, &minFreq, &maxFreq, &freqInterval); |
168 m_RadioItf, range, &minFreq, &maxFreq, &freqInterval); |
179 if (!status) |
169 if (!status) |
180 { |
170 { |
181 /* If duration does not fall between the range we expected fail the case */ |
171 /* If duration does not fall between the range we expected fail the case */ |
182 if ( ( minFreq != (XAuint32)expectedMinFreq) || (maxFreq != (XAuint32)expectedMaxFreq) || (freqInterval != (XAuint32)expectedFreqInterval) ) |
172 if ( ( minFreq != (XAuint32)expectedMinFreq) || (maxFreq != (XAuint32)expectedMaxFreq) || (freqInterval != (XAuint32)expectedFreqInterval) ) |
183 { |
173 { |
186 } |
176 } |
187 } |
177 } |
188 else |
178 else |
189 { |
179 { |
190 status = KErrNotFound; |
180 status = KErrNotFound; |
191 } |
181 } |
192 return status; |
182 return status; |
193 } |
183 } |
194 |
184 |
195 TInt COpenMAXALTestModule::al_radioitf_SetFrequency( CStifItemParser& aItem ) |
185 TInt COpenMAXALTestModule::al_radioitf_SetFrequency( CStifItemParser& aItem ) |
196 { |
186 { |
197 TInt status(KErrNone); |
187 TInt status(KErrNone); |
198 TInt freq; |
188 TInt freq; |
199 XAuint32 currentFreq; |
189 status = aItem.GetNextInt(freq); |
200 status = aItem.GetNextInt(freq); |
190 RET_ERR_IF_ERR(status); |
201 RET_ERR_IF_ERR(status); |
191 if (m_RadioItf) |
202 |
192 { |
203 if (m_PlayItf) |
193 status = (*m_RadioItf)->SetFrequency( |
204 { |
194 m_RadioItf, freq); |
205 status = (*m_PlayItf)->SetPlayState( |
195 if (status != KErrNone) |
206 m_PlayItf, XA_PLAYSTATE_PLAYING); |
196 status = KErrCompletion; |
207 } |
197 } |
208 else |
198 else |
209 { |
199 { |
210 status = KErrNotFound; |
200 status = KErrNotFound; |
211 return status; |
201 } |
212 } |
|
213 |
|
214 if (m_RadioItf) |
|
215 { |
|
216 status = (*m_RadioItf)->GetFrequency(m_RadioItf, ¤tFreq); |
|
217 if (status != KErrNone) |
|
218 { |
|
219 status = KErrCompletion; |
|
220 return status; |
|
221 } |
|
222 } |
|
223 else |
|
224 { |
|
225 status = KErrNotFound; |
|
226 return status; |
|
227 } |
|
228 |
|
229 if (m_RadioItf) |
|
230 { |
|
231 status = (*m_RadioItf)->SetFrequency(m_RadioItf, freq); |
|
232 if (status != KErrNone) |
|
233 status = KErrCompletion; |
|
234 } |
|
235 else |
|
236 { |
|
237 status = KErrNotFound; |
|
238 } |
|
239 return status; |
202 return status; |
240 } |
203 } |
241 |
204 |
242 TInt COpenMAXALTestModule::al_radioitf_GetFrequency( CStifItemParser& aItem) |
205 TInt COpenMAXALTestModule::al_radioitf_GetFrequency( CStifItemParser& aItem) |
243 { |
206 { |
244 TInt status(KErrNone); |
207 TInt status(KErrNone); |
245 TInt expectedFreq; |
208 TInt expectedFreq; |
246 status = aItem.GetNextInt(expectedFreq); |
209 status = aItem.GetNextInt(expectedFreq); |
247 RET_ERR_IF_ERR(status); |
210 RET_ERR_IF_ERR(status); |
248 XAuint32 freq; |
211 XAuint32 freq; |
249 |
212 |
250 if (m_RadioItf) |
213 if (m_RadioItf) |
251 { |
214 { |
252 status = (*m_RadioItf)->GetFrequency( |
215 status = (*m_RadioItf)->GetFrequency( |
253 m_RadioItf, &freq); |
216 m_RadioItf, &freq); |
254 if (!status) |
217 if (!status) |
255 { |
218 { |
256 if ( freq != expectedFreq ) |
219 if ( freq != expectedFreq ) |
257 { |
220 { |
258 status = KErrCompletion; |
221 status = KErrCompletion; |
259 } |
222 } |
260 } |
223 } |
261 } |
224 } |
262 else |
225 else |
263 { |
226 { |
264 status = KErrNotFound; |
227 status = KErrNotFound; |
265 } |
228 } |
266 return status; |
229 return status; |
267 } |
230 } |
268 |
|
269 TInt COpenMAXALTestModule::al_radioitf_GetFrequencyDefault( CStifItemParser& aItem) |
|
270 { |
|
271 TInt status(KErrCompletion); |
|
272 XAuint32 freq; |
|
273 |
|
274 if (m_RadioItf) |
|
275 { |
|
276 status = (*m_RadioItf)->GetFrequency( |
|
277 m_RadioItf, &freq); |
|
278 } |
|
279 return status; |
|
280 } |
|
281 |
|
282 TInt COpenMAXALTestModule::al_radioitf_GetFreqRangeDefault( CStifItemParser& aItem ) |
|
283 { |
|
284 TInt status(KErrCompletion); |
|
285 XAuint8 freqRange; |
|
286 |
|
287 if (m_RadioItf) |
|
288 { |
|
289 status = (*m_RadioItf)->GetFreqRange( |
|
290 m_RadioItf, &freqRange); |
|
291 } |
|
292 else |
|
293 { |
|
294 status = KErrNotFound; |
|
295 } |
|
296 return status; |
|
297 } |
|
298 |
231 |
299 TInt COpenMAXALTestModule::al_radioitf_RegisterRadioCallback( CStifItemParser& /*aItem*/ ) |
232 TInt COpenMAXALTestModule::al_radioitf_RegisterRadioCallback( CStifItemParser& /*aItem*/ ) |
300 { |
233 { |
301 TInt status(KErrNone); |
234 TInt status(KErrNone); |
302 XAresult res; |
235 XAresult res; |
303 |
236 |
304 if(m_RadioItf) |
237 if(m_RadioItf) |
305 { |
238 { |
306 res = (*m_RadioItf)->RegisterRadioCallback( |
239 res = (*m_RadioItf)->RegisterRadioCallback( |
307 m_RadioItf, &RadioItfCallback, (void*)this); |
240 m_RadioItf, &RadioItfCallback, (void*)this); |
308 status = res; |
241 status = res; |
309 } |
242 } |
310 else |
243 else |
311 { |
244 { |
312 status = KErrNotFound; |
245 status = KErrNotFound; |
313 } |
246 } |
314 |
247 |
315 return status; |
248 return status; |
316 } |
249 } |
317 |
250 |
318 |
251 |
325 |
258 |
326 if(m_RadioItf) |
259 if(m_RadioItf) |
327 { |
260 { |
328 status = (*m_RadioItf)->SetSquelch( |
261 status = (*m_RadioItf)->SetSquelch( |
329 m_RadioItf, squelch); |
262 m_RadioItf, squelch); |
330 |
|
331 } |
263 } |
332 else |
264 else |
333 { |
265 { |
334 status = KErrNotFound; |
266 status = KErrNotFound; |
335 } |
267 } |
336 return status; |
268 return status; |
337 } |
269 } |
338 |
270 |
339 TInt COpenMAXALTestModule::al_radioitf_GetSquelch( CStifItemParser& aItem ) |
271 TInt COpenMAXALTestModule::al_radioitf_GetSquelch( CStifItemParser& aItem ) |
340 { |
272 { |
341 TInt status(KErrNone); |
273 TInt status(KErrNone); |
342 TBool expectedSquelch; |
274 TBool expectedSquelch; |
343 status = aItem.GetNextInt(expectedSquelch); |
275 status = aItem.GetNextInt(expectedSquelch); |
352 { |
284 { |
353 if (squelch != (XAboolean)expectedSquelch) |
285 if (squelch != (XAboolean)expectedSquelch) |
354 { |
286 { |
355 status = KErrCompletion; |
287 status = KErrCompletion; |
356 } |
288 } |
357 } |
289 } |
358 } |
290 } |
359 else |
291 else |
360 { |
292 { |
361 status = KErrNotFound; |
293 status = KErrNotFound; |
362 } |
294 } |
363 return status; |
295 return status; |
364 } |
296 } |
365 |
297 |
366 TInt COpenMAXALTestModule::al_radioitf_CancelSetFrequency( CStifItemParser& /*aItem*/ ) |
298 TInt COpenMAXALTestModule::al_radioitf_CancelSetFrequency( CStifItemParser& /*aItem*/ ) |
367 { |
299 { |
368 TInt status(KErrNone); |
300 TInt status(KErrNone); |
369 |
301 |
370 if(m_RadioItf) |
302 if(m_RadioItf) |
371 { |
303 { |
372 status = (*m_RadioItf)->CancelSetFrequency( |
304 status = (*m_RadioItf)->CancelSetFrequency( |
373 m_RadioItf); |
305 m_RadioItf); |
374 } |
306 } |
375 else |
307 else |
376 { |
308 { |
377 status = KErrNotFound; |
309 status = KErrNotFound; |
378 } |
310 } |
379 return status; |
311 return status; |
380 } |
312 } |
381 |
313 |
382 TInt COpenMAXALTestModule::al_radioitf_SetStereoMode( CStifItemParser& aItem ) |
314 TInt COpenMAXALTestModule::al_radioitf_SetStereoMode( CStifItemParser& aItem ) |
383 { |
315 { |
384 TInt status(KErrNone); |
316 TInt status(KErrNone); |
385 TInt stereoMode; |
317 TInt stereoMode; |
386 status = aItem.GetNextInt(stereoMode); |
318 status = aItem.GetNextInt(stereoMode); |
387 RET_ERR_IF_ERR(status); |
319 RET_ERR_IF_ERR(status); |
388 |
320 |
389 if(m_RadioItf) |
321 if(m_RadioItf) |
390 { |
322 { |
392 m_RadioItf, (XAuint32)stereoMode); |
324 m_RadioItf, (XAuint32)stereoMode); |
393 } |
325 } |
394 else |
326 else |
395 { |
327 { |
396 status = KErrNotFound; |
328 status = KErrNotFound; |
397 } |
329 } |
398 return status; |
330 return status; |
399 } |
331 } |
400 |
332 |
401 TInt COpenMAXALTestModule::al_radioitf_GetStereoMode( CStifItemParser& aItem ) |
333 TInt COpenMAXALTestModule::al_radioitf_GetStereoMode( CStifItemParser& aItem ) |
402 { |
334 { |
403 TInt status(KErrNone); |
335 TInt status(KErrNone); |
404 TInt expectedStereoMode; |
336 TInt expectedStereoMode; |
405 status = aItem.GetNextInt(expectedStereoMode); |
337 status = aItem.GetNextInt(expectedStereoMode); |
406 RET_ERR_IF_ERR(status); |
338 RET_ERR_IF_ERR(status); |
407 XAuint32 stereoMode; |
339 XAuint32 stereoMode; |
408 |
340 |
409 if(m_RadioItf) |
341 if(m_RadioItf) |
436 m_RadioItf, &signalStrength); |
368 m_RadioItf, &signalStrength); |
437 } |
369 } |
438 else |
370 else |
439 { |
371 { |
440 status = KErrNotFound; |
372 status = KErrNotFound; |
441 } |
373 } |
442 return status; |
374 return status; |
443 } |
375 } |
444 |
376 |
445 TInt COpenMAXALTestModule::al_radioitf_Seek( CStifItemParser& aItem ) |
377 TInt COpenMAXALTestModule::al_radioitf_Seek( CStifItemParser& aItem ) |
446 { |
378 { |
447 TInt status(KErrNone); |
379 TInt status(KErrNone); |
448 TBool upwards; |
380 TBool upwards; |
449 status = aItem.GetNextInt(upwards); |
381 status = aItem.GetNextInt(upwards); |
450 RET_ERR_IF_ERR(status); |
382 RET_ERR_IF_ERR(status); |
451 |
383 |
452 if(m_RadioItf) |
384 if(m_RadioItf) |
453 { |
385 { |
454 status = (*m_RadioItf)->Seek( |
386 status = (*m_RadioItf)->Seek( |
455 m_RadioItf, upwards); |
387 m_RadioItf, upwards); |
456 } |
388 } |
457 else |
389 else |
458 { |
390 { |
459 status = KErrNotFound; |
391 status = KErrNotFound; |
460 } |
392 } |
461 return status; |
393 return status; |
462 } |
394 } |
463 |
395 |
464 TInt COpenMAXALTestModule::al_radioitf_StopSeeking( CStifItemParser& /*aItem*/ ) |
396 TInt COpenMAXALTestModule::al_radioitf_StopSeeking( CStifItemParser& /*aItem*/ ) |
465 { |
397 { |
466 TInt status(KErrNone); |
398 TInt status(KErrNone); |
467 |
399 |
468 if(m_RadioItf) |
400 if(m_RadioItf) |
471 m_RadioItf); |
403 m_RadioItf); |
472 } |
404 } |
473 else |
405 else |
474 { |
406 { |
475 status = KErrNotFound; |
407 status = KErrNotFound; |
476 } |
408 } |
477 return status; |
409 return status; |
478 } |
410 } |
479 |
411 |
480 |
412 TInt COpenMAXALTestModule::al_radioitf_GetNumberOfPresets( CStifItemParser& aItem) |
|
413 { |
|
414 TInt status(KErrNone); |
|
415 RET_ERR_IF_ERR(status); |
|
416 XAuint32 num; |
|
417 |
|
418 if (m_RadioItf) |
|
419 { |
|
420 status = (*m_RadioItf)->GetNumberOfPresets( |
|
421 m_RadioItf, &num); |
|
422 } |
|
423 else |
|
424 { |
|
425 status = KErrNotFound; |
|
426 } |
|
427 return status; |
|
428 } |
|
429 |
|
430 TInt COpenMAXALTestModule::al_radioitf_SetPreset( CStifItemParser& aItem) |
|
431 { |
|
432 TInt status(KErrNone); |
|
433 TInt preset; |
|
434 status = aItem.GetNextInt(preset); |
|
435 RET_ERR_IF_ERR(status); |
|
436 XAuint32 presetVal = preset; |
|
437 XAuint32 freq = 0; |
|
438 XAuint8 range = 0; |
|
439 XAuint32 mode = 0; |
|
440 |
|
441 if (m_RadioItf) |
|
442 { |
|
443 status = (*m_RadioItf)->SetPreset(m_RadioItf, presetVal, freq, range, mode, 0); |
|
444 } |
|
445 else |
|
446 { |
|
447 status = KErrNotFound; |
|
448 } |
|
449 return status; |
|
450 } |
|
451 |
|
452 TInt COpenMAXALTestModule::al_radioitf_GetPreset( CStifItemParser& aItem) |
|
453 { |
|
454 TInt status(KErrNone); |
|
455 TInt presetToGet; |
|
456 status = aItem.GetNextInt(presetToGet); |
|
457 RET_ERR_IF_ERR(status); |
|
458 XAuint32 preset = presetToGet; |
|
459 XAuint32 freq = 0; |
|
460 XAuint8 range = 0; |
|
461 XAuint32 mode = 0; |
|
462 XAuint16 nameLength = 0; |
|
463 |
|
464 if (m_RadioItf) |
|
465 { |
|
466 status = (*m_RadioItf)->GetPreset(m_RadioItf, preset, &freq, &range, &mode, 0, &nameLength); |
|
467 } |
|
468 else |
|
469 { |
|
470 status = KErrNotFound; |
|
471 } |
|
472 return status; |
|
473 } |
|
474 |
481 void COpenMAXALTestModule::HandleRadioItfCallback( |
475 void COpenMAXALTestModule::HandleRadioItfCallback( |
482 XARadioItf caller, |
476 XARadioItf caller, |
483 XAuint32 event |
477 XAuint32 event |
484 ) |
478 ) |
485 { |
479 { |
486 |
480 |
487 switch (event) |
481 switch (event) |
488 { |
482 { |
489 case XA_RADIO_EVENT_ANTENNA_STATUS_CHANGED: |
483 case XA_RADIO_EVENT_ANTENNA_STATUS_CHANGED: |
490 { |
484 { |
491 TEventIf antennaStatusEvent( TEventIf::ESetEvent, _L("Event_XA_RADIO_EVENT_ANTENNA_STATUS_CHANGED:") ); |
485 TEventIf antennaStatusEvent( TEventIf::ESetEvent, _L("Event_XA_RADIO_EVENT_ANTENNA_STATUS_CHANGED:") ); |
492 TestModuleIf().Event( antennaStatusEvent ); |
486 TestModuleIf().Event( antennaStatusEvent ); |
493 } |
487 } |