/*

* Copyright (c) 2009 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:

* widget manager plugin implementation

*

*/

// INCLUDE FILES

#include <bautils.h>

#include <coemain.h>

#include <aknViewAppUi.h>

#include <eikappui.h>

#include <eikapp.h>

#include <e32property.h>

#include <e32base.h>

#include <activeidle2domainpskeys.h>

#include <widgetmanagerview.rsg>

#include "wmcommon.h"

#include "widgetmanager.hrh"

#include "wmmaincontainer.h"

#include "wmmaincontainerview.h"

#include "wmresourceloader.h"

#include "wmplugin.h"

#include "wmeffectmanager.h"

#include "wmwidgetdata.h"

#include "wminstaller.h"

#include "wmlistbox.h"

const TInt KExecuteCommandDelay( 50000 ); // 50ms

const TInt KMaxCmdExecutionCount( 6 );

// ---------------------------------------------------------

// CWmPlugin::NewL

// ---------------------------------------------------------

//

CWmPlugin* CWmPlugin::NewL()

    {

    CWmPlugin* self = new( ELeave ) CWmPlugin();

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

// ---------------------------------------------------------

// CWmPlugin::~CWmPlugin

// ---------------------------------------------------------

//

CWmPlugin::~CWmPlugin()

    {

    if ( iLauncher && iLauncher->IsActive() )

        {

        iLauncher->Cancel();

        }

    delete iLauncher;

    if ( iWmInstaller && 

       iWmInstaller->IsActive() )

        {

        iWmInstaller->Cancel();

        }

    // delete members

    delete iResourceLoader;

    delete iEffectManager;

    delete iPostponedContent;

    delete iWmInstaller;

    }

// ---------------------------------------------------------

// CWmPlugin::CWmPlugin

// ---------------------------------------------------------

//

CWmPlugin::CWmPlugin()

    {

    iPreviousViewUid.iViewUid = KNullUid;

    iExecutionCount = 0;

    }

// ---------------------------------------------------------

// CWmPlugin::ConstructL

// ---------------------------------------------------------

//

void CWmPlugin::ConstructL()

    {

    iWmMainContainer = NULL;

    iPostponedCommand = ENone;

    // store static view app ui

    CEikonEnv* eikonEnv = CEikonEnv::Static();

    if ( !eikonEnv ) User::Leave( KErrUnknown );

    iViewAppUi = (CAknViewAppUi*)eikonEnv->EikAppUi();

    if ( !iViewAppUi ) User::Leave( KErrUnknown );

    // create resource loader

    iFs = &eikonEnv->FsSession();

    iResourceLoader = CWmResourceLoader::NewL( *eikonEnv );

    iEffectManager = CWmEffectManager::NewL( *eikonEnv );

    iWmInstaller = CWmInstaller::NewL( *this );

    // main view

    CWmMainContainerView* mainView =

            CWmMainContainerView::NewL( *this );

    CleanupStack::PushL( mainView );

	iViewAppUi->AddViewL( mainView );	

	CleanupStack::Pop( mainView );

	// laucher for adding widgets.

	iLauncher = CPeriodic::NewL( CActive::EPriorityUserInput + 1 );

    }

// ---------------------------------------------------------

// CWmPlugin::Activate

// ---------------------------------------------------------

//

void CWmPlugin::Activate()

    {

	// prevents opening wm if adding widget is ongoing.

    if ( !iLauncher->IsActive() )

        {

        CWmMainContainerView* view = static_cast<CWmMainContainerView*>(

                iViewAppUi->View( TUid::Uid(EWmMainContainerViewId) ) );

        if ( !IsActive() && view && iHsContentController )

            {

            // stop displaying menubar before starting fullscreen effects

            CEikMenuBar* menuBar = CEikonEnv::Static()->AppUiFactory()->MenuBar();

            if ( menuBar && menuBar->IsDisplayed() )

                {

                menuBar->StopDisplayingMenuBar();

                }

            TRAP_IGNORE( 

                iEffectManager->BeginFullscreenEffectL( 

                iViewAppUi->ActivateLocalViewL(

                    TUid::Uid( EWmMainContainerViewId ) );

                );

            }

        }

    }

// ---------------------------------------------------------

// CWmPlugin::DeActivate

// ---------------------------------------------------------

//

void CWmPlugin::DeActivate()

    {

    iPostponedCommand = ENone;

    iPreviousViewUid.iViewUid = KNullUid;    

    CWmMainContainerView* view = static_cast<CWmMainContainerView*>(

        iViewAppUi->View( TUid::Uid(EWmMainContainerViewId) ) );

    if ( view ) { view->DoDeactivate(); }

    }

// ---------------------------------------------------------

// CWmPlugin::Views

// ---------------------------------------------------------

//

void CWmPlugin::Views( RPointerArray<CAknView>& aViews )

    {

    // return view to be destroyed.

    CAknView* view = iViewAppUi->View( 

            TUid::Uid(EWmMainContainerViewId) );

    if ( view )

        {        

        aViews.Append( view );

        }

    }

// ---------------------------------------------------------

// CWmPlugin::IsActive

// ---------------------------------------------------------

//

TBool CWmPlugin::IsActive()

    {

    TVwsViewId activeViewId(KNullUid,KNullUid);

    if ( iViewAppUi->GetActiveViewId( activeViewId ) == KErrNone &&

        activeViewId.iViewUid == TUid::Uid( EWmMainContainerViewId ) )

        {

        if ( iPreviousViewUid.iViewUid == KNullUid && 

            iViewAppUi->GetDefaultViewId( iPreviousViewUid ) != KErrNone ) 

            {            

            iPreviousViewUid.iAppUid = iViewAppUi->Application()->AppDllUid();

            iPreviousViewUid.iViewUid = TUid::Uid( 1 );

            }

        return ETrue;

        }

    return( iPreviousViewUid.iViewUid != KNullUid );

    }

// ---------------------------------------------------------

// CWmPlugin::CloseView

// ---------------------------------------------------------

//

void CWmPlugin::CloseView()

    {

    if ( IsActive() )

        {

        iWmMainContainer->SetClosingDown( ETrue );

        TRAPD( err, 

            iEffectManager->BeginFullscreenEffectL(

                KAppExitEffectStyle );

            iViewAppUi->ActivateLocalViewL(

                iPreviousViewUid.iViewUid ); 

            );

        if ( KErrNone != err )

            {

            iWmMainContainer->SetClosingDown( EFalse );

            }

        }

    }

// ---------------------------------------------------------

// CWmPlugin::MainViewActivated

// ---------------------------------------------------------

//

void CWmPlugin::MainViewActivated( 

                    const TVwsViewId& /*aViewId*/,

                    CWmMainContainer* aWmMainContainer )

    {

    // previous view for Wm is always default view.

    if ( iViewAppUi->GetDefaultViewId( iPreviousViewUid ) != KErrNone )

        {

        // use default if we got wrong viewid as previous view

        iPreviousViewUid.iAppUid = iViewAppUi->Application()->AppDllUid();

        iPreviousViewUid.iViewUid = TUid::Uid( 1 );

        }

    iWmMainContainer = aWmMainContainer;

    iEffectManager->UiRendered();

    iWmMainContainer->SetClosingDown( EFalse );

    // Don't forward numeric keys to phone

    ForwardNumericKeysToPhone( EFalse );

    }

// ---------------------------------------------------------

// CWmPlugin::MainViewDeactivated

// ---------------------------------------------------------

//

void CWmPlugin::MainViewDeactivated()

    {

    // Forward numeric keys to phone

    ForwardNumericKeysToPhone( ETrue );

    iPreviousViewUid.iViewUid = KNullUid;

    iWmMainContainer = NULL;

    if ( iEffectManager )

        {

        iEffectManager->UiRendered();

        }

    if ( !iEffectManager->IsEffectActive() )

        {

        // launch effect without delay

        if ( !iLauncher->IsActive() )

            {

            iExecutionCount = KMaxCmdExecutionCount;

            iLauncher->Start( 0, 0, TCallBack( ExecuteCommand, this ) );

            }

        }

    else

        {

        // maximum wait time is 300ms (6 x 50ms)

        if ( !iLauncher->IsActive() )

            {

            iExecutionCount++;

            iLauncher->Start(

                KExecuteCommandDelay,

                KExecuteCommandDelay,

                TCallBack( ExecuteCommand, this ) );

            }

        }

    }

// ---------------------------------------------------------

// CWmPlugin::ForwardNumericKeysToPhone

// ---------------------------------------------------------

//

void CWmPlugin::ForwardNumericKeysToPhone( TBool aEnabled )

    {

    TInt value = aEnabled ? 

        EPSAiForwardNumericKeysToPhone : 

        EPSAiDontForwardNumericKeysToPhone;

    RProperty::Set(

        KPSUidAiInformation,

        KActiveIdleForwardNumericKeysToPhone,

        value );

    }

// ---------------------------------------------------------

// CWmPlugin::SetPostponedCommandL

// ---------------------------------------------------------

//

void CWmPlugin::SetPostponedCommandL(

        TCommand aCommand, CHsContentInfo& aContentInfo )

    {

    iPostponedCommand = aCommand;

    delete iPostponedContent;

    iPostponedContent = NULL;

    iPostponedContent = aContentInfo.CloneL();

    }

// ---------------------------------------------------------

// CWmPlugin::ExecuteCommand

// ---------------------------------------------------------

//

TInt CWmPlugin::ExecuteCommand( TAny* aSelf )

    {

    CWmPlugin* plugin = static_cast<CWmPlugin*>( aSelf );

    plugin->DoExecuteCommand();

    return 0;

    }

// ---------------------------------------------------------

// CWmPlugin::DoExecuteCommand

// ---------------------------------------------------------

//

void CWmPlugin::DoExecuteCommand()

    {

    // prevent multiple events

    if ( iLauncher->IsActive() )

        {

        iLauncher->Cancel();

        }

    if ( !iEffectManager->IsEffectActive() ||

        iExecutionCount == KMaxCmdExecutionCount )

        {

        if ( iPostponedCommand == EAddToHomescreen )

            {

            TRAP_IGNORE(

                TInt err( KErrNone );

                err = ContentController().AddWidgetL( *iPostponedContent );

                if ( KErrNone != err )

                    ShowErrorNoteL( err );

                );

            }

        iPostponedCommand = ENone;

        delete iPostponedContent;

        iPostponedContent = NULL;

        iExecutionCount = 0; // reset counter

        }

    else

        {

        iExecutionCount++;

        iLauncher->Start(

            KExecuteCommandDelay,

            KExecuteCommandDelay,

            TCallBack( ExecuteCommand, this ) );

        }

    }

// ---------------------------------------------------------

// CWmPlugin::ShowErrorNoteL

// ---------------------------------------------------------

//

void CWmPlugin::ShowErrorNoteL( TInt aError )

    {

    switch ( aError )

        {

        case KHsErrorViewFull:

        case KHsErrorDoesNotFit:

            // Not enough space to add new widget to active page. 

            // Remove some content first.

            ResourceLoader().InfoPopupL(

                R_QTN_HS_ADD_WIDGET_NO_SPACE_NOTE, KNullDesC );

            break;

        case KErrNoMemory:

        case KErrDiskFull:

            // do not show error note here to avoid multiple error notes

            break;   

        default:

            ResourceLoader().ErrorPopup( aError );

            break;

        }

    }

// ---------------------------------------------------------

// CWmPlugin::ViewAppUi

// ---------------------------------------------------------

//

CAknViewAppUi& CWmPlugin::ViewAppUi()

    {

    return *iViewAppUi;

    }

// ---------------------------------------------------------

// CWmPlugin::ResourceLoader

// ---------------------------------------------------------

//

CWmResourceLoader& CWmPlugin::ResourceLoader()

    {

    return *iResourceLoader;

    }

// ---------------------------------------------------------

// CWmPlugin::ContentController

// ---------------------------------------------------------

//

MHsContentController& CWmPlugin::ContentController()

    {

    return *iHsContentController;

    }

// ---------------------------------------------------------

// CWmPlugin::FileServer

// ---------------------------------------------------------

//

RFs& CWmPlugin::FileServer()

    {

    return *iFs;

    }

// ---------------------------------------------------------

// CWmPlugin::NotifyWidgetListChanged

// ---------------------------------------------------------

//

void CWmPlugin::NotifyWidgetListChanged()

    {

    if ( iWmMainContainer && !iWmMainContainer->ClosingDown() )

        {

        iWmMainContainer->HandleWidgetListChanged();

        }

    }

// ---------------------------------------------------------

// CWmPlugin::WmInstaller

// ---------------------------------------------------------

//

CWmInstaller& CWmPlugin::WmInstaller()

    {

    return *iWmInstaller;

    }

// ---------------------------------------------------------

// CWmPlugin::GetUnistalledWidget

// ---------------------------------------------------------

//

CWmWidgetData* CWmPlugin::GetUninstalledWidgetByUid( TUid aUid )

    {

    CWmWidgetData* retVal = NULL;

    if ( iWmMainContainer )

        {

        const RWidgetDataValues& widgetArray =

            iWmMainContainer->WmListBox().WidgetDataArray();

        for ( TInt i = 0; i < widgetArray.Count(); i++ )

            {

            CWmWidgetData* widgetData = widgetArray[i];

            if ( widgetData->IsUninstalling() &&

                widgetData->PublisherUid() == aUid )

                {

                retVal = widgetArray[i];

                break;

                }

            }

        }

    return retVal;

    }

// End of file