/*

* Copyright (c) 2005-2006 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:  Shortcut plug-in engine class

*

*/

#include <coemain.h>                // For CCoeEnv

#include <centralrepository.h>      // For CRepository

#include <w32std.h>                 // For RWsSession

#include <apgtask.h>                // For TApaTaskList

#include <viewcli.h>                // For CVwsSessionWrapper

#include <vwsdef.h>                 // For TVwsViewId

#include <e32property.h>            // For RProperty

#include <utf.h>                    // For CnvUtfConverter

#include <bautils.h>

#include <featmgr.h>

#include <ActiveFavouritesDbNotifier.h> // For CActiveFavouritesDbNotifier

#include <pathinfo.h>

#include <data_caging_path_literals.hrh>

#include <AknSgcc.h>                    // for fast swap

#ifdef SYMBIAN_ENABLE_SPLIT_HEADERS

#include <viewclipartner.h>

#endif

#include <ctsydomainpskeys.h>

#include <UikonInternalPSKeys.h>

#include <menu2internalcrkeys.h>

#include <activeidle2internalpskeys.h>

#include <activeidle2domaincrkeys.h>

#include <activeidle2domainpskeys.h>

#include <aipspropertyobserver.h>

#include <aiscuttexts.rsg>

#include "caiscutengine.h"

#include "aiscutpluginprivatecrkeys.h"

#include "aiscutcontentmodel.h"

#include "caiscutplugin.h"

#include "caiscutshortcut.h"

#include "caiscutshortcutinfo.h"

#include "aidefaultshortcut.h"

#include "aiscutappuidparser.h"

#include "aiscutrepositorywatcher.h"

#include "aiscuttargetshutter.h"

#include "aiscutdefs.h"

#include "aiscutfactory.h"

#include <keylockpolicyapi.h>

#include "debug.h"

/**

 * Timer delay for access check retry. Two seconds.

 */

const TInt KScutAccessCheckRetryDelay = 2000000;

const TUid KVoiceCallUidViewId = { 0x10282D81 };

const TUid KVideoCallUid = { 0x101F8681 };

_LIT(KScutTextsResourceFileName,    "aiscuttexts.rsc");

_LIT8(KScutDirectOpen,    "?open");

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

LOCAL_C TInt CompareKey(const TUint32& aLeft, const TUint32& aRight)

{

    TUint32 left  = aLeft  & (KScutBitMaskThemeDefault & KScutBitMaskLocked);

    TUint32 right = aRight & (KScutBitMaskThemeDefault & KScutBitMaskLocked);

    if (left < right)

    {

        return -1;

    }

    else if (left > right)

    {

        return 1;

    }

    return 0;

}

static TInt IntFromDesc( const TDesC &aParam )

    {

    TInt err = KErrArgument;

    if (aParam.Length() > 0)

       {

           _LIT(KHexPrefix, "0x");

           const TInt prefixLen = 2;

           TRadix radix(EDecimal);

           TPtrC ptr(aParam);

           if (aParam.Left(prefixLen).CompareC(KHexPrefix) == 0)

           {

               // Strip the '0x' prefix.

               ptr.Set(aParam.Right(aParam.Length() - prefixLen));

               radix = EHex;

           }

           TLex lexer(ptr);

           TUint32 id;

           err = lexer.Val(id, radix);

           if ( err == KErrNone )

               {

               return id;

               }

           else

               {

               return err;

               }

       }

    return err;

    }

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

// Timer callback.

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

//

TInt DelayedCheckCallBack(TAny* aEngine)

{

    if (aEngine)

    {

    	static_cast<CAiScutEngine*>(aEngine)->RetryAccessCheck();	

    }

    return KErrNone;

}

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

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

//

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

//

CAiScutEngine::CAiScutEngine(CAiScutPlugin& aPlugin)

    :

    iPlugin(aPlugin),

    iResourceLoaderTexts(*CCoeEnv::Static()),

    iResourceLoaderSendUi(*CCoeEnv::Static())

{

}

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

//

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

//

void CAiScutEngine::ConstructL()

