/*
* Copyright (c) 2002-2007 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of "Eclipse Public License v1.0"
* which accompanies this distribution, and is available
* at the URL "http://www.eclipse.org/legal/epl-v10.html".
*
* Initial Contributors:
* Nokia Corporation - initial contribution.
*
* Contributors:
*
* Description:  UI class of Psln.
*
*/


// INCLUDE FILES

#include "PslnUi.h"

#include <barsread.h>
#include <StringLoader.h>

// Navi pane, Title Pane & Tab groups
#include <aknnavi.h>
#include <aknnavide.h>
#include <akntitle.h>

// Notes & Dialogs
#include <AknGlobalNote.h>
#include <aknnotewrappers.h>

// DRM.
#include <DRMHelper.h>
#include <DRMRights.h>

// Psln specific.
#include <psln.rsg>
#include "PslnModel.h"
#include "PslnSkinEntry.h"
#include "PslnFeatures.h"
#include "PslnSoundActivator.h"
#include "pslntaskactivatesounds.h"
#include "pslntaskgenericupdate.h"
#include "pslnidletaskcreateviews.h"
#include "PslnConst.h"
#include "PslnDebug.h"
#include "PslnModel.h"
#include "PslnPropertySubscriber.h"

// Views
#include "PslnMainView.h"
#include "PslnGeneralThemeView.h"
#include "PslnScreenSaverView.h"
#include "PslnWallpaperView.h"

// Framework
#include "PslnPluginHandler.h"
#include <pslnfwplugininterface.h>
#include <pslnfwbaseview.h>

// Help texts
#include <hlplch.h>
#include <csxhelp/skins.hlp.hrh>
#include <UsbWatcherInternalPSKeys.h>           // KPSUidUsbWatcher
#include <usbpersonalityids.h>                  // Usb Personality Ids

// Sets internal state correctly when leave occurs in skin changing.

// Handles application exit correctly when leave occurs in exiting.
void HandleExitLeave( TAny* aPtr )
    {
    CPslnUi* psln = static_cast<CPslnUi*>(aPtr);
    psln->HandleCmdExitLeave();
    }

// ========================= MEMBER FUNCTIONS ================================
// ---------------------------------------------------------------------------
// C++ constructor can NOT contain any code, that might leave.
// ---------------------------------------------------------------------------
//
CPslnUi::CPslnUi() : iPslnUiStatus ( EPslnCreated )
    {
    }

// ---------------------------------------------------------------------------
// Symbian two-phased constructor.
// ---------------------------------------------------------------------------
//
void CPslnUi::ConstructL()
    {
    PSLN_TRACE_DEBUG1("CPslnUi::ConstructL, Start:%d", User::NTickCount() );

    BaseConstructL( EAknEnableSkin | EAknEnableMSK | EAknSingleClickCompatible );
    EnableExternalViewSwitches(ETrue);

    // Create ECOM plugin loader.
    PSLN_TRACE_DEBUG("CPslnUi::ConstructL PluginHandler");
    iPluginHandler = CPslnPluginHandler::NewL( this );

    PSLN_TRACE_DEBUG("CPslnUi::ConstructL Model");
    // Force creation of model, since it is anyway created when ANY view is
    // activated.
    CreateModelL();

    PSLN_TRACE_DEBUG("CPslnUi::ConstructL StatusPane");
    // Show tabs for main views from resources
    CEikStatusPane* sp = StatusPane();
    if ( sp )
        {
        // Fetch pointer to the default navi pane control
        iNaviPane = (CAknNavigationControlContainer*)sp->ControlL(
            TUid::Uid(EEikStatusPaneUidNavi));
        }

    // New main view
    PSLN_TRACE_DEBUG("CPslnUi::ConstructL View-Main");
    CPslnMainView* view = CPslnMainView::NewLC();
    AddViewL( view );          // transfer ownership to CAknViewAppUi
    CleanupStack::Pop( view ); // the view has to be popped from cleanupstack here
    iMainView = view;
    SetDefaultViewL( *view );

    iIdleActivateSkin = CIdle::NewL( CActive::EPriorityIdle );
    iIdleUpdateSkin = CIdle::NewL( CActive::EPriorityIdle );
    
    PSLN_TRACE_DEBUG("CPslnUi::ConstructL OK");
    User::LeaveIfError( iEnableUSBWatchProperty.Attach(
          KPSUidUsbWatcher, KUsbWatcherSelectedPersonality) );
    iUSBWatchSubscriber = new (ELeave) CPslnPropertySubscriber(
        TCallBack(USBCallBackL, this), iEnableUSBWatchProperty );
    iUSBWatchSubscriber->Subscribe();
    
    
    TInt value = KErrNone;
    iEnableUSBWatchProperty.Get(value);
    if (value == KUsbPersonalityIdMS)
        {
        iUSBAttached = ETrue;
        }
    else
        {
        iUSBAttached = EFalse;
        }
    }

// ---------------------------------------------------------------------------
// Destructor
// ---------------------------------------------------------------------------
//
CPslnUi::~CPslnUi()
    {
    PSLN_TRACE_DEBUG("CPslnUi::Destructor");

    // Reset skin info when exiting normally. This prevents model class
    // from trying to revert back to previous skin.
    if ( iView && iView->Id().iUid == KPslnMainView2.iUid )
        {
        // It is possible that Model is not created, if exiting immediately after
        // application launch. So first check that Model is created.
        if ( iModel )
            {
            TInt currentlySelected = iModel->ActiveSkinIndex();
            iModel->SetCurrentSelectedSkinIndex( currentlySelected );
            }
        }
    delete iModel;
    // This nullification is needed, since external DLL's may try to access
    // model through view framework and it might succeed even if model and UI
    // classes are already deleted, but external DLLs aren't.
    // This is due to that model reference is passed as a pointer due to delayed
    // construction - it is not available at the time when view is constructed.
    iModel = NULL;
    delete iDecoratedTabGroup;

    if ( iPluginHandler )
        {
        delete iPluginHandler;
        }

    delete iIdleTask;
    delete iIdleActivateSkin;
    delete iIdleUpdateSkin;
    
    
    if( iUSBWatchSubscriber )
        {
        iUSBWatchSubscriber->Cancel();
        }
    iEnableUSBWatchProperty.Close();
    delete iUSBWatchSubscriber;
    }

