/*

* 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:  The engine class of MCS plugin. 

*

*/

// System includes

#include <gulicon.h>

#include <AknsItemID.h>

#include <gslauncher.h>

#include <mcsmenuitem.h>

#include <mcsmenufilter.h>

#include <mcsmenuoperation.h>

#include <mcsmenuiconutility.h>

#include <activefavouritesdbnotifier.h>

#include <favouritesitemlist.h>

#include <bautils.h>

#include <StringLoader.h>

#include <aknnotedialog.h>

#include <AknsConstants.h>

#include <avkon.rsg>

#include <mcspluginres.rsg>

#include <apgtask.h>

#include <apgcli.h> 

#include <apacmdln.h>

#include <gfxtranseffect/gfxtranseffect.h>      

#include <akntranseffect.h>

// User includes

#include <aisystemuids.hrh>

#include "mcspluginengine.h"

#include "mcsplugin.h"

#include "mcsplugindata.h"

#include "mcspluginuids.hrh"

// Constants

_LIT( KMyMenuData, "matrixmenudata" );

_LIT( KSkin,         "skin" );

_LIT( KMif,          "mif" );

_LIT( KResourceDrive, "Z:" );

_LIT( KResourceFile, "mcspluginres.rsc" );

_LIT( KResPath, "\\resource\\" );

_LIT( KMenuAttrRefcount, "ref_count" );

_LIT( KMMApplication, "mm://" );

_LIT( KHideExit2, "&exit=hide" );

_LIT( KSetFocusString, "!setfocus?applicationgroup_name=" );

_LIT( KApplicationGroupName, "applicationgroup_name" );

_LIT( KIcon, "icon" );

_LIT( KMenuAttrUndefUid, "0x99999991" );

const TUid KHomescreenUid = { AI_UID3_AIFW_COMMON };

const TUid KMMUid = { 0x101F4CD2 };

// ======== LOCAL FUNCTIONS ========

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

// NextIdToken

//

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

//

static TPtrC NextIdToken( TLex& aLexer )

   {

   aLexer.SkipSpace();

   aLexer.Mark();

   while( !aLexer.Eos() && !aLexer.Peek().IsSpace() && aLexer.Peek() != ')' )

       {

       aLexer.Inc();

       }

   return aLexer.MarkedToken();

   }

// ============================ MEMBER FUNCTIONS ===============================

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

// CMCSPluginEngine::CMCSPluginEngine

//

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

//

CMCSPluginEngine::CMCSPluginEngine( CMCSPlugin& aPlugin, 

    const TDesC8& aInstanceUid ) 

    : iPlugin( aPlugin ), iInstanceUid( aInstanceUid )    

    {

    }

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

// CMCSPluginEngine::NewL

// 

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

//

CMCSPluginEngine* CMCSPluginEngine::NewL( CMCSPlugin& aPlugin, 

    const TDesC8& aInstanceUid )

    {

    CMCSPluginEngine* self = 

        new( ELeave ) CMCSPluginEngine( aPlugin, aInstanceUid );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CMCSPluginEngine::ConstructL

//

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

//

void CMCSPluginEngine::ConstructL()

    {

    TFullName resourceFile( KResourceDrive );

    resourceFile.Append( KResPath );

    resourceFile.Append( KResourceFile );

    BaflUtils::NearestLanguageFile(

        CCoeEnv::Static()->FsSession(),

        resourceFile );

    iResourceOffset =

        CCoeEnv::Static()->AddResourceFileL( resourceFile );

    InitL();

    StartObservingL();

    // Get "Undefined" item

    CMenuFilter* filter = CMenuFilter::NewL();

    CleanupStack::PushL( filter );

    filter->HaveAttributeL( KMenuAttrUid, KMenuAttrUndefUid );

    iUndefinedItemHeader = FindMenuItemL( *filter );

    CleanupStack::PopAndDestroy( filter );

    filter = NULL;

    iUndefinedItem = CMenuItem::OpenL( iMenu, iUndefinedItemHeader );    

    }

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

// CMCSPluginEngine::~CMCSPluginEngine

//

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

//

CMCSPluginEngine::~CMCSPluginEngine()

    {

    StopObserving();

    delete iPluginData;

    iMenu.Close();

    //iWatcher->Cancel();

    delete iWatcher;

    CCoeEnv::Static()->DeleteResourceFile( iResourceOffset );

    if ( iUndefinedItem )

        {

        delete iUndefinedItem;

        iUndefinedItem = NULL;

        }

    }

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

// CMCSPluginEngine::InitL

//

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

//

void CMCSPluginEngine::InitL()

    {

    iMenu.OpenL( KMyMenuData );

    iPluginData = CMCSPluginData::NewL( *this, iInstanceUid );

    iWatcher = CMCSPluginWatcher::NewL( CMCSPluginWatcher::EOperation );

    TInt err( iNotifier.Open( iMenu ) ); 

    if ( err == KErrNone )

        {

        iNotifyWatcher = CMCSPluginWatcher::NewL( CMCSPluginWatcher::ENotify );

        iNotifier.Notify( 0,

            RMenuNotifier::EItemsAddedRemoved |

            RMenuNotifier::EItemsReordered |

            RMenuNotifier::EItemAttributeChanged,

            iNotifyWatcher->iStatus );

        iNotifyWatcher->WatchNotify( this );

        }

    }

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

// CMCSPluginEngine::StartObservingL

//

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

//

void CMCSPluginEngine::StartObservingL()

    {

    // registering to mailbox db. changes observing

    iMsvSession = CMsvSession::OpenAsObserverL( *this );

    }

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

// CMCSPluginEngine::StopObserving

//

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

//

void CMCSPluginEngine::StopObserving()

    {       

    delete iMsvSession;

    iMsvSession = NULL;    

    }

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

// CMCSPluginEngine::MenuDataL

//

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

//

TMCSData& CMCSPluginEngine::MenuDataL( const TInt& aIndex )

    {

    return iPluginData->DataItemL( aIndex );

    }

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

// CMCSPluginEngine::MenuItemCount

//

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

//

TInt CMCSPluginEngine::MenuItemCount()

    {

    return iPluginData->DataCount();

    }

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

// CMCSPluginEngine::FindMenuItemL

// Returns the menu item header, which matches the given filter.

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

//

TMenuItem CMCSPluginEngine::FindMenuItemL( CMenuFilter& aFilter )

    {    

    TMenuItem item;

    const TInt root( iMenu.RootFolderL() );

    RArray<TMenuItem> items;

    CleanupClosePushL( items );

    iMenu.GetItemsL( items, root, &aFilter, ETrue );

    if ( items.Count() > 0 )

        {

        item = items[0];

        }

    CleanupStack::PopAndDestroy( &items );

    return item;

    }

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

// CMCSPluginEngine::FetchMenuItemL

// Returns the actual menu item for the given header.

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

//

CMenuItem* CMCSPluginEngine::FetchMenuItemL( const TMenuItem& aMenuItem )

    {

    return CMenuItem::OpenL( iMenu, aMenuItem );

    }

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

// CMCSPluginEngine::ItemIconL

// Returns MCS default icon if attribute is 'icon' else parses the

// skin definition from attribute and sets attributes to aMenuItem.

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

//

    const TDesC& aAttr )

    {

    CMenuItem* menuItem;

        {

        menuItem = iUndefinedItem;

        }

    CAknIcon* icon( NULL );

    CGulIcon* gIcon( NULL );

    TBool exists( ETrue );

    if ( aAttr != KIcon )

        {

        // Resolve secondary icon definition from attribute

        TPtrC iconDef( menuItem->GetAttributeL( aAttr, exists ) );

        if ( exists )

            {

            exists = ConstructMenuItemForIconL( iconDef, *menuItem );

            }

        }

    if ( exists )

        {

        icon = MenuIconUtility::GetItemIconL( *menuItem );

        if ( icon )

            {

            CleanupStack::PushL( icon );

            gIcon = CGulIcon::NewL( icon->Bitmap(), icon->Mask() );

            // Detach and delete

            icon->SetBitmap( NULL );

            icon->SetMask( NULL );    

            CleanupStack::PopAndDestroy( icon );

            }

        }

    return gIcon;

    }

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

