/*

 * ===========================================================================

 *  Name        : hgfswengine.cpp

 *  Part of     : Huriganes / Fast Swap Server

 *  Description : Task monitor engine

 *  Version     : %version: sa1spcx1#37 %

 *

 *  Copyright © 2008 Nokia Corporation.

 *  This material, including documentation and any related 

 *  computer programs, is protected by copyright controlled by 

 *  Nokia Corporation. All rights are reserved. Copying, 

 *  including reproducing, storing, adapting or translating, any 

 *  or all of this material requires the prior written consent of 

 *  Nokia Corporation. This material also contains confidential 

 *  information which may not be disclosed to others without the 

 *  prior written consent of Nokia Corporation.

 * ===========================================================================

 */

#include "hgfswengine.h"

#include "hgfsalwaysshownapplist.h"

#include "hgfshiddenapplist.h"

#include "hgfswidgetlist.h"

#include "hgfswiconcache.h"

#include "hgpreviewprovider.h"

#include "hgfswclient.h"

#include <apgtask.h>

#include <AknDef.h>

#include <apgwgnam.h>

#include <mmf/common/mmfcontrollerpluginresolver.h> // for CleanupResetAndDestroyPushL

#include <featmgr.h>

#include <swi/swispubsubdefs.h>

#include "enginelogging.h"

// time to wait before refreshing content

const TInt KContentRefreshDelay = 500000; // 0.5 sec

// for screenshots, they are scaled down to (screensize/this_factor).

const TInt KScreenSizeFactor = 2;

// format to get a lowercase hex string prefixed with 0x

_LIT( KHexFmt, "0x%x" );

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

// CHgFswEngine::NewL

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

//

EXPORT_C CHgFswEngine* CHgFswEngine::NewL( MHgFswEngineObserver& aObserver )

    {

    CHgFswEngine* self = NewLC( aObserver );

    CleanupStack::Pop( self );

    return self;

    }

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

// CHgFswEngine::NewLC

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

//