// ---------------------------------------------------------------------------
// Handles event when focus loss or gain.
// ---------------------------------------------------------------------------
//
void CPslnUi::HandleWsEventL( const TWsEvent& aEvent, CCoeControl* aDestination )
    {
    PSLN_TRACE_DEBUG("CPslnUi::HandlwWSEvent");
    if ( iView )
        {
        TInt eventType = aEvent.Type();
        TUid currentView = iView->Id();

        // do this everytime when foreground gained.
        if ( ( currentView.iUid == KPslnGeneralView.iUid ) &&
             ( eventType == EEventFocusGained ) &&
             ( GetStatus( EPslnListUpdateNeeded )  ||
               GetStatus( EPslnProtectedSkinInList ) ) && IsForeground() )
            {
            PSLN_TRACE_DEBUG("CPslnUi::HandlwWSEvent Update list");
            SetStateOff( EPslnListUpdateNeeded );
            DoCreateWaitNoteL();
            }
        }
    CAknViewAppUi::HandleWsEventL( aEvent, aDestination );
    }

// ---------------------------------------------------------------------------
// Handles commands directed to this class.
// ---------------------------------------------------------------------------
//
void CPslnUi::HandleCommandL( TInt aCommand )
    {
    PSLN_TRACE_DEBUG1("CPslnUi::HandleCommand %d", aCommand );
    switch ( aCommand )
        {
        //both exit commands should do the same thing
        case EEikCmdExit:
        case EAknCmdExit:
        case EAknSoftkeyExit:
            HandleCmdExitL();
            break;

        case EPslnCmdAppActivate:
            {
            if (!iIdleActivateSkin->IsActive())
                {
                iIdleActivateSkin->Start(TCallBack( DoActivateSkinL, this ));
                }
            }
            break;
        case EPslnCmdAppDownload:
            DownloadSkinL();
            break;
        case EAknCmdHelp:
        case EPslnCmdAppHelp:
            {
            HlpLauncher::LaunchHelpApplicationL(
                iEikonEnv->WsSession(), AppHelpContextL());
            }
            break;
        case EAknSoftkeyBack:
            // If General view is active and Back key is
            // pressed and there is skin activation ongoing
            // set internal state off.
            if ( iView && GetStatus( EPslnSkinChangeRequested ) &&
                   ( iView->Id().iUid == KPslnGeneralView.iUid )  )
                {
                SetStateOff( EPslnSkinChangeRequested );
                }
            ActivateLocalViewL( KPslnMainView2 );
            break;
        default:
            CAknViewAppUi::HandleCommandL( aCommand );
            break;
        }
    }

// ---------------------------------------------------------------------------
// CPslnUi::HandleResourceChangeL
// ---------------------------------------------------------------------------
//
void CPslnUi::HandleResourceChangeL( TInt aType )
    {
    PSLN_TRACE_DEBUG("CPslnUi::HandleResourceChangeL");
    if (  iView && !GetStatus( EPslnSkinChangeRequested ) &&
          iView->Id().iUid == KPslnGeneralView.iUid &&
          aType == KAknsMessageSkinChange )
        {
        iGeneralThemeView->UpdateSkinListItemsDColumnOnlyL();
        }
    CAknViewAppUi::HandleResourceChangeL( aType );
    }

// ---------------------------------------------------------------------------
// CPslnUi::ActivateLocalViewL
// ---------------------------------------------------------------------------
//
void CPslnUi::ActivateLocalViewL( TUid aViewId )
    {
    if ( GetStatus( EPslnListUpdateNeeded ) &&
         ( aViewId.iUid == KPslnGeneralView.iUid ) )
        {
        PSLN_TRACE_DEBUG("CPslnUi::ActivateLocalViewL update list");
        SetStateOff( EPslnListUpdateNeeded );
        DoCreateWaitNoteL();
        }
    CAknViewAppUi::ActivateLocalViewL( aViewId );
    }

// ---------------------------------------------------------------------------
// CPslnUi::SkinContentChanged
// ---------------------------------------------------------------------------
//
void CPslnUi::SkinContentChanged()
    {
    PSLN_TRACE_DEBUG("CPslnUi::SkinContentChanged");
    if ( !iView || iView->Id().iUid != KPslnGeneralView.iUid  )
        {
        SetStateOn( EPslnListUpdateNeeded );
        }
    }

// ---------------------------------------------------------------------------
// CPslnUi::SkinConfigurationChanged
// ---------------------------------------------------------------------------
//
void CPslnUi::SkinConfigurationChanged(
    const TAknsSkinStatusConfigurationChangeReason aReason )
    {
    PSLN_TRACE_DEBUG("CPslnUi::SkinConfigurationChanged");
    TRAPD( err, SkinConfigurationChangedL( aReason ) );
    if ( err != KErrNone )
        {
        TRAP_IGNORE( iGeneralThemeView->UpdateSkinListItemsL() );
        TRAP_IGNORE( ToggleScreenBlankerL( EFalse, EFalse ) );
        }
    }

// ---------------------------------------------------------------------------
// CPslnUi::SkinPackageChanged
// ---------------------------------------------------------------------------
//
void CPslnUi::SkinPackageChanged(
    const TAknsSkinStatusPackageChangeReason aReason )
    {
    PSLN_TRACE_DEBUG("CPslnUi::SkinPackageChanged");
    if ( aReason == EAknsSkinStatusPackageListUpdate )
        {
        if ( !iView || iView->Id().iUid != KPslnGeneralView.iUid )
            {
            SetStateOn( EPslnListUpdateNeeded );
            }
        else
            {
            PSLN_TRACE_DEBUG("CPslnUi::SkinPackageChanged update list");
            //To Fix Defect:ESNN-7CXCT2:Themes: Layout is incorrect 
            //when removing memory card which the active theme is installed in.
            //DoCreateWaitNoteL take too much time and stop the skin refresh.
            //Need to wait for the Skin Server finish its work,so we use CIdle.
            //Also we need User::After to delay some time to make sure 
            //iIdleUpdateSkin start late enough.
            User::After(KPslnUpdateSkinDelay);
            if (!iIdleUpdateSkin->IsActive())
                {
                iIdleUpdateSkin->Start(TCallBack( DoCreateWaitNoteL, this ));
                }
            SetStateOff( EPslnListUpdateNeeded );
            }
        }
    }

// ---------------------------------------------------------------------------
// Return model pointer.
// ---------------------------------------------------------------------------
//
CPslnModel* CPslnUi::Model() const
    {
    return iModel;
    }