{

    FeatureManager::InitializeLibL();

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

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

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

    iVwsSession = CVwsSessionWrapper::NewL();

    iRepository = CRepository::NewL(KCRUidShortcutItems);

    iHiddenAppsRepository = CRepository::NewL(KCRUidMenu);

    // Create message server session because it may be needed during shortcut

    // creation for checking mailbox access.

    iMsvSession = CMsvSession::OpenAsObserverL(*this);

    iEnv = CCoeEnv::Static();

    TParsePtrC driveParse(PathInfo::RomRootPath());

    TFileName resourceName(driveParse.Drive());

    TParse parse;

    parse.Set(KScutTextsResourceFileName, &KDC_RESOURCE_FILES_DIR, NULL);

    resourceName.Append(parse.FullName());

    iResourceLoaderTexts.OpenL(resourceName);

    TFileName resourceName2(driveParse.Drive());

    TParse parse2;

    parse2.Set(KSendNormResource, &KDC_RESOURCE_FILES_DIR, NULL);

    resourceName2.Append(parse2.FullName());

    iResourceLoaderSendUi.OpenL(resourceName2);

    LoadAppTitleListL();

    // Engine should still remain alive even though shortcut construction failed

    // because LaunchByValue must still be possible.

    TRAP_IGNORE(CreateShortcutsL());

    // Close message server session for now. It's opened again in Resume if needed.

    delete iMsvSession;

    iMsvSession = NULL;

    iKeyEventObserver = AiUtility::CreatePSPropertyObserverL(

        TCallBack(HandlePSCommand, this),

        KUidSystemCategory, KPSUidShortcutCmd);

    iCallStateObserver = AiUtility::CreatePSPropertyObserverL(

        TCallBack(CallStateChangeCallback, this),

        KPSUidCtsyCallInformation, KCTsyCallState);

    iKeylockApi = CKeyLockPolicyApi::NewL( EPolicyActivateKeyguard );

    if ( !iKeylockApi->HasConfiguration() )

        {

        delete iKeylockApi;

        iKeylockApi = NULL;

        }

    CRepository* repository = CRepository::NewLC(TUid::Uid(KCRUidActiveIdleLV));

    repository->Get(KAIFirstKeyLockKey,  iFirstLockKey);

    repository->Get(KAISecondKeyLockKey, iSecondLockKey);

    repository->Get(KAIKeyLockTimeout,  iDelayTimerDelay);    

    CleanupStack::PopAndDestroy(repository);

    // convert micro to milliseconds

    const TInt KUsInMs = 1000;

    iDelayTimerDelay = KUsInMs * iDelayTimerDelay;       

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

}

TInt CAiScutEngine::DelayTimerCallBack (TAny *aSelf )

    {

    CAiScutEngine* self = static_cast<CAiScutEngine*>(aSelf );

    TInt err = KErrNone;

    if (self )

        {

        self->iDelayTimer->Cancel();

        TRAP(err,

                self->HandleLaunchByIndexL( *(self->iDelayedLaunchCmd) );

                );

        }

    return err;

    }

void CAiScutEngine::DelayedLaunchByIndexL( const TDesC &aParam )

    {

    delete iDelayedLaunchCmd;        

    iDelayedLaunchCmd = NULL;

    iDelayedLaunchCmd = aParam.AllocL();

    iDelayTimer->Cancel();

    iDelayTimer->Start( iDelayTimerDelay,

            iDelayTimerDelay,

            TCallBack( DelayTimerCallBack, this ));

}

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

//

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

//

CAiScutEngine* CAiScutEngine::NewL(CAiScutPlugin& aPlugin)

{

    CAiScutEngine* self = new (ELeave) CAiScutEngine(aPlugin);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

}

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

//

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

//

CAiScutEngine::~CAiScutEngine()

{

#ifdef __WEB_WIDGETS

    if( iWidgetRegistryConnected )

        {

        iWidgetRegistry.Disconnect();

        }

#endif

    delete iKeylockApi;

    delete iSettingsNotifier;

    delete iRepository;

    delete iHiddenAppsNotifier;

    delete iHiddenAppsRepository;

    iHiddenApps.Close();

    delete iAppNotifier;

    delete iTimer;

    delete iMsvSession;

    delete iVwsSession;

    delete iScutShutter;

    Release(iKeyEventObserver);

    Release(iCallStateObserver);

    iShortcuts.ResetAndDestroy();

    iThemeShortcuts.ResetAndDestroy();

    iDefaultUsed.Close();

    delete iBookmarkDbObserver;

    iBookmarkDb.Close();

    iBookmarkSess.Close();

    iApaSession.Close();

    while(iAppTitleList.Count())

    {

        delete iAppTitleList[0].iLongTitle;

        delete iAppTitleList[0].iShortTitle;

        delete iAppTitleList[0].iSkeyTitle;

        delete iAppTitleList[0].iMskTitle;

        iAppTitleList.Remove(0);

    }

    iAppTitleList.Close();

    iResourceLoaderTexts.Close();

    iResourceLoaderSendUi.Close();

    delete iDelayTimer;

    delete iDelayedLaunchCmd;

    iIcons.Close();

    FeatureManager::UnInitializeLib();

}

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

// From class MMsvSessionObserver.

// Handles an event from the message server.

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

//

