S60 3rd Edition SDK for Symbian OS Example Applications Guide

HWRMTestAppAppUi.cpp

/*
* ==============================================================================
*  Name        : HWRMTestAppAppUi.cpp
*  Part of     : HWRMTestApp
*  Interface   : 
*  Description : HWRM Test application UI implementation
*  Version     : 
*
*  Copyright (c) 2002-2006 Nokia Corporation.
*  This material, including documentation and any related 
*  computer programs, is protected by copyright controlled by 
*  Nokia Corporation. 
* ==============================================================================
*/

// INCLUDE FILES
#include <aknNoteWrappers.h>
#include <eikmenup.h>
#include <avkon.hrh>
#include <aknselectionlist.h>
#include <HWRMPowerStateSDKPSKeys.h>
#include <HWRMTestApp.rsg>
#include "HWRMTestAppPropertyObserver.h"
#include "HWRMTestAppAppUi.h"
#include "HWRMTestAppContainer.h" 
#include "HWRMTestApp.hrh"


// ============================ MEMBER FUNCTIONS ===============================


// -----------------------------------------------------------------------------
// CHWRMTestAppAppUi::ConstructL
// Symbian 2nd phase constructor can leave.
// -----------------------------------------------------------------------------
//
void CHWRMTestAppAppUi::ConstructL()
    {
    BaseConstructL(CAknAppUi::EAknEnableSkin);
    iAppContainer = new (ELeave) CHWRMTestAppContainer;
    iAppContainer->SetMopParent(this);
    iAppContainer->ConstructL( ClientRect() );
    AddToStackL( iAppContainer );
    
    // We can ignore this error, simply dim the menus if 
    // pointer is null with the DynInitMenuPaneL method
    TRAPD( err, iLight = CHWRMLight::NewL(this) );
    if( err == KErrNotSupported )
        {
        _LIT( KLightNotSupported, "Light API Not Supported!" );
        iAppContainer->AddMessageL( KLightNotSupported );
        }
    TRAP( err, iVibra = CHWRMVibra::NewL(this) );
    if( err == KErrNotSupported )
        {
        _LIT( KVibraNotSupported, "Vibra API Not Supported!" );
        iAppContainer->AddMessageL( KVibraNotSupported );
        }

    // Create the observers
    iBatteryStatusObserver = CHWRMTestAppPropertyObserver::NewL(
                    KPSUidHWRMPowerState,KHWRMBatteryStatus, iAppContainer );
    iBatteryLevelObserver = CHWRMTestAppPropertyObserver::NewL(
                    KPSUidHWRMPowerState,KHWRMBatteryLevel, iAppContainer );
    iChargingStatusObserver = CHWRMTestAppPropertyObserver::NewL(
                    KPSUidHWRMPowerState,KHWRMChargingStatus, iAppContainer );
    }

// -----------------------------------------------------------------------------
// CHWRMTestAppAppUi::~CHWRMTestAppAppUi
// Destructor
// Frees reserved resources
// -----------------------------------------------------------------------------
//
CHWRMTestAppAppUi::~CHWRMTestAppAppUi()
    {
    // Delete the observers
    delete iBatteryStatusObserver;
    delete iBatteryLevelObserver;
    delete iChargingStatusObserver;

    delete iLight; // kill light
    delete iVibra; // kill vibra

    if(iAppContainer)
        {
        RemoveFromStack( iAppContainer );
        delete iAppContainer;
        }
    }

// -----------------------------------------------------------------------------
// CHWRMTestAppAppUi::::DynInitMenuPaneL
//  This function is called by the EIKON framework just before it displays
//  a menu pane. Its default implementation is empty, and by overriding it,
//  the application can set the state of menu items dynamically according
//  to the state of application data.
// -----------------------------------------------------------------------------
//
void CHWRMTestAppAppUi::DynInitMenuPaneL(
    TInt aResourceId,CEikMenuPane* aMenuPane)
    {
    if( aResourceId==R_HWRMTESTAPP_MENU )
        {
        //the main application menu
        if( iLight )
            {
            //enable everything for lights
            aMenuPane->SetItemDimmed(EHWRMTestAppCmdLights,EFalse);
            }
        else
            {
            //dim everything for lights
            aMenuPane->SetItemDimmed(EHWRMTestAppCmdLights,ETrue);
            }
        if( iVibra )
            {
            //enable everything for vibra
            aMenuPane->SetItemDimmed(EHWRMTestAppCmdVibra,EFalse);
            }
        else
            {
            //dim everything for vibra
            aMenuPane->SetItemDimmed(EHWRMTestAppCmdVibra,ETrue);
            }
        }
        }