// ---------------------------------------------------------------------------
// Updates tab group to current tab index
// The parameters are optional.
// ---------------------------------------------------------------------------
//
#ifdef RD_CONTROL_PANEL
void CPslnUi::UpdateTabIndex( const TInt aMyId, const TInt /*aMyTabIndex*/ )
#else
void CPslnUi::UpdateTabIndex( const TInt /*aMyId*/, const TInt aMyTabIndex )
#endif // RD_CONTROL_PANEL
    {
#ifdef RD_CONTROL_PANEL
    if ( aMyId != KErrNotFound )
        {
        if ( iMainView )
            {
            iMainView->SetActiveFolder( TUid::Uid( aMyId ) );
            }
        }
#else
    if ( aMyTabIndex != KErrNotFound )
        {
        if ( iTabGroup )
            {
            iTabGroup->SetActiveTabById( aMyTabIndex );
            }
        }
    if ( ( iView == iMainView ) && iTabGroup && iMainView )
        {
        iTabGroup->SetActiveTabByIndex( iMainView->ActiveView() );
        }
#endif //RD_CONTROL_PANEL
    }

// ---------------------------------------------------------------------------
// Creates given view.
// ---------------------------------------------------------------------------
//
void CPslnUi::CreateViewL( TUid aViewUid )
    {
    PSLN_TRACE_DEBUG1("CPslnUi::CreateViewL, Start:%d", User::NTickCount() );
    TBitFlags views = ViewSupport();

if ( aViewUid == KPslnWallpaperView &&
              !GetStatus( EPslnWallpaperViewCreated ) )
        {

        if ( views.IsSet( EPslnWallpaperView ) )
            {
            CAknView* view = CPslnWallpaperView::NewLC();
            AddViewL( view );          // transfer ownership to CAknViewAppUi
            CleanupStack::Pop( view );

            SetStateOn( EPslnWallpaperViewCreated );

            PSLN_TRACE_DEBUG("CPslnUi::CreateViewL - Wallpaper");
            PSLN_TRACE_DEBUG1("CPslnUi::CreateViewL, End:%d", User::NTickCount() );
            }
        }
    // Screensaver view.
    else if ( aViewUid == KPslnScreenSaverView &&
              !GetStatus( EPslnScreenSaverViewCreated ) )
        {
        if ( views.IsSet( EPslnScreensaverView ) )
            {
            CAknView* view = CPslnScreenSaverView::NewLC();
            AddViewL( view );          // transfer ownership to CAknViewAppUi
            CleanupStack::Pop( view );

            SetStateOn( EPslnScreenSaverViewCreated );

            PSLN_TRACE_DEBUG("CPslnUi::CreateViewL - ScreenSaver");
            PSLN_TRACE_DEBUG1("CPslnUi::CreateViewL, End:%d", User::NTickCount() );
            }
        }
    // General view.
    else if ( aViewUid.iUid == KPslnGeneralView.iUid &&
              !GetStatus( EPslnGeneralViewCreated ) )
        {
        CAknView* view = CPslnGeneralThemeView::NewLC();
        AddViewL( view );          // transfer ownership to CAknViewAppUi
        iGeneralThemeView = static_cast< CPslnGeneralThemeView* >( view );
        CleanupStack::Pop( view );

        SetStateOn( EPslnGeneralViewCreated );

        PSLN_TRACE_DEBUG("CPslnUi::CreateViewL - General");
        PSLN_TRACE_DEBUG1("CPslnUi::CreateViewL, End:%d", User::NTickCount() );
        }
    }

// ---------------------------------------------------------------------------
// Return navi control container pointer.
// ---------------------------------------------------------------------------
//
CAknNavigationControlContainer* CPslnUi::NaviContainer() const
    {
    return iNaviPane;
    }

// ---------------------------------------------------------------------------
// Return tab group pointer.
// ---------------------------------------------------------------------------
//
CAknNavigationDecorator* CPslnUi::PslnTabGroup()
    {
     if ( !GetStatus( EPslnTabGroupCreated ) )
         {
         TRAP_IGNORE( ConstructTabGroupL() );
         }
    return iDecoratedTabGroup;
    }

// ---------------------------------------------------------------------------
// Return plugin handler pointer.
// ---------------------------------------------------------------------------
//
CPslnPluginHandler* CPslnUi::PluginHandler() const
    {
    return iPluginHandler;
    }

// ---------------------------------------------------------------------------
// Adds new view to UI class, if the UI class is not already completed.
// ---------------------------------------------------------------------------
//
void CPslnUi::AddNewViewL( CAknView* aNewView )
    {
    if ( GetStatus( EPslnCreated ) )
        {
        if ( aNewView && !View( aNewView->Id() ) )
            {
            AddViewL( aNewView );
            }
        }
    }

// ---------------------------------------------------------------------------
// When this method is called, UI class considers itself to be complete.
// ---------------------------------------------------------------------------
//
void CPslnUi::AllViewsDone()
    {
    SetStateOff( EPslnCreated );
    }

// ---------------------------------------------------------------------------
// Handles errors that occur when handling images.
// ---------------------------------------------------------------------------
//
void CPslnUi::HandleImageErrorsL( TInt aError )
    {
    PSLN_TRACE_DEBUG1("CPslnUi::HandleImageError %d", aError );
    if ( aError == KErrNoMemory || aError == KErrTooBig )
        {
        // Show information note
        HBufC* prompt = iCoeEnv->AllocReadResourceLC( R_PSLN_IMAGE_TOO_LARGE );
        CAknInformationNote* note = new (ELeave) CAknInformationNote( ETrue );
        note->ExecuteLD( *prompt );
        CleanupStack::PopAndDestroy( prompt );
        }
    else if ( aError == KErrCancel || aError == KErrCouldNotConnect )
        {
        // Other error codes are ignored; as not real errors (i.e. KErrCancel),
        // or such errors that Psln cannot react to them (KErrCouldNotConnect)
        }
    else
        {
        // Show information note
        HBufC* prompt = iCoeEnv->AllocReadResourceLC( R_PSLN_IMAGE_CORRUPTED );
        CAknInformationNote* note = new (ELeave) CAknInformationNote( ETrue );
        note->ExecuteLD( *prompt );
        CleanupStack::PopAndDestroy( prompt );
        }
    }

