MCL/sf/app/videoplayer: comparison videoplayback/videoplaybackviews/src/mpxvideoplaybackuserinputhandler.cpp

equal deleted inserted replaced

-:112a725ff2c2
+:8970fbd719ec
 *
 * Description:  Implementation of playback view's input handler
 *
 */
-// Version : %version: ou1cpsw#16 %
+// Version : %version: 17 %
 // INCLUDE FILES
 #include <w32std.h> // RWindowBase
 #include <e32base.h>
 // -------------------------------------------------------------------------------------------------
 //
 CMPXVideoPlaybackUserInputHandler* CMPXVideoPlaybackUserInputHandler::NewL(
 CMPXVideoPlaybackContainer* aContainer )
 {
-MPX_DEBUG(_L("CMPXVideoPlaybackUserInputHandler::NewL()"));
+MPX_ENTER_EXIT(_L("CMPXVideoPlaybackUserInputHandler::NewL()"));
 CMPXVideoPlaybackUserInputHandler* self =
 new (ELeave) CMPXVideoPlaybackUserInputHandler( aContainer );
 CleanupStack::PushL( self );
 self->ConstructL();
 // CMPXVideoPlaybackUserInputHandler::~CMPXVideoPlaybackUserInputHandler()
 // -------------------------------------------------------------------------------------------------
 //
 CMPXVideoPlaybackUserInputHandler::~CMPXVideoPlaybackUserInputHandler()
 {
+MPX_ENTER_EXIT(_L("CMPXVideoPlaybackUserInputHandler::~CMPXVideoPlaybackUserInputHandler()"));
 if ( iVolumeRepeatTimer )
 {
 iVolumeRepeatTimer->Cancel();
 delete iVolumeRepeatTimer;
 }
 {
 delete iInterfaceSelector;
 iCoreTarget = NULL;
 iInterfaceSelector = NULL;
 }
 }
 // -------------------------------------------------------------------------------------------------
 // CMPXVideoPlaybackUserInputHandler::MrccatoPlay()
 // -------------------------------------------------------------------------------------------------
 {
 MPX_ENTER_EXIT(
 _L("CMPXVideoPlaybackUserInputHandler::MrccatoPlay"),
 _L("aButtonAct = %d"), aButtonAct );
-ProcessMediaKey(ERemConCoreApiPlay, aButtonAct);
+ProcessMediaKey( ERemConCoreApiPlay, aButtonAct );
 }
 // -------------------------------------------------------------------------------------------------
 // CMPXVideoPlaybackUserInputHandler::MrccatoCommand()
 // -------------------------------------------------------------------------------------------------
 //
-void CMPXVideoPlaybackUserInputHandler::MrccatoCommand(TRemConCoreApiOperationId aOperationId,
+void CMPXVideoPlaybackUserInputHandler::MrccatoCommand( TRemConCoreApiOperationId aOperationId,
 TRemConCoreApiButtonAction aButtonAct )
 {
-MPX_ENTER_EXIT(
+MPX_ENTER_EXIT(_L("CMPXVideoPlaybackUserInputHandler::MrccatoCommand"));
-_L("CMPXVideoPlaybackUserInputHandler::MrccatoCommand"),
-_L("aButtonAct = %d"), aButtonAct );
+ProcessMediaKey( aOperationId, aButtonAct );
-ProcessMediaKey(aOperationId, aButtonAct);
 }
 // -------------------------------------------------------------------------------------------------
 // CMPXVideoPlaybackUserInputHandler::DoHandleMediaKey()
 // -------------------------------------------------------------------------------------------------
 //
 void CMPXVideoPlaybackUserInputHandler::DoHandleMediaKey( TRemConCoreApiOperationId aOperationId,
 TRemConCoreApiButtonAction aButtonAct )
 {
-MPX_ENTER_EXIT(_L("CMPXVideoPlaybackUserInputHandler::DoHandleMediaKey()"));
+MPX_ENTER_EXIT(_L("CMPXVideoPlaybackUserInputHandler::DoHandleMediaKey()"),
+_L("aOperationId = %d"), aOperationId );
 switch ( aOperationId )
 {
 case ERemConCoreApiStop:
 {
 }
 break;
 }
 case ERemConCoreApiRewind:
 {
-HandleRewind(aButtonAct);
+HandleRewind( aButtonAct );
 break;
 }
 case ERemConCoreApiFastForward:
 {
-HandleFastForward(aButtonAct);
+HandleFastForward( aButtonAct );
 break;
 }
 case ERemConCoreApiVolumeUp:
 {
-HandleVolumeUp(aButtonAct);
+HandleVolumeUp( aButtonAct );
 break;
 }
 case ERemConCoreApiVolumeDown:
 {
-HandleVolumeDown(aButtonAct);
+HandleVolumeDown( aButtonAct );
 break;
 }
 case ERemConCoreApiPausePlayFunction:
 {
 if ( aButtonAct == ERemConCoreApiButtonClick )
 {
-TRAP_IGNORE(iContainer->HandleCommandL(EMPXPbvCmdPlayPause));
+TRAP_IGNORE(iContainer->HandleCommandL( EMPXPbvCmdPlayPause ));
 }
 break;
 }
 case ERemConCoreApiPause:
 {
-TRAP_IGNORE(iContainer->HandleCommandL(EMPXPbvCmdPause));
+TRAP_IGNORE( iContainer->HandleCommandL(EMPXPbvCmdPause) );
 break;
 }
 case ERemConCoreApiPlay:
 {
 if ( aButtonAct == ERemConCoreApiButtonClick )
 {
-TRAP_IGNORE(iContainer->HandleCommandL(EMPXPbvCmdPlay));
+TRAP_IGNORE( iContainer->HandleCommandL( EMPXPbvCmdPlay ) );
 }
 break;
 }
-default:
-break;
 }
 }
 // -------------------------------------------------------------------------------------------------
 // CMPXVideoPlaybackUserInputHandler::HandleFastForward()
 // -------------------------------------------------------------------------------------------------
 //
-void CMPXVideoPlaybackUserInputHandler::HandleFastForward(TRemConCoreApiButtonAction aButtonAct)
+void CMPXVideoPlaybackUserInputHandler::HandleFastForward( TRemConCoreApiButtonAction aButtonAct )
 {
-if (aButtonAct == ERemConCoreApiButtonPress)
+MPX_ENTER_EXIT(_L("CMPXVideoPlaybackUserInputHandler::HandleFastForward()"));
-{
-TRAP_IGNORE(iContainer->HandleCommandL(EMPXPbvCmdSeekForward));
+if ( aButtonAct == ERemConCoreApiButtonPress )
-}
+{
-else if (aButtonAct == ERemConCoreApiButtonRelease)
+TRAP_IGNORE( iContainer->HandleCommandL( EMPXPbvCmdSeekForward ) );
-{
+}
-TRAP_IGNORE(iContainer->HandleCommandL(EMPXPbvCmdEndSeek));
+else if ( aButtonAct == ERemConCoreApiButtonRelease )
+{
+TRAP_IGNORE( iContainer->HandleCommandL( EMPXPbvCmdEndSeek ) );
 }
 }
 // -------------------------------------------------------------------------------------------------
 // CMPXVideoPlaybackUserInputHandler::HandleRewind()
 // -------------------------------------------------------------------------------------------------
 //
-void CMPXVideoPlaybackUserInputHandler::HandleRewind(TRemConCoreApiButtonAction aButtonAct)
+void CMPXVideoPlaybackUserInputHandler::HandleRewind( TRemConCoreApiButtonAction aButtonAct )
 {
-if (aButtonAct == ERemConCoreApiButtonPress)
+MPX_ENTER_EXIT(_L("CMPXVideoPlaybackUserInputHandler::HandleFastForward()"));
-{
-TRAP_IGNORE(iContainer->HandleCommandL(EMPXPbvCmdSeekBackward));
+if ( aButtonAct == ERemConCoreApiButtonPress )
-}
+{
-else if (aButtonAct == ERemConCoreApiButtonRelease)
+TRAP_IGNORE( iContainer->HandleCommandL( EMPXPbvCmdSeekBackward ) );
-{
+}
-TRAP_IGNORE(iContainer->HandleCommandL(EMPXPbvCmdEndSeek));
+else if ( aButtonAct == ERemConCoreApiButtonRelease )
+{
+TRAP_IGNORE( iContainer->HandleCommandL( EMPXPbvCmdEndSeek ) );
 }
 }
 // -------------------------------------------------------------------------------------------------
 // CMPXVideoPlaybackUserInputHandler::HandleVolumeUp()
 // -------------------------------------------------------------------------------------------------
 //
-void CMPXVideoPlaybackUserInputHandler::HandleVolumeUp(TRemConCoreApiButtonAction aButtonAct)
+void CMPXVideoPlaybackUserInputHandler::HandleVolumeUp( TRemConCoreApiButtonAction aButtonAct )
 {
+MPX_ENTER_EXIT(_L("CMPXVideoPlaybackUserInputHandler::HandleVolumeUp()"),
+_L("aButtonAct = %d"), aButtonAct );
 switch ( aButtonAct )
 {
 case ERemConCoreApiButtonPress:
 {
 // Volume Up - Pressed
 {
 iVolumeRepeatTimer->Cancel();
 }
 iVolumeRepeatUp = ETrue;
 iVolumeRepeatTimer->Start(
 KAknStandardKeyboardRepeatRate,
 KAknStandardKeyboardRepeatRate,
 TCallBack(
 CMPXVideoPlaybackUserInputHandler::HandleVolumeRepeatTimeoutL,
 // -------------------------------------------------------------------------------------------------
 // CMPXVideoPlaybackUserInputHandler::HandleVolumeDown()
 // -------------------------------------------------------------------------------------------------
 //
-void CMPXVideoPlaybackUserInputHandler::HandleVolumeDown(TRemConCoreApiButtonAction aButtonAct)
+void CMPXVideoPlaybackUserInputHandler::HandleVolumeDown( TRemConCoreApiButtonAction aButtonAct )
 {
+MPX_ENTER_EXIT(_L("CMPXVideoPlaybackUserInputHandler::HandleVolumeDown()"));
 switch ( aButtonAct )
 {
 case ERemConCoreApiButtonPress:
 {
 // Volume Up - Pressed
 {
 iVolumeRepeatTimer->Cancel();
 }
 iVolumeRepeatUp = EFalse;
 iVolumeRepeatTimer->Start(
 KAknStandardKeyboardRepeatRate,
 KAknStandardKeyboardRepeatRate,
 TCallBack(
 CMPXVideoPlaybackUserInputHandler::HandleVolumeRepeatTimeoutL,
 EXPORT_C void
 CMPXVideoPlaybackUserInputHandler::ProcessPointerEventL( CCoeControl* aControl,
 const TPointerEvent& aPointerEvent,
 TMPXVideoControlType aMPXControl )
 {
-MPX_DEBUG(_L("CMPXVideoPlaybackUserInputHandler::ProcessPointerEvent"));
+MPX_ENTER_EXIT(_L("CMPXVideoPlaybackUserInputHandler::ProcessPointerEvent()"));
-switch (iProcessingInputType)
+switch ( iProcessingInputType )
 {
 case EMpxVideoNone:
 {
-if (aPointerEvent.iType == TPointerEvent::EButton1Down && iForeground)
+if ( aPointerEvent.iType == TPointerEvent::EButton1Down && iForeground )
 {
 iProcessingInputType = EMpxVideoTouch;
-ReRoutePointerEventL(aControl, aPointerEvent, aMPXControl);
+ReRoutePointerEventL( aControl, aPointerEvent, aMPXControl );
 }
 break;
 }
 case EMpxVideoTouch:
 {
-if (aPointerEvent.iType != TPointerEvent::EButton1Down)
+if ( aPointerEvent.iType != TPointerEvent::EButton1Down )
 {
-ReRoutePointerEventL(aControl, aPointerEvent, aMPXControl);
+ReRoutePointerEventL( aControl, aPointerEvent, aMPXControl );
 // reset the value only on pointer up event - but not on drag
 if ( aPointerEvent.iType == TPointerEvent::EButton1Up )
 {
 iProcessingInputType = EMpxVideoNone;
 }
 }
 break;
 }
-default:
-{
-// user input is disallowed
-break;
-}
 } // switch
 }
 // -------------------------------------------------------------------------------------------------
 // -------------------------------------------------------------------------------------------------
 //
 void CMPXVideoPlaybackUserInputHandler::ProcessKeyEventL( const TKeyEvent& aKeyEvent,
 TEventCode aType )
 {
-MPX_DEBUG(_L("MPXVideoPlaybackUserInputHandler::ProcessKeyEvent"));
+MPX_ENTER_EXIT(_L("MPXVideoPlaybackUserInputHandler::ProcessKeyEvent()"));
-switch (iProcessingInputType)
+switch ( iProcessingInputType )
 {
 case EMpxVideoNone:
 {
-if (aType == EEventKeyDown && iForeground)
+if ( aType == EEventKeyDown && iForeground )
 {
 iProcessingInputType = EMpxVideoKeyboard;
 iLastPressedKeyCode = aKeyEvent.iCode;
 iLastPressedKeyScanCode = aKeyEvent.iScanCode;
 }
 break;
 }
 case EMpxVideoKeyboard:
 {
-if (aType == EEventKeyUp)
+if ( aType == EEventKeyUp )
 {
 // only handle up event for the key being handled
 // ignore spurious key presses
-if (aKeyEvent.iCode == iLastPressedKeyCode  &&
+if ( aKeyEvent.iCode == iLastPressedKeyCode  &&
-aKeyEvent.iScanCode == iLastPressedKeyScanCode)
+aKeyEvent.iScanCode == iLastPressedKeyScanCode )
 {
 iContainer->DoHandleKeyEventL(aKeyEvent, aType);
 // reset the value only on key up event
 iProcessingInputType = EMpxVideoNone;
 }
 }
 break;
 }
-default:
-{
-// user input is disallowed
-break;
-}
 } // switch
 }
 // -------------------------------------------------------------------------------------------------
 // CMPXVideoPlaybackUserInputHandler::ProcessMediaKey()
 // -------------------------------------------------------------------------------------------------
 //
 void CMPXVideoPlaybackUserInputHandler::ProcessMediaKey( TRemConCoreApiOperationId aOperationId,
 TRemConCoreApiButtonAction aButtonAct )
 {
-MPX_DEBUG(_L("CMPXVideoPlaybackUserInputHandler::ProcessMediaKey"));
+MPX_ENTER_EXIT(_L("CMPXVideoPlaybackUserInputHandler::ProcessMediaKey()"),
+_L("iProcessingInputType = %d, aButtonAct = %d"),
+iProcessingInputType, aButtonAct );
 switch ( iProcessingInputType )
 {
 case EMpxVideoNone:
 {
-if ( aButtonAct == ERemConCoreApiButtonPress && iForeground )
+if ( iForeground )
 {
-iProcessingInputType = EMpxVideoMediaKeys;
+if ( aButtonAct == ERemConCoreApiButtonPress )
-iLastMediaKeyPressed = aOperationId;
-DoHandleMediaKey(aOperationId, aButtonAct);
-}
-else if (aButtonAct == ERemConCoreApiButtonClick && iForeground)
-{
-DoHandleMediaKey(aOperationId, aButtonAct);
-// reset on click AND/OR release
-iProcessingInputType = EMpxVideoNone;
-}
-break;
-}
-case EMpxVideoMediaKeys:
-{
-if (aButtonAct == ERemConCoreApiButtonRelease)
-{
-// handle only if this release is for media-key being currently handled
-// ignore spurious media key presses
-if (iLastMediaKeyPressed == aOperationId)
 {
-DoHandleMediaKey(aOperationId, aButtonAct);
+iProcessingInputType = EMpxVideoMediaKeys;
+iLastMediaKeyPressed = aOperationId;
+DoHandleMediaKey( aOperationId, aButtonAct );
+}
+else if ( aButtonAct == ERemConCoreApiButtonClick )
+{
+DoHandleMediaKey( aOperationId, aButtonAct );
 // reset on click AND/OR release
 iProcessingInputType = EMpxVideoNone;
 }
 }
 break;
 }
-default:
+case EMpxVideoMediaKeys:
 {
-// user input is disallowed
+if ( aButtonAct == ERemConCoreApiButtonRelease )
+{
+//
+//  Handle only if this release is for media-key being currently handled
+//  Ignore spurious media key presses
+//
+if ( iLastMediaKeyPressed == aOperationId )
+{
+DoHandleMediaKey( aOperationId, aButtonAct );
+iProcessingInputType = EMpxVideoNone;
+}
+}
 break;
 }
 } // switch
 }
 // -------------------------------------------------------------------------------------------------
 //   CMPXVideoPlaybackUserInputHandler::HandleVolumeRepeatTimeoutL()
 // -------------------------------------------------------------------------------------------------
 //
 TInt CMPXVideoPlaybackUserInputHandler::HandleVolumeRepeatTimeoutL( TAny* aPtr )
 //   CMPXVideoPlaybackUserInputHandler::HandleVolumeRepeatL()
 // -------------------------------------------------------------------------------------------------
 //
 void CMPXVideoPlaybackUserInputHandler::HandleVolumeRepeatL()
 {
-MPX_DEBUG(_L("CMPXVideoPlaybackUserInputHandler::HandleVolumeRepeatL()"));
+MPX_ENTER_EXIT(_L("CMPXVideoPlaybackUserInputHandler::HandleVolumeRepeatL()"));
 TMPXVideoPlaybackViewCommandIds command = EMPXPbvCmdDecreaseVolume;
 if ( iVolumeRepeatUp )
 {
 // -------------------------------------------------------------------------------------------------
 //   CMPXVideoPlaybackUserInputHandler::ReRoutePointerEventL()
 // -------------------------------------------------------------------------------------------------
 //
-void CMPXVideoPlaybackUserInputHandler::ReRoutePointerEventL(CCoeControl* aControl,
+void CMPXVideoPlaybackUserInputHandler::ReRoutePointerEventL( CCoeControl* aControl,
 const TPointerEvent& aPointerEvent,
-TMPXVideoControlType aMPXControl)
+TMPXVideoControlType aMPXControl )
 {
-MPX_DEBUG(_L("CMPXVideoPlaybackUserInputHandler::ReRoutePointerEventL()"));
+MPX_ENTER_EXIT(_L("CMPXVideoPlaybackUserInputHandler::ReRoutePointerEventL()"));
 if ( aMPXControl == EMpxVideoPlaybackContainer )
 {
 iContainer->DoHandlePointerEventL(aPointerEvent);
 }
 // -------------------------------------------------------------------------------------------------
 //   CMPXVideoPlaybackUserInputHandler::SetForeground()
 // -------------------------------------------------------------------------------------------------
 //
-void CMPXVideoPlaybackUserInputHandler::SetForeground(TBool aForeground)
+void CMPXVideoPlaybackUserInputHandler::SetForeground( TBool aForeground )
 {
+MPX_ENTER_EXIT(_L("CMPXVideoPlaybackUserInputHandler::SetForeground()"),
+_L("aForeground = %d"), aForeground );
 iForeground = aForeground;
-if ( !iForeground )
+if ( ! iForeground )
 {
-// we are in background so reset iProcessingInputType value
+//
+//  Keyboard focus has been lost
+//  Reset input type and clear volume timer if necessary
+//
 iProcessingInputType = EMpxVideoNone;
+if ( iVolumeRepeatTimer->IsActive() )
+{
+iVolumeRepeatTimer->Cancel();
+}
 }
 }
 // EOF

branch	RCL_3
changeset 11	8970fbd719ec
parent 9	5294c000a26d
child 12	7f2b2a65da29