// -----------------------------------------------------------------------------
// CHWRMTestAppAppUi::HandleKeyEventL
// Pass key event to app container
// -----------------------------------------------------------------------------
//
TKeyResponse CHWRMTestAppAppUi::HandleKeyEventL(
    const TKeyEvent& aKeyEvent,TEventCode aType)
    {
    return iAppContainer->OfferKeyEventL( aKeyEvent, aType );
    }

// -----------------------------------------------------------------------------
// CHWRMTestAppAppUi::HandleCommandL
// Handle command entered by user
// -----------------------------------------------------------------------------
//
void CHWRMTestAppAppUi::HandleCommandL(TInt aCommand)
    {
    TInt err(KErrNone);
    
    switch ( aCommand )
        {
        case EAknSoftkeyBack:
        case EEikCmdExit:
            {
            Exit();
            break;
            }
        case EHWRMTestAppCmdVibraReserve:
            {
            _LIT(KReserveVibra, "Reserve vibra");
            iAppContainer->AddMessageL( KReserveVibra );
            TRAP( err, VibraReserveL() );
            break;
            }
        case EHWRMTestAppCmdVibraRelease:
            {
            _LIT(KReleaseVibra, "Release vibra");
            iAppContainer->AddMessageL( KReleaseVibra );
            TRAP( err, VibraReleaseL() );
            break;
            }
        case EHWRMTestAppCmdVibraStart:
            {
            _LIT(KStartVibra, "Start vibra");
            iAppContainer->AddMessageL( KStartVibra );
            TRAP( err, VibraStartL() );
            break;
            }
        case EHWRMTestAppCmdVibraStop:
            {
            _LIT(KStopVibra, "Stop vibra");
            iAppContainer->AddMessageL( KStopVibra );
            TRAP( err, VibraStopL() );
            break;
            }
        case EHWRMTestAppCmdVibraSettings:
                {
                _LIT(KVibraSettings, "Vibra settings");
                iAppContainer->AddMessageL( KVibraSettings );
            VibraSettings();
            break;
                }
        case EHWRMTestAppCmdVibraStatus:
                {
                _LIT(KVibraStatus, "Vibra status");
                iAppContainer->AddMessageL( KVibraStatus );
            VibraStatus();
            break;
                }
        case EHWRMTestAppCmdLightsReserve:
            {
            _LIT(KReserveLights, "Reserve lights");
            iAppContainer->AddMessageL( KReserveLights );
            TRAP( err, LightsReserveL() );
            break;
            }
        case EHWRMTestAppCmdLightsRelease:
            {
            _LIT(KReleaseLights, "Release lights");
            iAppContainer->AddMessageL( KReleaseLights );
            TRAP( err, LightsReleaseL() );
            break;
            }
        case EHWRMTestAppCmdLightsOn:
                {
                _LIT(KLightsOn, "Lights on");
                iAppContainer->AddMessageL( KLightsOn );
            TRAP( err, LightsOnL() );
            break;
                }
        case EHWRMTestAppCmdLightsBlink:
                {
                _LIT(KBlinkLights, "Blink lights");
                iAppContainer->AddMessageL( KBlinkLights );
            TRAP( err, LightsBlinkL() );
            break;
                }
        case EHWRMTestAppCmdLightsOff:
                {
                _LIT(KLightsOff, "Lights off");
                iAppContainer->AddMessageL( KLightsOff );
            TRAP( err, LightsOffL() );
            break;
                }
        case EHWRMTestAppCmdLightsStatus:
                {
                _LIT(KLightsStatus, "Lights status");
                iAppContainer->AddMessageL( KLightsStatus );
            TRAP( err, LightsStatusL() );
            break;
                }
        default:
            break;      
        }
    if( err != KErrNone )
        {
        TBuf<100> buf;
        _LIT(KErrorTrapped, "Error Trapped = %d!!!");
        buf.Format( KErrorTrapped, err );
        iAppContainer->AddMessageL( buf );
        }
    }