void CAiScutEngine::HandleSessionEventL(

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

{

    switch (aEvent)

    {

    case EMsvEntriesCreated:

    case EMsvEntriesDeleted:

    case EMsvEntriesChanged:

        if (iShortcuts.Count() > 0)

        {

            MergeShortcuts(EScutMailbox, ETrue);

            CheckAccessAndPublish(EScutCheckMailbox, EFalse);

        }

        break;

    default:

        break;

    }

}

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

// From class MApaAppListServObserver.

// Handles a change in the application list.

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

//

void CAiScutEngine::HandleAppListEvent(TInt /*aEvent*/)

{

    TRAP_IGNORE( CheckForThemeDefaultReinstalledL() );

    MergeShortcuts(EScutAnyType, ETrue);

    CheckAccessAndPublish(EScutCheckApp, ETrue);

}

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

// Resumes the engine.

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

//

void CAiScutEngine::ResumeL(TBool aPublishAll, TAiTransitionReason /*aReason*/)

{

    // Merge shortcuts and start notifiers only if we have publishable shortcuts.

    if (iShortcuts.Count() > 0)

    {

        if (!iSettingsNotifier)

        {

            iSettingsNotifier = CAiScutRepositoryWatcher::NewL(

                KCRUidShortcutItems,

                TCallBack(HandleShortcutsChanged, this),

                iRepository);

        }

        if (!iHiddenAppsNotifier)

        {

            iHiddenAppsNotifier = CAiScutRepositoryWatcher::NewL(

                KCRUidMenu,

                KMenuHideApplication,

                CCenRepNotifyHandler::EStringKey,

                TCallBack(HandleHiddenAppsChanged, this),

                iHiddenAppsRepository);

        }

    }

#ifdef __WEB_WIDGETS

    if( !iWidgetRegistryConnected )

        {

        TInt cError = iWidgetRegistry.Connect();

        if( cError == KErrNone )

            {

            iWidgetRegistryConnected = ETrue;

            }

        }

#endif

    GetHiddenAppsL();

    MergeShortcutsL(EScutAnyType, EFalse);

    // Call state check must be done always because RSK "Back"

    // must be published when theme is changed during phone call, too.

    HandleCallStateChange();

    CheckAccessAndPublish(EScutCheckAll, aPublishAll);

    if (iShortcuts.Count() > 0)

    {

        iSettingsNotifier->StartListeningL();

        iHiddenAppsNotifier->StartListeningL();

        if (!iAppNotifier)

        {

            iAppNotifier = CApaAppListNotifier::NewL(this, CActive::EPriorityStandard);

        }

    }

}

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

// Suspends the engine.

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

//

void CAiScutEngine::Suspend()

{

    delete iMsvSession; // This is to stop receiving message server events.

    iMsvSession = NULL;

    delete iSettingsNotifier;

    iSettingsNotifier = NULL;

    delete iHiddenAppsNotifier;

    iHiddenAppsNotifier = NULL;

    delete iAppNotifier;

    iAppNotifier = NULL;

    delete iTimer;

    iTimer = NULL;

    delete iScutShutter;

    iScutShutter = NULL;

    if (iBookmarkDbObserver)

    {

        iBookmarkDbObserver->Cancel();

    }

    delete iBookmarkDbObserver;

    iBookmarkDbObserver = NULL;

#ifdef __WEB_WIDGETS

    if( iWidgetRegistryConnected )

        {

        TInt cError = iWidgetRegistry.Disconnect();

        if( cError == KErrNone )

            {

            iWidgetRegistryConnected = EFalse;

            }

        }

#endif

}

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

//

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

//

TInt CAiScutEngine::HandleShortcutsChanged(TAny* aPtr)

{

    __PRINTS("XAI: CAiScutEngine::HandleShortcutsChanged");

    CAiScutEngine* self = static_cast<CAiScutEngine*>(aPtr);

	if (self)

	{

    	self->MergeShortcuts(EScutAnyType, ETrue);

    	self->CheckAccessAndPublish(EScutCheckAll, EFalse);		

	}

    return KErrNone;

}

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

//

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

//

TInt CAiScutEngine::HandleHiddenAppsChanged(TAny* aPtr)

{

    CAiScutEngine* self = static_cast<CAiScutEngine*>(aPtr);

	if (self)

	{

    	TRAP_IGNORE(self->GetHiddenAppsL());

    	self->MergeShortcuts(EScutAnyType, ETrue);

    	self->CheckAccessAndPublish(EScutCheckAll, EFalse);		

	}

    return KErrNone;

}

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

//

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

//

TBool CAiScutEngine::IsLockKey( TInt aScanCode, TScutLockKey aLockKey ) const

    {

    TBool returnValue = EFalse;

    if ( iKeylockApi )

        {      

        TInt index = 0;

        TUint32 priKey = 0;

        TUint32 secKey = 0;

        TInt err = KErrNone;  

        // Loop through all the combinations in order

        // to find wether this key is part of the locking

        // process or not (1st or 2nd key)      

        while( !returnValue )

            {

            err = iKeylockApi->GetKeyCombination(index, priKey, secKey);

            if ( err == KErrNone )

                {

                switch( aLockKey )

                    {

                    case EScutFirstLockKey:

                        returnValue = (priKey == aScanCode);

                        break;

                    case EScutSecondLockKey:

                        returnValue = (secKey == aScanCode);

                        break;

                    default: