/*
* 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: cadrmscanner.mmp
*
*/

#include <apgwgnam.h>

#include "carunningappmonitor.h"
#include "cadef.h"
#include "castoragetask.h"
#include "cainnerquery.h"
#include "cainnerentry.h"
#include "caarraycleanup.inl"
#include "castorageproxy.h"

const TInt KRunningAppGranularity(10);
// -----------------------------------------------------------------------------
// ExecuteL
// -----------------------------------------------------------------------------
//
void CCaRunningAppMonitor::ExecuteL( MCaRunningTaskHandler& aTaskHandler,
                                     CCaStorageProxy& aStorage )
    {
    CCaRunningAppMonitor* self = 
        new (ELeave)CCaRunningAppMonitor( aTaskHandler, aStorage );
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    }

// -----------------------------------------------------------------------------
// ~CCaRunningAppMonitor
// -----------------------------------------------------------------------------
//
CCaRunningAppMonitor::~CCaRunningAppMonitor()
    {
    Cancel();
    iWg.Close();
    iSession.Close();
    iRunningTasks.Close();
    }

// -----------------------------------------------------------------------------
// CCaRunningAppMonitor
// -----------------------------------------------------------------------------
//
CCaRunningAppMonitor::CCaRunningAppMonitor( MCaRunningTaskHandler& aTaskHandler, 
                                            CCaStorageProxy& aStorage )
:
CActive( EPriorityStandard ),
iTaskHandler( aTaskHandler ),
iStorage( aStorage )
    {
    CActiveScheduler::Add( this );
    }

// -----------------------------------------------------------------------------
// ConstructL
// -----------------------------------------------------------------------------
//
void CCaRunningAppMonitor::ConstructL()
    {
    //Create window server observer
    ConstractObserverL();
    
    //start listen
    Subscribe();
    
    //At plugin start mark all entry as "not running"
    ResetStorageL();
    
    iTaskHandler.RegisterTaskL(this);//this operation has to be as a last one
    }

// -----------------------------------------------------------------------------
// UpdateRunningAppStorageL
// -----------------------------------------------------------------------------
//
void CCaRunningAppMonitor::UpdateRunningAppStorageL()
    {
    RArray<RWsSession::TWindowGroupChainInfo> 
        windowGroupIds(KRunningAppGranularity, 
                       _FOFF( RWsSession::TWindowGroupChainInfo, iId ));
    CleanupClosePushL( windowGroupIds );
    User::LeaveIfError( iSession.WindowGroupList( 0, &windowGroupIds ) );
    TInt itemIndex( KErrNotFound );
    
    //Verify what apps has stopped
    THashMapIter<TInt, TUid> iterator( iRunningTasks );
    RWsSession::TWindowGroupChainInfo item = { KErrNotFound, KErrNotFound };
    while( 0 != iterator.NextKey() )
        {
        item.iId = *iterator.CurrentKey();
        itemIndex = windowGroupIds.Find(item);
        if(KErrNotFound == itemIndex)
            {
            //push new task to register application update in storage
            CCaStorageTask::ExecuteL( iTaskHandler,
                                      iStorage,
                                      *iterator.CurrentValue(),
                                      KErrNotFound );
            iterator.RemoveCurrent();
            }
        else
            {
            //application is already registered.
            //remove entry to skip its processing
            windowGroupIds.Remove( itemIndex );
            }
        }
    
    //Verify what apps has started
    const TInt count(windowGroupIds.Count());
    for(TInt iter(0); iter < count; ++iter)
        {
        if( 0 >= windowGroupIds[iter].iParentId )
            {
            //push new task to register application update in storage and
            //register it running task list 
            CApaWindowGroupName* name = 
                CApaWindowGroupName::NewLC( iSession, windowGroupIds[iter].iId);
            if( 0 != name->AppUid().iUid )
                {
                CCaStorageTask::ExecuteL( iTaskHandler,
                                          iStorage,
                                          name->AppUid(),
                                          windowGroupIds[iter].iId );
                iRunningTasks.Insert( windowGroupIds[iter].iId,
                                      name->AppUid() );
                }
            CleanupStack::PopAndDestroy( name );
            }
        }
    CleanupStack::PopAndDestroy( &windowGroupIds );
    }

// -----------------------------------------------------------------------------
// Subscribe
// -----------------------------------------------------------------------------
//
void CCaRunningAppMonitor::Subscribe()
    {
    if( !IsActive() )
        {
        iSession.EventReady( &iStatus );
        SetActive();
        }
    }

// -----------------------------------------------------------------------------
// ConstractObserverL
// -----------------------------------------------------------------------------
//
void CCaRunningAppMonitor::ConstractObserverL()
{
    User::LeaveIfError( iSession.Connect() );
    iWg = RWindowGroup( iSession );
    User::LeaveIfError( iWg.Construct( 
                        reinterpret_cast<TUint32>( &iWg ) ) );
    iWg.DisableFocusChangeEvents();
    iWg.DisableModifierChangedEvents();
    iWg.DisableOnEvents();
    iWg.DisableScreenChangeEvents();

    //enable notifications about group lists
    User::LeaveIfError( iWg.EnableGroupListChangeEvents() );
}

// -----------------------------------------------------------------------------
// ResetStorageL
// -----------------------------------------------------------------------------
//
void CCaRunningAppMonitor::ResetStorageL()
{
    CCaInnerQuery* allAppQuery = CCaInnerQuery::NewLC();
    allAppQuery->SetFlagsOn( ERunning );
    RPointerArray<CCaInnerEntry> entries;
    CleanupResetAndDestroyPushL( entries );
    iStorage.GetEntriesL( allAppQuery, entries );
    for( TInt i(0); i < entries.Count(); ++i )
        {
        CCaStorageTask::ExecuteL( iTaskHandler,
                                  iStorage,
                                  TUid::Uid(entries[i]->GetUid()),
                                  KErrNotFound );
        }
    CleanupStack::PopAndDestroy(&entries);
    CleanupStack::PopAndDestroy(allAppQuery);
}

// -----------------------------------------------------------------------------
// RunL
// -----------------------------------------------------------------------------
//
void CCaRunningAppMonitor::RunL()
    {
    User::LeaveIfError( iStatus.Int() );
    TWsEvent event;
    iSession.GetEvent( event );
    Subscribe();//new subscribtion has to be called after picking event
    if( EEventWindowGroupListChanged == event.Type() )
        {
        UpdateRunningAppStorageL();
        }
    }

// -----------------------------------------------------------------------------
// RunError
// -----------------------------------------------------------------------------
//
TInt CCaRunningAppMonitor::RunError( TInt /*aError*/ )
    {
    //ignore error
    Subscribe();
    return KErrNone;
    }

// -----------------------------------------------------------------------------
// DoCancel
// -----------------------------------------------------------------------------
//
void CCaRunningAppMonitor::DoCancel()
    {
    if( IsActive() )
        {
        iSession.EventReadyCancel();
        }
    }