// -----------------------------------------------------------------------------
// CHWRMTestAppAppUi::HandleForegroundEventL
// Handle situation when app is sent to the foreground or background
// -----------------------------------------------------------------------------
//
void CHWRMTestAppAppUi::HandleForegroundEventL(TBool aForeground)
    {
    // first call base implementation
    CEikAppUi::HandleForegroundEventL( aForeground );
    
    if( aForeground )
        {
        _LIT(KAppSentToForeground, "App sent to foreground");
        iAppContainer->AddMessageL( KAppSentToForeground );
        }
    else
        {
        _LIT(KAppSentToBackground, "App sent to background");
        iAppContainer->AddMessageL( KAppSentToBackground );
        }
    }


// =============================================================================
//                          VIBRA RELATED METHODS
// =============================================================================

// -----------------------------------------------------------------------------
// CHWRMTestAppAppUi::VibraReserveL
// Reserve vibra
// -----------------------------------------------------------------------------
//
void CHWRMTestAppAppUi::VibraReserveL()
    {
    TInt item(0);
    TBuf<100> buf;
    TBool restore;
    TBool forceNoCCoeEnv;
    
    CAknListQueryDialog* listDlg = new (ELeave)CAknListQueryDialog( &item );
    if( listDlg->ExecuteLD(R_HWRMTESTAPP_RESTORE_LIST) )
        {
        // got restore state parameter
        item == 0 ? restore = EFalse : restore = ETrue;
        //now get force no CCoeEnv parameter
        listDlg = new (ELeave)CAknListQueryDialog( &item );
        if( listDlg->ExecuteLD(R_HWRMTESTAPP_NOCCOEENV_LIST) )
            {
            // got ForceNoCCoeEnv parameter
            item == 0 ? forceNoCCoeEnv = EFalse : forceNoCCoeEnv = ETrue;
            _LIT(KReserveVibraLParameters, "ReserveVibraL(restore=%d,forceNoCCoeEnv=%d)");
            buf.Format( KReserveVibraLParameters, restore, forceNoCCoeEnv );
            iAppContainer->AddMessageL( buf );
            iVibra->ReserveVibraL( restore, forceNoCCoeEnv );
            }
        else
            {
            // did not get ForceNoCCoeEnv parameter
            _LIT(KReserveVibraLNotCalled, "ReserveVibraL not called, no ForceNoCCoeEnv value");
            iAppContainer->AddMessageL( KReserveVibraLNotCalled );
            }
        }
    else
        {
        // did not get restore parameter
        _LIT(KReserveVibraL, "ReserveVibraL()");
        iAppContainer->AddMessageL( KReserveVibraL );
        iVibra->ReserveVibraL();
        }
    }
    
// -----------------------------------------------------------------------------
// CHWRMTestAppAppUi::VibraReleaseL
// Release vibra
// -----------------------------------------------------------------------------
//
void CHWRMTestAppAppUi::VibraReleaseL()
    {
    _LIT(KReleaseVibraCalled, "ReleaseVibra called");
    iAppContainer->AddMessageL( KReleaseVibraCalled );
    iVibra->ReleaseVibra();
    }
    
// -----------------------------------------------------------------------------
// CHWRMTestAppAppUi::VibraStartL
// Start vibra
// -----------------------------------------------------------------------------
//
void CHWRMTestAppAppUi::VibraStartL()
    {
    CAknNumberQueryDialog* dlg;
    TInt intensity(0);
    TInt duration(0);
    TBuf<100> buf;
    
    //duration
    dlg = CAknNumberQueryDialog::NewL( duration );
    
    //KHWRMVibraMinIntensity, KHWRMVibraMaxIntensity, 5 ;
    if( dlg->ExecuteLD( R_HWRMTESTAPP_DURATION_QUERY ) )
        {
        // got duration so now optionally get the intensity
        dlg = CAknNumberQueryDialog::NewL( intensity );
        //KHWRMVibraMinIntensity, KHWRMVibraMaxIntensity, 5 ;
        if( dlg->ExecuteLD( R_HWRMTESTAPP_VIBRA_INTENSITY_QUERY ) )
            {
            // got the intenstity
            _LIT(KStartVibraL, "StartVibraL(duration=%d,intensity=%d)");
            buf.Format( KStartVibraL, duration, intensity );
            iAppContainer->AddMessageL( buf );
            iVibra->StartVibraL( duration, intensity );
            }
        else
            {
            // user pressed cancel for intensity query
            _LIT(KStartVibraLDuration, "StartVibraL(duration=%d)");
            buf.Format( KStartVibraLDuration, duration );
            iAppContainer->AddMessageL( buf );
            iVibra->StartVibraL( duration );
            }
        }
    else
        {
        // user pressed cancel for duration query
        // do nothing...
        _LIT(KStartVibraLNotCalled, "StartVibraL not called!");
        iAppContainer->AddMessageL( KStartVibraLNotCalled );
        }
    }