// CMCSPluginEngine::ItemTextL

// Returns text string for the given attribute

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

//

    CMenuItem* menuItem;

        {

        menuItem = iUndefinedItem;

        }

    TBool exists( KErrNotFound );

    TPtrC name( menuItem->GetAttributeL( aAttr, exists ) );

    if ( exists )

        {

        return name;

        }

    return KNullDesC();

    }

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

// CMCSPluginEngine::LaunchItemL

// Calls the open command for the given menu item header

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

//

void CMCSPluginEngine::LaunchItemL( const TInt& aIndex )

    {

    if ( iBackupRestore )

        {

        HBufC* temp = StringLoader::LoadLC( R_MCS_DISABLE_OPEN_ITEM );

        CAknNoteDialog* dialog = new (ELeave) CAknNoteDialog(

            CAknNoteDialog::EConfirmationTone,

            CAknNoteDialog::ENoTimeout );

        dialog->SetTextL( temp->Des() );

        dialog->ExecuteDlgLD( R_MCS_DISABLE_OPEN_ITEM_DLG );

        CleanupStack::PopAndDestroy( temp );        

        return;

        }

    if( iWatcher->IsActive())

        {

        return;

        }

    TMCSData& dataItem( iPluginData->DataItemL( aIndex ) );

    CleanupStack::PushL( item );

    TBool attrExists = ETrue;

    TPtrC uid = item->GetAttributeL( KMenuAttrUid, attrExists );

    // or app on MMC which was removed )

    // -> We display a note for a user that this is not possible¨

    TUint32 isHidden = item->Flags() & TMenuItem::EHidden;

    TUint32 isMissing = item->Flags() & TMenuItem::EMissing;

    if ( ( attrExists && uid == KMenuAttrUndefUid ) || isHidden || isMissing )

        {

        CleanupStack::PopAndDestroy( item );

        HBufC* temp = StringLoader::LoadLC( R_MCS_DISABLE_OPEN_ITEM_MISSING );

        CAknNoteDialog* dialog = new (ELeave) CAknNoteDialog(

            CAknNoteDialog::EConfirmationTone,

            CAknNoteDialog::ENoTimeout );

        dialog->SetTextL( temp->Des() );

        dialog->ExecuteDlgLD( R_MCS_DISABLE_OPEN_ITEM_DLG );

        CleanupStack::PopAndDestroy( temp );

        temp = NULL;

        return;

        }

    // run item based on its type

    TPtrC type( item->Type() );

    // run folder

    if ( type == KMenuTypeFolder )

        {

        // message for MM application

        HBufC8* message; 

        // prepare message for launching folder

        TBool hasApplicationGroupName( EFalse );

        TPtrC applicationGroupName( item->GetAttributeL(  

            KApplicationGroupName, hasApplicationGroupName ) );

        if ( !hasApplicationGroupName )

            {

            CleanupStack::PopAndDestroy( item );

            return;

            }