// ---------------------------------------------------------------------------
// Indicate that tab group has been changed.
// ---------------------------------------------------------------------------
//
#ifndef RD_CONTROL_PANEL
void CPslnUi::TabChangedL( TInt aIndex )
    {
    PSLN_TRACE_DEBUG("CPslnUi::TabChangedL 1" );
    // If it is one of the dynamically created views, check if the view is
    // already created. If view is not created, create it.
    if ( aIndex == KPslnGeneralView.iUid )
        {
        if ( !GetStatus( EPslnGeneralViewCreated ) )
            {
            CreateViewL( KPslnGeneralView );
            }
        }
    else if ( aIndex == KPslnWallpaperView.iUid )
        {
        if ( !GetStatus( EPslnWallpaperViewCreated ) )
            {
            CreateViewL( KPslnWallpaperView );
            }
        }
    else if ( aIndex == KPslnScreenSaverView.iUid )
        {
        if ( !GetStatus( EPslnScreenSaverViewCreated ) )
            {
            CreateViewL( KPslnScreenSaverView );
            }
        }
    if ( iMainView )
        {
        iMainView->SetActiveFolder( aIndex );
        ActivateLocalViewL( TUid::Uid( iMainView->ActiveFolderUid() ) );
        }
    }
#endif //RD_CONTROL_PANEL

// ---------------------------------------------------------------------------
// Loads views when application is idle.
// ---------------------------------------------------------------------------
//
void CPslnUi::LoadViewsWhenIdleL()
    {
    if ( !iIdleTask )
        {
        iIdleTask = CPslnIdleTaskCreateViews::NewL( this );
        }
    }

// ---------------------------------------------------------------------------
// Constructs the Tab group.
// ---------------------------------------------------------------------------
void CPslnUi::ConstructTabGroupL()
    {
#ifdef RD_CONTROL_PANEL
    return;
#else
    if ( GetStatus( EPslnTabGroupCreated ) )
        {
        // Tabgroup has already been created.
        return;
        }
    // Tabgroup has been read from resource and it were pushed to the navi pane.
    // Get pointer to the navigation decorator
    // and set this to be a MAknTabObserver.
    if ( iNaviPane )
        {
        iDecoratedTabGroup = iNaviPane->ResourceDecorator();
        }
    if ( iDecoratedTabGroup )
        {
        PSLN_TRACE_DEBUG("CPslnUi::ConstructTabGroupL DecoTabGrp");
        iTabGroup = static_cast <CAknTabGroup*>
            ( iDecoratedTabGroup->DecoratedControl() );
        iTabGroup->SetObserver( this );
        }
    TInt tabCount = 1; // index 0 = general view
    TBitFlags views = ViewSupport();

    // Update Tab group to contain default plugins.
    if ( iPluginHandler )
        {
        CPslnFWPluginInterface* plugin =
            iPluginHandler->GetPlugin( KPslnASPluginUid );
        if ( plugin )
            {
            AddPluginToTab( *plugin );
            static_cast <CPslnFWBaseView*>
                (plugin)->SetNaviPaneDecorator( iDecoratedTabGroup );
            tabCount++; // index 1 = AS plugin
            }
        plugin = iPluginHandler->GetPlugin( KPslnAIPluginUid );
        if ( plugin )
            {
            AddPluginToTab( *plugin );
            static_cast <CPslnFWBaseView*>
                (plugin)->SetNaviPaneDecorator( iDecoratedTabGroup );
            tabCount++; // index 2 = AI plugin
            }
        }

    // Add tabs for screen saver and wallpaper.
    if ( iTabGroup )
        {
        if ( views.IsSet( EPslnWallpaperView ) )
            {
            TResourceReader reader;
            iCoeEnv->CreateResourceReaderLC( reader, R_PSLN_WALLPAPER_TAB );
            iTabGroup->AddTabL( reader );
            CleanupStack::PopAndDestroy(); // reader - AppUi now owns this tab,
            tabCount++; // index 3 = Wallpaper view
            }

        if ( views.IsSet( EPslnScreensaverView ) )
            {
            TResourceReader reader2;
            iCoeEnv->CreateResourceReaderLC( reader2, R_PSLN_SCREENSAVER_TAB );
            iTabGroup->AddTabL( reader2 );
            CleanupStack::PopAndDestroy(); // reader2  - AppUi now owns this tab,
            tabCount++; // index 4 = Screensaver view
            }
        PSLN_TRACE_DEBUG("CPslnUi::ConstructTabGroupL Default Tabs added to TabGrp");
        }

    // Add rest of the plugins to tabs.
    if ( iPluginHandler )
        {
        // Fetch the plugin array.
        CArrayPtrFlat<CPslnFWPluginInterface>* pluginArray =
            iPluginHandler->GetPluginArray();
        CleanupStack::PushL( pluginArray );
        TInt pluginCount = pluginArray->Count();
        PSLN_TRACE_DEBUG1("CPslnUi::ConstructTabGroupL Plugin count=%d", pluginCount );

        // Go through all the plugins and add plugins to tab group.
        for ( TInt i = 0; i < pluginCount; i++ )
            {
            CPslnFWPluginInterface* plugin = pluginArray->operator[]( i );

            if ( !plugin )
                {
                PSLN_TRACE_DEBUG("CPslnUi::ConstructTabGroupL Plugin fails");
                }
            // Default plugins can be skipped.
            else if ( plugin->Id().iUid == KPslnASPluginUid.iUid ||
                      plugin->Id().iUid == KPslnAIPluginUid.iUid )
                {
                PSLN_TRACE_DEBUG("CPslnUi::ConstructTabGroupL Plugin skipped");
                }
            else
                {
                PSLN_TRACE_DEBUG1("CPslnUi::ConstructTabGroupL Plugin Id=%d", plugin->Id().iUid );
                AddPluginToTab( *plugin );
                static_cast <CPslnFWBaseView*>
                    (plugin)->SetNaviPaneDecorator( iDecoratedTabGroup );
                // Inform to the plugin which tab index it is using.
                static_cast <CPslnFWBaseView*>
                    (plugin)->SetTabIndex( tabCount++ );
                PSLN_TRACE_DEBUG("CPslnUi::ConstructTabGroupL Plugin added to tab");
                }
            }
        CleanupStack::Pop( pluginArray ); // plugin handler owns plugin array
        }
    // Push empty navi pane, so that tab group is not shown with default item (first),
    // if other than main view is activated externally.
    iNaviPane->PushDefaultL();
    SetStateOn( EPslnTabGroupCreated );
#endif //RD_CONTROL_PANEL
    }