// -----------------------------------------------------------------------------
// CHWRMTestAppAppUi::VibraStopL
// Stop vibra
// -----------------------------------------------------------------------------
//
void CHWRMTestAppAppUi::VibraStopL()
    {
    _LIT(KStopVibraLCalled, "StopVibraL called");
    iAppContainer->AddMessageL( KStopVibraLCalled );
    iVibra->StopVibraL();
    }

// -----------------------------------------------------------------------------
// CHWRMTestAppAppUi::VibraSettings
// Retrieve vibra settings
// -----------------------------------------------------------------------------
//
void CHWRMTestAppAppUi::VibraSettings()
    {
    VibraModeChanged( iVibra->VibraSettings() );
    }

// -----------------------------------------------------------------------------
// CHWRMTestAppAppUi::VibraStatus
// Retrieve vibra status
// -----------------------------------------------------------------------------
//
void CHWRMTestAppAppUi::VibraStatus()
    {
    VibraStatusChanged( iVibra->VibraStatus() );
    }


// =============================================================================
//                          LIGHTS RELATED METHODS
// =============================================================================

// -----------------------------------------------------------------------------
// CHWRMTestAppAppUi::LightsReserveL
// Reserve lights
// -----------------------------------------------------------------------------
//
void CHWRMTestAppAppUi::LightsReserveL()
    {
    TInt item(0);
    TBuf<100> buf;
    TBool restore;
    TBool forceNoCCoeEnv;
    TInt target(CHWRMLight::ENoTarget);
    
    // Get the lights target
    target = GetLightsTargetL();
    
    if( target == KErrCancel )
        {
        // no target entered
        _LIT(KReserveLightLNotCalled, "ReserveLightL not called, no target!");
        iAppContainer->AddMessageL( KReserveLightLNotCalled );
        return;
        }
    
    CAknListQueryDialog* listDlg = new (ELeave)CAknListQueryDialog( &item );
    
    if( listDlg->ExecuteLD(R_HWRMTESTAPP_RESTORE_LIST) )
        {
        // got restore state parameter
        item == 0 ? restore = EFalse : restore = ETrue;
        //now get force no CCoeEnv parameter
        listDlg = new (ELeave)CAknListQueryDialog( &item );
        if( listDlg->ExecuteLD(R_HWRMTESTAPP_NOCCOEENV_LIST) )
            {
            // got ForceNoCCoeEnv parameter
            item == 0 ? forceNoCCoeEnv = EFalse : forceNoCCoeEnv = ETrue;
            _LIT(KReserveLightL, "ReserveLightL(target=%d,restore=%d,forceNoCCoeEnv=%d)");
            buf.Format( KReserveLightL, target, restore, forceNoCCoeEnv );
            iAppContainer->AddMessageL( buf );
            iLight->ReserveLightL( target, restore, forceNoCCoeEnv );
            }
        else
            {
            // did not get ForceNoCCoeEnv parameter
            _LIT(KReserveLightLNotCalled, "ReserveLightL not called, no ForceNoCCoeEnv value");
            iAppContainer->AddMessageL( KReserveLightLNotCalled );
            }
        }
    else
        {
        // did not get restore parameter
        _LIT(KReserveLightLTarget, "ReserveLightL(target=%d)");
        buf.Format( KReserveLightLTarget, target );
        iAppContainer->AddMessageL( buf );
        iLight->ReserveLightL( target );
        }

    }
    
