author | Dario Sestito <darios@symbian.org> |
Fri, 17 Sep 2010 17:50:17 +0100 | |
branch | RCL_3 |
changeset 73 | 461e71b327da |
parent 71 | d5e927d5853b |
child 83 | 26b2b12093af |
permissions | -rw-r--r-- |
66 | 1 |
/* |
2 |
* Copyright (c) 2002-2007 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: This class is base class for all players. |
|
15 |
* |
|
16 |
*/ |
|
17 |
||
18 |
// INCLUDE FILES |
|
19 |
#include <jdebug.h> |
|
20 |
#include <JniEnvWrapper.h> |
|
21 |
#include <ctsydomainpskeys.h> |
|
22 |
||
23 |
#include "cmmaplayer.h" |
|
24 |
#include "cmmaeventsource.h" |
|
25 |
#include "cmmadurationupdater.h" |
|
26 |
#include "cmmavolumecontrol.h" |
|
27 |
#include "cmmacallstatemonitor.h" |
|
28 |
||
29 |
// CONSTANTS |
|
30 |
_LIT(KPanicOutOfMem, "out of memory"); |
|
31 |
||
32 |
#ifdef _DEBUG // Needed only in ASSER_DEBUG statements. |
|
33 |
_LIT(KPanicMethod, "method not found"); |
|
34 |
#endif |
|
35 |
||
36 |
EXPORT_C CMMAPlayer::~CMMAPlayer() |
|
37 |
{ |
|
38 |
DEBUG("CMMAPlayer::~CMMAPlayer()"); |
|
39 |
||
40 |
iSourceStreams.ResetAndDestroy(); |
|
41 |
if (iControls.Count() > 0) |
|
42 |
iControls.ResetAndDestroy(); |
|
43 |
iStateListeners.Reset(); |
|
44 |
delete iActionCompletedEvent; |
|
45 |
delete iOOMErrorEvent; |
|
46 |
delete iDurationUpdater; |
|
47 |
delete iContentType; |
|
48 |
delete iStateObserver; |
|
49 |
} |
|
50 |
||
51 |
||
52 |
EXPORT_C CMMAPlayer::CMMAPlayer(): |
|
53 |
iRepeatNumberOfTimes(0), |
|
54 |
iRepeatForever(EFalse), |
|
55 |
iRepeatCount(0), |
|
56 |
iDuration(KTimeUnknown), |
|
57 |
iState(EUnrealized), |
|
58 |
isPausedByCall(EFalse) |
|
59 |
{ |
|
60 |
} |
|
61 |
||
62 |
||
63 |
void CMMAPlayer::ConstructL() |
|
64 |
{ |
|
65 |
DEBUG("MMA::CMMAPlayer::ConstructL + "); |
|
66 |
iDurationUpdater = CMMADurationUpdater::NewL(*this); |
|
67 |
// Listen to call state changes |
|
68 |
iStateObserver = CMMACallStateMonitor::NewL(KPSUidCtsyCallInformation, |
|
69 |
KCTsyCallState,this); |
|
70 |
||
71 |
DEBUG("MMA::CMMAPlayer::ConstructL - "); |
|
72 |
} |
|
73 |
||
74 |
||
75 |
void CMMAPlayer::StaticAddSourceStreamL(JNIEnv* aJniEnv, |
|
76 |
CMMAPlayer* aPlayer, |
|
77 |
CMMAEventSource* aEventSource, |
|
78 |
jobject aReader, |
|
79 |
CMMASourceStream** aSourceStream) |
|
80 |
{ |
|
81 |
DEBUG("MMA::CMMAPlayer::StaticAddSourceStreamL +"); |
|
82 |
||
83 |
// JNI interface pointer can't be passed to different thread, so |
|
84 |
// it is needed to get valid JNI interface pointer for Event Server thread |
|
85 |
aJniEnv = JniEnvWrapper::GetValidJniRef(); |
|
86 |
||
87 |
*aSourceStream = aPlayer->AddSourceStreamL(aJniEnv, |
|
88 |
aEventSource, |
|
89 |
aReader); |
|
90 |
DEBUG("MMA::CMMAPlayer::StaticAddSourceStreamL -"); |
|
91 |
} |
|
92 |
||
93 |
||
94 |
||
95 |
void CMMAPlayer::StaticSetPlayerListenerObjectL(CMMAPlayer* aPlayer, |
|
96 |
jobject aListenerObject, |
|
97 |
JNIEnv* aJni, |
|
98 |
MMMAEventPoster* aPoster) |
|
99 |
{ |
|
100 |
||
101 |
DEBUG("MMA::CMMAPlayer::StaticSetPlayerListenerObjectL +"); |
|
102 |
||
103 |
// JNI interface pointer can't be passed to different thread, so |
|
104 |
// it is needed to get valid JNI interface pointer for Event Server thread |
|
105 |
aJni = JniEnvWrapper::GetValidJniRef(); |
|
106 |
||
107 |
aPlayer->SetPlayerListenerObjectL(aListenerObject, aJni, aPoster); |
|
108 |
||
109 |
DEBUG("MMA::CMMAPlayer::StaticSetPlayerListenerObjectL -"); |
|
110 |
} |
|
111 |
||
112 |
||
113 |
void CMMAPlayer::StaticInitPlayerL(CMMAPlayer* aPlayer, |
|
114 |
jobject aPlayerObject, |
|
115 |
JNIEnv* aJni) |
|
116 |
{ |
|
117 |
DEBUG("MMA::CMMAPlayer::StaticInitPlayerL +"); |
|
118 |
||
119 |
// JNI interface pointer can't be passed to different thread, so |
|
120 |
// it is needed to get valid JNI interface pointer for Event Server thread |
|
121 |
aJni = JniEnvWrapper::GetValidJniRef(); |
|
122 |
||
123 |
jmethodID actionCompletedMethod = aJni->GetMethodID( |
|
124 |
aJni->GetObjectClass(aPlayerObject), |
|
125 |
"actionCompleted", |
|
126 |
"(I)V"); |
|
127 |
||
128 |
// Sanity Check, something is really wrong if methods cannot be found |
|
129 |
__ASSERT_DEBUG(actionCompletedMethod, |
|
130 |
User::Panic(KPanicMethod, KErrGeneral)); |
|
131 |
||
132 |
aPlayer->iActionCompletedEvent = new(ELeave) CMMAEvent( |
|
133 |
aPlayerObject, |
|
134 |
actionCompletedMethod, |
|
135 |
CMMAEvent::EReusableEvent); |
|
136 |
||
137 |
DEBUG("MMA::CMMAPlayer::StaticInitPlayerL -"); |
|
138 |
} |
|
139 |
||
140 |
CMMAControl* CMMAPlayer::StaticControl(CMMAPlayer* aPlayer, TInt aIndex) |
|
141 |
{ |
|
142 |
DEBUG("MMA::CMMAPlayer::StaticControl +"); |
|
143 |
return aPlayer->Control(aIndex); |
|
144 |
||
145 |
} |
|
146 |
||
147 |
||
148 |
void CMMAPlayer::RealizeL() |
|
149 |
{ |
|
150 |
DEBUG("MMA::CMMAPlayer::RealizeL +"); |
|
151 |
ChangeState(ERealized); |
|
152 |
||
153 |
} |
|
154 |
||
155 |
||
156 |
EXPORT_C void CMMAPlayer::CloseL() |
|
157 |
{ |
|
158 |
DEBUG("MMA::CMMAPlayer::CloseL "); |
|
159 |
PostObjectEvent(CMMAPlayerEvent::EClosed, NULL); |
|
160 |
||
161 |
ChangeState(EClosed); |
|
162 |
} |
|
163 |
||
164 |
||
165 |
EXPORT_C void CMMAPlayer::GetDuration(TInt64* aDuration) |
|
166 |
{ |
|
167 |
DEBUG("MMA::CMMAPlayer::GetDuration "); |
|
168 |
*aDuration = iDuration; |
|
169 |
} |
|
170 |
||
171 |
||
172 |
void CMMAPlayer::SetMediaTimeL(TInt64* aTime) |
|
173 |
{ |
|
174 |
DEBUG("MMA::CMMAPlayer::SetMediaTimeL "); |
|
175 |
*aTime = KErrNotSupported; |
|
176 |
} |
|
177 |
||
178 |
void CMMAPlayer::GetMediaTime(TInt64* aMediaTime) |
|
179 |
{ |
|
180 |
DEBUG("MMA::CMMAPlayer::GetMediaTime "); |
|
181 |
*aMediaTime = KErrNotSupported; |
|
182 |
} |
|
183 |
||
184 |
||
185 |
EXPORT_C void CMMAPlayer::SetLoopCount(TInt aCount) |
|
186 |
{ |
|
187 |
DEBUG("MMA::CMMAPlayer::SetLoopCount "); |
|
188 |
iRepeatForever = (aCount == KJavaRepeatForever); |
|
189 |
iRepeatNumberOfTimes = aCount; |
|
190 |
iRepeatCount = 0; |
|
191 |
} |
|
192 |
||
193 |
HBufC* CMMAPlayer::ContentType() const |
|
194 |
{ |
|
195 |
DEBUG("MMA::CMMAPlayer::ContentType "); |
|
196 |
return iContentType; |
|
197 |
} |
|
198 |
||
199 |
EXPORT_C void CMMAPlayer::SetPlayerListenerObjectL(jobject aListenerObject, |
|
200 |
JNIEnv* aJni, |
|
201 |
MMMAEventPoster* aEventPoster) |
|
202 |
{ |
|
203 |
DEBUG("MMA::CMMAPlayer::SetPlayerListenerObjectL +"); |
|
204 |
iListenerObject = aListenerObject; |
|
205 |
iEventPoster = aEventPoster; |
|
206 |
||
207 |
jclass listenerClass = aJni->GetObjectClass(aListenerObject); |
|
208 |
||
209 |
iPostEvent = aJni->GetMethodID( |
|
210 |
listenerClass, |
|
211 |
"postEvent", |
|
212 |
"(Ljava/lang/String;Ljava/lang/Object;)V"); |
|
213 |
||
214 |
iPostObjectEvent = aJni->GetMethodID(listenerClass, |
|
215 |
"postObjectEvent", |
|
216 |
"(ILjava/lang/Object;)V"); |
|
217 |
||
218 |
iPostLongEvent = aJni->GetMethodID(listenerClass, |
|
219 |
"postLongEvent", |
|
220 |
"(IJ)V"); |
|
221 |
||
222 |
iPostStringEvent = aJni->GetMethodID(listenerClass, |
|
223 |
"postStringEvent", |
|
224 |
"(ILjava/lang/String;)V"); |
|
225 |
||
226 |
iPostControlEvent = aJni->GetMethodID(listenerClass, |
|
227 |
"postControlEvent", |
|
228 |
"(ILjava/lang/String;)V"); |
|
229 |
||
230 |
||
231 |
// Sanity Check, something is really wrong if methods cannot be found |
|
232 |
__ASSERT_DEBUG(iPostEvent && |
|
233 |
iPostObjectEvent && |
|
234 |
iPostLongEvent && |
|
235 |
iPostStringEvent && |
|
236 |
iPostControlEvent, |
|
237 |
User::Panic(KPanicMethod, KErrGeneral)); |
|
238 |
||
239 |
iOOMErrorEvent = new(ELeave) CMMAPlayerEvent(iListenerObject, |
|
240 |
iPostStringEvent, |
|
241 |
CMMAEvent::EReusableEvent); |
|
242 |
iOOMErrorEvent->SetStringEventL(CMMAPlayerEvent::EError, |
|
243 |
KPanicOutOfMem); |
|
244 |
||
245 |
DEBUG("MMA::CMMAPlayer::SetPlayerListenerObjectL -"); |
|
246 |
} |
|
247 |
||
248 |
||
249 |
EXPORT_C TInt CMMAPlayer::ControlCount() |
|
250 |
{ |
|
251 |
return iControls.Count(); |
|
252 |
} |
|
253 |
||
254 |
||
255 |
EXPORT_C CMMAControl* CMMAPlayer::Control(TInt aIndex) |
|
256 |
{ |
|
257 |
return iControls[ aIndex ]; |
|
258 |
} |
|
259 |
||
260 |
void CMMAPlayer::RefreshControls() |
|
261 |
{ |
|
262 |
||
263 |
for (TInt index = 0; index < iControls.Count(); index++) |
|
264 |
{ |
|
265 |
CMMAControl* control = iControls[ index ]; |
|
266 |
control->RefreshControl(); |
|
267 |
} |
|
268 |
||
269 |
} |
|
270 |
||
271 |
EXPORT_C void CMMAPlayer::AddStateListenerL(MMMAPlayerStateListener* aListener) |
|
272 |
{ |
|
273 |
||
274 |
User::LeaveIfError(iStateListeners.Append(aListener)); |
|
275 |
||
276 |
} |
|
277 |
||
278 |
EXPORT_C void CMMAPlayer::RemoveStateListener(MMMAPlayerStateListener* aListener) |
|
279 |
{ |
|
280 |
||
281 |
TInt index = iStateListeners.Find(aListener); |
|
282 |
||
283 |
if (index != KErrNotFound) |
|
284 |
{ |
|
285 |
iStateListeners.Remove(index); |
|
286 |
} |
|
287 |
||
288 |
} |
|
289 |
||
290 |
const TDesC& CMMAPlayer::Type() |
|
291 |
{ |
|
292 |
// by default player has not the type |
|
293 |
return KNullDesC; |
|
294 |
} |
|
295 |
||
296 |
void CMMAPlayer::SetContentType(HBufC* aContentType) |
|
297 |
{ |
|
298 |
||
299 |
delete iContentType; |
|
300 |
iContentType = aContentType; |
|
301 |
||
302 |
} |
|
303 |
||
304 |
void CMMAPlayer::ResetSourceStreams() |
|
305 |
{ |
|
306 |
DEBUG("MMA::CMMAPlayer::ResetSourceStreams +"); |
|
307 |
int sourceStreamsCount = iSourceStreams.Count(); |
|
308 |
for (int i = 0; i < sourceStreamsCount; i++) |
|
309 |
{ |
|
310 |
iSourceStreams[ i ]->ResetData(); |
|
311 |
} |
|
312 |
DEBUG("MMA::CMMAPlayer::ResetSourceStreams -"); |
|
313 |
} |
|
314 |
||
315 |
EXPORT_C void CMMAPlayer::AddControlL(CMMAControl* aControl) |
|
316 |
{ |
|
317 |
||
318 |
User::LeaveIfError(iControls.Append(aControl)); |
|
319 |
||
320 |
} |
|
321 |
||
322 |
void CMMAPlayer::PostLongEvent(CMMAPlayerEvent::TEventType aEventType, |
|
323 |
const TInt64& aLongEventData) |
|
324 |
{ |
|
325 |
DEBUG("MMA::CMMAPlayer::PostLongEvent "); |
|
326 |
if (!iListenerObject || !iEventPoster) |
|
327 |
{ |
|
328 |
DEBUG("MMA::CMMAPlayer::PostLongEvent No listener"); |
|
329 |
// return since player is not ready for posting any events and is not initialized |
|
330 |
return; |
|
331 |
} |
|
332 |
||
333 |
CMMAPlayerEvent* playerEvent = new CMMAPlayerEvent(iListenerObject, |
|
334 |
iPostLongEvent); |
|
335 |
if (!playerEvent) |
|
336 |
{ |
|
337 |
// creation of player event failed, informing Java |
|
338 |
iEventPoster->PostEvent(iOOMErrorEvent); |
|
339 |
return; |
|
340 |
} |
|
341 |
playerEvent->SetLongEvent(aEventType, aLongEventData); |
|
342 |
||
343 |
// event poster takes ownership of event |
|
344 |
iEventPoster->PostEvent(playerEvent); |
|
345 |
} |
|
346 |
||
347 |
||
348 |
EXPORT_C void CMMAPlayer::PostStringEvent(CMMAPlayerEvent::TEventType aEventType, |
|
349 |
const TDesC& aStringEventData) |
|
350 |
{ |
|
351 |
DEBUG("MMA::CMMAPlayer::PostStringEvent "); |
|
352 |
if (!iListenerObject || !iEventPoster) |
|
353 |
{ |
|
354 |
DEBUG("MMA::CMMAPlayer::PostStringEvent No listener"); |
|
355 |
// return since player is not ready for posting any events and is not initialized |
|
356 |
return; |
|
357 |
} |
|
358 |
||
359 |
CMMAPlayerEvent* playerEvent = new CMMAPlayerEvent(iListenerObject, |
|
360 |
iPostStringEvent); |
|
361 |
if (!playerEvent) |
|
362 |
{ |
|
363 |
// creation of player event failed, informing Java |
|
364 |
iEventPoster->PostEvent(iOOMErrorEvent); |
|
365 |
return; |
|
366 |
} |
|
367 |
||
368 |
TRAPD(err, playerEvent->SetStringEventL(aEventType, aStringEventData)); |
|
369 |
if (err != KErrNone) |
|
370 |
{ |
|
371 |
// string setting failed, informing Java |
|
372 |
iEventPoster->PostEvent(iOOMErrorEvent); |
|
373 |
return; |
|
374 |
} |
|
375 |
||
376 |
// event poster takes ownership of event |
|
377 |
iEventPoster->PostEvent(playerEvent); |
|
378 |
} |
|
379 |
||
380 |
||
381 |
EXPORT_C void CMMAPlayer::PostObjectEvent(CMMAPlayerEvent::TEventType aEventType, |
|
382 |
const jobject aEventData) |
|
383 |
{ |
|
384 |
DEBUG("MMA::CMMAPlayer::PostObjectEvent "); |
|
385 |
||
386 |
if (!iListenerObject || !iEventPoster) |
|
387 |
{ |
|
388 |
DEBUG("MMA::CMMAPlayer::PostObjectEvent No listener"); |
|
389 |
// return since player is not ready for posting any events and is not initialized |
|
390 |
return; |
|
391 |
} |
|
392 |
||
393 |
CMMAPlayerEvent* playerEvent = new CMMAPlayerEvent(iListenerObject, |
|
394 |
iPostObjectEvent); |
|
395 |
||
396 |
if (!playerEvent) |
|
397 |
{ |
|
398 |
// creation of player event failed, informing Java |
|
399 |
iEventPoster->PostEvent(iOOMErrorEvent); |
|
400 |
return; |
|
401 |
} |
|
402 |
||
403 |
TRAPD(err, playerEvent->SetObjectEventL(aEventType, aEventData)); |
|
404 |
if (err != KErrNone) |
|
405 |
{ |
|
406 |
// creation of player event failed, informing Java |
|
407 |
iEventPoster->PostEvent(iOOMErrorEvent); |
|
408 |
return; |
|
409 |
} |
|
410 |
||
411 |
// event poster takes ownership of event |
|
412 |
iEventPoster->PostEvent(playerEvent); |
|
413 |
} |
|
414 |
||
415 |
EXPORT_C CMMASourceStream* CMMAPlayer::AddSourceStreamL(JNIEnv* aJNIEnv, |
|
416 |
CMMAEventSource* aEventSource, |
|
417 |
jobject aReader) |
|
418 |
{ |
|
419 |
DEBUG("MMA::CMMAPlayer::AddSourceStreamL "); |
|
420 |
CMMASourceStream* sourceStream = CMMASourceStream::NewL(aJNIEnv, |
|
421 |
aEventSource, |
|
422 |
aReader, |
|
423 |
this); |
|
424 |
||
425 |
CleanupStack::PushL(sourceStream); |
|
426 |
User::LeaveIfError(iSourceStreams.Append(sourceStream)); |
|
427 |
CleanupStack::Pop(); // sourceStream |
|
428 |
return sourceStream; |
|
429 |
} |
|
430 |
||
431 |
||
432 |
EXPORT_C void CMMAPlayer::PostActionCompleted(TInt aError) |
|
433 |
{ |
|
434 |
iActionCompletedEvent->SetEventData(aError); |
|
435 |
iEventPoster->PostEvent(iActionCompletedEvent, |
|
436 |
CMMAEvent::ENotifyPriority); |
|
437 |
} |
|
438 |
||
439 |
||
440 |
EXPORT_C void CMMAPlayer::ChangeState(TPlayerState aState) |
|
441 |
{ |
|
442 |
iState = aState; |
|
443 |
DEBUG_INT("MMA::CMMAPlayer::ChangeState - iStateListeners count is %d", iStateListeners.Count()); |
|
444 |
for (TInt i(0); i<iStateListeners.Count(); i++) |
|
445 |
{ |
|
446 |
iStateListeners[ i ]->StateChanged(aState); |
|
447 |
} |
|
448 |
DEBUG_INT("MMA::CMMAPlayer::ChangeState - State changed to %d", iState); |
|
449 |
} |
|
450 |
||
451 |
void CMMAPlayer::ReadCompletedL(TInt /*aStatus*/, const TDesC8& /*aData*/) |
|
452 |
{ |
|
453 |
// empty implementation |
|
454 |
DEBUG("MMA::CMMAPlayer::ReadCompletedL "); |
|
455 |
} |
|
456 |
void CMMAPlayer:: DeleteControls() |
|
457 |
{ |
|
458 |
if (iControls.Count() > 0) |
|
459 |
{ |
|
460 |
iControls.ResetAndDestroy(); |
|
461 |
} |
|
462 |
} |
|
463 |
||
464 |
||
71
d5e927d5853b
Revision: v2.2.11
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
66
diff
changeset
|
465 |
EXPORT_C void CMMAPlayer::HandleCallStateEventL(TUid aUid, TInt aKey) |
66 | 466 |
{ |
71
d5e927d5853b
Revision: v2.2.11
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
66
diff
changeset
|
467 |
(void)aUid; // Suppress warnings about unused arguments in urel builds |
d5e927d5853b
Revision: v2.2.11
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
66
diff
changeset
|
468 |
(void)aKey; |
d5e927d5853b
Revision: v2.2.11
Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
parents:
66
diff
changeset
|
469 |
|
66 | 470 |
DEBUG("CMMAPlayer::HandleCallStateEvent +"); |
471 |
DEBUG_INT2( "CMMAVideoUrlPlayer::HandleCallStateEvent(TUid aUid, TInt aKey) = (%d, %d)",aUid.iUid, aKey); |
|
472 |
||
473 |
TInt callState; |
|
474 |
iStateObserver->GetValue(callState); |
|
475 |
DEBUG_INT( "CMMAVideoUrlPlayer::HandleCallStateEvent: state = %d", callState); |
|
476 |
||
477 |
switch (callState) |
|
478 |
{ |
|
479 |
case EPSCTsyCallStateUninitialized: |
|
480 |
{ |
|
481 |
DEBUG_INT( "CMMAVideoUrlPlayer::HandlePSEvent EPSCTsyCallStateUninitialized istate = %d", iState); |
|
482 |
break; |
|
483 |
} |
|
484 |
||
485 |
case EPSCTsyCallStateAlerting: |
|
486 |
||
487 |
case EPSCTsyCallStateRinging: |
|
488 |
||
489 |
case EPSCTsyCallStateDialling: |
|
490 |
||
491 |
case EPSCTsyCallStateAnswering: |
|
492 |
||
493 |
case EPSCTsyCallStateConnected: |
|
494 |
{ |
|
495 |
DEBUG_INT( "CMMAVideoUrlPlayer::HandlePSEvent EPSCTsyCallStateConnected iState = %d", iState); |
|
496 |
if(iState == CMMAPlayer::EStarted) |
|
497 |
{ |
|
498 |
DEBUG( "CMMAVideoUrlPlayer::HandlePSEvent EPSCTsyCallStateConnected started state"); |
|
499 |
StopL(ETrue); |
|
500 |
isPausedByCall = ETrue; |
|
501 |
} |
|
502 |
break; |
|
503 |
} |
|
504 |
case EPSCTsyCallStateDisconnecting: |
|
505 |
{ |
|
506 |
DEBUG_INT( "CMMAVideoUrlPlayer::HandlePSEvent EPSCTsyCallStateDisconnecting istate = %d", iState); |
|
507 |
break; |
|
508 |
} |
|
509 |
case EPSCTsyCallStateNone: |
|
510 |
{ |
|
511 |
DEBUG_INT( "CMMAVideoUrlPlayer::HandlePSEvent EPSCTsyCallStateNone istate = %d", iState); |
|
512 |
if( (iState == CMMAPlayer::EPrefetched) && isPausedByCall ) |
|
513 |
{ |
|
514 |
DEBUG( "CMMAVideoUrlPlayer::HandlePSEvent EPSCTsyCallStateNone Prefetched state"); |
|
515 |
StartL(ETrue); |
|
516 |
isPausedByCall = EFalse; |
|
517 |
} |
|
518 |
break; |
|
519 |
} |
|
520 |
||
521 |
case EPSCTsyCallStateHold: |
|
522 |
{ |
|
523 |
DEBUG_INT( "CMMAVideoUrlPlayer::HandlePSEvent EPSCTsyCallStateHold iState = %d", iState); |
|
524 |
break; |
|
525 |
} |
|
526 |
default: |
|
527 |
{ |
|
528 |
DEBUG( "CMMAVideoUrlPlayer::HandlePSEvent default"); |
|
529 |
// Default is no pause |
|
530 |
break; |
|
531 |
} |
|
532 |
} |
|
533 |
} |
|
534 |
// END OF FILE |