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 

   465 void CMMAPlayer::HandleCallStateEventL(TUid aUid, TInt aKey)

   466 {

   467     DEBUG("CMMAPlayer::HandleCallStateEvent +");

   468     DEBUG_INT2( "CMMAVideoUrlPlayer::HandleCallStateEvent(TUid aUid, TInt aKey) = (%d, %d)",aUid.iUid, aKey);

   469 

   470     TInt callState;

   471     iStateObserver->GetValue(callState);

   472     DEBUG_INT( "CMMAVideoUrlPlayer::HandleCallStateEvent: state = %d", callState);

   473 

   474     switch (callState)

   475     {

   476     case EPSCTsyCallStateUninitialized:

   477     {

   478         DEBUG_INT( "CMMAVideoUrlPlayer::HandlePSEvent EPSCTsyCallStateUninitialized istate = %d", iState);

   479         break;

   480     }

   481 

   482     case EPSCTsyCallStateAlerting:

   483 

   484     case EPSCTsyCallStateRinging:

   485 

   486     case EPSCTsyCallStateDialling:

   487  

   488     case EPSCTsyCallStateAnswering:

   489 

   490     case EPSCTsyCallStateConnected:

   491     {

   492         DEBUG_INT( "CMMAVideoUrlPlayer::HandlePSEvent EPSCTsyCallStateConnected iState = %d", iState);

   493         if(iState == CMMAPlayer::EStarted)

   494         {

   495             DEBUG(  "CMMAVideoUrlPlayer::HandlePSEvent EPSCTsyCallStateConnected started state");

   496             StopL(ETrue);

   497             isPausedByCall = ETrue;

   498         }

   499         break;

   500     }

   501     case EPSCTsyCallStateDisconnecting:

   502     {

   503       DEBUG_INT( "CMMAVideoUrlPlayer::HandlePSEvent EPSCTsyCallStateDisconnecting istate = %d", iState);

   504       break;

   505     }

   506     case EPSCTsyCallStateNone:

   507     {

   508         DEBUG_INT( "CMMAVideoUrlPlayer::HandlePSEvent EPSCTsyCallStateNone istate = %d", iState);

   509         if( (iState == CMMAPlayer::EPrefetched) && isPausedByCall )

   510         {

   511             DEBUG(  "CMMAVideoUrlPlayer::HandlePSEvent EPSCTsyCallStateNone Prefetched state");

   512             StartL(ETrue);

   513             isPausedByCall = EFalse;

   514         }

   515         break;

   516     }

   517 

   518     case EPSCTsyCallStateHold:

   519     {

   520         DEBUG_INT( "CMMAVideoUrlPlayer::HandlePSEvent EPSCTsyCallStateHold iState = %d", iState);

   521         break;

   522     }

   523     default:

   524     {

   525         DEBUG( "CMMAVideoUrlPlayer::HandlePSEvent default");

   526         // Default is no pause

   527         break;

   528     }

   529     }

   530 }

   531 //  END OF FILE