// -----------------------------------------------------------------------------
// CHWRMTestAppAppUi::LightsReleaseL
// Release lights
// -----------------------------------------------------------------------------
//
void CHWRMTestAppAppUi::LightsReleaseL()
    {
    TBuf<100> buf;
    TInt target(CHWRMLight::ENoTarget);
    
    // Get the lights target
    target = GetLightsTargetL();
    
    if( target == KErrCancel )
        {
        // no target entered
        _LIT(KReleaseLightNotCalled, "ReleaseLight not called, no target!");
        iAppContainer->AddMessageL( KReleaseLightNotCalled );
        }
    else
        {
        _LIT(KReleaseLight, "ReleaseLight(target=%d)");
        buf.Format( KReleaseLight, target );
        iAppContainer->AddMessageL( buf );
        iLight->ReleaseLight( target );
        }
    }

// -----------------------------------------------------------------------------
// CHWRMTestAppAppUi::LightsOnL
// Turn lights on
// -----------------------------------------------------------------------------
//
void CHWRMTestAppAppUi::LightsOnL()
    {
    TInt item(0);
    TInt duration(0);
    TInt intensity(0);
    TInt target(CHWRMLight::ENoTarget);
    TBool fade(EFalse);
    TBuf<100> buf;
    
    // Get the lights target
    target = GetLightsTargetL();
    
    if( target == KErrCancel )
        {
        // no target entered
        _LIT(KLightOnLNotCalled, "LightOnL not called, no target!");
        iAppContainer->AddMessageL( KLightOnLNotCalled );
        return;
        }
    
    //duration
    CAknNumberQueryDialog* queryDlg = CAknNumberQueryDialog::NewL( duration );
    if( queryDlg->ExecuteLD( R_HWRMTESTAPP_DURATION_QUERY ) )
        {
        // got duration so get intensity
        queryDlg = CAknNumberQueryDialog::NewL( intensity );
        if( queryDlg->ExecuteLD( R_HWRMTESTAPP_LIGHT_INTENSITY_QUERY ) )
            {
            // got the intenstity
            CAknListQueryDialog* listDlg = new (ELeave)CAknListQueryDialog( &item );
            if( listDlg->ExecuteLD(R_HWRMTESTAPP_FADE_LIST) )
                {
                // got fade parameter
                item == 0 ? fade = EFalse : fade = ETrue;
                _LIT(KLightOnLParameters, "LightOnL(target=%d,duration=%d,intensity=%d,fade=%d)");
                buf.Format( KLightOnLParameters, target, duration, intensity, fade );
                iAppContainer->AddMessageL( buf );
                iLight->LightOnL( target, duration, intensity, fade );
                }
            else
                {
                // did not get fade parameter
                _LIT(KLightOnL, "LightOnL not called, no fade value!");
                iAppContainer->AddMessageL( KLightOnL );
                }
            }
        else
            {
            // user pressed cancel for intensity query
            _LIT(KLightOnLTargetDuration, "LightOnL(target=%d,duration=%d)");
            buf.Format( KLightOnLTargetDuration, target, duration );
            iAppContainer->AddMessageL( buf );
            iLight->LightOnL( target, duration );
            }        
        }
    else
        {
        // didn't get duration so call basic API
        _LIT(KLightOnLTarget, "LightOnL(target=%d)");
        buf.Format( KLightOnLTarget, target );
        iAppContainer->AddMessageL( buf );
        }
    }