// ---------------------------------------------------------------------------
// Activates screen blanker. Note that second parameter is only used when
// enabling blanker (i.e. first parameter is ETrue ).
// ---------------------------------------------------------------------------
void CPslnUi::ToggleScreenBlankerL( 
    const TBool& aToggleValue, const TBool& /*aStatusPaneVisible*/, const TBool& aRealAct )
    {
    TInt transitionEffectsValue = iModel->GetTransitionEffectStateL();
    if ( aToggleValue )
        {
        // Effects are enabled if value is NOT KMaxTInt.
        if( transitionEffectsValue != KMaxTInt )
            {
            if ( aRealAct )
                {
                iModel->TransEffect(EPslnTransitionEffectStartThemeActivation);
                }
            else
                {
                iModel->TransEffect(EPslnTransitionEffectStartPreview);
                }
            }
//        else if ( iView && iView->MenuBar()->IsDisplayed() )
//            {
//            iView->MenuBar()->StopDisplayingMenuBar();
//            }
        }
    else
        {
        // Effects are enabled if value is NOT KMaxTInt.
        if( transitionEffectsValue != KMaxTInt )
            {
            iModel->TransEffect(EPslnTransitionEffectStop);
            }
//        else if ( iView && iView->MenuBar()->IsDisplayed() )
//            {
//            iView->MenuBar()->MenuPane()->DrawNow();
//            }
        }
    }


// ---------------------------------------------------------------------------
// Is this class able to handle a new skin activation related command.
// ---------------------------------------------------------------------------
TBool CPslnUi::IsReadyToHandleCommands()
    {
    return !GetStatus( EPslnSkinChangeRequested );
    }

// ---------------------------------------------------------------------------
// Ensure that Exit() is called when trying to exit and leave occurs.
// ---------------------------------------------------------------------------
void CPslnUi::HandleCmdExitLeave()
    {
    Exit();
    }

// ---------------------------------------------------------------------------
// Sets title pane back to default text.
// ---------------------------------------------------------------------------
void CPslnUi::SetTitleToDefaultL()
    {
    // Set default title back. But do not change title when application is about
    // to die.
    if ( iCoeEnv && Model() )
        {
        TResourceReader rReader;
        iCoeEnv->CreateResourceReaderLC( rReader, R_PSLN_SKIN_LIST_VIEW_TITLE );
        if ( iAvkonAppUi )
            {
            CEikStatusPane* sp = iAvkonAppUi->StatusPane();
            if ( sp )
                {
                CAknTitlePane* title = static_cast<CAknTitlePane*>(
                    sp->ControlL( TUid::Uid( EEikStatusPaneUidTitle ) ) );

                if ( title )
                    {
                    title->SetFromResourceL( rReader );
                    }
                }
            }
        CleanupStack::PopAndDestroy(); // rReader
        }
    }

// ---------------------------------------------------------------------------
// Checks if a view has been created.
// ---------------------------------------------------------------------------
TBitFlags CPslnUi::ViewSupport()
    {
    // Initially all views are 'on'.
    TBitFlags viewFlags;
    viewFlags.SetAll();
    if ( GetStatus( EPslnViewSupportChecked ) )
        {
        if ( GetStatus( EPslnNoScreenSaverView ) )
            {
            viewFlags.Clear( EPslnScreensaverView );
            }
        if ( GetStatus( EPslnNoWallpaperView ) )
            {
            viewFlags.Clear( EPslnWallpaperView );
            }
        }
    else
        {
        TBool noWallpaperView = PslnFeatures::IsSupported( KPslnRemoveWallpaper );
        TBool noScreenSaverView = PslnFeatures::IsSupported( KPslnRemoveScreensaver );
        if ( noWallpaperView )
            {
            SetStateOn( EPslnNoWallpaperView );
            viewFlags.Clear( EPslnWallpaperView );
            }
        if ( noScreenSaverView )
            {
            SetStateOn( EPslnNoScreenSaverView );
            viewFlags.Clear( EPslnScreensaverView );
            }
        SetStateOn( EPslnViewSupportChecked );
        }
    return viewFlags;
    }

// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
void CPslnUi::SetDRMProtectedSkinInSkinList(
    const TBool& aProtectedSkinInList )
    {
    if ( aProtectedSkinInList )
        {
        SetStateOn( EPslnProtectedSkinInList );
        }
    else
        {
        SetStateOff( EPslnProtectedSkinInList );
        }
    }


// -----------------------------------------------------------------------------
// Callback - USB status change.
// -----------------------------------------------------------------------------
//
TInt CPslnUi::USBCallBackL(TAny* aPtr)
    {
    CPslnUi* self = static_cast<CPslnUi*>(aPtr);
    if ( self )
        {
        self->HandleUSBCallBackL();
        }
    return KErrNone;
    }
    
    
    /**
    * USB Attach State.
    * @return ETrue when USB already attached, otherwise EFalse,
    */
// ---------------------------------------------------------------------------
// USB Attach State.
// ---------------------------------------------------------------------------
TBool CPslnUi::USBAttachState()
    {
    return iUSBAttached;
    }

// ---------------------------------------------------------------------------
// Called when a key is pressed and no other class has catched the event.
// Handles only key events that are meant to control the tab group.
// ---------------------------------------------------------------------------
#ifdef RD_CONTROL_PANEL
TKeyResponse CPslnUi::HandleKeyEventL(
    const TKeyEvent& /*aKeyEvent*/, TEventCode /*aType*/ )
#else
TKeyResponse CPslnUi::HandleKeyEventL(
    const TKeyEvent& aKeyEvent, TEventCode aType )
#endif // RD_CONTROL_PANEL
    {
    PSLN_TRACE_DEBUG("CPslnUi::HandleKeyEventL");

#ifndef RD_CONTROL_PANEL
    // If tab group is not yet created, create it.
    if ( !GetStatus( EPslnTabGroupCreated ) )
        {
        ConstructTabGroupL();
        }
    iTabGroup = static_cast<CAknTabGroup*>
        ( iDecoratedTabGroup->DecoratedControl() );

    // Only forward key events to tabgroup when:
    //     1) TabGroup has been created (and is not NULL)
    //     2) Active view is not MainView (there is no tab group in Main)
    //     3) key event is either left key or right key
    if ( iTabGroup && iView && iView->Id().iUid != KPslnMainView2.iUid &&
         ( aKeyEvent.iScanCode == EStdKeyLeftArrow ||
           aKeyEvent.iScanCode == EStdKeyRightArrow ) )
        {
        PSLN_TRACE_DEBUG("CPslnUi::HandleKeyEventL forward event to Tab");
        // If preview is about to activate, cancel it.
        if ( GetStatus( EPslnSkinChangeRequested ) &&
             iView->Id().iUid == KPslnGeneralView.iUid )
            {
            SetStateOff( EPslnSkinChangeRequested );
            }

        return iTabGroup->OfferKeyEventL( aKeyEvent, aType );
        }
#endif // !RD_CONTROL_PANEL
    return EKeyWasNotConsumed;
    }

