/*

* 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. 

*

*/

// INCLUDE FILES

#include "mcspluginengine.h"

#include <gulicon.h>

#include <AknsItemID.h>

#include <gslauncher.h>

#include <aisystemuids.hrh>

#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 <avkon.rsg>

#include <mcspluginres.rsg>

#include "mcsplugin.h"

#include "mcsplugindata.h"

#include "mcspluginuids.hrh"

#include <apgtask.h>

#include <apgcli.h> 

#include <apacmdln.h>

#include <gfxtranseffect/gfxtranseffect.h>      // For Transition effect

#include <akntranseffect.h>

#include <AknsConstants.h>

_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( KHideExit, "?exit=hide" );

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

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

_LIT( KApplicationGroupName, "applicationgroup_name" );

_LIT( KSuiteName, "suite_name" );

_LIT( KIcon, "icon" );

_LIT( KMenuAttrUndefUid, "0x99999991" );

const TUid KHomescreenUid = { AI_UID3_AIFW_COMMON };

const TUid KMMUid = { 0x101F4CD2 };

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

static TPtrC NextIdToken( TLex& aLexer )

   {

   aLexer.SkipSpace();

   aLexer.Mark();

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

       {

       aLexer.Inc();

       }

   return aLexer.MarkedToken();

   }

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

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

// Default constructor

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

//

CMCSPluginEngine::CMCSPluginEngine( CMCSPlugin& aPlugin, const TDesC8& aInstanceUid ) 

    : iPlugin( aPlugin ), iInstanceUid( aInstanceUid ),

      iSuspend( EFalse )

    {

    }

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

// Two-phased constructor.

// Create instance of concrete ECOM interface implementation

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

//

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;

    }

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

// Symbian 2nd phase constructor can leave

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

//

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

    }

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

// Destructor.

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

//

CMCSPluginEngine::~CMCSPluginEngine()

    {

    StopObserving();

    delete iPluginData;

    iNotifier.Close();

    iMenu.Close();

    //iWatcher->Cancel();

    delete iWatcher;

    delete iNotifyWatcher;

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

    }

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

// 

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

//

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

        }

    }

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

// Tells the settings container to start observing for changes

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

//

void CMCSPluginEngine::StartObservingL()

    {

    // registering to bookmarks db. changes observing

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

    User::LeaveIfError( iBookmarkDb.Open( iBookmarkSession, KBrowserBookmarks ) );

    iBookmarkDbObserver = new (ELeave) CActiveFavouritesDbNotifier(

                                        iBookmarkDb, *this );

    iBookmarkDbObserver->Start();

    // registering to mailbox db. changes observing

    iMsvSession = CMsvSession::OpenAsObserverL( *this) ;

    }

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

// Tells the settings container to stop observing for changes

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

//

void CMCSPluginEngine::StopObserving()

    {

    if ( iBookmarkDbObserver )

        {

        delete iBookmarkDbObserver;

        iBookmarkDbObserver = NULL;

        }

    iBookmarkDb.Close();

    iBookmarkSession.Close();

    if ( iMsvSession )

        {

        delete iMsvSession;

        iMsvSession = NULL;

        }

    }

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

// 

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

//

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

    {

    return iPluginData->DataItemL( aIndex );

    }

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

// 

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

//

TInt CMCSPluginEngine::MenuItemCount()

    {

    return iPluginData->DataCount();

    }

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

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

    }

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

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

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

//

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

    {

    return CMenuItem::OpenL( iMenu, aMenuItem );

    }

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

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

    {

    CAknIcon* icon( NULL );

    CGulIcon* gIcon( NULL );

    TBool exists( ETrue );

    if( aAttr != KIcon )

        {

        // Resolve secondary icon definition from attribute

        TPtrC iconDef = aMenuItem.GetAttributeL( aAttr, exists );

        if( exists )

            {

            exists = ConstructMenuItemForIconL( iconDef, aMenuItem );

            }

        }

    if( exists )

        {

        icon = MenuIconUtility::GetItemIconL( aMenuItem );

        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;

    }

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

// Returns text string for the given attribute

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

//

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

    {    

    TBool exists( KErrNotFound );

    TPtrC name = aMenuItem.GetAttributeL( aAttr, exists );

    if( exists )

        {

        return name;

        }

    else

        {

        return KNullDesC();

        }

    }

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

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

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

//

void CMCSPluginEngine::LaunchItemL( const TInt& aIndex )

    {

    if ( iSuspend )

        {

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

    CMenuItem* item = CMenuItem::OpenL( iMenu, dataItem.MenuItem());

    CleanupStack::PushL( item );

    TPtrC type = item->Type();

    // run suite/folder

    if ( type == KMenuTypeSuite || type == KMenuTypeFolder )

        {

        // message for MM application

        HBufC8* message; 

        if ( type == KMenuTypeSuite )

            {

            // prepare message for launching suite

            TBool hasSuiteName = EFalse;

            TPtrC suiteName = item->GetAttributeL( KSuiteName, hasSuiteName );

            if ( !hasSuiteName )

                { 

                CleanupStack::PopAndDestroy( item );

                return;

                }

            message = HBufC8::NewLC( KMMApplication().Length() + 

                                     suiteName.Length() + 

                                     KHideExit().Length() );

            message->Des().Copy( KMMApplication );

            message->Des().Append( suiteName );

            message->Des().Append( KHideExit );

            }

        else 

            {

            // prepare message for launching folder

            TBool hasApplicationGroupName = EFalse;

            TPtrC applicationGroupName = item->GetAttributeL( KApplicationGroupName, 

                                                              hasApplicationGroupName );

            if ( !hasApplicationGroupName )

                {

                CleanupStack::PopAndDestroy( item );

                return;

                }

            message = HBufC8::NewLC( KMMApplication().Length() + 

                                     KSetFocusString().Length() +

                                     applicationGroupName.Length() + 

                                     KHideExit2().Length() );

            message->Des().Copy( KMMApplication );

            message->Des().Append( KSetFocusString );

            message->Des().Append( applicationGroupName );

            message->Des().Append( KHideExit2 );

            }

        // find MM application

        TApaTaskList taskList( CCoeEnv::Static()->WsSession() );

        TApaTask task = taskList.FindApp( KMMUid );

        if ( task.Exists() )

            {

            // MM is already running in background - send APA Message

            task.SendMessage( TUid::Uid( KUidApaMessageSwitchOpenFileValue ), *message );

            }

        else

            { 

            // MM not running yet - use Command Line Tail

            RApaLsSession appArcSession;

            CleanupClosePushL( appArcSession );

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

            TApaAppInfo appInfo;

            TInt err = appArcSession.GetAppInfo( appInfo, KMMUid );

            if ( err == KErrNone )

                {

                CApaCommandLine* cmdLine = CApaCommandLine::NewLC();

                cmdLine->SetExecutableNameL( appInfo.iFullName );

                cmdLine->SetCommandL( EApaCommandRun );

                cmdLine->SetTailEndL( *message );

                appArcSession.StartApp( *cmdLine );

                CleanupStack::PopAndDestroy( cmdLine );

                }

            CleanupStack::PopAndDestroy( &appArcSession ); 

            }

        CleanupStack::PopAndDestroy( message );

        }

    else

        {

        TBool exists( EFalse );

        TPtrC desc( item->GetAttributeL( KMenuAttrUid, exists ) );

        if( exists )

            {      

            _LIT( KPrefix, "0x" );

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

            if( pos != KErrNotFound )

                {

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

                // Hex parsing needs unsigned int

                TUint32 value = 0;

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

                if ( parseResult == KErrNone )

                    {

                    TUid uid( KNullUid );  

                    TInt32 value32( value );

                    uid.iUid = value32;   

                    if( uid != KNullUid )

                        {

                        //start a full screen effect

                        GfxTransEffect::BeginFullScreen( 

                        AknTransEffect::EApplicationStart,

                        TRect(0,0,0,0), 

                        AknTransEffect::EParameterType, 

                        AknTransEffect::GfxTransParam( uid,

                        AknTransEffect::TParameter::EActivateExplicitContinue ));

                        }

                    }

                }

            }

        // run application/shortcut/bookmark

        CMenuOperation* operation = item->HandleCommandL(

            KMenuCmdOpen, KNullDesC8, iWatcher->iStatus );

        iWatcher->Watch( operation );  

        }

    CleanupStack::PopAndDestroy( item );

    }

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

// Handle the change in Menu Content

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

//

void CMCSPluginEngine::HandleNotifyL()

    {

    TInt count( iPluginData->DataCount());

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

        {

        TMCSData& data = iPluginData->DataItemL(i);

        // Check that all the data still exist is MCS, if flag is hidden or

        // missing, we have to remove data from UI

        CMenuItem* menuItem = CMenuItem::OpenL( iMenu, data.MenuItem().Id() );

        CleanupStack::PushL( menuItem );

        if ( !menuItem || 

             ( menuItem->Flags() & TMenuItem::EHidden ) ||

             ( menuItem->Flags() & TMenuItem::EMissing ) )

            {

            // Get the replacement for hidden data

            CMenuFilter* filter = CMenuFilter::NewL();

            CleanupStack::PushL( filter );

            // 'Undefined' item

            filter->HaveAttributeL( KMenuAttrUid, KMenuAttrUndefUid );

            TMenuItem undefItem = FindMenuItemL( *filter );

            iPluginData->ReplaceMenuItemL( i, undefItem );

            iPluginData->SaveSettingsL( i, *FetchMenuItemL(undefItem) );

            CleanupStack::PopAndDestroy( filter );

            }

        CleanupStack::PopAndDestroy( menuItem );

        menuItem = NULL;

        }

    // Notification must be activated again

    iNotifyWatcher->Cancel();

    iNotifier.Notify( 0,

                RMenuNotifier::EItemsAddedRemoved |

                RMenuNotifier::EItemsReordered |

                RMenuNotifier::EItemAttributeChanged,

                iNotifyWatcher->iStatus );

    iNotifyWatcher->WatchNotify( this );

    // Publish changed data

    iPlugin.PublishL();

    }

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

// From class MMsvSessionObserver.

// Handles an event from the message server.

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

//

void CMCSPluginEngine::HandleSessionEventL(

    TMsvSessionEvent aEvent, TAny* /*aArg1*/, TAny* /*aArg2*/, TAny* /*aArg3*/)

    {

    switch ( aEvent )

        {

    case EMsvEntriesDeleted:

        // fall-through intended here

    case EMsvEntriesChanged:

        {

        }

        break;

    default:

        break;

        }

    }

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

// From class MFavouritesDbObserver.

// Handles database event.

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