/*

* Copyright (c) 2009-2010 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 <gslauncher.h>

#include <mcsmenufilter.h>

#include <mcsmenuoperation.h>

#include <mcsmenuiconutility.h>

#include <bautils.h>

#include <StringLoader.h>

#include <aknnotedialog.h>

#include <mcspluginres.rsg>

#include <apgcli.h> 

#include <apacmdln.h>

#include <gfxtranseffect/gfxtranseffect.h>      

#include <akntranseffect.h>

#include <schemehandler.h>

#include <viewcli.h>                // For CVwsSessionWrapper

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <viewclipartner.h>

#endif

#include <aisystemuids.hrh>

// User includes

#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( KMMApplication, "mm://" );

_LIT( KIcon, "icon" );

_LIT( KMenuAttrUndefUid, "0x99999991" );

_LIT( KMenuIconFile, "aimcsplugin.mif" );

_LIT( KMenuBookmarkIconId, "16386" );

_LIT( KMenuBookmarkMaskId, "16387" );

_LIT( KMenuMailboxIconId, "16388" );

_LIT( KMenuMailboxMaskId, "16389" );

_LIT( KMenuTypeMailbox, "menu:mailbox" );

_LIT( KPrefix, "0x" );

const TUid KHomescreenUid = { AI_UID3_AIFW_COMMON };

const TUid KMMUid = { 0x101F4CD2 };

const TUid KMCSCmailUidValue = { 0x2001E277 };

const TUid KMCSCmailMailboxViewIdValue = { 0x2 };

const TUid KBrowserUid = { 0x10008D39 };

// ======== 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();

   }

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

// Shows note dailog, with the given resource.

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

//

static void ShowNoteDlgL( TInt aResource )

    {

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

    CAknNoteDialog* dialog = new (ELeave) CAknNoteDialog(

    CAknNoteDialog::EConfirmationTone,

    CAknNoteDialog::ENoTimeout );

    CleanupStack::PushL( dialog );

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

    dialog->ExecuteDlgLD( R_MCS_DISABLE_OPEN_ITEM_DLG );

    CleanupStack::Pop( dialog );

    CleanupStack::PopAndDestroy( temp );

    }

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

// Parses uid in Hexadecimal format from the given string.

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

//

TUid ParseHexUidFromString(const TDesC& aUidString )

    {

    TUid uid( KNullUid ); 

    const TInt pos( aUidString.FindF( KPrefix ) );

    if ( pos != KErrNotFound )

        {

        TLex lex( aUidString.Mid( pos + KPrefix().Length() ) );

        // Hex parsing needs unsigned int

        TUint32 value( 0 );

        const TInt parseResult( lex.Val( value, EHex ) );

        if ( parseResult == KErrNone )

            {

            TInt32 value32( value );

            uid.iUid = value32;   

            }

        }

    return uid;

    }

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

// Start transition effect. User has launched the application with the given uid.

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

//

void StartEffect( TUid aUid )

    {

    //start a full screen effect

    GfxTransEffect::BeginFullScreen( 

        AknTransEffect::EApplicationStart,

        TRect(), 

        AknTransEffect::EParameterType, 

        AknTransEffect::GfxTransParam( aUid,

        AknTransEffect::TParameter::EActivateExplicitContinue ));

    }

// ============================ 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 );

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

    }

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

// CMCSPluginEngine::~CMCSPluginEngine

//

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

//

CMCSPluginEngine::~CMCSPluginEngine()

    {

    StopObserving();

    delete iPluginData;

    // Notifier close has to be before iMenu close

    iNotifier.Close();

    iMenu.Close();

    delete iWatcher;

    delete iNotifyWatcher;

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

    delete iUndefinedItem;

    }

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

// 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,

            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

//

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

//

CMCSData& 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( CMCSData& aData )

    {

    CMenuItem* item = NULL;

    TRAP_IGNORE( item = CMenuItem::OpenL( iMenu, aData.MenuItem().Id() ) );

    if( item )

        {

        return item; 

        }

    if( aData.MenuItem().Type() == KMenuTypeUrl )

        {

        item = CreateBkmItemL( aData );

        }

    else if( aData.MenuItem().Type() == KMenuTypeMailbox )

        {

        item = CreateMailboxItemL( aData);

        }

    return item;

    }

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

// 

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

//

CMenuItem* CMCSPluginEngine::CreateBkmItemL( CMCSData& aData )

    {

    CMenuItem* item( NULL );

    if( aData.MenuItem().Id() != KErrNotFound )

        {        

        item = CMenuItem::CreateL( iMenu, KMenuTypeUrl, 0, 0 );

        CleanupStack::PushL( item );

        item->SetAttributeL( KMenuAttrIconFile, KMenuIconFile );

        item->SetAttributeL( KMenuAttrIconId, KMenuBookmarkIconId );

        item->SetAttributeL( KMenuAttrMaskId, KMenuBookmarkMaskId );

        CleanupStack::Pop( item );

        }

    return item;

    }

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

// 

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

//

CMenuItem* CMCSPluginEngine::CreateMailboxItemL( CMCSData& aData )

    {

    CMenuItem* item( NULL );

    if( aData.MenuItem().Id() != KErrNotFound )

        {   

        item = CMenuItem::CreateL( iMenu, KMenuTypeMailbox, 0, 0 );

        CleanupStack::PushL( item );

        item->SetAttributeL( KMenuAttrIconFile, KMenuIconFile );

        item->SetAttributeL( KMenuAttrIconId, KMenuMailboxIconId );

        item->SetAttributeL( KMenuAttrMaskId, KMenuMailboxMaskId );

        CleanupStack::Pop( item );

        }

    return item;

    }

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

// CMCSPluginEngine::ItemIconL

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

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

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

//

CGulIcon* CMCSPluginEngine::ItemIconL( CMenuItem* aMenuItem, 

    const TDesC& aAttr )

    {

    CMenuItem* menuItem;

    // check if item exists in MCS

    if ( aMenuItem )

        { 

        TUint32 flags = aMenuItem->Flags();

        TUint32 isHidden = flags & TMenuItem::EHidden;

        TUint32 isMissing = flags & TMenuItem::EMissing;

            {

            menuItem = iUndefinedItem;

            }

        else

            {

            menuItem = aMenuItem;

            }

        }

    else 

        {

        // item not found in MCS. Use Undefined Icon

        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

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

//

TPtrC CMCSPluginEngine::ItemTextL( CMenuItem* aMenuItem, const TDesC& aAttr )

    {

    CMenuItem* menuItem;

    // check if item exists in MCS

    if ( aMenuItem )

        {

        TUint32 flags = aMenuItem->Flags();

        TUint32 isHidden = flags & TMenuItem::EHidden;

        TUint32 isMissing = flags & TMenuItem::EMissing;

        // if item is hidden or missing (mmc card removed)

        // use "Undefined" text instead

            {

            menuItem = iUndefinedItem;

            }

        else

            {

            menuItem = aMenuItem;

            }

        }

    else 

        {

        // item not found in MCS. Use "Undefined" text

        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 )

        {

        ShowNoteDlgL( R_MCS_DISABLE_OPEN_ITEM ); 

        return;

        }

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

    // run item based on its type

    TPtrC type( dataItem.MenuItem().Type());

    // run folder

    if ( type == KMenuTypeFolder )

        {

        LaunchFolderItemL( dataItem );

        }

    else if( type == KMenuTypeUrl )

        {

        LaunchBookmarkItemL( dataItem );