// ---------------------------------------------------------------------------
// CPslnUi::SkinConfigurationChangedL
// ---------------------------------------------------------------------------
//
void CPslnUi::SkinConfigurationChangedL(
    const TAknsSkinStatusConfigurationChangeReason aReason )
    {
    PSLN_TRACE_DEBUG1("CPslnUi::SkinConfigurationChangedL internal state before: %d", iPslnUiStatus );
    HBufC* errorBuf = NULL;

    switch( aReason )
        {
        // Skin activation failed due to OOM.
        // Set skin activation user activity off, so that subsequent attempts can be made.
        // Also, set error note text.
        // Finally, set skin activation attempt off and update skin list.
        case EAknsSkinStatusConfigurationFailedOOM:
            SetStateOff( EPslnSkinChangeRequested );
            errorBuf = StringLoader::LoadLC( R_PSLN_QTN_MEMLO_RAM_OUT_OF_MEM );
            if ( GetStatus( EPslnSkinActivated ) )
                {
                SetStateOff( EPslnSkinActivated );
                DoCreateWaitNoteL();
                }
            break;
        // Skin activation failed due to skin being corrupted.
        // Set skin activation user activity off, so that subsequent attempts can be made.
        // Also, set error note text.
        // Then set skin activation attempt off and update skin list.
        // Finally, activate default skin.
        case EAknsSkinStatusConfigurationFailedCorrupt:
            SetStateOff( EPslnSkinChangeRequested );
            iGeneralThemeView->HightlightDefaultSkin();
            errorBuf = StringLoader::LoadLC( R_PSLN_QTN_SKINS_ERROR_CORRUPTED );
            if ( GetStatus( EPslnSkinActivated ) )
                {
                SetStateOff( EPslnSkinActivated );
                DoCreateWaitNoteL();
                }
            SetStateOn( EPslnListUpdateNeeded );
            break;
        // Skin activation was success.
        // Set skin activation user activity off.
        // Show confirmation note about the skin change and set activation
        // request state off. Finally, check if there are sounds in the skin.
        case EAknsSkinStatusConfigurationDeployed:
            SetStateOff( EPslnSkinChangeRequested );
            if ( GetStatus( EPslnSkinActivated ) )
                {
                SetStateOff( EPslnSkinActivated );
                SkinDeployedL();
                }
            else // Theme changed by other app, update view.
                {
                iModel->PerformCompleteUpdateL();             
                iGeneralThemeView->UpdateSkinListItemsL( iModel->ActiveSkinIndex() + 
                                PslnFeatures::IsEnhancedEmbeddedLinksSupported() );
                iGeneralThemeView->RemoveLocalSkinItems();
                }
            
            if ( GetStatus( EPslnSoundActivationPending ) )
                {
                SetStateOff( EPslnSoundActivationPending );
                ActivateSoundsL();
                }
            ToggleScreenBlankerL( EFalse, EFalse );
            break;
        default:
            break;
        }

    if( errorBuf )
        {
        ShowErrorNoteL( *errorBuf );
        CleanupStack::PopAndDestroy( errorBuf );
        }
    PSLN_TRACE_DEBUG1("CPslnUi::SkinConfigurationChangedL internal state after: %d", iPslnUiStatus );
    }

// ---------------------------------------------------------------------------
// Activate a Skin.
// ---------------------------------------------------------------------------
//
void CPslnUi::ActivateSkinL()
    {
    PSLN_TRACE_DEBUG("CPslnUi::ActivateSkinL");
    TInt skinIndex = iModel->CurrentSelectedSkinIndex();

    CPslnSkinEntry* entry = iModel->VisibleSkin( skinIndex );
    if( !entry )
        {
        SetStateOff( EPslnSkinChangeRequested );
        return;
        }

    TBool showWaitNote = EFalse;
    TInt drmError = KErrNone;
    HBufC* errorBuf = NULL;

    PSLN_TRACE_DEBUG1("CPslnUi::ActivateSkinL entry->Protection: %d", entry->Protection() );
    switch ( entry->Protection() )
        {
        case EAknsSrvNoRights:
            drmError = CDRMRights::ENoRights;
            showWaitNote = ETrue;
            break;
        case EAknsSrvFutureRights:
            drmError = CDRMRights::ERightsExpired;
            break;
        case EAknsSrvExpiredRights:
            drmError = CDRMRights::ERightsExpired;
            showWaitNote = ETrue;
            break;
        default :
            break;
        }

    // DRMHelper handles the error.
    if ( drmError )
        {
        RAknsSrvSession skinsrv;
        User::LeaveIfError( skinsrv.Connect() );
        CleanupClosePushL( skinsrv );

        TInt fileserverhandle;
        TInt filehandle;
        fileserverhandle = skinsrv.OpenBitmapFile( entry->FullName(), filehandle );
        RFile file;
        User::LeaveIfError( file.AdoptFromServer( fileserverhandle, filehandle ) );
        CleanupClosePushL( file );

        TInt returnCode = KErrNone;
        PSLN_TRACE_DEBUG("CPslnUi::ActivateSkinL use DRMHelper to show the error note");
        CDRMHelper* drmhelper = CDRMHelper::NewLC( *CCoeEnv::Static() );
        returnCode = drmhelper->HandleErrorL(
            drmError,
            file );

        PSLN_TRACE_DEBUG1("CPslnUi::ActivateSkinL DRMHelper returns: %d", returnCode );
        if ( returnCode && showWaitNote )
            {
            if ( GetStatus( EPslnListUpdateNeeded ) )
                {
                SetStateOff( EPslnListUpdateNeeded );
                DoCreateWaitNoteL();
                }
            }
        SetStateOff( EPslnSkinChangeRequested );
        CleanupStack::PopAndDestroy( 3 ); // drmHelper, skinsrv, file
        }
    else
        {
        if ( entry->Protection() == EAknsSrvCountBased )
            {
            errorBuf = StringLoader::LoadLC( R_PSLN_QTN_DRM_PREV_RIGHTS_SET );
            }
        // Check for corruption.
        if ( entry->IsCorrupted() )
            {
            PSLN_TRACE_DEBUG("CPslnUi::ActivateSkinL corrupt skin!");
            errorBuf = StringLoader::LoadLC( R_PSLN_QTN_SKINS_ERROR_CORRUPTED );
            }

        // Non-DRMHelper error handling.
        if ( errorBuf )
            {
            SetStateOff( EPslnSkinChangeRequested );
            ShowErrorNoteL( *errorBuf );
            CleanupStack::PopAndDestroy( errorBuf );
            }
        // No errors, activate the skin.
        else
            {
            PSLN_TRACE_DEBUG("CPslnUi::ActivateSkinL 2");
            // Start changing active skin.
            iModel->GuardActivationLC();
            TBool shownote = EFalse;

            // Show screen clearer when skin is changing.
            ToggleScreenBlankerL( ETrue, ETrue );

            PSLN_TRACE_DEBUG("CPslnUi::ActivateSkinL directly");
            shownote = iModel->ActivateSkinL( skinIndex );

            if ( shownote )
                {
                PSLN_TRACE_DEBUG("CPslnUi::ActivateSkinL skin activated");
                SetStateOn( EPslnSkinActivated );
                }
            else
                {
                // If user declined to activate protected skin, re-initialize status
                // flag.
                if ( GetStatus( EPslnSkinChangeRequested ) )
                    {
                    PSLN_TRACE_DEBUG("CPslnUi::ActivateSkinL decline DRM activation");
                    SetStateOff( EPslnSkinChangeRequested );
                    // Remove screen clearer.
                    ToggleScreenBlankerL( EFalse, EFalse );
                    }
                }
            CleanupStack::PopAndDestroy(); // activation guard
            }
        }
    }