// -----------------------------------------------------------------------------
// CHWRMTestAppAppUi::LightsBlinkL
// Blink lights
// -----------------------------------------------------------------------------
//
void CHWRMTestAppAppUi::LightsBlinkL()
    {
    TInt duration(0);
    TInt onDuration(0);
    TInt offDuration(0);
    TInt intensity(0);
    TBuf<100> buf;
    
    // Get the lights target
    TInt target = GetLightsTargetL();
    if( target == KErrCancel )
        {
        // no target entered
        _LIT(KLightsBlinkNotCalled, "LightsBlink not called, no target!");
        iAppContainer->AddMessageL( KLightsBlinkNotCalled );
        return;
        }
    
    // get duration
    CAknNumberQueryDialog* queryDlg = CAknNumberQueryDialog::NewL( duration );
    if( queryDlg->ExecuteLD( R_HWRMTESTAPP_DURATION_QUERY ) )
        {
        // got duration so get OnDuration
        queryDlg = CAknNumberQueryDialog::NewL( onDuration );
        CleanupStack::PushL( queryDlg );
        
        _LIT(KEnterONDuration, "Enter ON duration (0 to 2147482)");
        queryDlg->SetPromptL( KEnterONDuration );
        
        CleanupStack::Pop( queryDlg );
        if( queryDlg->ExecuteLD( R_HWRMTESTAPP_DURATION_QUERY ) )
            {
            // got OnDuration so get OffDuration
            queryDlg = CAknNumberQueryDialog::NewL( offDuration );
            CleanupStack::PushL( queryDlg );
            
            _LIT(KEnterOFFDuration, "Enter OFF duration (0 to 2147482)");
            queryDlg->SetPromptL( KEnterOFFDuration );
            
            CleanupStack::Pop( queryDlg );
            if( queryDlg->ExecuteLD( R_HWRMTESTAPP_DURATION_QUERY ) )
                {
                // got OffDuration so get intensity
                queryDlg = CAknNumberQueryDialog::NewL( intensity );
                if( queryDlg->ExecuteLD( R_HWRMTESTAPP_LIGHT_INTENSITY_QUERY ) )
                    {
                    // got the intenstity
                    _LIT(KLightBlinkLParameters, "LightBlinkL(target=%d,duration=%d,onDuration=%d,offDuration=%d,intensity=%d)");
                    buf.Format( KLightBlinkLParameters,target, duration, onDuration, offDuration, intensity );
                    iAppContainer->AddMessageL( buf );
                    iLight->LightBlinkL( target, duration, onDuration,
                                         offDuration, intensity );
                    }
                else
                    {
                    // user pressed cancel for intensity
                    _LIT(KLightBlinkLNoIntensity, "LightBlinkL not called, no intensity value!");
                    iAppContainer->AddMessageL( KLightBlinkLNoIntensity );
                    }
                
                }
            else
                {
                // user pressed cancel for OffDuration
                _LIT(KLightBlinkLNoOffDuration, "LightBlinkL not called, no offDuration value!");
                iAppContainer->AddMessageL( KLightBlinkLNoOffDuration );
                }
            }
        else
            {
            // user pressed cancel for OnDuration
            _LIT(KLightBlinkLTargetDuration, "LightBlinkL(target=%d,duration=%d)");
            buf.Format( KLightBlinkLTargetDuration, target, duration );
            iAppContainer->AddMessageL( buf );
            }
        }
    else
        {
        // user pressed cancel for Duration
        _LIT(KLightBlinkLTarget, "LightBlinkL(target=%d)");
        buf.Format( KLightBlinkLTarget, target );
        iAppContainer->AddMessageL( buf );
        }
    }

// -----------------------------------------------------------------------------
// CHWRMTestAppAppUi::LightsOffL
// Turn lights off
// -----------------------------------------------------------------------------
//
void CHWRMTestAppAppUi::LightsOffL()
    {
    TInt item(0);
    TInt duration(0);
    TInt target(CHWRMLight::ENoTarget);
    TBool fade(EFalse);
    TBuf<100> buf;
    
    // Get the lights target
    target = GetLightsTargetL();
    
    if( target == KErrCancel )
        {
        // no target entered
        _LIT(KLightsOffLNoTarget, "LightsOffL not called, no target!");
        iAppContainer->AddMessageL( KLightsOffLNoTarget );
        return;
        }
    
    //duration
    CAknNumberQueryDialog* queryDlg = CAknNumberQueryDialog::NewL( duration );
    if( queryDlg->ExecuteLD( R_HWRMTESTAPP_DURATION_QUERY ) )
        {
        // got duration so get fade
        CAknListQueryDialog* listDlg = new (ELeave)CAknListQueryDialog( &item );
        if( listDlg->ExecuteLD(R_HWRMTESTAPP_FADE_LIST) )
            {
            // got fade parameter
            item == 0 ? fade = EFalse : fade = ETrue;
            _LIT(KLightOffLParameters, "LightOffL(target=%d,duration=%d,fade=%d)");
            buf.Format( KLightOffLParameters, target, duration, fade );
            iAppContainer->AddMessageL( buf );
            iLight->LightOffL( target, duration, fade );
            }
        else
            {
            // did not get fade parameter
            _LIT(KLightOffLTargetDuration, "LightOffL(target=%d,duration=%d)");
            buf.Format( KLightOffLTargetDuration, target, duration );
            iAppContainer->AddMessageL( buf );
            iLight->LightOffL( target, duration );
            }
        }
    else
        {
        // didn't get duration so call basic API
        _LIT(KLightOffLTarget, "LightOffL(target=%d)");
        buf.Format( KLightOffLTarget, target );
        iAppContainer->AddMessageL( buf );
        }
    }

