/*

* 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 );