// ---------------------------------------------------------------------------
// CPslnUi::ActivateSoundsL
// ---------------------------------------------------------------------------
//
void CPslnUi::ActivateSoundsL()
    {
    PSLN_TRACE_DEBUG("CPslnUi::ActivateSoundsL");

    // Is sounds are not supperted, ignore.
    if ( !PslnFeatures::IsSoundsInSkinsSupported()

    // If sounds are supported, but general view is not active, ignore.
        || iView && iView->Id().iUid != KPslnGeneralView.iUid  )
        {
        return;
        }

    TPath skinPath;
    CPslnSkinEntry* entry = iModel->VisibleSkin( iModel->ActiveSkinIndex() );
    if( entry )
        {
        entry->GetSkinPath( skinPath );
        skinPath.Append( KPslnPathSeparator );
        }
    else
        {
        User::Leave( KErrUnknown );
        }

    // Find sound files.
    CPslnSoundActivator* activator = CPslnSoundActivator::NewLC();
    TInt numberOfSounds = 0;
    activator->CollectSoundsL( skinPath, numberOfSounds );

    PSLN_TRACE_DEBUG1("CPslnUi::ActivateSoundsL num of tunes %d", numberOfSounds );

    if ( numberOfSounds <= 0 )
        {
        CleanupStack::PopAndDestroy( activator );
        return;
        }

    // Launch profile settings loader.
    CPslnTaskActivateSounds* activateTask = new (ELeave)
        CPslnTaskActivateSounds( *activator );
    CleanupStack::PushL( activateTask );

    CreateAndShowWaitWrapperL(
        *activateTask,
        R_PSLN_QTN_GEN_NOTE_OPENING,
        KNullDesC() );

    HBufC* noteText = NULL;

    PSLN_TRACE_DEBUG1("CPslnUi::ActivateSoundsL error %d", activateTask->iActivationErr );

    if( activateTask->iActivationErr == KErrNone )
        {
        if ( numberOfSounds == 1 )
            {
            noteText = StringLoader::LoadLC(
                R_PSLN_QTN_SKINS_NOTE_TONE_ACTIVATED );
            }
        else
            {
            noteText = StringLoader::LoadLC(
                R_PSLN_QTN_SKINS_NOTE_TONES_ACTIVATED );
            }

        CAknConfirmationNote* note =
            new (ELeave) CAknConfirmationNote( ETrue );
        note->ExecuteLD( *noteText );
        }
    else
        {
        if( activateTask->iActivationErr == KErrPermissionDenied )
            {
            noteText = StringLoader::LoadLC(
                R_PSLN_QTN_PROFILES_INFO_TONE_NO_DRM );
            }
        else
            {
            noteText = StringLoader::LoadLC(
                R_PSLN_QTN_FILE_FORMAT_ERROR );
            }
        CAknErrorNote* note =
            new (ELeave) CAknErrorNote( ETrue );
        note->ExecuteLD( *noteText );
        }
    
    CleanupStack::PopAndDestroy( 3, activator );
    }

// ---------------------------------------------------------------------------
// CPslnUi::DownloadSkinL
// ---------------------------------------------------------------------------
//
void CPslnUi::DownloadSkinL()
    {
    PSLN_TRACE_DEBUG("CPslnUi::DownloadSkinL");
    iModel->DownloadSkinL();
    }

// ---------------------------------------------------------------------------
// CPslnUi::CreateAndShowWaitWrapperL
// ---------------------------------------------------------------------------
//
void CPslnUi::CreateAndShowWaitWrapperL( MAknBackgroundProcess& aTask,
    const TInt aResourceID, const TDesC& aString,
    const TBool aShowImmediately )
    {
    HBufC* noteText = NULL;
    if ( aString.Length() == 0 )
        {
        noteText = StringLoader::LoadLC( aResourceID, iEikonEnv );
        }
    else
        {
        noteText = StringLoader::LoadLC( aResourceID, aString, iEikonEnv );
        }

    CAknWaitNoteWrapper* wrapper = CAknWaitNoteWrapper::NewL();
    CleanupDeletePushL( wrapper );
    if ( wrapper )
        {
        wrapper->ExecuteL(
            R_PSLN_GENERAL_WAIT_NOTE, aTask, *noteText, aShowImmediately );
        }

    CleanupStack::PopAndDestroy( 2, noteText ); // noteText, wrapper
    }

// ---------------------------------------------------------------------------
// CPslnUi::AddPluginToTabL
// ---------------------------------------------------------------------------
//
#ifndef RD_CONTROL_PANEL
void CPslnUi::AddPluginToTabL( CPslnFWPluginInterface& aPlugin )
    {
    PSLN_TRACE_DEBUG("CPslnUi::AddPluginToTabL Start");
    HBufC* buf = HBufC::NewLC( KPslnItemLength );
    TPtr ptrBuf = buf->Des();
    aPlugin.GetTabTextL( ptrBuf );
    TInt pluginUid = aPlugin.Id().iUid;
    if ( iTabGroup )
        {
        iTabGroup->AddTabL( pluginUid, ptrBuf );
        }
    PSLN_TRACE_DEBUG("CPslnUi::AddPluginToTabL Default Plugin added to tab");
    CleanupStack::PopAndDestroy( buf );
    }
