--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/hwrmhaptics/examples/hapticstestapp/src/hapticstestappui.cpp Fri Oct 08 14:33:25 2010 +0300
@@ -0,0 +1,3369 @@
+/*
+* Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies).
+* All rights reserved.
+* This component and the accompanying materials are made available
+* under the terms of the License "Symbian Foundation License v1.0"
+* which accompanies this distribution, and is available
+* at the URL "http://www.symbianfoundation.org/legal/sfl-v10.html".
+*
+* Initial Contributors:
+* Nokia Corporation - initial contribution.
+*
+* Contributors:
+*
+* Description: AppUi class implementation.
+*
+*/
+
+
+#include <avkon.hrh>
+#include <e32math.h>
+#include <eikmenup.h>
+#include <aknlistquerydialog.h>
+#include <hapticstest.rsg>
+#include <utf.h>
+
+#include "hapticstest.pan"
+#include "hapticstestappui.h"
+#include "hapticstestappview.h"
+#include "hapticstesteffectdatahandler.h"
+#include "hapticstest.hrh"
+
+_LIT( KSessionPathMem, "C:\\Data\\Others\\" );
+_LIT( KSessionPathCrd, "E:\\Others\\" );
+_LIT( KIVTFileType, "*.ivt" );
+
+const TInt KSampleCount = 8;
+
+static const TUint8 KStreamArray[KSampleCount][10] =
+ {
+ 0x00, 0x00, 0x20, 0x13, 0x00, 0x00, 0x7f, 0x01, 0x5d, 0x41,
+ 0x29, 0x00, 0x20, 0x08, 0x00, 0x00, 0x7f, 0xc1, 0x4d, 0x42,
+ 0x51, 0x00, 0x20, 0x08, 0x00, 0x00, 0x7f, 0x01, 0x5d, 0xc1,
+ 0x65, 0x00, 0x20, 0x07, 0x00, 0x00, 0x7f, 0x01, 0x5d, 0xd1,
+ 0x7a, 0x00, 0x20, 0x08, 0x00, 0x00, 0x7f, 0xc1, 0x4d, 0x42,
+ 0x8e, 0x00, 0x20, 0x16, 0x00, 0x00, 0x7f, 0x01, 0x5d, 0x01,
+ 0xa2, 0x00, 0x20, 0x08, 0x00, 0x00, 0x7f, 0xc1, 0x4d, 0x42,
+ 0x06, 0x00, 0x20, 0x08, 0x00, 0x00, 0x7f, 0xc1, 0x4d, 0x42
+ };
+
+
+
+
+// ---------------------------------------------------------
+// ConstructL is called by the application framework
+// ---------------------------------------------------------
+//
+void CHapticsTestAppUi::ConstructL()
+ {
+ BaseConstructL();
+
+ // create appview
+ iAppView = CHapticsTestAppView::NewL( ClientRect() );
+ AddToStackL( iAppView );
+
+ // create effect data handler
+ iEffectData = CHapticsTestEffectDataHandler::NewL();
+
+ // create async play sender
+ iAsyncPlaySender = new ( ELeave ) CHapticsTestAsyncPlaySender( this );
+
+ FindIVTFiles();
+
+ iAppView->InsertOutput( _L("Haptics usage from options menu.") );
+ }
+
+// ---------------------------------------------------------
+// Constructor.
+// ---------------------------------------------------------
+//
+CHapticsTestAppUi::CHapticsTestAppUi()
+ : iSynchronous( ETrue ), iUseHandle( EFalse ), iUsesMemCard( EFalse )
+ {
+ // no implementation required
+ }
+
+// ---------------------------------------------------------
+// Destructor.
+// ---------------------------------------------------------
+//
+CHapticsTestAppUi::~CHapticsTestAppUi()
+ {
+ if (iAppView)
+ {
+ RemoveFromStack( iAppView );
+ delete iAppView;
+ iAppView = NULL;
+ }
+
+ if( iHaptics )
+ {
+ delete iHaptics;
+ iHaptics = NULL;
+ }
+
+ if ( iTempHaptics )
+ {
+ delete iTempHaptics;
+ iTempHaptics = NULL;
+ }
+
+ delete iEffectData;
+
+ iIVTFileArray.Close();
+
+ while ( iLoadedIVTFileArray.Count() )
+ {
+ delete iLoadedIVTFileArray[0].iDataBuffer;
+ iLoadedIVTFileArray.Remove( 0 );
+ }
+
+ iLoadedIVTFileArray.Close();
+
+ if ( iAsyncPlaySender )
+ {
+ iAsyncPlaySender->Cancel();
+ delete iAsyncPlaySender;
+ iAsyncPlaySender = NULL;
+ }
+ }
+
+// ---------------------------------------------------------
+// handle any menu commands
+// ---------------------------------------------------------
+//
+void CHapticsTestAppUi::HandleCommandL( TInt aCommand )
+ {
+ switch( aCommand )
+ {
+ case EEikCmdExit:
+ case EAknSoftkeyExit:
+ Exit();
+ break;
+
+ case EHapticsTestOpenHaptics:
+ {
+ OpenHapticsL();
+ }
+ break;
+
+ case EHapticsTestAutoInit:
+ {
+ // automatically create haptics instance, fetch supported
+ // actuators, and open Any-actuator
+ OpenHapticsL();
+ FetchSupportedActuators();
+ OpenActuator( EHWRMLogicalActuatorAny );
+ }
+ break;
+
+ case EHapticsTestSupportedActuators:
+ {
+ FetchSupportedActuators();
+ }
+ break;
+
+ case EHapticsTestOpenActuator:
+ case EHapticsTestOpenActuatorAny:
+ {
+ OpenActuator( EHWRMLogicalActuatorAny );
+ }
+ break;
+ case EHapticsTestOpenActuatorDevice:
+ {
+ OpenActuator( EHWRMLogicalActuatorDevice );
+ }
+ break;
+ case EHapticsTestOpenActuatorPrimaryDisplay:
+ {
+ OpenActuator( EHWRMLogicalActuatorPrimaryDisplay );
+ }
+ break;
+ case EHapticsTestOpenActuatorSecondaryDisplay:
+ {
+ OpenActuator( EHWRMLogicalActuatorSecondaryDisplay );
+ }
+ break;
+ case EHapticsTestOpenActuatorGame:
+ {
+ OpenActuator( EHWRMLogicalActuatorGame );
+ }
+ break;
+ case EHapticsTestOpenActuatorGameLeft:
+ {
+ OpenActuator( EHWRMLogicalActuatorGameLeft );
+ }
+ break;
+ case EHapticsTestOpenActuatorGameRight:
+ {
+ OpenActuator( EHWRMLogicalActuatorGameRight );
+ }
+ break;
+ case EHapticsTestOpenActuatorExternalVibra:
+ {
+ OpenActuator( EHWRMLogicalActuatorExternalVibra );
+ }
+ break;
+
+ case EHapticsTestLoadIVTFile:
+ case EHapticsTestLoadIVTFileNoneFound:
+ {
+ // nothing to do
+ }
+ break;
+ case EHapticsTestLoadIVTFileSelected:
+ {
+ // open selected file
+ TInt index = iMenuPane->SelectedItem();
+ LoadIVTDataL( iIVTFileArray[index] );
+ }
+ break;
+
+ case EHapticsTestPlayEffect:
+ case EHapticsTestPlayEffectNoneFound:
+ {
+ // nothing to do
+ }
+ break;
+ case EHapticsTestPlayEffectSelected:
+ {
+ // play selected effect
+ TInt index = CountFileHandleAndEffectIndex( iMenuPane->SelectedItem() );
+ PlayEffect( index );
+ PrintEffectInfo( index );
+ }
+ break;
+ case EHapticsTestPlayEffectRepeat:
+ case EHapticsTestPlayEffectRepeatNoneFound:
+ {
+ // nothing to do
+ }
+ break;
+ case EHapticsTestPlayEffectRepeatSelected:
+ {
+ // play selected effect repeatedly
+ TInt index = CountFileHandleAndEffectIndex( iMenuPane->SelectedItem() );
+ RepeatEffect( index, GetNumberOfRepeats() );
+ PrintEffectInfo( index );
+ }
+ break;
+
+ case EHapticsTestPlayEffectManual:
+ {
+ // nothing to do
+ }
+ break;
+ case EHapticsTestPlayEffectManualMagSweep:
+ {
+ PlayMagSweepL();
+ }
+ break;
+ case EHapticsTestPlayEffectManualMagSweepInf:
+ {
+ PlayMagSweepL( ETrue );
+ }
+ break;
+ case EHapticsTestPlayEffectManualMagSweepInfMod:
+ {
+ PlayMagSweepL( ETrue, ETrue );
+ }
+ break;
+ case EHapticsTestPlayEffectManualPeriodic:
+ {
+ PlayPeriodicL();
+ }
+ break;
+ case EHapticsTestPlayEffectManualPeriodicInf:
+ {
+ PlayPeriodicL( ETrue );
+ }
+ break;
+ case EHapticsTestPlayEffectManualPeriodicInfMod:
+ {
+ PlayPeriodicL( ETrue, ETrue );
+ }
+ break;
+ case EHapticsTestPlayEffectManualRepeat:
+ {
+ PlayRepeatL( GetNumberOfRepeats() );
+ }
+ break;
+
+ case EHapticsTestChangeState:
+ case EHapticsTestChangeStateNoneFound:
+ {
+ // nothing to do
+ }
+ break;
+
+ case EHapticsTestChangeStatePause:
+ {
+ // get itemindex and pause effect
+ TInt itemIndex = iMenuPane->SelectedItem();
+ PauseEffect( itemIndex );
+ }
+ break;
+
+ case EHapticsTestChangeStateResume:
+ {
+ // get itemindex and resume effect
+ TInt itemIndex = iMenuPane->SelectedItem();
+ ResumeEffect( itemIndex );
+ }
+ break;
+
+ case EHapticsTestChangeStateStop:
+ {
+ // get itemindex and stop effect
+ TInt itemIndex = iMenuPane->SelectedItem();
+ StopEffect( itemIndex );
+ }
+ break;
+
+ case EHapticsTestChangeStateStopAll:
+ {
+ TInt err = iHaptics->StopAllPlayingEffects();
+ if ( err )
+ {
+ TBuf<8> errBuf;
+ errBuf.AppendNum( err );
+ iAppView->InsertOutput( _L("Stopping all effects failed, err = "), EFalse );
+ iAppView->InsertOutput( errBuf );
+ }
+ else
+ {
+ iAppView->InsertOutput( _L("Stopping all effects succeeded.") );
+
+ // reset the auto-modification
+ iEffectData->ResetModifiableEffectTimer();
+ }
+ }
+ break;
+
+ case EHapticsTestModifyEffect:
+ {
+ // nothing to do
+ }
+ break;
+ case EHapticsTestModifyEffectDuration1:
+ {
+ iEffectData->SetDuration( KEffectDuration1 );
+ ModifyEffect();
+ }
+ break;
+ case EHapticsTestModifyEffectDuration5:
+ {
+ iEffectData->SetDuration( KEffectDuration5 );
+ ModifyEffect();
+ }
+ break;
+ case EHapticsTestModifyEffectDuration10:
+ {
+ iEffectData->SetDuration( KEffectDuration10 );
+ ModifyEffect();
+ }
+ break;
+ case EHapticsTestModifyEffectDuration30:
+ {
+ iEffectData->SetDuration( KEffectDuration30 );
+ ModifyEffect();
+ }
+ break;
+ case EHapticsTestModifyEffectDuration60:
+ {
+ iEffectData->SetDuration( KEffectDuration60 );
+ ModifyEffect();
+ }
+ break;
+ case EHapticsTestModifyEffectMagnitudeMin:
+ {
+ iEffectData->SetMagnitude( KHWRMHapticsMinMagnitude );
+ ModifyEffect();
+ }
+ break;
+ case EHapticsTestModifyEffectMagnitude25:
+ {
+ iEffectData->SetMagnitude( KEffectMagnitude25 );
+ ModifyEffect();
+ }
+ break;
+ case EHapticsTestModifyEffectMagnitude50:
+ {
+ iEffectData->SetMagnitude( KEffectMagnitude50 );
+ ModifyEffect();
+ }
+ break;
+ case EHapticsTestModifyEffectMagnitude75:
+ {
+ iEffectData->SetMagnitude( KEffectMagnitude75 );
+ ModifyEffect();
+ }
+ break;
+ case EHapticsTestModifyEffectMagnitudeMax:
+ {
+ iEffectData->SetMagnitude( KHWRMHapticsMaxMagnitude );
+ ModifyEffect();
+ }
+ break;
+ case EHapticsTestModifyEffectStyleSmooth:
+ {
+ iEffectData->SetStyle( CHWRMHaptics::EHWRMHapticsStyleSmooth );
+ ModifyEffect();
+ }
+ break;
+ case EHapticsTestModifyEffectStyleStrong:
+ {
+ iEffectData->SetStyle( CHWRMHaptics::EHWRMHapticsStyleStrong );
+ ModifyEffect();
+ }
+ break;
+ case EHapticsTestModifyEffectStyleSharp:
+ {
+ iEffectData->SetStyle( CHWRMHaptics::EHWRMHapticsStyleSharp );
+ ModifyEffect();
+ }
+ break;
+ case EHapticsTestModifyEffectAttackMin:
+ {
+ iEffectData->SetAttackLevel( KHWRMHapticsMinMagnitude );
+ ModifyEffect();
+ }
+ break;
+ case EHapticsTestModifyEffectAttack25:
+ {
+ iEffectData->SetAttackLevel( KEffectMagnitude25 );
+ ModifyEffect();
+ }
+ break;
+ case EHapticsTestModifyEffectAttack50:
+ {
+ iEffectData->SetAttackLevel( KEffectMagnitude50 );
+ ModifyEffect();
+ }
+ break;
+ case EHapticsTestModifyEffectAttack75:
+ {
+ iEffectData->SetAttackLevel( KEffectMagnitude75 );
+ ModifyEffect();
+ }
+ break;
+ case EHapticsTestModifyEffectAttackMax:
+ {
+ iEffectData->SetAttackLevel( KHWRMHapticsMaxMagnitude );
+ ModifyEffect();
+ }
+ break;
+ case EHapticsTestModifyEffectFadeMin:
+ {
+ iEffectData->SetFadeLevel( KHWRMHapticsMinMagnitude );
+ ModifyEffect();
+ }
+ break;
+ case EHapticsTestModifyEffectFade25:
+ {
+ iEffectData->SetFadeLevel( KEffectMagnitude25 );
+ ModifyEffect();
+ }
+ break;
+ case EHapticsTestModifyEffectFade50:
+ {
+ iEffectData->SetFadeLevel( KEffectMagnitude50 );
+ ModifyEffect();
+ }
+ break;
+ case EHapticsTestModifyEffectFade75:
+ {
+ iEffectData->SetFadeLevel( KEffectMagnitude75 );
+ ModifyEffect();
+ }
+ break;
+ case EHapticsTestModifyEffectFadeMax:
+ {
+ iEffectData->SetFadeLevel( KHWRMHapticsMaxMagnitude );
+ ModifyEffect();
+ }
+ break;
+ case EHapticsTestModifyEffectAttackTime02:
+ {
+ iEffectData->SetAttackTime( KEffectAttackTime02 );
+ ModifyEffect();
+ }
+ break;
+ case EHapticsTestModifyEffectAttackTime1:
+ {
+ iEffectData->SetAttackTime( KEffectAttackTime1 );
+ ModifyEffect();
+ }
+ break;
+ case EHapticsTestModifyEffectAttackTime5:
+ {
+ iEffectData->SetAttackTime( KEffectAttackTime5 );
+ ModifyEffect();
+ }
+ break;
+ case EHapticsTestModifyEffectAttackTime10:
+ {
+ iEffectData->SetAttackTime( KEffectAttackTime10 );
+ ModifyEffect();
+ }
+ break;
+ case EHapticsTestModifyEffectAttackTime30:
+ {
+ iEffectData->SetAttackTime( KEffectAttackTime30 );
+ ModifyEffect();
+ }
+ break;
+ case EHapticsTestModifyEffectAttackTime60:
+ {
+ iEffectData->SetAttackTime( KEffectAttackTime60 );
+ ModifyEffect();
+ }
+ break;
+ case EHapticsTestModifyEffectFadeTime02:
+ {
+ iEffectData->SetFadeTime( KEffectFadeTime02 );
+ ModifyEffect();
+ }
+ break;
+ case EHapticsTestModifyEffectFadeTime1:
+ {
+ iEffectData->SetFadeTime( KEffectFadeTime1 );
+ ModifyEffect();
+ }
+ break;
+ case EHapticsTestModifyEffectFadeTime5:
+ {
+ iEffectData->SetFadeTime( KEffectFadeTime5 );
+ ModifyEffect();
+ }
+ break;
+ case EHapticsTestModifyEffectFadeTime10:
+ {
+ iEffectData->SetFadeTime( KEffectFadeTime10 );
+ ModifyEffect();
+ }
+ break;
+ case EHapticsTestModifyEffectFadeTime30:
+ {
+ iEffectData->SetFadeTime( KEffectFadeTime30 );
+ ModifyEffect();
+ }
+ break;
+ case EHapticsTestModifyEffectFadeTime60:
+ {
+ iEffectData->SetFadeTime( KEffectFadeTime60 );
+ ModifyEffect();
+ }
+ break;
+ case EHapticsTestModifyEffectPeriod50:
+ {
+ iEffectData->SetPeriod( KEffectPeriod50 );
+ ModifyEffect();
+ }
+ break;
+ case EHapticsTestModifyEffectPeriod100:
+ {
+ iEffectData->SetPeriod( KEffectPeriod100 );
+ ModifyEffect();
+ }
+ break;
+ case EHapticsTestModifyEffectPeriod300:
+ {
+ iEffectData->SetPeriod( KEffectPeriod300 );
+ ModifyEffect();
+ }
+ break;
+ case EHapticsTestModifyEffectPeriod600:
+ {
+ iEffectData->SetPeriod( KEffectPeriod600 );
+ ModifyEffect();
+ }
+ break;
+ case EHapticsTestModifyEffectPeriod1000:
+ {
+ iEffectData->SetPeriod( KEffectPeriod1000 );
+ ModifyEffect();
+ }
+ break;
+ case EHapticsTestModifyEffectPeriod3000:
+ {
+ iEffectData->SetPeriod( KEffectPeriod3000 );
+ ModifyEffect();
+ }
+ break;
+
+ case EHapticsTestCloseHaptics:
+ {
+ CloseHaptics();
+ }
+ break;
+
+ case EHapticsTestSynchronousCalls:
+ {
+ iSynchronous = ETrue;
+ iAppView->InsertOutput( _L("Using synchronous methods.") );
+ }
+ break;
+
+ case EHapticsTestAsynchronousCalls:
+ {
+ iSynchronous = EFalse;
+ iAppView->InsertOutput( _L("Using asynchronous methods.") );
+ }
+ break;
+
+ case EHapticsTestUsingFileHandle:
+ {
+ iUseHandle = ETrue;
+ iAppView->InsertOutput( _L("Using file handle in play methods.") );
+ }
+ break;
+
+ case EHapticsTestNotUsingFileHandle:
+ {
+ iUseHandle = EFalse;
+ iAppView->InsertOutput( _L("Using data buffer in play methods.") );
+ }
+ break;
+
+ case EHapticsTestShowEffectInfo:
+ {
+ iShowEffectInfo = ETrue;
+ iAppView->InsertOutput( _L("Shows information of played effect.") );
+ }
+ break;
+
+ case EHapticsTestHideEffectInfo:
+ {
+ iShowEffectInfo = EFalse;
+ iAppView->InsertOutput( _L("Stops showing information of played effect.") );
+ }
+ break;
+
+ case EHapticsTestDeleteIVTData:
+ case EHapticsTestDeleteIVTDataNoneFound:
+ {
+ // nothing to do
+ }
+ break;
+
+ case EHapticsTestDeleteIVTDataSelected:
+ {
+ // delete selected loaded IVT file
+ TInt index = iMenuPane->SelectedItem();
+ DeleteLoadedIVTData( index );
+ }
+ break;
+
+ case EHapticsTestDeleteAllIVTData:
+ {
+ // delete all loaded IVT files
+ DeleteAllLoadedIVTData();
+ }
+ break;
+
+ case EHapticsTestReserve:
+ {
+ // nothing to do
+ }
+ case EHapticsTestReserveNotTrusted:
+ {
+ ReserveHaptics( iHaptics, EFalse );
+ }
+ break;
+ case EHapticsTestReserveTrusted:
+ {
+ ReserveHaptics( iHaptics, ETrue );
+ }
+ break;
+ case EHapticsTestReserveNotTrustedTemp:
+ {
+ // create the temp haptics client, if it does not exist
+ if ( !iTempHaptics )
+ {
+ iTempHaptics = CHWRMHaptics::NewL( NULL, NULL );
+ }
+
+ ReserveHaptics( iTempHaptics, EFalse );
+ }
+ break;
+ case EHapticsTestRelease:
+ {
+ iHaptics->ReleaseHaptics();
+ iAppView->InsertOutput( _L("Reservation released.") );
+ }
+ break;
+ case EHapticsTestReleaseTemp:
+ {
+ if ( iTempHaptics )
+ {
+ iTempHaptics->ReleaseHaptics();
+ iAppView->InsertOutput( _L("Temp client's reservation released.") );
+
+ delete iTempHaptics;
+ iTempHaptics = NULL;
+ }
+ else
+ {
+ iAppView->InsertOutput( _L("Temp client not created/reserved.") );
+ }
+ }
+ break;
+
+ case EHapticsTestConstGetters:
+ {
+ ConstGetters();
+ }
+ break;
+
+ case EHapticsTestGetStatus:
+ {
+ // fetch haptics status, and print it
+ MHWRMHapticsObserver::THWRMHapticsStatus status =
+ iHaptics->HapticsStatus();
+
+ if ( iTempHaptics )
+ {
+ iAppView->InsertOutput( _L("[Haptics client] - "), EFalse );
+ PrintStatusInfo( status );
+
+ status = iTempHaptics->HapticsStatus();
+ iAppView->InsertOutput( _L("[Temporary client] - "), EFalse );
+ PrintStatusInfo( status );
+ }
+ else
+ {
+ PrintStatusInfo( status );
+ }
+
+ }
+ break;
+
+ case EHapticsTestSetPropertyPriorityMin:
+ {
+ SetPropertyPriorityMin();
+ }
+ break;
+
+ case EHapticsTestSetPropertyPriorityDefault:
+ {
+ SetPropertyPriorityDefault();
+ }
+ break;
+
+ case EHapticsTestSetPropertyPriorityMax:
+ {
+ SetPropertyPriorityMax();
+ }
+ break;
+
+ case EHapticsTestSetPropertyDisableEffectsTrue:
+ {
+ SetPropertyDisableEffectsTrue();
+ }
+ break;
+
+ case EHapticsTestSetPropertyDisableEffectsFalse:
+ {
+ SetPropertyDisableEffectsFalse();
+ }
+ break;
+
+ case EHapticsTestSetPropertyStrengthMute:
+ {
+ SetPropertyStrengthMin();
+ }
+ break;
+
+ case EHapticsTestSetPropertyStrengthHalf:
+ {
+ SetPropertyStrengthMiddle();
+ }
+ break;
+
+ case EHapticsTestSetPropertyStrengthFull:
+ {
+ SetPropertyStrengthMax();
+ }
+ break;
+
+ case EHapticsTestGetPropertyPriority:
+ {
+ GetPropertyPriority();
+ }
+ break;
+
+ case EHapticsTestGetPropertyDisableEffects:
+ {
+ GetPropertyDisableEffects();
+ }
+ break;
+
+ case EHapticsTestGetPropertyStrength:
+ {
+ GetPropertyStrength();
+ }
+ break;
+
+
+ case EHapticsTestGetCapabilityDeviceCategory:
+ {
+ GetCapabilityDeviceCategory();
+ }
+ break;
+
+ case EHapticsTestGetCapabilityMaxNestedRepeats:
+ {
+ GetCapabilityMaxNestedRepeats();
+ }
+ break;
+
+
+ case EHapticsTestGetCapabilityNumActuators:
+ {
+ GetCapabilityNumActuators();
+ }
+ break;
+
+
+ case EHapticsTestGetCapabilityActuatorType:
+ {
+ GetCapabilityActuatorType();
+ }
+ break;
+
+
+ case EHapticsTestGetCapabilityNumEffectSlots:
+ {
+ GetCapabilityNumEffectSlots();
+ }
+ break;
+
+ case EHapticsTestGetCapabilityNumEffectStyles:
+ {
+ GetCapabilityNumEffectStyles();
+ }
+ break;
+
+ case EHapticsTestGetCapabilityMinPeriod:
+ {
+ GetCapabilityMinPeriod();
+ }
+ break;
+
+ case EHapticsTestGetCapabilityMaxPeriod:
+ {
+ GetCapabilityMaxPeriod();
+ }
+ break;
+
+ case EHapticsTestGetCapabilityMaxEffectDuration:
+ {
+ GetCapabilityMaxEffectDuration();
+ }
+ break;
+
+ case EHapticsTestGetCapabilitySupportedEffects:
+ {
+ GetCapabilitySupportedEffects();
+ }
+ break;
+
+ case EHapticsTestGetCapabilityDeviceName:
+ {
+ GetCapabilityDeviceName();
+ }
+ break;
+
+ case EHapticsTestGetCapabilityMaxEnvelopeTime:
+ {
+ GetCapabilityMaxEnvelopeTime();
+ }
+ break;
+
+ case EHapticsTestGetCapabilityAPIVersionNumber:
+ {
+ GetCapabilityAPIVersionNumber();
+ }
+ break;
+
+ case EHapticsTestGetCapabilityMaxIVTSize:
+ {
+ GetCapabilityMaxIVTSize();
+ }
+ break;
+
+ case EHapticsTestClearOutput:
+ {
+ iAppView->ClearOutput();
+ }
+ break;
+
+ case EHapticsTestStreaming:
+ {
+ StartStreaming();
+ }
+ break;
+
+ case EHapticsTestPlayStreamSample:
+ case EHapticsTestNextStreamSample:
+ {
+ PlayStreamingSample( iCurrentSample );
+ iCurrentSample >= KSampleCount ? iCurrentSample = 0 : iCurrentSample++;
+ }
+ break;
+
+ case EHapticsTestPlayAllSamples:
+ {
+ for ( TInt n = 0; n < 8; n++ )
+ {
+ PlayStreamingSample( n );
+ User::After( 300000 );
+ }
+ }
+ break;
+
+ case EHapticsTestStopStreaming:
+ {
+ StopStreaming();
+ }
+ break;
+
+ case EHapticsTestPanic:
+ default:
+ Panic( EHapticsTestBasicUi );
+ break;
+ }
+ }
+
+// ---------------------------------------------------------
+// Manages the options menu contents based on user actions and data.
+// ---------------------------------------------------------
+//
+void CHapticsTestAppUi::DynInitMenuPaneL( TInt aResourceId,
+ CEikMenuPane* aMenuPane )
+ {
+ CAknAppUi::DynInitMenuPaneL( aResourceId, aMenuPane );
+
+ // store menupane to be used in HandleCommandL()
+ iMenuPane = aMenuPane;
+
+ if ( aResourceId == R_HAPTICSTEST_MENU )
+ {
+ if ( !iHaptics )
+ {
+ // haptics client not created, hide commands using it
+ aMenuPane->SetItemDimmed( EHapticsTestReserve, ETrue );
+ aMenuPane->SetItemDimmed( EHapticsTestConstGetters, ETrue );
+ aMenuPane->SetItemDimmed( EHapticsTestGetStatus, ETrue );
+ }
+ if ( !iActuatorOpened )
+ {
+ // Actuator has not been opened yet, hide ivt-file loading
+ // submenu and general play-submenu
+ aMenuPane->SetItemDimmed( EHapticsTestGeneralPlayEffect, ETrue );
+ aMenuPane->SetItemDimmed( EHapticsTestLoadIVTFile, ETrue );
+ aMenuPane->SetItemDimmed( EHapticsTestPropertiesSubmenu, ETrue );
+ aMenuPane->SetItemDimmed( EHapticsTestCapabilitiesSubmenu, ETrue );
+ aMenuPane->SetItemDimmed( EHapticsTestStreaming, ETrue );
+ }
+ if ( 0 == iLoadedIVTFileArray.Count() )
+ {
+ // also hide the deleteIVT data related menu items
+ aMenuPane->SetItemDimmed( EHapticsTestDeleteIVTData, ETrue );
+ aMenuPane->SetItemDimmed( EHapticsTestDeleteAllIVTData, ETrue );
+ }
+ if ( !iEffectData->Count() )
+ {
+ // hide the pause/resume/stop submenu
+ aMenuPane->SetItemDimmed( EHapticsTestChangeState, ETrue );
+ }
+ if ( !iEffectData->ModifiableEffectExists() )
+ {
+ aMenuPane->SetItemDimmed( EHapticsTestModifyEffect, ETrue );
+ }
+ if ( iStreaming )
+ {
+ aMenuPane->SetItemDimmed( EHapticsTestStreaming, ETrue );
+ aMenuPane->SetItemDimmed( EHapticsTestReserve, ETrue );
+ aMenuPane->SetItemDimmed( EHapticsTestLoadIVTFile, ETrue );
+ aMenuPane->SetItemDimmed( EHapticsTestGeneralPlayEffect, ETrue );
+ aMenuPane->SetItemDimmed( EHapticsTestChangeState, ETrue );
+ aMenuPane->SetItemDimmed( EHapticsTestModifyEffect, ETrue );
+ aMenuPane->SetItemDimmed( EHapticsTestDeleteIVTData, ETrue );
+ aMenuPane->SetItemDimmed( EHapticsTestPropertiesSubmenu, ETrue );
+ aMenuPane->SetItemDimmed( EHapticsTestCapabilitiesSubmenu, ETrue );
+ aMenuPane->SetItemDimmed( EHapticsTestDeleteAllIVTData, ETrue );
+ aMenuPane->SetItemDimmed( EHapticsTestGetStatus, ETrue );
+ aMenuPane->SetItemDimmed( EHapticsTestConstGetters, ETrue );
+ aMenuPane->SetItemDimmed( EHapticsTestClearOutput, ETrue );
+ aMenuPane->SetItemDimmed( EHapticsTestPanic, ETrue );
+ aMenuPane->SetItemDimmed( EHapticsTestInit, ETrue );
+ aMenuPane->SetItemDimmed( EHapticsToggle, ETrue );
+ aMenuPane->SetItemDimmed( EAknSoftkeyExit, ETrue );
+ aMenuPane->SetItemDimmed( EHapticsTestPlayStreamSample, iCurrentSample );
+ aMenuPane->SetItemDimmed( EHapticsTestNextStreamSample, !iCurrentSample );
+ }
+ else
+ {
+ aMenuPane->SetItemDimmed( EHapticsTestPlayAllSamples, ETrue );
+ aMenuPane->SetItemDimmed( EHapticsTestPlayStreamSample, ETrue );
+ aMenuPane->SetItemDimmed( EHapticsTestNextStreamSample, ETrue );
+ aMenuPane->SetItemDimmed( EHapticsTestStopStreaming, ETrue );
+ }
+ }
+ else if ( aResourceId == R_HAPTICSTEST_INIT_SUBMENU )
+ {
+ if ( !iHaptics )
+ {
+ // haptics client not created, hide commands using it
+ aMenuPane->SetItemDimmed( EHapticsTestSupportedActuators, ETrue );
+ aMenuPane->SetItemDimmed( EHapticsTestOpenActuator, ETrue );
+ }
+ if ( !iSupportedActuators )
+ {
+ // either there are no supported actuators, or they have not
+ // been fethed yet --> hide actuator opening submenu
+ aMenuPane->SetItemDimmed( EHapticsTestOpenActuator, ETrue );
+ }
+ }
+ else if ( aResourceId == R_HAPTICSTEST_GENERALPLAY_SUBMENU )
+ {
+ if ( !iActuatorOpened )
+ {
+ // Actuator has not been opened yet, hide the manual effect
+ // play submenu
+ aMenuPane->SetItemDimmed( EHapticsTestPlayEffectManual, ETrue );
+ }
+ if ( 0 == iLoadedIVTFileArray.Count() )
+ {
+ // IVT-data has not been loaded, hide the effect submenu
+ aMenuPane->SetItemDimmed( EHapticsTestPlayEffect, ETrue );
+ aMenuPane->SetItemDimmed( EHapticsTestPlayEffectRepeat, ETrue );
+ }
+ }
+ else if ( aResourceId == R_HAPTICSTEST_TOGGLE_SUBMENU )
+ {
+ if ( iSynchronous )
+ {
+ // synchronous calls in ON, hide synchronous call selection
+ aMenuPane->SetItemDimmed( EHapticsTestSynchronousCalls, ETrue );
+ }
+ else
+ {
+ // asynchronous calls in ON, hide asynchronous call selection
+ aMenuPane->SetItemDimmed( EHapticsTestAsynchronousCalls, ETrue );
+ }
+ if ( iUseHandle )
+ {
+ aMenuPane->SetItemDimmed( EHapticsTestUsingFileHandle, ETrue );
+ if ( iShowEffectInfo )
+ {
+ aMenuPane->SetItemDimmed( EHapticsTestShowEffectInfo, ETrue );
+ }
+ else
+ {
+ aMenuPane->SetItemDimmed( EHapticsTestHideEffectInfo, ETrue );
+ }
+ }
+ else
+ {
+ aMenuPane->SetItemDimmed( EHapticsTestNotUsingFileHandle, ETrue );
+ aMenuPane->SetItemDimmed( EHapticsTestShowEffectInfo, ETrue );
+ aMenuPane->SetItemDimmed( EHapticsTestHideEffectInfo, ETrue );
+ }
+ }
+ else if ( aResourceId == R_HAPTICSTEST_ACTUATORS_SUBMENU )
+ {
+ if ( !(EHWRMLogicalActuatorAny & iSupportedActuators) )
+ {
+ aMenuPane->SetItemDimmed( EHapticsTestOpenActuatorAny, ETrue );
+ }
+ if ( !(EHWRMLogicalActuatorDevice & iSupportedActuators) )
+ {
+ aMenuPane->SetItemDimmed( EHapticsTestOpenActuatorDevice, ETrue );
+ }
+ if ( !(EHWRMLogicalActuatorPrimaryDisplay & iSupportedActuators) )
+ {
+ aMenuPane->SetItemDimmed( EHapticsTestOpenActuatorPrimaryDisplay, ETrue );
+ }
+ if ( !(EHWRMLogicalActuatorSecondaryDisplay & iSupportedActuators) )
+ {
+ aMenuPane->SetItemDimmed( EHapticsTestOpenActuatorSecondaryDisplay, ETrue );
+ }
+ if ( !(EHWRMLogicalActuatorGame & iSupportedActuators) )
+ {
+ aMenuPane->SetItemDimmed( EHapticsTestOpenActuatorGame, ETrue );
+ }
+ if ( !(EHWRMLogicalActuatorGameLeft & iSupportedActuators) )
+ {
+ aMenuPane->SetItemDimmed( EHapticsTestOpenActuatorGameLeft, ETrue );
+ }
+ if ( !(EHWRMLogicalActuatorGameRight & iSupportedActuators) )
+ {
+ aMenuPane->SetItemDimmed( EHapticsTestOpenActuatorGameRight, ETrue );
+ }
+ if ( !(EHWRMLogicalActuatorExternalVibra & iSupportedActuators) )
+ {
+ aMenuPane->SetItemDimmed( EHapticsTestOpenActuatorExternalVibra, ETrue );
+ }
+ }
+ else if ( aResourceId == R_HAPTICSTEST_IVTFILES_SUBMENU )
+ {
+ if ( iIVTFileArray.Count() )
+ {
+ // ivt-files present, hide the "no files" -item
+ aMenuPane->SetItemDimmed( EHapticsTestLoadIVTFileNoneFound, ETrue );
+
+ // make file names visible in the submenu
+ CEikMenuPaneItem::SData data;
+ for ( TInt i = 0; i < iIVTFileArray.Count(); ++i )
+ {
+ data.iText.Copy( iIVTFileArray[i] );
+ data.iCommandId = EHapticsTestLoadIVTFileSelected;
+ data.iCascadeId = 0;
+ data.iFlags = 0;
+ data.iExtraText = KNullDesC;
+
+ aMenuPane->AddMenuItemL( data );
+ }
+ }
+ }
+ else if ( aResourceId == R_HAPTICSTEST_PLAYEFFECT_SUBMENU )
+ {
+ CreatePlayEffectSubmenuL( aMenuPane,
+ EHapticsTestPlayEffectSelected,
+ EHapticsTestPlayEffectNoneFound );
+ }
+ else if ( aResourceId == R_HAPTICSTEST_PLAYEFFECTREPEAT_SUBMENU )
+ {
+ CreatePlayEffectSubmenuL( aMenuPane,
+ EHapticsTestPlayEffectRepeatSelected,
+ EHapticsTestPlayEffectRepeatNoneFound );
+ }
+ else if ( aResourceId == R_HAPTICSTEST_DELETEIVTDATA_SUBMENU )
+ {
+ if ( iLoadedIVTFileArray.Count() )
+ {
+ // loaded ivt-files present, hide the "no files" -item
+ aMenuPane->SetItemDimmed( EHapticsTestDeleteIVTDataNoneFound, ETrue );
+
+ // make loaded ivt-files visible in the submenu
+ CEikMenuPaneItem::SData data;
+ for ( TInt i = 0; i < iLoadedIVTFileArray.Count(); ++i )
+ {
+ data.iText.Copy( iLoadedIVTFileArray[i].iFileName );
+ data.iCommandId = EHapticsTestDeleteIVTDataSelected;
+ data.iCascadeId = 0;
+ data.iFlags = 0;
+ data.iExtraText = KNullDesC;
+
+ aMenuPane->AddMenuItemL( data );
+ }
+ }
+ }
+ else if ( aResourceId == R_HAPTICSTEST_PAUSE_SUBMENU )
+ {
+ // fill effect history data to pause submenu
+ iEffectData->DynInitChangeEffectStateSubmenuL(
+ aMenuPane, EHapticsTestChangeStatePause, iHaptics );
+ }
+ else if ( aResourceId == R_HAPTICSTEST_RESUME_SUBMENU )
+ {
+ // fill effect history data to resume submenu
+ iEffectData->DynInitChangeEffectStateSubmenuL(
+ aMenuPane, EHapticsTestChangeStateResume, iHaptics );
+ }
+ else if ( aResourceId == R_HAPTICSTEST_STOP_SUBMENU )
+ {
+ // fill effect history data to stop submenu
+ iEffectData->DynInitChangeEffectStateSubmenuL(
+ aMenuPane, EHapticsTestChangeStateStop, iHaptics );
+ }
+ else if ( aResourceId == R_HAPTICSTEST_MODIFYDURATION_SUBMENU )
+ {
+ iEffectData->DynInitDurationSubmenu( aMenuPane );
+ }
+ else if ( aResourceId == R_HAPTICSTEST_MODIFYMAGNITUDE_SUBMENU )
+ {
+ iEffectData->DynInitMagnitudeSubmenu( aMenuPane );
+ }
+ else if ( aResourceId == R_HAPTICSTEST_MODIFYSTYLE_SUBMENU )
+ {
+ iEffectData->DynInitStyleSubmenu( aMenuPane );
+ }
+ else if ( aResourceId == R_HAPTICSTEST_MODIFYATTACK_SUBMENU )
+ {
+ iEffectData->DynInitAttackLevelSubmenu( aMenuPane );
+ }
+ else if ( aResourceId == R_HAPTICSTEST_MODIFYFADE_SUBMENU )
+ {
+ iEffectData->DynInitFadeLevelSubmenu( aMenuPane );
+ }
+ else if ( aResourceId == R_HAPTICSTEST_MODIFYATTACKTIME_SUBMENU )
+ {
+ iEffectData->DynInitAttackTimeSubmenu( aMenuPane );
+ }
+ else if ( aResourceId == R_HAPTICSTEST_MODIFYFADETIME_SUBMENU )
+ {
+ iEffectData->DynInitFadeTimeSubmenu( aMenuPane );
+ }
+ else if ( aResourceId == R_HAPTICSTEST_MODIFYPERIOD_SUBMENU )
+ {
+ iEffectData->DynInitPeriodSubmenu( aMenuPane );
+ }
+ }
+
+// ---------------------------------------------------------
+//
+// ---------------------------------------------------------
+//
+void CHapticsTestAppUi::HandleWsEventL(const TWsEvent& aEvent, CCoeControl* aDestination)
+ {
+ CAknAppUi::HandleWsEventL(aEvent, aDestination);
+
+ TInt eventType = aEvent.Type();
+ if (eventType == EEventKeyUp)
+ {
+ TKeyEvent key = *(aEvent.Key());
+ GetAliasKeyCodeL(key.iCode, key, EEventKey);
+ TUint code = key.iScanCode;
+
+ if (code == '5' && !iActuatorOpened )
+ {
+ HandleCommandL(EHapticsTestOpenHaptics); // open client
+ HandleCommandL(EHapticsTestSupportedActuators); // ask supported actuators
+ HandleCommandL(EHapticsTestOpenActuatorAny); // open any actuator
+
+ HandleCommandL(EHapticsTestGetCapabilityDeviceName);
+ }
+ }
+ }
+
+// ---------------------------------------------------------
+// Prints received haptics status notifications onto
+// the screen.
+// ---------------------------------------------------------
+//
+void CHapticsTestAppUi::HapticsStatusChangedL( THWRMHapticsStatus aStatus )
+ {
+ PrintStatusInfo( aStatus );
+ }
+
+// ---------------------------------------------------------
+// Empty implementation.
+// ---------------------------------------------------------
+//
+void CHapticsTestAppUi::EffectCompletedL( TInt /*aError*/,
+ TInt /*aEffectHandle*/ )
+ {
+ }
+
+// ---------------------------------------------------------
+// Outputs received actuator events onto the screen.
+// ---------------------------------------------------------
+//
+void CHapticsTestAppUi::ActuatorEventL( THWRMActuatorEvents aEvent,
+ THWRMLogicalActuators aActuator )
+ {
+ // actuator name
+ TBuf<64> actuator;
+ switch( aActuator )
+ {
+ case EHWRMLogicalActuatorAny:
+ actuator.Append( _L("Any") );
+ break;
+ case EHWRMLogicalActuatorDevice:
+ actuator.Append( _L("Device") );
+ break;
+ case EHWRMLogicalActuatorPrimaryDisplay:
+ actuator.Append( _L("PrimaryDisplay") );
+ break;
+ case EHWRMLogicalActuatorSecondaryDisplay:
+ actuator.Append( _L("SecondaryDisplay") );
+ break;
+ case EHWRMLogicalActuatorGame:
+ actuator.Append( _L("Game") );
+ break;
+ case EHWRMLogicalActuatorGameLeft:
+ actuator.Append( _L("GameLeft") );
+ break;
+ case EHWRMLogicalActuatorGameRight:
+ actuator.Append( _L("GameRight") );
+ break;
+ case EHWRMLogicalActuatorExternalVibra:
+ actuator.Append( _L("ExternalVibra") );
+ break;
+ default:
+ actuator.Append( _L("<unknown>") );
+ break;
+ }
+
+ iAppView->InsertOutput( _L("Received actuator event: "), EFalse );
+ iAppView->InsertOutput( actuator, EFalse );
+
+ switch( aEvent )
+ {
+ case MHWRMHapticsActuatorObserver::EHWRMActuatorAttached:
+ {
+ iAppView->InsertOutput( _L(" Attached.") );
+ break;
+ }
+ case MHWRMHapticsActuatorObserver::EHWRMActuatorDetached:
+ {
+ iAppView->InsertOutput( _L(" Deattached.") );
+ break;
+ }
+ case MHWRMHapticsActuatorObserver::EHWRMActuatorEnabled:
+ {
+ iAppView->InsertOutput( _L(" Enabled.") );
+ break;
+ }
+ case MHWRMHapticsActuatorObserver::EHWRMActuatorDisabled:
+ {
+ iAppView->InsertOutput( _L(" Disabled.") );
+ break;
+ }
+ default:
+ {
+ iAppView->InsertOutput( _L(" <unknown status>") );
+ break;
+ }
+ }
+ }
+
+// ---------------------------------------------------------
+// Creates haptics client instance.
+// ---------------------------------------------------------
+//
+void CHapticsTestAppUi::OpenHapticsL()
+ {
+ if ( iHaptics )
+ {
+ iAppView->InsertOutput( _L("Already created.") );
+ }
+ else
+ {
+ // Create haptics client
+ if ( iSynchronous )
+ {
+ iHaptics = CHWRMHaptics::NewL( this, this );
+ }
+ else
+ {
+ // asynchronous creation
+ TRequestStatus status;
+ iHaptics = CHWRMHaptics::NewL( this, this, status );
+ User::WaitForRequest( status );
+ User::LeaveIfError( status.Int() );
+ }
+
+ if ( iHaptics )
+ {
+ iAppView->InsertOutput( _L("Haptics client created.") );
+ }
+ else
+ {
+ iAppView->InsertOutput( _L("Error: Creation failed.") );
+ }
+ }
+ }
+
+// ---------------------------------------------------------
+// Deletes haptics client instance, and resets member variables
+// so that options-menu is updated accordingly.
+// ---------------------------------------------------------
+//
+void CHapticsTestAppUi::CloseHaptics()
+ {
+ if( iHaptics )
+ {
+ delete iHaptics;
+ iHaptics = NULL;
+ iAppView->InsertOutput( _L("Haptics client deleted.") );
+
+ // uninit members
+ iSupportedActuators = 0;
+ iActuatorOpened = EFalse;
+ iIVTFileHandle = 0;
+
+ while ( iLoadedIVTFileArray.Count() )
+ {
+ if ( iLoadedIVTFileArray[0].iDataBuffer )
+ {
+ delete iLoadedIVTFileArray[0].iDataBuffer;
+ iLoadedIVTFileArray[0].iDataBuffer = NULL;
+ }
+ iLoadedIVTFileArray.Remove( 0 );
+ }
+
+ iIVTDataBuffer = NULL;
+ }
+ else
+ {
+ iAppView->InsertOutput( _L("Error: Haptics client doesn\'t exist.") );
+ }
+ }
+
+// ---------------------------------------------------------
+// Fetches the supported actuators from haptics server,
+// and stores the mask to iSupportedActuators.
+// ---------------------------------------------------------
+//
+void CHapticsTestAppUi::FetchSupportedActuators()
+ {
+ TInt err = iHaptics->SupportedActuators( iSupportedActuators );
+
+ if ( err )
+ {
+ iAppView->InsertOutput( _L("Error: Getting supported actuators failed.") );
+ }
+ else
+ {
+ PrintSupportedActuators();
+ }
+ }
+
+// ---------------------------------------------------------
+// Prints the given supported actuators to the UI.
+// ---------------------------------------------------------
+//
+void CHapticsTestAppUi::PrintSupportedActuators()
+ {
+ iAppView->InsertOutput( _L("Supported actuators:") );
+
+ if( EHWRMLogicalActuatorAny & iSupportedActuators )
+ {
+ iAppView->InsertOutput( _L(" EHWRMLogicalActuatorAny") );
+ }
+ if( EHWRMLogicalActuatorDevice & iSupportedActuators )
+ {
+ iAppView->InsertOutput( _L(" EHWRMLogicalActuatorDevice") );
+ }
+ if( EHWRMLogicalActuatorPrimaryDisplay & iSupportedActuators )
+ {
+ iAppView->InsertOutput( _L(" EHWRMLogicalActuatorPrimaryDisplay") );
+ }
+ if( EHWRMLogicalActuatorSecondaryDisplay & iSupportedActuators )
+ {
+ iAppView->InsertOutput( _L(" EHWRMLogicalActuatorSecondaryDisplay") );
+ }
+ if( EHWRMLogicalActuatorGame & iSupportedActuators )
+ {
+ iAppView->InsertOutput( _L(" EHWRMLogicalActuatorGame") );
+ }
+ if( EHWRMLogicalActuatorGameLeft & iSupportedActuators )
+ {
+ iAppView->InsertOutput( _L(" EHWRMLogicalActuatorGameLeft") );
+ }
+ if( EHWRMLogicalActuatorGameRight & iSupportedActuators )
+ {
+ iAppView->InsertOutput( _L(" EHWRMLogicalActuatorGameRight") );
+ }
+ if( EHWRMLogicalActuatorExternalVibra & iSupportedActuators )
+ {
+ iAppView->InsertOutput( _L(" EHWRMLogicalActuatorExternalVibra") );
+ }
+ if( EHWRMLogicalActuatorLast & iSupportedActuators )
+ {
+ // ?????
+ iAppView->InsertOutput( _L(" EHWRMLogicalActuatorLast") );
+ }
+ }
+
+// ---------------------------------------------------------
+// Attemps to open the given actuator. Prints the result
+// of the attemp to the UI.
+// ---------------------------------------------------------
+//
+void CHapticsTestAppUi::OpenActuator( THWRMLogicalActuators aActuator )
+ {
+ TRAPD( err, iHaptics->OpenActuatorL( aActuator ) );
+ TBuf<100> buf;
+ if ( err )
+ {
+ buf.Append( _L("Error: Opening actuator failed; ") );
+ buf.AppendNum( err );
+ iAppView->InsertOutput( buf );
+
+ iActuatorOpened = EFalse;
+ }
+ else
+ {
+ iAppView->InsertOutput( _L("Actuator opened successfully.") );
+
+ iActuatorOpened = ETrue;
+
+ TInt err = iHaptics->SetDeviceProperty( CHWRMHaptics::EHWRMHapticsLicensekey,
+ KNullDesC8() );
+ if (err)
+ {
+ buf.Append( _L("Error: Setting licensefailed: ") );
+ buf.AppendNum( err );
+ iAppView->InsertOutput( buf );
+
+ iActuatorOpened = EFalse;
+ return;
+ }
+ iAppView->InsertOutput( _L("License is set.") );
+
+ err = iHaptics->SetDeviceProperty( CHWRMHaptics::EHWRMHapticsPriority,
+ KHWRMHapticsMaxDevicePriority );
+
+ }
+ }
+
+// ---------------------------------------------------------
+// Reserves haptics for this application.
+// ---------------------------------------------------------
+//
+void CHapticsTestAppUi::ReserveHaptics( CHWRMHaptics* aHaptics,
+ TBool aForceNoCoe )
+ {
+ TInt err = KErrNone;
+ TBuf<24> forceNoCoe;
+
+ if ( aForceNoCoe )
+ {
+ forceNoCoe.Append( _L("(trusted).") );
+ TRAP( err, aHaptics->ReserveHapticsL( ETrue ) );
+ }
+ else
+ {
+ forceNoCoe.Append( _L("(not trusted).") );
+ TRAP( err, aHaptics->ReserveHapticsL() );
+ }
+
+ if ( err )
+ {
+ TBuf<8> errorCode;
+ errorCode.AppendNum( err );
+
+ iAppView->InsertOutput( _L("Reserving haptics failed err = "), EFalse );
+ iAppView->InsertOutput( errorCode );
+ }
+ else
+ {
+ iAppView->InsertOutput( _L("Reserved haptics "), EFalse );
+ iAppView->InsertOutput( forceNoCoe );
+ }
+ }
+
+// ---------------------------------------------------------
+// Searches for IVT-files in the filesystem, and writes
+// them to iIVTFileArray.
+// ---------------------------------------------------------
+//
+void CHapticsTestAppUi::FindIVTFiles()
+ {
+ iAppView->InsertOutput( _L("Searching IVT-files...") );
+
+ // open file server session
+ RFs rfs;
+ TInt err = rfs.Connect();
+
+ if ( err )
+ {
+ iAppView->InsertOutput( _L("Error occured while opening fileserver session!") );
+ return;
+ }
+
+ // set path where to search files
+ CDir* dirList = 0;
+ TInt memCrdUsageErr = KErrNone;
+
+#ifdef __MARM_ARMV5__
+ // first, try to use mem card.. (in ARMV5 builds)
+ memCrdUsageErr = rfs.SetSessionPath( KSessionPathCrd );
+
+ if ( !memCrdUsageErr )
+ {
+ memCrdUsageErr = rfs.GetDir( KIVTFileType, KEntryAttMaskSupported,
+ ESortByName, dirList );
+ }
+ if ( !memCrdUsageErr && dirList )
+ {
+ iUsesMemCard = ETrue;
+ }
+#endif
+
+ if ( !iUsesMemCard )
+ {
+ // secondly, try to use phone mem.. (actually first in non-ARMV5 builds)
+ err = rfs.SetSessionPath( KSessionPathMem );
+
+ if ( err )
+ {
+ iAppView->InsertOutput( _L("Setting path for fileserver failed!") );
+ return;
+ }
+
+ // get directory file listing of IVT-files
+ err = rfs.GetDir( KIVTFileType, KEntryAttMaskSupported,
+ ESortByName, dirList );
+
+ if ( err || !dirList )
+ {
+ iAppView->InsertOutput( _L("Fetching folder content failed!") );
+ return;
+ }
+ }
+
+ // file server session not needed anymore, close it
+ rfs.Close();
+
+ // go through all found ivt-files and read directory
+ // entries to filenamearray
+ for( TInt i = 0; i < dirList->Count(); i++ )
+ {
+ iIVTFileArray.Append( (*dirList)[i].iName );
+
+ // print findings to the UI
+ iAppView->InsertOutput( _L(" "), EFalse );
+ iAppView->InsertOutput( (*dirList)[i].iName );
+ }
+
+ delete dirList;
+ dirList = NULL;
+ }
+
+// ---------------------------------------------------------
+// Loads IVT data from the given file to haptics.
+// ---------------------------------------------------------
+//
+void CHapticsTestAppUi::LoadIVTDataL( TFileName& aFile )
+ {
+ // open file server session
+ RFs rfs;
+ if ( rfs.Connect() )
+ {
+ iAppView->InsertOutput( _L("Error occured while opening fileserver session!") );
+ return;
+ }
+
+ // set path where to search files
+#ifdef __MARM_ARMV5__
+ if ( iUsesMemCard )
+ {
+ rfs.SetSessionPath( KSessionPathCrd );
+ }
+ else
+ {
+#endif
+
+ rfs.SetSessionPath( KSessionPathMem );
+
+#ifdef __MARM_ARMV5__
+ }
+#endif
+
+ RFile effectFile;
+ TInt fileSize( 0 );
+
+ User::LeaveIfError( effectFile.Open( rfs, aFile, EFileRead ) );
+
+ effectFile.Size( fileSize );
+
+ // create buffer for the IVT-data
+ HBufC8* IVTDataBuffer = HBufC8::NewLC( fileSize );
+ TPtr8 dataBufPtr = IVTDataBuffer->Des();
+
+ // read the data from file to buffer
+ effectFile.Read( dataBufPtr );
+
+ // close file handle and file server session
+ effectFile.Close();
+ rfs.Close();
+
+ // load data to haptics
+ TInt IVTFileHandle = 0;
+ TInt err = iHaptics->LoadEffectData( *IVTDataBuffer, IVTFileHandle );
+
+ if ( err )
+ {
+ CleanupStack::PopAndDestroy( IVTDataBuffer );
+
+ if ( err == KErrAlreadyExists )
+ {
+ iAppView->InsertOutput( _L("IVT-data already loaded!") );
+ }
+ else
+ {
+ iAppView->InsertOutput( _L("Error loading IVT-data!") );
+ }
+ }
+ else
+ {
+ TInt count;
+ iHaptics->GetEffectCount( IVTFileHandle, count );
+
+ TLoadedIVTFileItem newItem;
+ newItem.iFileName.Copy( aFile );
+ newItem.iFileHandle = IVTFileHandle;
+ newItem.iDataBuffer = IVTDataBuffer;
+ if ( KErrNotFound == iLoadedIVTFileArray.Find( newItem, TIdentityRelation<TLoadedIVTFileItem>( TLoadedIVTFileItem::Match ) ) )
+ {
+ iLoadedIVTFileArray.AppendL( newItem );
+ CleanupStack::Pop( IVTDataBuffer ); // ownership now in the array
+ TBuf<24> handleBuf;
+ handleBuf.AppendNum( IVTFileHandle );
+ iAppView->InsertOutput( _L("IVT-data loaded succesfully!") );
+ iAppView->InsertOutput( _L(" File: "), EFalse );
+ iAppView->InsertOutput( aFile );
+ iAppView->InsertOutput( _L(" FileHandle: "), EFalse );
+ iAppView->InsertOutput( handleBuf, EFalse );
+ }
+ else
+ {
+ CleanupStack::PopAndDestroy( IVTDataBuffer );
+ iAppView->InsertOutput( _L("IVT-data already loaded!") );
+ iAppView->InsertOutput( _L(" File: "), EFalse );
+ iAppView->InsertOutput( aFile );
+ }
+ iAppView->InsertOutput( _L(" Effect count: "), EFalse );
+ TBuf<5> countBuf;
+ countBuf.AppendNum( count );
+ iAppView->InsertOutput( countBuf );
+ }
+ }
+
+// ---------------------------------------------------------
+// Plays the effect of the given index in the currently
+// loaded IVT-file.
+// ---------------------------------------------------------
+//
+void CHapticsTestAppUi::PlayEffect( TInt aIndex )
+ {
+ TInt err = KErrNone;
+ iEffectHandle = KErrNotFound;
+ TBool usingAsyncSender( EFalse );
+
+ if ( iSynchronous )
+ {
+ iAppView->InsertOutput( _L("Playing effect synchronously...") );
+ if ( iUseHandle )
+ {
+ err = iHaptics->PlayEffect( iIVTFileHandle,
+ aIndex, iEffectHandle );
+ }
+ else
+ {
+ err = iHaptics->PlayEffect( *iIVTDataBuffer,
+ aIndex, iEffectHandle );
+ }
+ }
+ else
+ {
+ iAppView->InsertOutput( _L("Playing effect asynchronously...") );
+
+ if ( iUseHandle )
+ {
+ usingAsyncSender = ETrue;
+ iAsyncPlaySender->Play( iHaptics, iIVTFileHandle,
+ aIndex, iEffectHandle );
+ }
+ else
+ {
+ TRequestStatus status;
+ iHaptics->PlayEffect( *iIVTDataBuffer,
+ aIndex, iEffectHandle, status );
+ User::WaitForRequest( status );
+ err = status.Int();
+ }
+ }
+
+ if ( !usingAsyncSender )
+ {
+ // print error/success
+ PrintPlayEffectStatus( err );
+ GetCurrentEffectState();
+
+ // if effect played successfully, add history data
+ if ( !err )
+ {
+ iEffectData->AddEffectInfo( iEffectHandle, iIVTFileHandle, aIndex );
+ }
+ }
+ }
+
+// ---------------------------------------------------------
+// Plays the effect of the given index in the currently
+// loaded IVT-file repeatedly
+// ---------------------------------------------------------
+//
+void CHapticsTestAppUi::RepeatEffect( TInt aIndex, TInt aRepeats )
+ {
+ TInt err = KErrNone;
+ iEffectHandle = KErrNotFound;
+ TBool usingAsyncSender( EFalse );
+
+ if ( iSynchronous )
+ {
+ _LIT( KInsertedText, "Playing Repeat %d times synchronously..." );
+ TBuf<50> buf;
+ buf.Format( KInsertedText, aRepeats );
+ iAppView->InsertOutput( buf );
+
+ if ( iUseHandle )
+ {
+ err = iHaptics->PlayEffectRepeat( iIVTFileHandle,
+ aIndex, aRepeats, iEffectHandle );
+ }
+ else
+ {
+ err = iHaptics->PlayEffectRepeat( *iIVTDataBuffer,
+ aIndex, aRepeats, iEffectHandle );
+ }
+ }
+ else
+ {
+ _LIT( KInsertedText, "Playing Repeat %d times asynchronously..." );
+ TBuf<50> buf;
+ buf.Format( KInsertedText, aRepeats );
+ iAppView->InsertOutput( buf );
+
+ if ( iUseHandle )
+ {
+ usingAsyncSender = ETrue;
+ iAsyncPlaySender->PlayRepeat( iHaptics,
+ iIVTFileHandle,
+ aIndex,
+ aRepeats,
+ iEffectHandle );
+ }
+ else
+ {
+ TRequestStatus status;
+ iHaptics->PlayEffectRepeat( *iIVTDataBuffer,
+ aIndex, aRepeats, iEffectHandle, status );
+ User::WaitForRequest( status );
+ err = status.Int();
+ }
+ }
+
+ if ( !usingAsyncSender )
+ {
+ // print error/success
+ PrintPlayEffectStatus( err );
+ GetCurrentEffectState();
+
+ // if effect played successfully, add history data
+ if ( !err )
+ {
+ iEffectData->AddEffectInfo( iEffectHandle, iIVTFileHandle, aIndex );
+ }
+ }
+ }
+
+// ---------------------------------------------------------
+// Plays a magsweep effect using manual definition.
+// ---------------------------------------------------------
+//
+void CHapticsTestAppUi::PlayMagSweepL( TBool aInfinite, TBool aModifiable )
+ {
+ // construct default magsweep data
+ CHWRMHaptics::THWRMHapticsMagSweepEffect magsweep;
+ iEffectData->FillDefaultMagSweepData( magsweep, aInfinite,
+ aModifiable, iHaptics );
+
+ TInt err = KErrNone;
+ iEffectHandle = KErrNotFound;
+
+ if ( iSynchronous )
+ {
+ iAppView->InsertOutput( _L("Playing MagSweep synchronously...") );
+
+ // synchronous call
+ err = iHaptics->PlayMagSweepEffect( magsweep, iEffectHandle );
+ }
+ else
+ {
+ iAppView->InsertOutput( _L("Playing MagSweep asynchronously...") );
+
+ // asynchronous call
+ TRequestStatus status;
+ iHaptics->PlayMagSweepEffect( magsweep, iEffectHandle,
+ status );
+ User::WaitForRequest( status );
+ err = status.Int();
+ }
+
+ // print error/success
+ PrintPlayEffectStatus( err );
+ GetCurrentEffectState();
+
+ // if effect played successfully, add history data
+ if ( !err )
+ {
+ iEffectData->AddEffectInfo( iEffectHandle );
+ iEffectData->ResetModifiableMagSweepEffectL( magsweep, iEffectHandle,
+ iHaptics );
+
+ // if this effect should be auto-modifiable, reset modification timer
+ if ( aModifiable )
+ {
+ iEffectData->StartModifiableEffectTimerL( ModifyPlayingEffect );
+ }
+ }
+ }
+
+// ---------------------------------------------------------
+// Plays a periodic effect using manual definition.
+// ---------------------------------------------------------
+//
+void CHapticsTestAppUi::PlayPeriodicL( TBool aInfinite, TBool aModifiable )
+ {
+ // construct default periodic data
+ CHWRMHaptics::THWRMHapticsPeriodicEffect periodic;
+ iEffectData->FillDefaultPeriodicData( periodic, aInfinite,
+ aModifiable, iHaptics );
+
+ TInt err = KErrNone;
+ iEffectHandle = KErrNotFound;
+
+ if ( iSynchronous )
+ {
+ iAppView->InsertOutput( _L("Playing Periodic synchronously...") );
+
+ // synchronous call
+ err = iHaptics->PlayPeriodicEffect( periodic, iEffectHandle );
+ }
+ else
+ {
+ iAppView->InsertOutput( _L("Playing Periodic asynchronously...") );
+
+ // asynchronous call
+ TRequestStatus status;
+ iHaptics->PlayPeriodicEffect( periodic, iEffectHandle,
+ status );
+ User::WaitForRequest( status );
+ err = status.Int();
+ }
+
+ // print error/success
+ PrintPlayEffectStatus( err );
+ GetCurrentEffectState();
+
+ // if effect played successfully, add history data
+ if ( !err )
+ {
+ iEffectData->AddEffectInfo( iEffectHandle );
+ iEffectData->ResetModifiablePeriodicEffectL( periodic, iEffectHandle,
+ iHaptics );
+
+ // if this effect should be auto-modifiable, reset modification timer
+ if ( aModifiable )
+ {
+ iEffectData->StartModifiableEffectTimerL( ModifyPlayingEffect );
+ }
+ }
+ }
+
+// ---------------------------------------------------------
+// Plays repeatedly a timeline effect using manual definition.
+// ---------------------------------------------------------
+//
+void CHapticsTestAppUi::PlayRepeatL( TInt aRepeats )
+ {
+ TInt err = KErrNone;
+ iEffectHandle = KErrNotFound;
+
+ // This is a simple effect (just plays magsweep type thingie for a second)
+ // produced from VibeStudio (export to C-file functionality there..)
+ static const TUint8 simpleTimelineEffect[] =
+ {
+ 0x01, 0x00, 0x02, 0x00, 0x1c, 0x00, 0x28, 0x00, 0x00, 0x00,
+ 0x07, 0x00, 0xf1, 0xe0, 0x01, 0xe2, 0x00, 0x00, 0xff, 0x30,
+ 0xc8, 0x00, 0xc8, 0x00, 0x00, 0x00, 0x00, 0x20, 0x3e, 0x00,
+ 0x00, 0x5f, 0x00, 0x00, 0x81, 0x00, 0x00, 0x00, 0x12, 0x00,
+ 0x54, 0x00, 0x69, 0x00, 0x6d, 0x00, 0x65, 0x00, 0x6c, 0x00,
+ 0x69, 0x00, 0x6e, 0x00, 0x65, 0x00, 0x00, 0x00, 0x4d, 0x00,
+ 0x61, 0x00, 0x67, 0x00, 0x53, 0x00, 0x77, 0x00, 0x65, 0x00,
+ 0x65, 0x00, 0x70, 0x00, 0x00, 0x00
+ };
+
+ RBuf8 effectBuffer;
+ CleanupClosePushL( effectBuffer );
+ effectBuffer.ReAlloc( sizeof( simpleTimelineEffect ) );
+ TUint8* tmpPtr = const_cast<TUint8*>( effectBuffer.Ptr() );
+ memcpy( tmpPtr, simpleTimelineEffect, sizeof ( simpleTimelineEffect ) );
+ effectBuffer.SetLength( sizeof ( simpleTimelineEffect ) );
+
+ if ( iSynchronous )
+ {
+ _LIT( KInsertedText, "Playing Repeat %d times synchronously..." );
+ TBuf<50> buf;
+ buf.Format( KInsertedText, aRepeats );
+ iAppView->InsertOutput( buf );
+
+ err = iHaptics->PlayEffectRepeat( effectBuffer, 0, aRepeats, iEffectHandle );
+ }
+ else
+ {
+ _LIT( KInsertedText, "Playing Repeat %d times asynchronously..." );
+ TBuf<50> buf;
+ buf.Format( KInsertedText, aRepeats );
+ iAppView->InsertOutput( buf );
+
+ TRequestStatus status;
+ iHaptics->PlayEffectRepeat( effectBuffer, 0, aRepeats, iEffectHandle, status );
+ User::WaitForRequest( status );
+ err = status.Int();
+ }
+
+ CleanupStack::PopAndDestroy(); // effectBuffer (closed here..)
+
+ // print error/success
+ PrintPlayEffectStatus( err );
+ GetCurrentEffectState();
+
+ // if effect played successfully, add history data
+ if ( !err )
+ {
+ iEffectData->AddEffectInfo( iEffectHandle );
+ }
+ }
+
+// ---------------------------------------------------------
+// Pauses the effect of the given index in the effect
+// history data.
+// ---------------------------------------------------------
+//
+void CHapticsTestAppUi::PauseEffect( TInt aIndex )
+ {
+ // get effect handle
+ TInt effectHandle = iEffectData->EffectHandle(aIndex);
+
+ // pause effect
+ TInt err = iHaptics->PausePlayingEffect( effectHandle );
+
+ if ( err )
+ {
+ TBuf<8> errBuf;
+ errBuf.AppendNum( err );
+ iAppView->InsertOutput( _L("Pausing effect failed, err = "), EFalse );
+ iAppView->InsertOutput( errBuf );
+ }
+ else
+ {
+ iAppView->InsertOutput( _L("Pausing effect succeeded.") );
+ }
+ }
+
+// ---------------------------------------------------------
+// Resumes the effect of the given index in the effect
+// history data.
+// ---------------------------------------------------------
+//
+void CHapticsTestAppUi::ResumeEffect( TInt aIndex )
+ {
+ // get effect handle
+ TInt effectHandle = iEffectData->EffectHandle(aIndex);
+
+ // resume effect
+ TInt err = iHaptics->ResumePausedEffect( effectHandle );
+
+ if ( err )
+ {
+ TBuf<8> errBuf;
+ errBuf.AppendNum( err );
+ iAppView->InsertOutput( _L("Resuming effect failed, err = "), EFalse );
+ iAppView->InsertOutput( errBuf );
+ }
+ else
+ {
+ iAppView->InsertOutput( _L("Resuming effect succeeded.") );
+ }
+ }
+
+// ---------------------------------------------------------
+// Stops the effect of the given index in the effect
+// history data.
+// ---------------------------------------------------------
+//
+void CHapticsTestAppUi::StopEffect( TInt aIndex )
+ {
+ // get effect handle
+ TInt effectHandle = iEffectData->EffectHandle(aIndex);
+
+ // stop effect
+ TInt err = iHaptics->StopPlayingEffect( effectHandle );
+
+ if ( err )
+ {
+ TBuf<8> errBuf;
+ errBuf.AppendNum( err );
+ iAppView->InsertOutput( _L("Stopping effect failed, err = "), EFalse );
+ iAppView->InsertOutput( errBuf );
+ }
+ else
+ {
+ iAppView->InsertOutput( _L("Stopping effect succeeded.") );
+ }
+
+ // stop auto-modify effect, if it is on
+ iEffectData->ResetModifiableEffectTimer();
+ }
+
+// ---------------------------------------------------------
+// Deletes loaded IVT data
+// ---------------------------------------------------------
+//
+void CHapticsTestAppUi::DeleteLoadedIVTData( TInt aIndex )
+ {
+ if ( 0 > aIndex || aIndex >= iLoadedIVTFileArray.Count() )
+ {
+ iAppView->InsertOutput( _L("Error: Delete index mismatch!") );
+ return;
+ }
+
+ TInt err = iHaptics->DeleteEffectData( iLoadedIVTFileArray[aIndex].iFileHandle );
+ if ( KErrNone == err )
+ {
+ // delete effect history
+ iEffectData->DeleteEffectInfo( iLoadedIVTFileArray[aIndex].iFileHandle );
+
+ // delete ivt-data item
+ if ( iLoadedIVTFileArray[aIndex].iDataBuffer )
+ {
+ delete iLoadedIVTFileArray[aIndex].iDataBuffer;
+ }
+
+ iLoadedIVTFileArray.Remove( aIndex );
+
+ iAppView->InsertOutput( _L("IVT data deletion succeeded") );
+ }
+ else
+ {
+ _LIT( KInsertedText, "IVT data deletion failed: %d" );
+ TBuf<80> buf;
+ buf.Format( KInsertedText, err );
+ iAppView->InsertOutput( buf );
+ }
+ }
+
+// ---------------------------------------------------------
+// Deletes all loaded IVT datas
+// ---------------------------------------------------------
+//
+void CHapticsTestAppUi::DeleteAllLoadedIVTData()
+ {
+ iAppView->InsertOutput( _L("Deleting all loaded IVT datas.") );
+
+ TInt err = iHaptics->DeleteAllEffectData();
+
+ if ( KErrNone == err )
+ {
+ iAppView->InsertOutput( _L("All IVT data deletion succeeded") );
+
+ while ( iLoadedIVTFileArray.Count() )
+ {
+ // delete effect history
+ iEffectData->DeleteEffectInfo( iLoadedIVTFileArray[0].iFileHandle );
+
+ // delete ivt-data item
+ if ( iLoadedIVTFileArray[0].iDataBuffer )
+ {
+ delete iLoadedIVTFileArray[0].iDataBuffer;
+ }
+
+ iLoadedIVTFileArray.Remove( 0 );
+ }
+ }
+ else
+ {
+ _LIT( KInsertedText, "All IVT data deletion failed: %d" );
+ TBuf<80> buf;
+ buf.Format( KInsertedText, err );
+ iAppView->InsertOutput( buf );
+ }
+ }
+
+
+// ---------------------------------------------------------
+// Fetches the current state of the last played effect
+// (iEffectHandle), and prints the result to the UI.
+// ---------------------------------------------------------
+//
+void CHapticsTestAppUi::GetCurrentEffectState()
+ {
+ TInt effectState = KErrNotFound;
+ TInt err = iHaptics->GetEffectState( iEffectHandle, effectState );
+
+ if ( err )
+ {
+ TBuf<16> errCode;
+ errCode.AppendNum( err );
+ iAppView->InsertOutput( _L(" Fetching effect state failed! Err: "), EFalse );
+ iAppView->InsertOutput( errCode );
+ }
+ else
+ {
+ TBuf<16> stateBuf;
+
+ switch ( effectState )
+ {
+ case CHWRMHaptics::EHWRMHapticsEffectNotPlaying:
+ stateBuf.Append( _L("Not playing.") );
+ break;
+ case CHWRMHaptics::EHWRMHapticsEffectPlaying:
+ stateBuf.Append( _L("Playing.") );
+ break;
+ case CHWRMHaptics::EHWRMHapticsEffectPaused:
+ stateBuf.Append( _L("Paused.") );
+ break;
+ default:
+ stateBuf.Append( _L("Unknown!") );
+ break;
+ }
+
+ iAppView->InsertOutput( _L(" Effect state: "), EFalse );
+ iAppView->InsertOutput( stateBuf );
+ }
+ }
+
+// ---------------------------------------------------------
+// Prints the status of a "play effect".
+// ---------------------------------------------------------
+//
+void CHapticsTestAppUi::PrintPlayEffectStatus( TInt aErrorCode ) const
+ {
+ if ( aErrorCode )
+ {
+ TBuf<16> errCode;
+ errCode.AppendNum( aErrorCode );
+ iAppView->InsertOutput( _L("Playing effect failed! Err: "), EFalse );
+ iAppView->InsertOutput( errCode );
+ }
+ else
+ {
+ TBuf<16> handleBuf;
+ handleBuf.AppendNum( iEffectHandle );
+ iAppView->InsertOutput( _L("Played effect successfully!") );
+ iAppView->InsertOutput( _L(" Effect handle: "), EFalse );
+ iAppView->InsertOutput( handleBuf );
+ }
+ }
+
+// ---------------------------------------------------------
+// Queries user how many repeats to have in case of playing
+// some effect repeatedly.
+// ---------------------------------------------------------
+//
+TInt CHapticsTestAppUi::GetNumberOfRepeats()
+ {
+ TInt repeatsIndex;
+ TInt retVal = 2; // default is 2 repeats
+
+ // Uses non-leavable new for CAknListQueryDialog construction
+ CAknListQueryDialog* query = new CAknListQueryDialog( &repeatsIndex );
+
+ if ( query )
+ {
+ query->PrepareLC( R_HAPTICS_REPEATEFFECT_REPEATS_QUERY );
+
+ if ( query->RunLD() )
+ {
+ switch ( repeatsIndex )
+ {
+ case 0:
+ retVal = 0;
+ break;
+ case 1:
+ retVal = 1;
+ break;
+ case 2:
+ retVal = 2;
+ break;
+ case 3:
+ retVal = 3;
+ break;
+ case 4:
+ retVal = 7;
+ break;
+ case 5:
+ retVal = iHaptics->InfiniteRepeat();
+ break;
+ default:
+ break; // uses default (2) as return value
+ };
+ }
+ }
+ return retVal;
+ }
+
+// ---------------------------------------------------------
+// Calculates the effect index from the submenu index.
+// ---------------------------------------------------------
+//
+TInt CHapticsTestAppUi::CountFileHandleAndEffectIndex(TInt aSubmenuIndex)
+ {
+ TInt effectFileCount = iLoadedIVTFileArray.Count();
+ TInt retVal = 0xFFFFFFFF;
+ TInt totalRunningEffectCount = 0;
+ TInt effectCountAfterPreviousFile = 0;
+
+ for ( TInt i = 0; i < effectFileCount; ++i )
+ {
+ TInt effectsInThisFile = 0;
+ iHaptics->GetEffectCount( iLoadedIVTFileArray[i].iFileHandle, effectsInThisFile );
+ effectCountAfterPreviousFile = totalRunningEffectCount;
+ totalRunningEffectCount += effectsInThisFile;
+ if ( aSubmenuIndex < totalRunningEffectCount )
+ {
+ iIVTFileHandle = iLoadedIVTFileArray[i].iFileHandle;
+ iIVTDataBuffer = iLoadedIVTFileArray[i].iDataBuffer;
+ retVal = aSubmenuIndex - effectCountAfterPreviousFile;
+ break;
+ }
+ }
+ return retVal;
+ }
+
+// ---------------------------------------------------------
+// Creates all submenu items for a play effect submenu.
+// Fetches all the names of the effects from currently
+// loaded IVT-data.
+// ---------------------------------------------------------
+//
+void CHapticsTestAppUi::CreatePlayEffectSubmenuL( CEikMenuPane* aMenuPane,
+ TInt aCommandId,
+ TInt aDimCommandId )
+ {
+ TInt loadedIVTFileCount = iLoadedIVTFileArray.Count();
+ TBool dimmingNeeded = EFalse;
+
+ if ( loadedIVTFileCount )
+ {
+ // make all effect names (in all loaded files) visible in the submenu
+ CEikMenuPaneItem::SData data;
+ for ( TInt j = 0; j < loadedIVTFileCount; ++j)
+ {
+ if ( iLoadedIVTFileArray[j].iDataBuffer )
+ {
+ TInt effectCount = 0;
+ iHaptics->GetEffectCount( iLoadedIVTFileArray[j].iFileHandle, effectCount );
+ HBufC8* tempBuf8 = HBufC8::New( iHaptics->MaxEffectNameLength() );
+ TPtr8 effectName = tempBuf8->Des();
+ for ( TInt i = 0; i < effectCount; ++i )
+ {
+ // fetch effect name
+ iHaptics->GetEffectName( iLoadedIVTFileArray[j].iFileHandle, i, effectName );
+
+ data.iText.Copy( effectName );
+ data.iCommandId = aCommandId;
+ data.iCascadeId = 0;
+ data.iFlags = 0;
+ data.iExtraText = KNullDesC;
+
+ aMenuPane->AddMenuItemL( data );
+ dimmingNeeded = ETrue;
+ }
+ delete tempBuf8;
+ }
+ }
+ }
+ if ( dimmingNeeded )
+ {
+ // effects found in IVT-data, hide the "no effects" -item
+ aMenuPane->SetItemDimmed( aDimCommandId, ETrue );
+ }
+ }
+
+// ---------------------------------------------------------
+// Prints effect information got from getter functions
+// ---------------------------------------------------------
+//
+void CHapticsTestAppUi::PrintEffectInfo( TInt aIndex )
+ {
+ if ( iUseHandle && iShowEffectInfo )
+ {
+ TInt duration;
+ iHaptics->GetEffectDuration( iIVTFileHandle,
+ aIndex,
+ duration );
+
+ HBufC8* tempBuf8 = HBufC8::New( iHaptics->MaxEffectNameLength() );
+ TPtr8 effectName = tempBuf8->Des();
+
+ iHaptics->GetEffectName( iIVTFileHandle, aIndex, effectName );
+
+ TInt effectIndex;
+ iHaptics->GetEffectIndexFromName( iIVTFileHandle,
+ effectName,
+ effectIndex );
+
+ TInt type;
+ iHaptics->GetEffectType( iIVTFileHandle, aIndex, type );
+
+
+ HBufC* tempBuf16 = HBufC::New( iHaptics->MaxEffectNameLength() );
+ TPtr buf = tempBuf16->Des();
+
+ iAppView->InsertOutput( _L(" Effect name: "), EFalse );
+ buf.Copy( effectName );
+ iAppView->InsertOutput( buf, EFalse );
+
+ buf.Delete( 0, buf.MaxLength() );
+ buf.AppendNum( effectIndex );
+ iAppView->InsertOutput( _L(" Idx: "), EFalse );
+ iAppView->InsertOutput( buf );
+
+ buf.Delete( 0, buf.MaxLength() );
+ buf.AppendNum( duration );
+ iAppView->InsertOutput( _L(" Effect duration: "), EFalse );
+ iAppView->InsertOutput( buf );
+
+ buf.Delete( 0, buf.MaxLength() );
+ buf.AppendNum( type );
+ iAppView->InsertOutput( _L(" Effect type: "), EFalse );
+ iAppView->InsertOutput( buf );
+
+ if ( type == CHWRMHaptics::EHWRMHapticsTypeMagSweep )
+ {
+ CHWRMHaptics::THWRMHapticsMagSweepEffect def;
+ iHaptics->GetMagSweepEffectDefinition( iIVTFileHandle,
+ aIndex,
+ def );
+ iAppView->InsertOutput( _L(" MagSweep definition -> Duration:"), EFalse );
+ buf.Delete( 0, buf.MaxLength() );
+ buf.AppendNum( def.iDuration );
+ iAppView->InsertOutput( buf );
+ iAppView->InsertOutput( _L(" MagSweep definition -> Magnitude: "), EFalse );
+ buf.Delete( 0, buf.MaxLength() );
+ buf.AppendNum( def.iMagnitude );
+ iAppView->InsertOutput( buf );
+ iAppView->InsertOutput( _L(" MagSweep definition -> Style: "), EFalse );
+ buf.Delete( 0, buf.MaxLength() );
+ buf.AppendNum( def.iStyle );
+ iAppView->InsertOutput( buf );
+ iAppView->InsertOutput( _L(" MagSweep definition -> Attack time: "), EFalse );
+ buf.Delete( 0, buf.MaxLength() );
+ buf.AppendNum( def.iAttackTime );
+ iAppView->InsertOutput( buf );
+ iAppView->InsertOutput( _L(" MagSweep definition -> Attack level: "), EFalse );
+ buf.Delete( 0, buf.MaxLength() );
+ buf.AppendNum( def.iAttackLevel );
+ iAppView->InsertOutput( buf );
+ iAppView->InsertOutput( _L(" MagSweep definition -> Fade time: "), EFalse );
+ buf.Delete( 0, buf.MaxLength() );
+ buf.AppendNum( def.iFadeTime );
+ iAppView->InsertOutput( buf );
+ iAppView->InsertOutput( _L(" MagSweep definition -> Fade level: "), EFalse );
+ buf.Delete( 0, buf.MaxLength() );
+ buf.AppendNum( def.iFadeLevel );
+ iAppView->InsertOutput( buf );
+ }
+ else if ( type == CHWRMHaptics::EHWRMHapticsTypePeriodic )
+ {
+ CHWRMHaptics::THWRMHapticsPeriodicEffect def;
+ iHaptics->GetPeriodicEffectDefinition( iIVTFileHandle,
+ aIndex,
+ def );
+ iAppView->InsertOutput( _L(" Periodic definition -> Duration: "), EFalse );
+ buf.Delete( 0, buf.MaxLength() );
+ buf.AppendNum( def.iDuration );
+ iAppView->InsertOutput( buf );
+ iAppView->InsertOutput( _L(" Periodic definition -> Magnitude: "), EFalse );
+ buf.Delete( 0, buf.MaxLength() );
+ buf.AppendNum( def.iMagnitude );
+ iAppView->InsertOutput( buf );
+ iAppView->InsertOutput( _L(" Periodic definition -> Period: "), EFalse );
+ buf.Delete( 0, buf.MaxLength() );
+ buf.AppendNum( def.iPeriod );
+ iAppView->InsertOutput( buf );
+ iAppView->InsertOutput( _L(" Periodic definition -> Style: "), EFalse );
+ buf.Delete( 0, buf.MaxLength() );
+ buf.AppendNum( def.iStyle );
+ iAppView->InsertOutput( buf );
+ iAppView->InsertOutput( _L(" Periodic definition -> Attack time: "), EFalse );
+ buf.Delete( 0, buf.MaxLength() );
+ buf.AppendNum( def.iAttackTime );
+ iAppView->InsertOutput( buf );
+ iAppView->InsertOutput( _L(" Periodic definition -> Attack level: "), EFalse );
+ buf.Delete( 0, buf.MaxLength() );
+ buf.AppendNum( def.iAttackLevel );
+ iAppView->InsertOutput( buf );
+ iAppView->InsertOutput( _L(" Periodic definition -> Fade time: "), EFalse );
+ buf.Delete( 0, buf.MaxLength() );
+ buf.AppendNum( def.iFadeTime );
+ iAppView->InsertOutput( buf );
+ iAppView->InsertOutput( _L(" Periodic definition -> Attack level: "), EFalse );
+ buf.Delete( 0, buf.MaxLength() );
+ buf.AppendNum( def.iFadeLevel );
+ iAppView->InsertOutput( buf );
+ }
+ delete tempBuf8;
+ delete tempBuf16;
+ }
+ }
+
+// ---------------------------------------------------------
+// Prints the given status onto the screen.
+// ---------------------------------------------------------
+//
+void CHapticsTestAppUi::PrintStatusInfo(
+ MHWRMHapticsObserver::THWRMHapticsStatus aStatus ) const
+ {
+ iAppView->InsertOutput( _L("Received status: "), EFalse );
+
+ switch( aStatus )
+ {
+ case MHWRMHapticsObserver::EHWRMHapticsStatusAvailable:
+ {
+ iAppView->InsertOutput( _L("Available.") );
+ break;
+ }
+ case MHWRMHapticsObserver::EHWRMHapticsStatusReserved:
+ {
+ iAppView->InsertOutput( _L("Reserved.") );
+ break;
+ }
+ case MHWRMHapticsObserver::EHWRMHapticsStatusSuspended:
+ {
+ iAppView->InsertOutput( _L("Suspended.") );
+ break;
+ }
+ default:
+ {
+ iAppView->InsertOutput( _L("<unknown status>") );
+ break;
+ }
+ }
+ }
+
+// ---------------------------------------------------------
+// Calls the getter methods for system constants
+// and prints out the results.
+// ---------------------------------------------------------
+//
+void CHapticsTestAppUi::ConstGetters() const
+ {
+ _LIT( KNumFormat, "%d" );
+ TBuf<50> buf;
+ iAppView->InsertOutput( _L(" Infinite repeats: "), EFalse );
+ buf.Format( KNumFormat, iHaptics->InfiniteRepeat() );
+ iAppView->InsertOutput( buf );
+ iAppView->InsertOutput( _L(" Infinite duration: "), EFalse );
+ buf.Format( KNumFormat, iHaptics->InfiniteDuration() );
+ iAppView->InsertOutput( buf );
+ iAppView->InsertOutput( _L(" Max effect name length: "), EFalse );
+ buf.Format( KNumFormat, iHaptics->MaxEffectNameLength() );
+ iAppView->InsertOutput( buf );
+ iAppView->InsertOutput( _L(" Max device name length: "), EFalse );
+ buf.Format( KNumFormat, iHaptics->MaxDeviceNameLength() );
+ iAppView->InsertOutput( buf );
+ iAppView->InsertOutput( _L(" Max capability string length: "), EFalse );
+ buf.Format( KNumFormat, iHaptics->MaxCapabilityStringLength() );
+ iAppView->InsertOutput( buf );
+ iAppView->InsertOutput( _L(" Max property string length: "), EFalse );
+ buf.Format( KNumFormat, iHaptics->MaxPropertyStringLength() );
+ iAppView->InsertOutput( buf );
+ iAppView->InsertOutput( _L(" Max streaming sample size: "), EFalse );
+ buf.Format( KNumFormat, iHaptics->MaxStreamingSampleSize() );
+ iAppView->InsertOutput( buf );
+ iAppView->InsertOutput( _L(" Default device priority: "), EFalse );
+ buf.Format( KNumFormat, iHaptics->DefaultDevicePriority() );
+ iAppView->InsertOutput( buf );
+ }
+
+// ---------------------------------------------------------------------------
+// Modifies an effect using the values set for iModifyEffect.
+// ---------------------------------------------------------------------------
+//
+void CHapticsTestAppUi::ModifyEffect()
+ {
+ if ( !iEffectData->ModifiableEffectExists() )
+ {
+ return;
+ }
+
+ TInt err = KErrNone;
+ TInt effectHandle = iEffectData->ModifiableEffectHandle();
+
+ if ( iEffectData->ModifiableEffectIsMagSweep() )
+ {
+ // fill magsweep data
+ CHWRMHaptics::THWRMHapticsMagSweepEffect magsweep;
+ iEffectData->FillModifiableMagSweepData( magsweep );
+
+ // execute modification
+ if ( iSynchronous )
+ {
+ err = iHaptics->ModifyPlayingMagSweepEffect( effectHandle, magsweep );
+ }
+ else
+ {
+ TRequestStatus status;
+ iHaptics->ModifyPlayingMagSweepEffect( effectHandle, magsweep, status );
+ User::WaitForRequest( status );
+ err = status.Int();
+ }
+ }
+ else if ( iEffectData->ModifiableEffectIsPeriodic() )
+ {
+ // fill periodic data
+ CHWRMHaptics::THWRMHapticsPeriodicEffect periodic;
+ iEffectData->FillModifiablePeriodicData( periodic );
+
+ // execute modification
+ if ( iSynchronous )
+ {
+ err = iHaptics->ModifyPlayingPeriodicEffect( effectHandle, periodic );
+ }
+ else
+ {
+ TRequestStatus status;
+ iHaptics->ModifyPlayingPeriodicEffect( effectHandle, periodic, status );
+ User::WaitForRequest( status );
+ err = status.Int();
+ }
+ }
+
+ if ( err )
+ {
+ TBuf<8> errBuf;
+ errBuf.AppendNum( err );
+ iAppView->InsertOutput( _L("Modifying effect failed, err = "), EFalse );
+ iAppView->InsertOutput( errBuf );
+ }
+ else
+ {
+ iAppView->InsertOutput( _L("Modifying effect succeeded.") );
+ }
+ }
+
+// ---------------------------------------------------------------------------
+// Static callback method from a periodic timer used for
+// continuous effect modification (magnitude/period).
+// ---------------------------------------------------------------------------
+//
+TInt CHapticsTestAppUi::ModifyPlayingEffect( TAny* aPtr )
+ {
+ CHapticsTestEffectDataHandler* effectData =
+ static_cast<CHapticsTestEffectDataHandler*>( aPtr );
+
+ // hundred modifications to get to KPi (up and down with magnitude)
+ TReal stepLengthRad = KPi/100 * effectData->ModifyCount();
+
+ // calculate absolute sin value
+ TReal sinValue = 0;
+ TInt errSin = Math::Sin( sinValue, stepLengthRad );
+ sinValue = Abs( sinValue );
+
+ // increase the amount of modifications done
+ effectData->SetModifyCount( effectData->ModifyCount() + 1 );
+
+ TInt err = KErrNone;
+ TInt effectHandle = effectData->ModifiableEffectHandle();
+
+ if ( effectData->ModifiableEffectIsMagSweep() )
+ {
+ // modify magsweep effect
+ CHWRMHaptics::THWRMHapticsMagSweepEffect magsweep;
+ effectData->FillModifiableMagSweepData( magsweep );
+
+ // new magnitude value according to sin value
+ magsweep.iMagnitude = KHWRMHapticsMaxMagnitude * sinValue;
+
+ // modify effect
+ err = effectData->Haptics()->ModifyPlayingMagSweepEffect(
+ effectHandle, magsweep );
+ }
+ else if ( effectData->ModifiableEffectIsPeriodic() )
+ {
+ // modify periodic effect
+ CHWRMHaptics::THWRMHapticsPeriodicEffect periodic;
+ effectData->FillModifiablePeriodicData( periodic );
+
+ // period getting smaller when magnitude getting higher
+ periodic.iPeriod = 20 + (1-sinValue)*200;
+
+ // modify effect
+ err = effectData->Haptics()->ModifyPlayingPeriodicEffect(
+ effectHandle, periodic );
+ }
+
+ if ( err )
+ {
+ CEikonEnv::Static()->InfoMsg( _L("Modify failed!") );
+ }
+
+ return KErrNone;
+ }
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+void CHapticsTestAppUi::GetCapabilityDeviceCategory()
+ {
+ TBuf<50> buf;
+ iAppView->InsertOutput( _L(" Device category: "), EFalse );
+ TInt retValue( CHWRMHaptics::EHWRMHapticsEmbedded );
+ TInt err( iHaptics->GetDeviceCapability(
+ CHWRMHaptics::EHWRMHapticsDeviceCategory, retValue ) );
+
+ if ( err )
+ {
+ _LIT( KFailedFormat, "GetDeviceCapability failed (%d)!" );
+ buf.Format( KFailedFormat, err );
+ }
+ else
+ {
+ switch ( retValue )
+ {
+ case CHWRMHaptics::EHWRMHapticsVirtual:
+ buf.Append( _L("Virtual") );
+ break;
+ case CHWRMHaptics::EHWRMHapticsEmbedded:
+ buf.Append( _L("Embedded") );
+ break;
+ default:
+ buf.Append( _L("Unknown") );
+ break;
+ }
+ }
+ iAppView->InsertOutput( buf );
+ }
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+void CHapticsTestAppUi::GetCapabilityMaxNestedRepeats()
+ {
+ TBuf<50> buf;
+ iAppView->InsertOutput( _L(" Max nested repeats: "), EFalse );
+ TInt retValue( 0 );
+ TInt err( iHaptics->GetDeviceCapability(
+ CHWRMHaptics::EHWRMHapticsMaxNestedRepeats, retValue ) );
+
+ if ( err )
+ {
+ _LIT( KFailedFormat, "GetDeviceCapability failed (%d)!" );
+ buf.Format( KFailedFormat, err );
+ }
+ else
+ {
+ _LIT( KNumFormat, "%d" );
+ buf.Format( KNumFormat, retValue );
+ }
+
+ iAppView->InsertOutput( buf );
+ }
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+void CHapticsTestAppUi::GetCapabilityNumActuators()
+ {
+ TBuf<50> buf;
+ iAppView->InsertOutput( _L(" Number of actuators: "), EFalse );
+ TInt retValue( 0 );
+ TInt err( iHaptics->GetDeviceCapability(
+ CHWRMHaptics::EHWRMHapticsNumActuators, retValue ) );
+
+ if ( err )
+ {
+ _LIT( KFailedFormat, "GetDeviceCapability failed (%d)!" );
+ buf.Format( KFailedFormat, err );
+ }
+ else
+ {
+ _LIT( KNumFormat, "%d" );
+ buf.Format( KNumFormat, retValue );
+ }
+
+ iAppView->InsertOutput( buf );
+ }
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+void CHapticsTestAppUi::GetCapabilityActuatorType()
+ {
+ TBuf<50> buf;
+ iAppView->InsertOutput( _L(" Actuator type: "), EFalse );
+ TInt retValue( 0 );
+ TInt err( iHaptics->GetDeviceCapability(
+ CHWRMHaptics::EHWRMHapticsActuatorType, retValue ) );
+
+ if ( err )
+ {
+ _LIT( KFailedFormat, "GetDeviceCapability failed (%d)!" );
+ buf.Format( KFailedFormat, err );
+ }
+ else
+ {
+ switch (retValue)
+ {
+ case CHWRMHaptics::EHWRMHapticsTypeERM:
+ buf.Append( _L("EHWRMHapticsTypeERM") );
+ break;
+ case CHWRMHaptics::EHWRMHapticsTypeLRA:
+ buf.Append( _L("EHWRMHapticsTypeLRA") );
+ break;
+ default:
+ buf.Append( _L("Unknown") );
+ break;
+ }
+ }
+ iAppView->InsertOutput( buf );
+ }
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+void CHapticsTestAppUi::GetCapabilityNumEffectSlots()
+ {
+ TBuf<50> buf;
+ iAppView->InsertOutput( _L(" Number of effect slots: "), EFalse );
+ TInt retValue( 0 );
+ TInt err( iHaptics->GetDeviceCapability(
+ CHWRMHaptics::EHWRMHapticsNumEffectSlots, retValue ) );
+
+ if ( err )
+ {
+ _LIT( KFailedFormat, "GetDeviceCapability failed (%d)!" );
+ buf.Format( KFailedFormat, err );
+ }
+ else
+ {
+ _LIT( KNumFormat, "%d" );
+ buf.Format( KNumFormat, retValue );
+ }
+
+ iAppView->InsertOutput( buf );
+ }
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+void CHapticsTestAppUi::GetCapabilityNumEffectStyles()
+ {
+ TBuf<150> buf;
+ iAppView->InsertOutput( _L(" Effect styles: "), EFalse );
+ TInt retValue( 0 );
+ TInt err( iHaptics->GetDeviceCapability(
+ CHWRMHaptics::EHWRMHapticsSupportedStyles, retValue ) );
+
+ if ( err )
+ {
+ _LIT( KFailedFormat, "GetDeviceCapability failed (%d)!" );
+ buf.Format( KFailedFormat, err );
+ }
+ else
+ {
+ if ( retValue & CHWRMHaptics::EHWRMHapticsSupportSmooth )
+ {
+ buf.Append( _L(" EHWRMHapticsSupportSmooth") );
+ }
+
+ if ( retValue & CHWRMHaptics::EHWRMHapticsSupportStrong )
+ {
+ buf.Append( _L(" EHWRMHapticsSupportStrong") );
+ }
+
+ if ( retValue & CHWRMHaptics::EHWRMHapticsSupportSharp )
+ {
+ buf.Append( _L(" EHWRMHapticsSupportSharp") );
+ }
+ }
+ iAppView->InsertOutput( buf );
+ }
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+void CHapticsTestAppUi::GetCapabilityMinPeriod()
+ {
+ TBuf<50> buf;
+ iAppView->InsertOutput( _L(" Minimum period for periodic effects: "), EFalse );
+ TInt retValue( 0 );
+ TInt err( iHaptics->GetDeviceCapability(
+ CHWRMHaptics::EHWRMHapticsMinPeriod, retValue ) );
+
+ if ( err )
+ {
+ _LIT( KFailedFormat, "GetDeviceCapability failed (%d)!" );
+ buf.Format( KFailedFormat, err );
+ }
+ else
+ {
+ _LIT( KNumFormat, "%d" );
+ buf.Format( KNumFormat, retValue );
+ }
+
+ iAppView->InsertOutput( buf );
+ }
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+void CHapticsTestAppUi::GetCapabilityMaxPeriod()
+ {
+ TBuf<50> buf;
+ iAppView->InsertOutput( _L(" Maximum period for periodic effects: "), EFalse );
+ TInt retValue( 0 );
+ TInt err( iHaptics->GetDeviceCapability(
+ CHWRMHaptics::EHWRMHapticsMaxPeriod, retValue ) );
+
+ if ( err )
+ {
+ _LIT( KFailedFormat, "GetDeviceCapability failed (%d)!" );
+ buf.Format( KFailedFormat, err );
+ }
+ else
+ {
+ _LIT( KNumFormat, "%d" );
+ buf.Format( KNumFormat, retValue );
+ }
+
+ iAppView->InsertOutput( buf );
+ }
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+void CHapticsTestAppUi::GetCapabilityMaxEffectDuration()
+ {
+ TBuf<50> buf;
+ iAppView->InsertOutput( _L(" Maximum effect duration: "), EFalse );
+ TInt retValue( 0 );
+ TInt err( iHaptics->GetDeviceCapability(
+ CHWRMHaptics::EHWRMHapticsMaxEffectDuration, retValue ) );
+
+ if ( err )
+ {
+ _LIT( KFailedFormat, "GetDeviceCapability failed (%d)!" );
+ buf.Format( KFailedFormat, err );
+ }
+ else
+ {
+ _LIT( KNumFormat, "%d" );
+ buf.Format( KNumFormat, retValue );
+ }
+
+ iAppView->InsertOutput( buf );
+ }
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+void CHapticsTestAppUi::GetCapabilitySupportedEffects()
+ {
+ TBuf<150> buf;
+ iAppView->InsertOutput( _L(" Supported effect types: "), EFalse );
+ TInt retValue( 0 );
+ TInt err( iHaptics->GetDeviceCapability(
+ CHWRMHaptics::EHWRMHapticsSupportedEffects, retValue ) );
+
+ if ( err )
+ {
+ _LIT( KFailedFormat, "GetDeviceCapability failed (%d)!" );
+ buf.Format( KFailedFormat, err );
+ }
+ else
+ {
+ if ( retValue & CHWRMHaptics::EHWRMHapticsSupportPeriodic )
+ {
+ buf.Append( _L(" EHWRMHapticsSupportPeriodic") );
+ }
+
+ if ( retValue & CHWRMHaptics::EHWRMHapticsSupportMagSweep )
+ {
+ buf.Append( _L(" EHWRMHapticsSupportMagSweep") );
+ }
+
+ if ( retValue & CHWRMHaptics::EHWRMHapticsSupportTimeline )
+ {
+ buf.Append( _L(" EHWRMHapticsSupportTimeline") );
+ }
+
+ if ( retValue & CHWRMHaptics::EHWRMHapticsSupportStreaming )
+ {
+ buf.Append( _L(" EHWRMHapticsSupportStreaming") );
+ }
+ }
+ iAppView->InsertOutput( buf );
+ }
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+void CHapticsTestAppUi::GetCapabilityDeviceName()
+ {
+ TBuf<100> buf;
+ iAppView->InsertOutput( _L(" Device name: "), EFalse );
+ TBuf8<100> retValue;
+ TInt err( iHaptics->GetDeviceCapability(
+ CHWRMHaptics::EHWRMHapticsDeviceName, retValue ) );
+ if ( err )
+ {
+ _LIT( KFailedFormat, "GetDeviceCapability failed (%d)!" );
+ buf.Format( KFailedFormat, err );
+ }
+ else
+ {
+ CnvUtfConverter::ConvertToUnicodeFromUtf8( buf, retValue );
+ }
+
+ iAppView->InsertOutput( buf );
+ }
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+void CHapticsTestAppUi::GetCapabilityMaxEnvelopeTime()
+ {
+ TBuf<50> buf;
+ iAppView->InsertOutput( _L(" Maximum envelop time: "), EFalse );
+ TInt retValue( 0 );
+ TInt err( iHaptics->GetDeviceCapability(
+ CHWRMHaptics::EHWRMHapticsMaxEnvelopeTime, retValue ) );
+
+ if ( err )
+ {
+ _LIT( KFailedFormat, "GetDeviceCapability failed (%d)!" );
+ buf.Format( KFailedFormat, err );
+ }
+ else
+ {
+ _LIT( KNumFormat, "%d" );
+ buf.Format( KNumFormat, retValue );
+ }
+
+ iAppView->InsertOutput( buf );
+ }
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+void CHapticsTestAppUi::GetCapabilityAPIVersionNumber()
+ {
+ TBuf<50> buf;
+ TInt retValue( 0 );
+ iAppView->InsertOutput( _L(" API version: "), EFalse );
+ TInt err( iHaptics->GetDeviceCapability(
+ CHWRMHaptics::EHWRMHapticsAPIVersionNumber, retValue ) );
+
+ if ( err )
+ {
+ _LIT( KFailedFormat, "GetDeviceCapability failed (%d)!" );
+ buf.Format( KFailedFormat, err );
+ }
+ else
+ {
+ _LIT( KNumFormat, "%d" );
+ buf.Format( KNumFormat, retValue );
+ }
+
+ iAppView->InsertOutput( buf );
+ }
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+void CHapticsTestAppUi::GetCapabilityMaxIVTSize()
+ {
+ TBuf<50> buf;
+ iAppView->InsertOutput( _L(" Maximum size of IVT file: "), EFalse );
+ TInt retValue( 0 );
+ TInt err( iHaptics->GetDeviceCapability(
+ CHWRMHaptics::EHWRMHapticsMaxEffectDataSize, retValue ) );
+
+ if ( err )
+ {
+ _LIT( KFailedFormat, "GetDeviceCapability failed (%d)!" );
+ buf.Format( KFailedFormat, err );
+ }
+ else
+ {
+ _LIT( KNumFormat, "%d" );
+ buf.Format( KNumFormat, retValue );
+ }
+
+ iAppView->InsertOutput( buf, ETrue );
+ }
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+void CHapticsTestAppUi::SetPropertyPriorityMin()
+ {
+ iAppView->InsertOutput( _L(" Setting priority to minimum"), ETrue );
+ TInt value(KHWRMHapticsMinDevicePriority);
+ TRAPD( err, iHaptics->SetDeviceProperty(CHWRMHaptics::EHWRMHapticsPriority, value));
+ if ( err )
+ {
+ CEikonEnv::Static()->InfoMsg( _L("SetDeviceProperty failed!") );
+ }
+ }
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+void CHapticsTestAppUi::SetPropertyPriorityDefault()
+ {
+ iAppView->InsertOutput( _L(" Setting priority to default" ), ETrue );
+ TInt value( KHWRMHapticsMinDevicePriority );
+
+ TRAPD( err1, value = iHaptics->DefaultDevicePriority() );
+ if ( err1 )
+ {
+ CEikonEnv::Static()->InfoMsg( _L( "DefaultDevicePriority() failed!" ) );
+ return;
+ }
+
+ TRAPD( err2, iHaptics->SetDeviceProperty( CHWRMHaptics::EHWRMHapticsPriority, value ) );
+ if ( err2 )
+ {
+ CEikonEnv::Static()->InfoMsg( _L("SetDeviceProperty failed!") );
+ }
+ }
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+void CHapticsTestAppUi::SetPropertyPriorityMax()
+ {
+ iAppView->InsertOutput( _L(" Setting priority to maximum"), ETrue );
+ TInt value(KHWRMHapticsMaxDevicePriority);
+ TRAPD( err, iHaptics->SetDeviceProperty(CHWRMHaptics::EHWRMHapticsPriority, value));
+ if ( err )
+ {
+ CEikonEnv::Static()->InfoMsg( _L("SetDeviceProperty failed!") );
+ }
+ }
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+void CHapticsTestAppUi::GetPropertyPriority()
+ {
+ _LIT( KNumFormat, "%d" );
+ TBuf<50> buf;
+ iAppView->InsertOutput( _L(" Device priority: "), EFalse );
+ TInt retValue(0);
+ TRAPD( err, iHaptics->GetDeviceProperty(CHWRMHaptics::EHWRMHapticsPriority, retValue));
+ if ( err )
+ {
+ CEikonEnv::Static()->InfoMsg( _L("GetDeviceProperty failed!") );
+ }
+
+ buf.Format( KNumFormat, retValue );
+ iAppView->InsertOutput( buf, ETrue );
+ }
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+void CHapticsTestAppUi::SetPropertyDisableEffectsTrue()
+ {
+ iAppView->InsertOutput( _L(" Disabling effects" ), ETrue );
+ TBool value( ETrue );
+ TRAPD( err2, iHaptics->SetDeviceProperty( CHWRMHaptics::EHWRMHapticsDisableEffects, value ) );
+ if ( err2 )
+ {
+ CEikonEnv::Static()->InfoMsg( _L("SetDeviceProperty failed!") );
+ }
+ }
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+void CHapticsTestAppUi::SetPropertyDisableEffectsFalse()
+ {
+ iAppView->InsertOutput( _L(" Enabling effects" ), ETrue );
+ TBool value( EFalse );
+ TRAPD( err2, iHaptics->SetDeviceProperty( CHWRMHaptics::EHWRMHapticsDisableEffects, value ) );
+ if ( err2 )
+ {
+ CEikonEnv::Static()->InfoMsg( _L("SetDeviceProperty failed!") );
+ }
+ }
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+void CHapticsTestAppUi::GetPropertyDisableEffects()
+ {
+ iAppView->InsertOutput( _L(" Effects disabled: "), EFalse );
+ TInt retValue( EFalse );
+ TRAPD( err, iHaptics->GetDeviceProperty( CHWRMHaptics::EHWRMHapticsDisableEffects, retValue ) );
+ if ( err )
+ {
+ CEikonEnv::Static()->InfoMsg( _L("GetDeviceProperty failed!") );
+ }
+ else
+ {
+ if ( retValue )
+ {
+ iAppView->InsertOutput( _L("TRUE"), ETrue );
+ }
+ else
+ {
+ iAppView->InsertOutput( _L("FALSE"), ETrue );
+ }
+ }
+ }
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+void CHapticsTestAppUi::SetPropertyStrengthMin()
+ {
+ iAppView->InsertOutput( _L(" Setting strength to mininum" ), ETrue );
+ TBool value( KHWRMHapticsMinStrength );
+ TRAPD( err2, iHaptics->SetDeviceProperty( CHWRMHaptics::EHWRMHapticsStrength, value ) );
+ if ( err2 )
+ {
+ CEikonEnv::Static()->InfoMsg( _L("SetDeviceProperty failed!") );
+ }
+ }
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+void CHapticsTestAppUi::SetPropertyStrengthMiddle()
+ {
+ iAppView->InsertOutput( _L(" Setting strength to middle" ), ETrue );
+ TBool value( ( KHWRMHapticsMaxStrength - KHWRMHapticsMinStrength ) / 2 );
+ TRAPD( err2, iHaptics->SetDeviceProperty( CHWRMHaptics::EHWRMHapticsStrength, value ) );
+ if ( err2 )
+ {
+ CEikonEnv::Static()->InfoMsg( _L("SetDeviceProperty failed!") );
+ }
+ }
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+void CHapticsTestAppUi::SetPropertyStrengthMax()
+ {
+ iAppView->InsertOutput( _L(" Setting strength to max" ), ETrue );
+ TBool value( KHWRMHapticsMaxStrength );
+ TRAPD( err2, iHaptics->SetDeviceProperty( CHWRMHaptics::EHWRMHapticsStrength, value ) );
+ if ( err2 )
+ {
+ CEikonEnv::Static()->InfoMsg( _L("SetDeviceProperty failed!") );
+ }
+ }
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+void CHapticsTestAppUi::GetPropertyStrength()
+ {
+ _LIT( KNumFormat, "%d" );
+ TBuf<50> buf;
+ iAppView->InsertOutput( _L(" Strength level: "), EFalse );
+ TInt retValue(0);
+ TRAPD( err, iHaptics->GetDeviceProperty(CHWRMHaptics::EHWRMHapticsStrength, retValue));
+ if ( err )
+ {
+ CEikonEnv::Static()->InfoMsg( _L("GetDeviceProperty failed!") );
+ }
+
+ buf.Format( KNumFormat, retValue );
+ iAppView->InsertOutput( buf, ETrue );
+ }
+
+
+// ---------------------------------------------------------------------------
+// Enables streaming mode.
+// ---------------------------------------------------------------------------
+//
+void CHapticsTestAppUi::StartStreaming()
+ {
+ iCurrentSample = 0;
+ iEffectHandle = KErrNotFound;
+ TInt err = iHaptics->CreateStreamingEffect( iEffectHandle );
+
+ if ( err )
+ {
+ TBuf<16> errCode;
+ errCode.AppendNum( err );
+ iAppView->InsertOutput( _L("Create streaming effect failed! Err: "), EFalse );
+ iAppView->InsertOutput( errCode );
+ }
+ else
+ {
+ TBuf<16> handleBuf;
+ handleBuf.AppendNum( iEffectHandle );
+ iAppView->InsertOutput( _L("Streaming effect created successfully!") );
+ iAppView->InsertOutput( _L(" Effect handle: "), EFalse );
+ iAppView->InsertOutput( handleBuf );
+
+ iStreaming = ETrue;
+ }
+ }
+
+
+// ---------------------------------------------------------------------------
+// Plays one streaming sample from KStreamArray.
+// ---------------------------------------------------------------------------
+//
+void CHapticsTestAppUi::PlayStreamingSample( TInt aSampleId )
+ {
+ RBuf8 sampleBuffer;
+ sampleBuffer.ReAlloc( sizeof( KStreamArray[aSampleId] ) );
+ TUint8* tmpPtr = const_cast<TUint8*>( sampleBuffer.Ptr() );
+ memcpy( tmpPtr, KStreamArray[aSampleId], sizeof( KStreamArray[aSampleId] ) );
+ sampleBuffer.SetLength( sizeof( KStreamArray[aSampleId] ) );
+
+ iHaptics->PlayStreamingSample( iEffectHandle, sampleBuffer );
+
+ sampleBuffer.Close();
+ }
+
+
+// ---------------------------------------------------------------------------
+// Disables streaming mode.
+// ---------------------------------------------------------------------------
+//
+void CHapticsTestAppUi::StopStreaming()
+ {
+ iStreaming = EFalse;
+
+ TInt err = iHaptics->DestroyStreamingEffect( iEffectHandle );
+ if ( err )
+ {
+ TBuf<16> errCode;
+ errCode.AppendNum( err );
+ iAppView->InsertOutput( _L("Destoy streaming effect failed! Err: "), EFalse );
+ iAppView->InsertOutput( errCode );
+ }
+ else
+ {
+ TBuf<16> handleBuf;
+ handleBuf.AppendNum( iEffectHandle );
+ iAppView->InsertOutput( _L("Streaming effect destroyed successfully!") );
+ }
+ }
+
+// End of file