// -----------------------------------------------------------------------------
// CHWRMTestAppAppUi::LightsStatusL
// Retrieve lights status
// -----------------------------------------------------------------------------
//
void CHWRMTestAppAppUi::LightsStatusL()
    {
    TInt target(CHWRMLight::ENoTarget);
    TBuf<100> buf;
    
    // Get the lights target
    target = GetLightsTargetL();
    
    if( target == KErrCancel )
        {
        // no target entered
        _LIT(KLightStatusNoTarget, "LightStatus not called, no target!");
        iAppContainer->AddMessageL( KLightStatusNoTarget );
        }
    else
        {
        _LIT(KLightStatusTarget, "LightStatus(target=%d)");
        buf.Format( KLightStatusTarget, target );
        iAppContainer->AddMessageL( buf );
        LightStatusChanged( target, iLight->LightStatus( target ) );
        }
    }

// -----------------------------------------------------------------------------
// CHWRMTestAppAppUi::GetLightsTargetL
// Retrieve lights target
// -----------------------------------------------------------------------------
//
TInt CHWRMTestAppAppUi::GetLightsTargetL()
    {
    TInt item(0);
    TInt ret(KErrCancel);
    
    CAknListQueryDialog* listDlg = new (ELeave)CAknListQueryDialog( &item );
    if( listDlg->ExecuteLD(R_HWRMTESTAPP_LIGHTSTARGET_LIST) )
        {
        // This is a lookup table for the items defined in the
        // resource array r_hwrmtestapp_lightstarget_items
        switch ( item )
            {
            case 0: // ENoTarget
                {
                ret = CHWRMLight::ENoTarget;
                break;
                }
            case 1: // EPrimaryDisplay
                {
                ret = CHWRMLight::EPrimaryDisplay;
                break;
                }
            case 2: // EPrimaryKeyboard
                {
                ret = CHWRMLight::EPrimaryKeyboard;
                break;
                }
            case 3: // EPrimaryDisplayAndKeyboard
                {
                ret = CHWRMLight::EPrimaryDisplayAndKeyboard;
                break;
                }
            case 4: // ESecondaryDisplay
                {
                ret = CHWRMLight::ESecondaryDisplay;
                break;
                }
            case 5: // ESecondaryKeyboard
                {
                ret = CHWRMLight::ESecondaryKeyboard;
                break;
                }
            case 6: // ESecondaryDisplayAndKeyboard
                {
                ret = CHWRMLight::ESecondaryDisplayAndKeyboard;
                break;
                }
            default:
                break;
            }             
        }
    else
        {
        // no target entered
        ret = KErrCancel;
        }
    
    return ret;
    }


// =============================================================================
//                      MHWRMVibraObserver METHODS
// =============================================================================

// -----------------------------------------------------------------------------
// CHWRMTestAppAppUi::VibraModeChanged
// Callback for when vibra mode is changed
// -----------------------------------------------------------------------------
//
void CHWRMTestAppAppUi::VibraModeChanged(CHWRMVibra::TVibraModeState aStatus)
    {
    _LIT(KVibraModeStateChanged, "Vibra mode state changed:");
    TRAP_IGNORE( 
        iAppContainer->AddMessageL( KVibraModeStateChanged );
        switch ( aStatus )
            {
            case CHWRMVibra::EVibraModeUnknown:
                {
                _LIT(KEVibraModeUnknown, "  EVibraModeUnknown");
                iAppContainer->AddMessageL( KEVibraModeUnknown );
                break;
                }
            case CHWRMVibra::EVibraModeON:
                {
                _LIT(KEVibraModeOn, "  EVibraModeON");
                iAppContainer->AddMessageL( KEVibraModeOn );
                break;
                }
            case CHWRMVibra::EVibraModeOFF:
                {
                _LIT(KEVibraModeOff, "  EVibraModeOFF");
                iAppContainer->AddMessageL( KEVibraModeOff );
                break;
                }
            default:
                {
                _LIT(KVibraModeUndefined, "  UNDEFINED !!!");
                iAppContainer->AddMessageL( KVibraModeUndefined );
                break;
                }
            }
        ); // TRAP_IGNORE
    }

// -----------------------------------------------------------------------------
// CHWRMTestAppAppUi::VibraStatusChanged
// Callback for when vibra status is changed
// -----------------------------------------------------------------------------
//
void CHWRMTestAppAppUi::VibraStatusChanged(CHWRMVibra::TVibraStatus aStatus)
    {
    _LIT(KVibraStateChanged, "Vibra state changed:");
    TRAP_IGNORE(
        iAppContainer->AddMessageL( KVibraStateChanged );
        switch ( aStatus )
            {
            case CHWRMVibra::EVibraStatusUnknown:
                {
                _LIT(KEVibraStatusUnknown, "  EVibraStatusUnknown");
                iAppContainer->AddMessageL( KEVibraStatusUnknown );
                break;
                }
            case CHWRMVibra::EVibraStatusNotAllowed:
                {
                _LIT(KEVibraStatusNotAllowed, "  EVibraStatusNotAllowed");
                iAppContainer->AddMessageL( KEVibraStatusNotAllowed );
                break;
                }
            case CHWRMVibra::EVibraStatusStopped:
                {
                _LIT(KEVibraStatusStopped, "  EVibraStatusStopped");
                iAppContainer->AddMessageL( KEVibraStatusStopped );
                break;
                }
            case CHWRMVibra::EVibraStatusOn:
                {
                _LIT(KEVibraStatusOn, "  EVibraStatusOn");
                iAppContainer->AddMessageL( KEVibraStatusOn );
                break;
                }
            default:
                {
                _LIT(KVibraStatusUndefined, "  UNDEFINED !!!");
                iAppContainer->AddMessageL( KVibraStatusUndefined );
                break;
                }
            }
        ); // TRAP_IGNORE
    }


// =============================================================================
//                      MHWRMLightObserver METHODS
// =============================================================================

// -----------------------------------------------------------------------------
// CHWRMTestAppAppUi::LightStatusChanged
// Callback for when lights status is changed
// -----------------------------------------------------------------------------
//
void CHWRMTestAppAppUi::LightStatusChanged(TInt aTarget, 
                        CHWRMLight::TLightStatus aStatus)
    {
    TRAP_IGNORE(
        TBuf<100> buf;
        _LIT(KLightStateChangedForTarget, "Light state changed for target:");
        iAppContainer->AddMessageL( KLightStateChangedForTarget );
                _LIT( KHexTarget, " 0x%x");
                buf.Format(KHexTarget, aTarget);
        iAppContainer->AddMessageL( buf );
        
        switch ( aStatus )
            {
            case CHWRMLight::ELightOn:
                {
                _LIT(KLightChangedOn, "Light state changed: ELightOn");
                iAppContainer->AddMessageL( KLightChangedOn );
                break;
                }
            case CHWRMLight::ELightOff:
                {
                _LIT(KLightChangedOff, "Light state changed: ELightOff");
                iAppContainer->AddMessageL( KLightChangedOff );
                break;
                }
            case CHWRMLight::ELightBlink:
                {
                _LIT(KLightChangedBlink, "Light state changed: ELightBlink");
                iAppContainer->AddMessageL( KLightChangedBlink );
                break;
                }
            case CHWRMLight::ELightStatusUnknown:
                {
                _LIT(KLightChangedUnknown, "Light state changed: ELightStatusUnknown");
                iAppContainer->AddMessageL( KLightChangedUnknown );
                break;
                }
            default:
                {
                _LIT(KLightChangedUndefined, "Light state changed: UNDEFINED !!!");
                iAppContainer->AddMessageL( KLightChangedUndefined );
                break;
                }
            }
        ); // TRAP_IGNORE
    }


// End of File  

---

© Nokia 2006