#endif //!RD_CONTROL_PANEL

// ---------------------------------------------------------------------------
// Handles Exit command.
// ---------------------------------------------------------------------------
//
void CPslnUi::HandleCmdExitL()
    {
    Exit();
    }

// ---------------------------------------------------------------------------
// Shows error note.
// ---------------------------------------------------------------------------
//
void CPslnUi::ShowErrorNoteL( HBufC& aErrorBuf ) const
    {
    // Display global note.
    CAknGlobalNote* errorNote = CAknGlobalNote::NewLC();
    errorNote->ShowNoteL( EAknGlobalErrorNote, aErrorBuf );
    CleanupStack::PopAndDestroy( errorNote );
    }
// ---------------------------------------------------------------------------
// Callback when idle time occurs for skin update.
// ---------------------------------------------------------------------------
//
TInt CPslnUi::DoCreateWaitNoteL( TAny* aAny )
    {
    static_cast< CPslnUi* >( aAny )->DoCreateWaitNoteL();
    return EFalse;
    }
// ---------------------------------------------------------------------------
// CPslnUi::DoCreateWaitNoteL
// ---------------------------------------------------------------------------
//
void CPslnUi::DoCreateWaitNoteL()
    {
    CPslnTaskGenericUpdate* updateTask =
        new (ELeave) CPslnTaskGenericUpdate(
        *this, &CPslnModel::PerformCompleteUpdateL, ETrue );
    CleanupStack::PushL( updateTask );

    CreateAndShowWaitWrapperL( *updateTask,
        R_PSLN_QTN_GEN_NOTE_OPENING, KNullDesC(), EFalse );

    User::LeaveIfError( updateTask->iCallErr );

    CleanupStack::PopAndDestroy( updateTask );
    }

// ---------------------------------------------------------------------------
// This operation needs to be atomic. If it leaves, set state back to previous.
// ---------------------------------------------------------------------------
//
TInt CPslnUi::ActivateSkin( const TInt aPslnStatus )
    {
    TInt error = KErrNone;
    if ( !GetStatus( aPslnStatus ) )
        {
        SetStateOn( aPslnStatus );
        TRAPD( err, ActivateSkinL() );
        if ( err != KErrNone )
            {
            SetStateOff( aPslnStatus );
            error = err;
            }
        }
    iGeneralThemeView->RemoveLocalSkinItems();
    return error;
    }

// ---------------------------------------------------------------------------
// Non-leaving version of AddPluginToTabL.
// ---------------------------------------------------------------------------
//
#ifndef RD_CONTROL_PANEL
TInt CPslnUi::AddPluginToTab( CPslnFWPluginInterface& aPlugin )
    {
    TRAPD( err, AddPluginToTabL( aPlugin ) );
    if ( err )
        {
        PSLN_TRACE_DEBUG1("CPslnUi::AddPluginToTab plugin fails: ", aPlugin.Id().iUid );
        }
    return err;
    }
#endif //!RD_CONTROL_PANEL

// ---------------------------------------------------------------------------
// Show skin activated note.
// ---------------------------------------------------------------------------
//
void CPslnUi::SkinDeployedL()
    {
#ifdef RD_UI_TRANSITION_EFFECTS_PHASE2
    // Only set sound state - no conf note anymore.
    SetStateOn( EPslnSoundActivationPending );
#else
    HBufC* skinName = HBufC::NewLC( KMaxName );
    TPtr skinNamePtr = skinName->Des();
    TInt skinIndex = iModel->ActiveSkinIndex();

    iModel->GetSkinNameByIndex(
        skinIndex,
        skinNamePtr,
        EPslnSkinNameTypeTitle );

    // Show confirmation note about skin change.
    HBufC* noteTxt = StringLoader::LoadL(
        R_PSLN_CONFIRM_ACTIVE_SKIN_STRING,
        skinNamePtr,
        iEikonEnv );
    CleanupStack::PushL( noteTxt );

    SetStateOn( EPslnSoundActivationPending );
    CAknConfirmationNote* note =
        new (ELeave) CAknConfirmationNote( ETrue );
    note->ExecuteLD( *noteTxt );
    CleanupStack::PopAndDestroy( 2, skinName ); // skinName, noteTxt

#endif
    iGeneralThemeView->UpdateSkinListItemsL();
    }

// ---------------------------------------------------------------------------
// Creates model class.
// ---------------------------------------------------------------------------
//
void CPslnUi::CreateModelL()
    {
    if ( !GetStatus( EPslnModelCreated ) )
        {
        iModel = CPslnModel::NewL( this );
        SetStateOn( EPslnModelCreated );
        }
    }

// ---------------------------------------------------------------------------
// Callback when idle time occurs for skin activation.
// ---------------------------------------------------------------------------
//
TInt CPslnUi::DoActivateSkinL( TAny* aAny )
    {
    static_cast< CPslnUi* >( aAny )->DoActivateSkinL();
    return EFalse;
    }

// ---------------------------------------------------------------------------
// Callback when idle time occurs for skin activation.
// ---------------------------------------------------------------------------
//
void CPslnUi::DoActivateSkinL()
    {
    TInt error = ActivateSkin( EPslnSkinChangeRequested );
    if ( error == KErrNoMemory )
        {
        HBufC* errorBuf = StringLoader::LoadLC(
            R_PSLN_QTN_MEMLO_RAM_OUT_OF_MEM );
        // Display global note.
        CAknGlobalNote* errorNote = CAknGlobalNote::NewLC();
        errorNote->ShowNoteL( EAknGlobalErrorNote, *errorBuf );
        CleanupStack::PopAndDestroy( 2 ); // errorNote & errorBuf
        }
    }


/**
* Handle USB Callback.
*/
void CPslnUi::HandleUSBCallBackL()
    {
    if ( iView && iView->Id().iUid == KPslnGeneralView.iUid )
        {
        TInt value = KErrNone;
        iEnableUSBWatchProperty.Get(value);
        
        if (value == KUsbPersonalityIdMS )
            {
            iUSBAttached = ETrue;
            }
        else
            {
            iUSBAttached = EFalse;
            }
        static_cast< CPslnGeneralThemeView* >( iView )->RestartQuickPreviewL();
        }
    }
// End of File