EXPORT_C CHgFswEngine* CHgFswEngine::NewLC( MHgFswEngineObserver& aObserver )

    {

    CHgFswEngine* self = new ( ELeave ) CHgFswEngine( aObserver );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// CHgFswEngine::CHgFswEngine

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

//

CHgFswEngine::CHgFswEngine( MHgFswEngineObserver& aObserver )

        : CActive( EPriorityStandard ), iObserver( aObserver )

    {

    CActiveScheduler::Add( this );

    }

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

// CHgFswEngine::ConstructL

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

//

void CHgFswEngine::ConstructL()

    {

    iEnv = CEikonEnv::Static();

    User::LeaveIfError( iWsSession.Connect() );

    User::LeaveIfError( iAppArcSession.Connect() );

    iHiddenAppList = CHgFsHiddenAppList::NewL( *this );

    iAlwaysShownAppList = CHgFsAlwaysShownAppList::NewL();

    iWidgetsSupported = FeatureManager::FeatureSupported( KFeatureIdWebWidgets );

    if ( iWidgetsSupported )

        {

        iWidgetList = CHgFsWidgetList::NewL();

        }

    // create app icon retriever instance

    iAppIcons = CHgFswIconCache::NewL();

    // get an initial list of tasks

    iAppDataRefreshNeeded = ETrue;

    CollectTasksL();

    // listen for app screenshots

    iPreviewProvider = CHgFastSwapPreviewProvider::NewL( *this );

    SetPreviewParams();

    UpdatePreviewContent();

    iUpdateStarter = CPeriodic::NewL( CActive::EPriorityStandard );

    // start listening for swi ps property

    if ( iSwiProp.Attach( KUidSystemCategory,

            Swi::KUidSoftwareInstallKey ) == KErrNone )

        {

        iSwiProp.Subscribe( iStatus );

        SetActive();

        }

    }

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

// CHgFswEngine::~CHgFswEngine

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

//

CHgFswEngine::~CHgFswEngine()

    {

    Cancel();

    iSwiProp.Close();

    delete iUpdateStarter;

    delete iPreviewProvider;

    // delete the bitmaps as the hash map cannot do that

    THashMapIter<TInt, CFbsBitmap*> iter( iScreenshots );

    while ( const TInt* key = iter.NextKey() )

        {

        CFbsBitmap** value = iter.CurrentValue();

        delete *value;

        }

    iScreenshots.Close();

    delete iAppIcons;

    iData.ResetAndDestroy();

    iWgIds.Close();

    delete iHiddenAppList;

    delete iAlwaysShownAppList;

    delete iWidgetList;

    iAppArcSession.Close();

    iWsSession.Close();

//    delete iContextUtility;

    }

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

// CHgFswEngine::FswDataL

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

//

EXPORT_C const RHgFswArray& CHgFswEngine::FswDataL()

    {

    HGLOG_CONTEXT( FswDataL, HGLOG_LOCAL );

    HGLOG1_IN( "dirty flag = %d", iTaskListDirty );

    // check the dirty flag and refresh if needed

    if ( iTaskListDirty )

        {

        CollectTasksL();

        // dirty flag is cleared in the above call

        }

    // Get app icon for entries without screenshot,

    // do this only here as the app icon is not needed in case a screenshot

    // is already available.

    for ( TInt i = 0, ie = iData.Count(); i != ie; ++i )

        {

        if ( !iData[i]->ScreenshotHandle() )

            {

            CFbsBitmap* bmp;

            CFbsBitmap* mask;

            TUid appUid = iData[i]->AppUid();

            // this will leave with -46 in case of widgets if we do not have AllFiles cap

            TRAPD( err, iAppIcons->GetIconL( appUid, bmp, mask ) );

            if ( err == KErrNone && bmp )

                {

                iData[i]->SetAppIconHandles( bmp->Handle(),

                    mask ? mask->Handle() : 0 );

                }

            else

                {

                iAppIcons->DefaultIcon( bmp, mask );

                iData[i]->SetAppIconHandles( bmp->Handle(),

                    mask ? mask->Handle() : 0 );

                }

            }

        }

    HGLOG_OUT();

    return iData;

    }

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

// CHgFswEngine::CloseAppL

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

//

EXPORT_C void CHgFswEngine::CloseAppL( TInt aWgId )

    {

    HGLOG_CONTEXT( CloseAppL, HGLOG_LOCAL );

    HGLOG1_IN( "aWgId = %d", aWgId );

    if ( iWidgetsSupported && aWgId < 0 && iWidgetAppUiWgId )

        {

        // for widgets clients see a wgid that is -1*(index+1)

        const RWidgetInfoArray& arr( iWidgetList->RunningWidgets() );

        // convert aWgId to an index in the list of running widgets

        TInt idx = -aWgId - 1;

        // if index is valid then handle the widget specially

        if ( idx >= 0 && idx < arr.Count() )

            {

            TWsEvent event;

            event.SetType( EEventUser );

            TUint8* eventData = event.EventData();

            // Fill bits 0-31 with widget application uid.

            reinterpret_cast<TUint32&>( *eventData ) = KWidgetAppUidValue;

            eventData += sizeof( TUint32 );

            // Fill bits 32-63 with uid of the widget that should be closed.

            reinterpret_cast<TUint32&>( *eventData ) = arr[idx]->iUid.iUid;

            // Send the event to Widget AppUi.

            iEnv->WsSession().SendEventToWindowGroup(

                iWidgetAppUiWgId, event );

            // closing a widget may not cause a window group change so trigger

            // the update manually

            UpdateTaskList();

            HGLOG0_OUT( "widget processing finished" );

            return;

            }

        }

    TUid appUid = AppUidForWgIdL( aWgId );

    if ( !iAlwaysShownAppList->IsAlwaysShownApp( appUid ) )

        {

        // send window group event to kill the app

        TWsEvent event;

        event.SetTimeNow();

        event.SetType( KAknShutOrHideApp );

        iEnv->WsSession().SendEventToWindowGroup( aWgId, event );

        HGLOG0( HGLOG_INFO, "event sent to wg" );

        }

    HGLOG_OUT();

    }

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

// CHgFswEngine::SwitchToAppL

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

//

EXPORT_C void CHgFswEngine::SwitchToAppL( TInt aWgId )

    {

    HGLOG_CONTEXT( SwitchToAppL, HGLOG_LOCAL );

    HGLOG1_IN( "aWgId = %d", aWgId );

    if ( iWidgetsSupported && aWgId < 0 )

        {

        // for widgets clients see a wgid that is -1*(index+1)

        const RWidgetInfoArray& arr( iWidgetList->RunningWidgets() );

        // convert aWgId to an index in the list of running widgets

        TInt idx = -aWgId - 1;

        // if index is valid then handle the widget specially

        if ( idx >= 0 && idx < arr.Count() )

            {

            SwitchToWidgetL( idx );

            HGLOG1_OUT( "switched to widget %d", idx );

            return;

            }

        }

    TApaTask task( iEnv->WsSession() );

    task.SetWgId( aWgId );

    task.BringToForeground();

    HGLOG_OUT();

    }

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

// CHgFswEngine::SwitchToWidgetL

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

//

void CHgFswEngine::SwitchToWidgetL( TInt aWidgetIndex )

    {

    const RWidgetInfoArray& arr( iWidgetList->RunningWidgets() );

    RApaLsSession ls;

    User::LeaveIfError( ls.Connect() );

    CleanupClosePushL( ls );

    CApaCommandLine* cmdLine = CApaCommandLine::NewLC();

    cmdLine->SetCommandL( EApaCommandRun );

    TApaAppInfo info;

    iAppArcSession.GetAppInfo( info, arr[aWidgetIndex]->iUid ); // codescanner::accessArrayElementWithoutCheck2 (aWidgetIndex checked in SwitchToAppL())

    cmdLine->SetExecutableNameL( info.iFullName );

    ls.StartApp( *cmdLine );

    CleanupStack::PopAndDestroy( 2, &ls );

    }

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

// CHgFswEngine::UpdateTaskList

// Callback from appui

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

//

void CHgFswEngine::UpdateTaskList()

    {

    HGLOG_CONTEXT( UpdateTaskList, HGLOG_LOCAL );

    HGLOG_IN();

    // If no clients are subscribed for fsw content change notifications

    // then there is no need to waste time with rebuilding the task list,

    // just set the dirty flag.

    TInt listenerCount = iObserver.FswDataListenerCount();

    HGLOG1( HGLOG_INFO, "listener count = %d", listenerCount );

    if ( listenerCount > 0 )

        {

        // There can be many calls in a row, use a timer to prevent degrading

        // device performance.

        if ( !iUpdateStarter->IsActive() )

            {

            iUpdateStarter->Start( KContentRefreshDelay, 0,

                TCallBack( UpdateStarterCallback, this ) );

            }

        }

    else

        {

        iTaskListDirty = ETrue;

        }

    // screenshot taking support - call Register and Unregister when needed

    UpdatePreviewContent();

    // get the foreground app uid and publish it to CFW if different than before

    TRAP_IGNORE( PublishFgAppUidL() );

    HGLOG_OUT();

    }

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

// CHgFswEngine::ForegroundAppUidL

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

//

EXPORT_C TUid CHgFswEngine::ForegroundAppUidL( TInt aType )

    {

    // Do not use GetFocusWindowGroup or others.

    // We want to see only "real" application uids in FgApp,

    // i.e. stuff that would also be shown in the task swapper

    // area of Teleport.

    TUid result = KNullUid;

    RArray<RWsSession::TWindowGroupChainInfo> allWgIds;

    CleanupClosePushL( allWgIds );

    User::LeaveIfError( iWsSession.WindowGroupList( 0, &allWgIds ) );

    TInt count = allWgIds.Count();

    for ( TInt i = 0; i < count; ++i )

        {

        // Depending on aType we may not need to bother with iParentId here.

        // If aType == EUseEmbeddedUid => embedded apps are treated as others.

        // If aType == EUseStandaloneUid => embedded apps must be ignored.

        if ( allWgIds[i].iParentId > 0

                && aType == CHgFswClient::EUseStandaloneUid )

            {

            continue;

            }

        CApaWindowGroupName* wgn = CApaWindowGroupName::NewLC(

            iWsSession, allWgIds[i].iId );

        TUid newUid = wgn->AppUid();

        TBool hidden = wgn->Hidden() || iHiddenAppList->IsHiddenL(

            newUid, iWsSession, allWgIds[i].iId );

        CleanupStack::PopAndDestroy( wgn );

        if ( !hidden && newUid.iUid )

            {

            result = newUid;

            break;

            }

        }

    CleanupStack::PopAndDestroy( &allWgIds );

    return result;

    }

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

// CHgFswEngine::PublishFgAppUidL

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

//

void CHgFswEngine::PublishFgAppUidL()

    {

    HGLOG_CONTEXT( PublishFgAppUidL, HGLOG_LOCAL );

    HGLOG_IN();

    TUid newUid = ForegroundAppUidL( CHgFswClient::EUseEmbeddedUid );

    HGLOG2( HGLOG_INFO, "ws says: %x we have: %x", newUid.iUid, iFgAppUid.iUid );

    if ( iFgAppUid != newUid && newUid.iUid )

        {

        iFgAppUid = newUid;

        iFgAppUidStr.Format( KHexFmt, iFgAppUid.iUid );

        //PublishContextL( KHgCFTypeFgApp, iFgAppUidStr );

        }

    HGLOG_OUT();

    }

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

// CHgFswEngine::PublishContextL

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

//

//void CHgFswEngine::PublishContextL( const TDesC& aType, const TDesC& aValue )

//    {

//    HGLOG_CONTEXT( PublishContextL, HGLOG_LOCAL );

//    HGLOG2_IN( "%S: %S", &aType, &aValue );

//    if ( !iContextUtility )

//        {

//        iContextUtility = CHgContextUtility::NewL();

//        iContextUtility->AllowPublishFromBackground( ETrue );

//        }

//    iContextUtility->PublishContextL( aType, aValue );

//    HGLOG_OUT();

//    }

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

// CHgFswEngine::UpdateStarterCallback

// Callback for the timer

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

//

TInt CHgFswEngine::UpdateStarterCallback( TAny* aParam )

    {

    CHgFswEngine* self = static_cast<CHgFswEngine*>( aParam );

    self->iUpdateStarter->Cancel();

    // get list of tasks and notify observer if there is a change in the list

    TBool changed = EFalse;

    TRAPD( err, changed = self->CollectTasksL() );

    if ( err == KErrNone && changed )

        {

        self->iObserver.FswDataChanged();

        }

    return 0;

    }

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

// CHgFswEngine::CollectTasksL

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

//

TBool CHgFswEngine::CollectTasksL()

    {

    HGLOG_CONTEXT( CollectTasksL, HGLOG_LOCAL );

    HGLOG_IN();

    // clear dirty flag

    iTaskListDirty = EFalse;

    TBool changed = EFalse;

    RHgFswArray newList;

    CleanupResetAndDestroyPushL( newList );

    // update app data if needed

    // (usually on startup and when new apps might have been installed)

    if ( iAppDataRefreshNeeded )

        {

        HGLOG0( HGLOG_INFO, "refreshing app data" );

        iAppArcSession.GetAllApps();

        iAlwaysShownAppList->InitializeAlwaysShownListL();

        iAppDataRefreshNeeded = EFalse;

        }

    // get all window groups

    RArray<RWsSession::TWindowGroupChainInfo> allWgIds;

    CleanupClosePushL( allWgIds );

    User::LeaveIfError( iWsSession.WindowGroupList( 0, &allWgIds ) );

    TInt count = allWgIds.Count();

    for ( TInt i = 0; i < count; ++i )

        {

        // ignore uninteresting entries (e.g. embedded apps)

        if ( allWgIds[i].iParentId > 0 )

            {

            continue;

            }

        // get window group name

        TInt wgId = allWgIds[i].iId;

        CApaWindowGroupName* windowName =

            CApaWindowGroupName::NewLC( iWsSession, wgId );

        TUid appUid = windowName->AppUid();

        // ignore entries with null uid

        if ( !appUid.iUid )

            {

            CleanupStack::PopAndDestroy( windowName );

            continue;

            }

        // will append the task to our own list only if it is not hidden

        TBool onHiddenList = iHiddenAppList->IsHiddenL(

            appUid, iWsSession, wgId );

        // if this is the widget app then save wgid for later use

        // and ignore it, but include running widgets instead

        if ( iWidgetsSupported && appUid.iUid == KWidgetAppUidValue )

            {

            iWidgetAppUiWgId = wgId;

            onHiddenList = ETrue;

            CheckWidgetsL( newList );

            }

        // get screen number (-1=console, 0=main screen, 1=cover ui)

        TInt appScreen = 0;

        TInt scrNumErr = iAppArcSession.GetDefaultScreenNumber( appScreen, appUid );

        // check if it is on always-shown list

        TBool mustShow = iAlwaysShownAppList->IsAlwaysShownApp( appUid );

#ifdef _DEBUG

        const TDesC& captionDbg( windowName->Caption() );

        HGLOG4( HGLOG_INFO, "[%d] wgid=%d appuid=%x (%S)", i, wgId,

            appUid.iUid, &captionDbg );

        HGLOG4( HGLOG_INFO, "hidden=%d onhiddenlist=%d mustshow=%d scrno=%d",

            windowName->Hidden(), onHiddenList, mustShow, appScreen );

#endif

        // add item to task list if it is always-shown OR it is not hidden

        // and it is not on cover ui

        if ( mustShow

                || ( !onHiddenList

                    && !windowName->Hidden()

                    && ( appScreen == 0 || appScreen == -1 )