--- /dev/null Thu Jan 01 00:00:00 1970 +0000
+++ b/idlefw/plugins/shortcutplugin/src/caiscutengine.cpp Thu Dec 17 08:54:17 2009 +0200
@@ -0,0 +1,1787 @@
+/*
+* 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:
+ returnValue = EFalse;
+ break;
+ }
+ }
+ else // no more combinations
+ {
+ break;
+ }
+ ++index;
+ }
+ return returnValue;
+ }
+ switch( aLockKey )
+ {
+ case EScutFirstLockKey:
+ returnValue = iFirstLockKey == aScanCode;
+ break;
+ case EScutSecondLockKey:
+ returnValue = iSecondLockKey == aScanCode;
+ break;
+ default:
+ returnValue = EFalse;
+ break;
+ }
+ return returnValue;
+ }
+
+
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+TBool CAiScutEngine::IsHidden(const TUid& aAppUid) const
+{
+ if (iHiddenApps.Find(aAppUid) == KErrNotFound)
+ {
+ return EFalse;
+ }
+
+ __PRINT( __DBG_FORMAT( "XAI: CAiScutEngine::IsHidden (0x%x) ETrue"), aAppUid);
+ return ETrue;
+}
+
+// ---------------------------------------------------------------------------
+// Handles an event sent by the AI framework.
+// ---------------------------------------------------------------------------
+//
+void CAiScutEngine::HandleAiEventL(TInt aEvent, const TDesC& aParam)
+{
+ __PRINT( __DBG_FORMAT( "XAI: CAiScutEngine::HandleAiEventL( %d, '%S' ) alive = %d"), aEvent, &aParam, iPlugin.IsAlive());
+
+ TUid appUid = KNullUid;
+ iFirstLockKeyPressed = EFalse;
+ iSoftkeyAppRunning = EFalse;
+
+ if (aParam.Compare(KLeftSoftkey) == 0)
+ {
+ if ( IsLockKey( EStdKeyDevice0, EScutFirstLockKey) || IsLockKey( EStdKeyDevice0 , EScutSecondLockKey))
+ {
+ // Raise the first lock key pressed flag
+ // only when this is raised, keylock skip causes scut launch
+ iFirstLockKeyPressed = ETrue;
+ appUid = SoftkeyUid(KLeftSoftkeyId);
+ }
+ }
+
+ if (aParam.Compare(KRightSoftkey) == 0)
+ {
+ if ( IsLockKey( EStdKeyDevice1 , EScutFirstLockKey) || IsLockKey( EStdKeyDevice1 , EScutSecondLockKey))
+ {
+ // Raise the first lock key pressed flag
+ // only when this is raised, keylock skip causes scut launch
+ iFirstLockKeyPressed = ETrue;
+ appUid = SoftkeyUid(KRightSoftkeyId);
+ }
+ }
+
+ if (iFirstLockKeyPressed && appUid != KNullUid)
+ {
+ TApaTaskList taskList(iEnv->WsSession());
+ TApaTask task(taskList.FindApp(appUid));
+
+ if (task.Exists())
+ {
+ if (IsHiddenFromFSW(appUid))
+ iSoftkeyAppRunning = EFalse;
+ else
+ iSoftkeyAppRunning = ETrue;
+ }
+ }
+
+ if (IsDelayRequired(appUid))
+ {
+ DelayedLaunchByIndexL( aParam );
+ return;
+ }
+
+ if( iActiveCall && aParam.Compare( KRightSoftkey ) == 0 )
+ {
+ ActivateTopMostApp();
+ return;
+ }
+
+ switch( aEvent )
+ {
+ case EAiScutEventLaunchByIndex:
+ HandleLaunchByIndexL(aParam);
+ break;
+
+ case EAiScutEventLaunchByValue:
+ HandleLaunchByValueL(aParam);
+ break;
+
+ case EAiScutEventShowSettings:
+ ShowSettingsL(aParam);
+ break;
+
+ case EAiScutEventShowSetting:
+ ShowSettingL(aParam);
+ break;
+
+ case EAiScutEventLaunchFastswap:
+ OpenFastSwap();
+ break;
+
+ case EAiScutEventLaunchByIndexAlternate:
+ HandleLaunchByIndexAlternateL(aParam);
+ break;
+
+ default:
+ break;
+ }
+
+}
+
+// ---------------------------------------------------------------------------
+// Called by the timer. Retries the access check for shortcuts.
+// ---------------------------------------------------------------------------
+//
+void CAiScutEngine::RetryAccessCheck()
+{
+ CheckAccessAndPublish(EScutCheckAll, iPublishAll);
+
+ // One retry is enough.
+ iTimer->Cancel();
+ delete iTimer;
+ iTimer = NULL;
+}
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+TBool CAiScutEngine::IsNonNative(const TUid& aUid)
+{
+ TBool ret = EFalse;
+
+ const TUid KMidletAppType = { 0x10210E26 };
+ TUid typeuid = KNullUid;
+
+ if (KErrNone == iApaSession.GetAppType(typeuid, aUid))
+ {
+ if (typeuid == KMidletAppType)
+ {
+ ret = ETrue;
+ }
+ }
+
+#ifdef __WEB_WIDGETS
+ if (IsWidget(aUid))
+ {
+ ret = ETrue;
+ }
+#endif
+
+ return ret;
+}
+
+#ifdef __WEB_WIDGETS
+TBool CAiScutEngine::IsWidget(const TUid& aUid)
+{
+ if( iWidgetRegistryConnected )
+ {
+ return iWidgetRegistry.IsWidget(aUid);
+ }
+ else
+ {
+ return EFalse;
+ }
+}
+#endif
+
+// ---------------------------------------------------------------------------
+// Creates the default shortcuts.
+// ---------------------------------------------------------------------------
+//
+void CAiScutEngine::CreateShortcutsL()
+{
+ TInt scIndex = 0;
+
+ iShortcuts.ResetAndDestroy();
+
+ RArray<TUint32> keys;
+ CleanupClosePushL(keys);
+ // Find the keys that define theme-default shortcut settings.
+ iRepository->FindL(KScutCenRepKeyThemeDefault, KScutCenRepKeyMask, keys);
+
+
+ TLinearOrder<TUint32> order(CompareKey);
+ keys.Sort(order);
+
+ HBufC* buffer = HBufC::NewLC(NCentralRepositoryConstants::KMaxUnicodeStringLength);
+ TPtr bufferPtr = buffer->Des();
+
+ if (iSettingsNotifier)
+ {
+ iSettingsNotifier->StopListening();
+ }
+ if (iHiddenAppsNotifier)
+ {
+ iHiddenAppsNotifier->StopListening();
+ }
+
+ for (TInt i = 0; i < keys.Count(); ++i)
+ {
+ TUint32 key = keys[i];
+ if (iRepository->Get(key, bufferPtr) == KErrNone)
+ {
+ // Strip off the default-setting-bit, it's not part of the shortcut id.
+ key &= KScutBitMaskThemeDefault;
+
+ // Parse the icon from the URL and fetch the icon to our icon array
+ // The actual icon => shortcut matching and overriding is done in
+ // CheckAccessAndPublishL() just before publishing
+ iParser.Parse(bufferPtr);
+ TAiScutIcon icon = iParser.Icon();
+ if ( icon.iType != EScutIconNone )
+ {
+ AddOverrideIcon( icon );
+ }
+ // Keys over 0x20000000 means that they are just icon overrides
+ if ( !(key & KScutFlagBitIconOverride ) )
+ {
+ key &= KScutMaskAdditionalSetting;
+ // Ignore possible errors during shortcut construction
+ // and simply try to move on to the next shortcut.
+ CAiScutShortcut* shortcut = NULL;
+ TRAPD(err, shortcut = AiScutFactory::CreateAiScutShortcutL(key, bufferPtr, *this));
+ if (err == KErrNone)
+ {
+ // If shortcut is not accessible, replace it with platform default.
+ TBool access = EFalse;
+ if (shortcut)
+ {
+ // Append theme default to our array, incase of uninstall/reinstall/mem card removal
+ // restoration is required.
+ CAiScutShortcutInfo* shortcutInfo = NULL;
+ TRAP_IGNORE(shortcutInfo = CAiScutShortcutInfo::NewL(key | KScutFlagBitThemeDefault,
+ bufferPtr));
+ if ( shortcutInfo )
+ {
+ iThemeShortcuts.Append(shortcutInfo);
+ }
+
+ TScutDefault usedDefault = EScutDefaultToPlatform;
+
+ TRAP_IGNORE(access = shortcut->CheckAccessL(EScutCheckAll));
+ if (!access)
+ {
+ HBufC* target = HBufC::NewLC(NCentralRepositoryConstants::KMaxUnicodeStringLength);
+ TPtr targetPtr = target->Des();
+ TUid dummy;
+
+ // Get the default shortcut definition for index 'scIndex'.
+ // uid is ignored.
+ TAiDefaultShortcut::GetDefaultShortcut(key, dummy, targetPtr);
+
+ delete shortcut;
+ shortcut = NULL;
+ TRAP(err, shortcut = AiScutFactory::CreateAiScutShortcutL(key, targetPtr, *this));
+
+ if (err == KErrNone)
+ {
+ // Add the bit that indicates this is a default shortcut setting.
+ key |= KScutFlagBitThemeDefault;
+ iRepository->Set(key, targetPtr);
+
+ // Try to locate a icon override from the default
+ // definition
+ iParser.Parse( targetPtr );
+ TAiScutIcon tIcon = iParser.Icon();
+ if ( tIcon.iType != EScutIconNone )
+ {
+ AddOverrideIcon( tIcon );
+ }
+ }
+ CleanupStack::PopAndDestroy( target );
+ }
+ else
+ {
+ usedDefault = EScutDefaultToTheme;
+ }
+
+ scIndex++;
+
+ if (shortcut) // This test ensures that the creation right above went well.
+ {
+ iDefaultUsed.Append(usedDefault);
+ err = iShortcuts.Append(shortcut);
+
+ if (err != KErrNone)
+ {
+ delete shortcut;
+ shortcut = NULL;
+ }
+ }
+ }
+ }
+ }
+ }
+ }
+
+ if (iSettingsNotifier)
+ {
+ iSettingsNotifier->StartListeningL();
+ }
+ if (iHiddenAppsNotifier)
+ {
+ iHiddenAppsNotifier->StartListeningL();
+ }
+
+ CleanupStack::PopAndDestroy(buffer);
+ CleanupStack::PopAndDestroy(&keys);
+}
+
+// ---------------------------------------------------------------------------
+// Check whether theme default sc was reinstalled.
+// ---------------------------------------------------------------------------
+//
+void CAiScutEngine::CheckForThemeDefaultReinstalledL()
+{
+ HBufC* buffer = HBufC::NewLC(NCentralRepositoryConstants::KMaxUnicodeStringLength);
+ TPtr bufferPtr = buffer->Des();
+
+ if (iSettingsNotifier)
+ {
+ iSettingsNotifier->StopListening();
+ }
+ if (iHiddenAppsNotifier)
+ {
+ iHiddenAppsNotifier->StopListening();
+ }
+
+ TInt count = iThemeShortcuts.Count();
+ for (TInt i = 0; (i < count) &&
+ (i < iDefaultUsed.Count()) &&
+ (i < iShortcuts.Count());
+ ++i)
+ {
+ if (iDefaultUsed[i] == EScutDefaultToPlatform ||
+ iDefaultUsed[i] == EScutUserDefined)
+ {
+ bufferPtr.Zero();
+ CAiScutShortcut*& shortcut = iShortcuts[i];
+ // Strip off the default-setting-bit, it's not part of the shortcut id.
+ TUint32 scutKey = iThemeShortcuts[i]->Id() & KScutBitMaskThemeDefault;
+ bufferPtr.Append(iThemeShortcuts[i]->Target());
+ CAiScutShortcut* newScut = NULL;
+ TRAPD(err, newScut = AiScutFactory::CreateAiScutShortcutL(scutKey, bufferPtr, *this));
+ if (err == KErrNone)
+ {
+ delete shortcut;
+ shortcut = NULL;
+ shortcut = newScut;
+ // Add the bit that indicates this is a default shortcut setting.
+ scutKey |= KScutFlagBitThemeDefault;
+ iRepository->Set(scutKey, bufferPtr);
+ }
+ iDefaultUsed[i] = EScutDefaultToTheme;
+ // Recheck access
+ shortcut->CheckAccessL(EScutCheckAll);
+ }
+ }
+ if (iSettingsNotifier)
+ {
+ iSettingsNotifier->StartListeningL();
+ }
+ if (iHiddenAppsNotifier)
+ {
+ iHiddenAppsNotifier->StartListeningL();
+ }
+
+ CleanupStack::PopAndDestroy(buffer);
+}
+
+// ---------------------------------------------------------------------------
+// Merges the user defined shortcuts with the defaults and checks shortcut access.
+// ---------------------------------------------------------------------------
+//
+void CAiScutEngine::MergeShortcuts(TShortcutType aType, TBool aRecreateAll)
+{
+ TRAP_IGNORE(MergeShortcutsL(aType, aRecreateAll));
+}
+
+// ---------------------------------------------------------------------------
+// Merges the user defined shortcuts with the defaults.
+// ---------------------------------------------------------------------------
+//
+void CAiScutEngine::MergeShortcutsL(TShortcutType aType, TBool aRecreateAll)
+{
+ RArray<TUint32> keys;
+ CleanupClosePushL(keys);
+
+ // Find the keys that define user defined shortcut settings.
+ iRepository->FindL(KScutCenRepKeyUserDefined, KScutCenRepKeyMask, keys);
+
+ HBufC* buffer = HBufC::NewLC(
+ NCentralRepositoryConstants::KMaxUnicodeStringLength);
+ TPtr bufferPtr = buffer->Des();
+
+ for (TInt i = 0; i < iShortcuts.Count(); ++i)
+ {
+ CAiScutShortcut* shortcut = iShortcuts[i];
+ if (aType == EScutAnyType || shortcut->Type() == aType)
+ {
+
+ TInt keyIndex = keys.Find(shortcut->Id());
+ if (keyIndex != KErrNotFound)
+ {
+ // Set the new user target.
+ if (keys.Count() > keyIndex && keyIndex >= 0 &&
+ iRepository->Get(keys[keyIndex], bufferPtr) == KErrNone)
+ {
+ iParser.Parse(bufferPtr);
+ TAiScutIcon icon = iParser.Icon();
+ if ( icon.iType != EScutIconNone )
+ {
+ AddOverrideIcon( icon );
+ }
+ if ( aRecreateAll ||
+ buffer->CompareC( shortcut->ActiveDefinition() ) != 0 )
+ {
+ shortcut->DeleteUserTarget();
+ shortcut->SetUserTarget(bufferPtr);
+ }
+ if (i < iDefaultUsed.Count())
+ {
+ iDefaultUsed[i] = EScutUserDefined;
+ }
+ }
+ }
+ }
+ }
+
+ CleanupStack::PopAndDestroy(buffer);
+ CleanupStack::PopAndDestroy(&keys);
+}
+
+// ---------------------------------------------------------------------------
+// Checks shortcut accessibility.
+// ---------------------------------------------------------------------------
+//
+void CAiScutEngine::CheckAccessAndPublish(TInt aCheckType, TBool aPublishAll)
+{
+ TRAPD(err, CheckAccessAndPublishL(aCheckType, aPublishAll));
+
+ if (err == KErrNotReady)
+ {
+ // Access check failed, create a timer to try again later.
+ iTimer = CPeriodic::New(CActive::EPriorityStandard);
+ iTimer->Start(KScutAccessCheckRetryDelay, KScutAccessCheckRetryDelay,
+ TCallBack(DelayedCheckCallBack));
+ }
+}
+
+// ---------------------------------------------------------------------------
+// Tells each shortcut to check whether or not its target is accessible.
+// ---------------------------------------------------------------------------
+//
+void CAiScutEngine::CheckAccessAndPublishL(TInt aCheckType, TBool aPublishAll)
+{
+ __PRINTS("XAI: CheckAccessAndPublishL");
+ if (!iMsvSession && IsMsvSessionNeeded())
+ {
+ iMsvSession = CMsvSession::OpenAsObserverL(*this);
+ }
+
+ if (!iBookmarkDbObserver && IsBookmarkObserverNeeded())
+ {
+ iBookmarkDbObserver =
+ new (ELeave) CActiveFavouritesDbNotifier(iBookmarkDb, *this);
+ if (! iBookmarkDbObserver->IsActive())
+ {
+ iBookmarkDbObserver->Start();
+ }
+ }
+
+ iPublishAll = aPublishAll;
+
+ TInt count = iShortcuts.Count();
+ for (TInt i = 0; i < count; ++i)
+ {
+ CAiScutShortcut*& shortcut = iShortcuts[i];
+
+ // Check shortcut access and publish it if its target has changed.
+ // When the plug-in is being resumed, all shortcuts are published.
+ // Non-visible and locked shortcuts are never published.
+ if ( !shortcut->CheckAccessL(aCheckType) )
+ {
+ HBufC* target = HBufC::NewLC(NCentralRepositoryConstants::KMaxUnicodeStringLength);
+ TPtr targetPtr = target->Des();
+ TUid dummy;
+ // Get the default shortcut definition from cenrep using key 'key'.
+ // uid is ignored.
+ TUint32 key = shortcut->Id();
+ TAiDefaultShortcut::GetDefaultShortcut(key, dummy, targetPtr);
+ delete shortcut;
+ shortcut = NULL;
+ TRAPD(err, shortcut = AiScutFactory::CreateAiScutShortcutL(key, targetPtr, *this));
+ if (err == KErrNone)
+ {
+ // Add the bit that indicates this is a default shortcut setting.
+ key |= KScutFlagBitThemeDefault;
+ iRepository->Set(key, targetPtr);
+
+ // Try to locate a icon override from the default
+ // definition
+ iParser.Parse( targetPtr );
+ TAiScutIcon tIcon = iParser.Icon();
+ if ( tIcon.iType != EScutIconNone )
+ {
+ AddOverrideIcon( tIcon );
+ }
+ }
+ CleanupStack::PopAndDestroy( target );
+ if (i < iDefaultUsed.Count())
+ {
+ iDefaultUsed[i] = EScutDefaultToPlatform;
+ }
+ // Recheck access
+ shortcut->CheckAccessL(aCheckType);
+ }
+
+ TBool targetChanged = shortcut->IsTargetChanged();
+ TInt32 id = shortcut->Id();
+ TBool nonVisible = (0 != (id & KScutFlagBitNonVisible));
+
+ if (aCheckType == EScutCheckBkm && shortcut->Type() == EScutBookmark)
+ {
+ targetChanged = ETrue;
+ }
+
+ shortcut->SetToBePublished(
+ (targetChanged || iPublishAll) &&
+ !nonVisible
+ );
+
+ // Assign overridden icons to shortcuts if needed
+ for ( TInt j = 0; j < iIcons.Count(); j++)
+ {
+ // Check that the appuid and type matches
+ if ( shortcut->AppUid() == iIcons[j].iAppUid &&
+ shortcut->Type() == iIcons[j].iShortcutType )
+ {
+ // We need to check also the view id / bkm id if present or otherwise all bookmarks
+ // app views would be overridden
+ if ( iIcons[j].iViewId.iUid <= 0 ||
+ iIcons[j].iViewId == shortcut->AdditionalUid() )
+ {
+ shortcut->SetIcon(iIcons[j]);
+ }
+ }
+ }
+
+ __PRINT( __DBG_FORMAT( "XAI: id = 0x%x, type = %d, publish = %d"),
+ shortcut->Id(), shortcut->Type(), shortcut->NeedsToBePublished());
+ }
+
+ iPlugin.PublishShortcutsL(iShortcuts);
+}
+
+// ---------------------------------------------------------------------------
+// Finds the shortcut object with the given id.
+// ---------------------------------------------------------------------------
+//
+TInt CAiScutEngine::FindShortcutIndex(TInt32 aId)
+{
+ for (TInt i = 0; i < iShortcuts.Count(); ++i)
+ {
+ if (iShortcuts[i]->Id() == aId)
+ {
+ return i;
+ }
+ }
+
+ return KErrNotFound;
+}
+
+// ---------------------------------------------------------------------------
+// Handles the shortcut launch by index.
+// ---------------------------------------------------------------------------
+//
+void CAiScutEngine::HandleLaunchByIndexL(const TDesC& aParam)
+{
+ __PRINT( __DBG_FORMAT( "XAI: CAiScutEngine::HandleLaunchByIndexL ('%S')"), &aParam);
+ 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;
+ if (lexer.Val(id, radix) == KErrNone)
+ {
+ TInt idx = FindShortcutIndex(id);
+ if (idx != KErrNotFound && idx >= 0 && iShortcuts.Count() > idx)
+ {
+ iShortcuts[idx]->LaunchL();
+ }
+ }
+ }
+}
+// ---------------------------------------------------------------------------
+// Handles the shortcut launch by index.
+// ---------------------------------------------------------------------------
+//
+void CAiScutEngine::HandleLaunchByIndexAlternateL(const TDesC& aParam)
+/**
+ * These are the cases at the moment that are handled here.
+ * 1) Appshell targeted => Fastswap opened
+ */
+{
+ __PRINT( __DBG_FORMAT( "XAI: CAiScutEngine::HandleLaunchByIndexAlternateL ('%S')"), &aParam);
+ TInt index = IntFromDesc( aParam );
+ TInt idx = FindShortcutIndex( index );
+ if (idx != KErrNotFound && idx >= 0 && iShortcuts.Count() > idx)
+ {
+ CAiScutShortcut *scut = iShortcuts[idx];
+ // Open fastswap in case appshell was targeted with alternate launch
+ if ( scut->AppUid() == KScutAppShellUid )
+ {
+ OpenFastSwap();
+ return;
+ }
+ // add other special cases here
+ /*if ( index == EAiScutSoftKeyLeft )
+ {
+ // do something
+ }*/
+ }
+}
+
+// ---------------------------------------------------------------------------
+// Handles the shortcut launch by value.
+// ---------------------------------------------------------------------------
+//
+void CAiScutEngine::HandleLaunchByValueL(const TDesC& aParam)
+{
+ __PRINT( __DBG_FORMAT( "XAI: CAiScutEngine::HandleLaunchByIndexL ('%S')"), &aParam);
+
+ if (aParam.Length() > 0)
+ {
+ CAiScutShortcut* shortcut = AiScutFactory::CreateAiScutShortcutLC(0x0, aParam, *this);
+ shortcut->CheckAccessL(EScutCheckAll);
+ shortcut->LaunchL();
+ CleanupStack::PopAndDestroy(shortcut);
+ }
+}
+
+// ---------------------------------------------------------------------------
+// Shows the plug-in settings dialog.
+// ---------------------------------------------------------------------------
+//
+void CAiScutEngine::ShowSettingsL(const TDesC& aParam)
+{
+ __PRINT( __DBG_FORMAT( "XAI: CAiScutEngine::ShowSettingsL ('%S')"), &aParam);
+
+ _LIT(KGeneralSettings, "localapp:0x100058EC?view=0x102750FC");
+
+ CAiScutShortcut* shortcut = CAiScutShortcut::NewLC(0x0, KGeneralSettings, *this);
+ shortcut->CheckAccessL(EScutCheckAll);
+
+ if (aParam.Length() > 0)
+ {
+ HBufC8* param = CnvUtfConverter::ConvertFromUnicodeToUtf8L(aParam);
+ CleanupStack::PushL(param);
+
+ const TDesC8& msg(*param);
+
+ shortcut->LaunchL(msg);
+
+ CleanupStack::PopAndDestroy(param);
+ }
+ else
+ {
+ shortcut->LaunchL(KNullDesC8);
+ }
+
+
+ CleanupStack::PopAndDestroy(shortcut);
+}
+
+// ---------------------------------------------------------------------------
+// Shows the plug-in setting.
+// ---------------------------------------------------------------------------
+//
+void CAiScutEngine::ShowSettingL(const TDesC& aParam)
+{
+ __PRINT( __DBG_FORMAT( "XAI: CAiScutEngine::ShowSettingL ('%S')"), &aParam);
+
+ _LIT(KGeneralSettings, "localapp:0x100058EC?view=0x102750FC");
+
+ CAiScutShortcut* shortcut = CAiScutShortcut::NewLC(0x0, KGeneralSettings, *this);
+ shortcut->CheckAccessL(EScutCheckAll);
+
+ if (aParam.Length() > 0)
+ {
+ HBufC8* param = CnvUtfConverter::ConvertFromUnicodeToUtf8L(aParam);
+ CleanupStack::PushL(param);
+
+ HBufC8* param2 = HBufC8::NewLC(param->Des().Length()+KScutDirectOpen.iTypeLength);
+ param2->Des().Copy(param->Des());
+ param2->Des().Append(KScutDirectOpen);
+ const TDesC8& msg(*param2);
+
+ shortcut->LaunchL(msg);
+
+ CleanupStack::PopAndDestroy(param2);
+ CleanupStack::PopAndDestroy(param);
+ }
+ else
+ {
+ shortcut->LaunchL(KNullDesC8);
+ }
+
+
+ CleanupStack::PopAndDestroy(shortcut);
+}
+
+// ---------------------------------------------------------------------------
+// Opens the fastswap window
+// ---------------------------------------------------------------------------
+//
+void CAiScutEngine::OpenFastSwap()
+{
+ RAknUiServer* uiServer = CAknSgcClient::AknSrv();
+ if ( uiServer )
+ {
+ uiServer->MakeTaskListVisible( ETrue );
+ }
+}
+
+
+
+// ---------------------------------------------------------------------------
+// Handles PS commands from WSPlugin.
+// ---------------------------------------------------------------------------
+//
+TInt CAiScutEngine::HandlePSCommand(TAny* aAny)
+{
+ CAiScutEngine* self = reinterpret_cast< CAiScutEngine* >(aAny);
+ TInt err = KErrNone;
+ if (self)
+ {
+ TRAP(err, self->DoHandlePSCommandL());
+ }
+
+ return err;
+}
+
+// ---------------------------------------------------------------------------
+// Handles call state changes.
+// ---------------------------------------------------------------------------
+//
+TInt CAiScutEngine::CallStateChangeCallback(TAny* /*aAny*/)
+{
+ return KErrNone;
+}
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+TUid CAiScutEngine::SoftkeyUid(TUint32 aSoftkeyId)
+{
+ TUid uid = KNullUid;
+
+ TInt idx = FindShortcutIndex(aSoftkeyId);
+ if (idx != KErrNotFound && idx >= 0 && iShortcuts.Count() > idx)
+ {
+ uid = iShortcuts[idx]->AppUid();
+
+ __PRINT( __DBG_FORMAT( "XAI: SoftkeyUid %d app uid = 0x%x"), idx, uid.iUid);
+ }
+
+ return uid;
+}
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+TBool CAiScutEngine::IsDelayRequired(TUid aAppUid)
+{
+ // softkey delay is reuired for these applications because of problems
+ // in killing them immediatly after keylock activation.
+ if (aAppUid.iUid == KScutBrowserUidValue ||
+ aAppUid.iUid == KScutOperatorMenuUidValue ||
+ aAppUid.iUid == KScutVideoServicesUidValue ||
+ IsNonNative( aAppUid )
+ )
+ {
+ return ETrue;
+ }
+
+ return EFalse;
+}
+
+// ---------------------------------------------------------------------------
+// Handles PS commands from WSPlugin.
+// ---------------------------------------------------------------------------
+//
+void CAiScutEngine::DoHandlePSCommandL()
+{
+ TBuf<RProperty::KMaxPropertySize> command;
+ TUint32 lockKeyId = 0;
+ iKeyEventObserver->Get(command);
+
+ __PRINT( __DBG_FORMAT( "XAI: CAiScutEngine::DoHandlePSCommandL command = '%S'"), &command);
+
+ TUid appUid = KNullUid;
+
+ if (iFirstLockKey == EStdKeyDevice0)
+ {
+ appUid = SoftkeyUid(KLeftSoftkeyId);
+ lockKeyId = KLeftSoftkeyId;
+ }
+
+ if (iFirstLockKey == EStdKeyDevice1)
+ {
+ appUid = SoftkeyUid(KRightSoftkeyId);
+ lockKeyId = KRightSoftkeyId;
+ }
+
+ if (iFirstLockKeyPressed && command.Compare(KAiPSEnableKeyLock) == 0)
+ {
+ if (appUid != KNullUid)
+ {
+ TBool isDialog = EFalse;
+ TInt idx = 0;
+ delete iScutShutter;
+ iScutShutter = NULL;
+
+ // In case new message shortcut in lockkey
+ // we need to dismiss the dialog
+ if ( lockKeyId > 0 )
+ {
+ idx = FindShortcutIndex( lockKeyId );
+ if (idx != KErrNotFound)
+ {
+ switch (iShortcuts[idx]->Type())
+ {
+ case EScutNewMsgType:
+ isDialog = ETrue;
+ break;
+ default:
+ isDialog = EFalse;
+ break;
+ }
+ }
+
+ }
+ iDelayTimer->Cancel();
+ iScutShutter = CAiScutTargetShutter::NewL(iEnv, appUid, iSoftkeyAppRunning, isDialog);
+ iScutShutter->StartL();
+ }
+ }
+
+ if (command.Compare(KAiPSSkipKeyLock) == 0)
+ {
+ iDelayTimer->Cancel();
+ return ;
+ }
+ else if (command.Compare(KAiPSKeyLockTimeout) == 0)
+ {
+ if (iFirstLockKeyPressed)
+ {
+ iFirstLockKeyPressed = EFalse;
+
+ if (iFirstLockKey == EStdKeyDevice0)
+ {
+ if (IsDelayRequired(appUid))
+ {
+ HandleLaunchByIndexL(KLeftSoftkey);
+ }
+ return ;
+ }
+
+ if (iFirstLockKey == EStdKeyDevice1)
+ {
+ if (IsDelayRequired(appUid))
+ {
+ HandleLaunchByIndexL(KRightSoftkey);
+ }
+ return ;
+ }
+ }
+ return ;
+ }
+
+ if (FeatureManager::FeatureSupported(KFeatureIdKeypadNoVoiceKey) &&
+ command.Compare(KAiPSSkipNameDialer) == 0)
+ {
+ HandleLaunchByIndexL(KRightSoftkey);
+ return ;
+ }
+
+ HandleLaunchByValueL(command);
+}
+
+// ---------------------------------------------------------------------------
+// Handles call state changes.
+// ---------------------------------------------------------------------------
+//
+void CAiScutEngine::HandleCallStateChange()
+{
+ TInt value = 0;
+ TInt err = iCallStateObserver->Get(value);
+ iActiveCall = (value > EPSCTsyCallStateNone) && err == KErrNone;
+
+ __PRINT( __DBG_FORMAT( "XAI: CAiScutEngine::HandleCallStateChange = %d"), value);
+ __PRINT( __DBG_FORMAT( "XAI: iActiveCall = %d"), iActiveCall);
+
+ for (TInt i = 0; i < iShortcuts.Count(); ++i)
+ {
+ iShortcuts[i]->SetCallState(iActiveCall);
+ }
+}
+
+// ---------------------------------------------------------------------------
+// Activates TopMost Application
+// ---------------------------------------------------------------------------
+//
+void CAiScutEngine::ActivateTopMostApp()
+{
+ // Phone Topmost app as default
+ TInt idleAppUid = 0;
+ TInt topMostAppId = 0;
+
+ RProperty::Get(KPSUidAiInformation, KActiveIdleUid, idleAppUid);
+
+ RProperty property;
+ TInt err = property.Attach(KPSUidUikon, KUikVideoCallTopApp);
+
+ if (err == KErrNone)
+ {
+ property.Get(topMostAppId);
+ }
+
+ property.Close();
+
+ __PRINT( __DBG_FORMAT( "XAI: ActivateTopMostApp idle uid = 0x%x topmost = 0x%x"), idleAppUid, topMostAppId);
+
+ TUid appId(TUid::Uid(topMostAppId));
+
+ if(appId == KVideoCallUid)
+ {
+ const TVwsViewId viewId(appId, appId);
+ err = iVwsSession->CreateActivateViewEvent(viewId, KNullUid, KNullDesC8());
+
+ __PRINT( __DBG_FORMAT( "XAI: CreateActivateViewEvent = %d"), err);
+ }
+ else
+ {
+ const TVwsViewId viewId(appId, KVoiceCallUidViewId);
+ err = iVwsSession->CreateActivateViewEvent(viewId, KVoiceCallUidViewId, KNullDesC8());
+
+ __PRINT( __DBG_FORMAT( "XAI: CreateActivateViewEvent = %d"), err);
+ }
+
+}
+
+// ---------------------------------------------------------------------------
+// From class MFavouritesDbObserver.
+// Handles database event.
+// ---------------------------------------------------------------------------
+//
+void CAiScutEngine::HandleFavouritesDbEventL(RDbNotifier::TEvent aEvent)
+{
+ __PRINT( __DBG_FORMAT( "XAI: CAiScutEngine::HandleFavouritesDbEventL aEvent = %d"), aEvent);
+
+ if (aEvent == RDbNotifier::ECommit)
+ {
+ MergeShortcuts(EScutBookmark, ETrue);
+ CheckAccessAndPublish(EScutCheckBkm, EFalse);
+ }
+}
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+TBool CAiScutEngine::IsMsvSessionNeeded()
+{
+ TInt count = iShortcuts.Count();
+
+ for (TInt i = 0; i < count; ++i)
+ {
+ CAiScutShortcut* shortcut = iShortcuts[i];
+ TShortcutType type = shortcut->Type();
+
+ if (type == EScutNewMessage ||
+ type == EScutNewEmail ||
+ type == EScutNewSyncMLMail ||
+ type == EScutNewPostcard ||
+ type == EScutNewAudioMsg ||
+ type == EScutNewMsgType ||
+ type == EScutMailbox)
+ {
+ return ETrue;
+ }
+ }
+
+ return EFalse;
+}
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+TBool CAiScutEngine::IsBookmarkObserverNeeded()
+{
+ TInt count = iShortcuts.Count();
+
+ for (TInt i = 0; i < count; ++i)
+ {
+ CAiScutShortcut* shortcut = iShortcuts[i];
+ if (shortcut->Type() == EScutBookmark)
+ {
+ return ETrue;
+ }
+ }
+
+ return EFalse;
+}
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+TBool CAiScutEngine::GetAppTitle(
+ const TUid& aAppUid, const TUid& aViewId, TDes& aTitle, TAiScutAppTitleType aType)
+{
+ TBool ret = EFalse;
+ TInt count = iAppTitleList.Count();
+
+ for (TInt i = 0; i < count; i++)
+ {
+ TAiScutAppTitleEntry entry = iAppTitleList[i];
+
+ if (entry.iAppUid == aAppUid && entry.iViewId == aViewId)
+ {
+ switch (aType)
+ {
+ case EAiScutLongTitle:
+ if (entry.iLongTitle)
+ {
+ aTitle = *entry.iLongTitle;
+ ret = ETrue;
+ }
+ break;
+
+ case EAiScutShortTitle:
+ if (entry.iShortTitle)
+ {
+ aTitle = *entry.iShortTitle;
+ ret = ETrue;
+ }
+ break;
+
+ case EAiScutSkeyTitle:
+ if (entry.iSkeyTitle)
+ {
+ aTitle = *entry.iSkeyTitle;
+ ret = ETrue;
+ }
+ break;
+
+ case EAiScutMskTitle:
+ if (entry.iMskTitle)
+ {
+ aTitle = *entry.iMskTitle;
+ ret = ETrue;
+ }
+ break;
+ default :
+ break;
+ }
+
+ break; // break the for loop
+ }
+ }
+
+ if (! ret) __PRINT( __DBG_FORMAT( "XAI: GetAppTitle NOT found for uid = 0x%x"), aAppUid);
+
+ return ret;
+}
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+void CAiScutEngine::LoadAppTitleListL()
+{
+ TResourceReader reader;
+ iEnv->CreateResourceReaderLC(reader, R_SCUT_APP_TITLE_LIST);
+
+ TInt items = reader.ReadInt16();
+
+ __PRINT( __DBG_FORMAT( "XAI: LoadAppTitleListL items = %d"), items);
+
+ TUid appuid;
+ TUid viewid;
+
+ for (TInt i = 0; i < items; i++)
+ {
+ appuid.iUid = reader.ReadInt32();
+ viewid.iUid = reader.ReadInt32();
+
+ HBufC16* longTitle = reader.ReadHBufC16L();
+ CleanupStack::PushL(longTitle);
+
+ HBufC16* shortTitle = reader.ReadHBufC16L();
+ CleanupStack::PushL(shortTitle);
+
+ HBufC16* skeyTitle = reader.ReadHBufC16L();
+ CleanupStack::PushL(skeyTitle);
+
+ HBufC16* mskTitle = reader.ReadHBufC16L();
+ CleanupStack::PushL(mskTitle);
+
+ TAiScutAppTitleEntry entry;
+
+ entry.iAppUid = appuid;
+ entry.iViewId = viewid;
+ entry.iLongTitle = longTitle;
+ entry.iShortTitle = shortTitle;
+ entry.iSkeyTitle = skeyTitle;
+ entry.iMskTitle = mskTitle;
+
+ User::LeaveIfError(iAppTitleList.Append(entry));
+
+ // Title names are deleted in destructor.
+ CleanupStack::Pop(4, longTitle);
+ }
+
+ CleanupStack::PopAndDestroy(); // reader
+}
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+void CAiScutEngine::GetHiddenAppsL()
+{
+ HBufC* buffer = HBufC::NewLC(
+ NCentralRepositoryConstants::KMaxUnicodeStringLength);
+ TPtr bufferPtr = buffer->Des();
+
+ iHiddenAppsRepository->Get(KMenuHideApplication, bufferPtr);
+
+ __PRINT( __DBG_FORMAT( "XAI: CAiScutSettingsModel::GetHiddenAppsL '%S' "), buffer);
+
+ iHiddenApps.Reset();
+ TAiScutAppUidParser uidParser(bufferPtr, iHiddenApps);
+ uidParser.ParseL();
+
+ CleanupStack::PopAndDestroy(buffer);
+}
+
+// ---------------------------------------------------------------------------
+//
+// ---------------------------------------------------------------------------
+//
+TBool CAiScutEngine::IsHiddenFromFSW( const TUid& aAppUid )
+{
+ const TUid KPSUidUikon = { 0x101F8773 };
+ const TUint32 KUikAppHiddenList = 0x00000010;
+ const TInt KMaxHiddenApps = 25;
+
+ TBuf16 <2*KMaxHiddenApps> retrievedList;
+ TInt err = RProperty::Get( KPSUidUikon, KUikAppHiddenList,
+retrievedList );
+ TInt i = 0;
+
+ TUint32 listValue;
+ while( i < KMaxHiddenApps && KErrNone == err )
+ {
+ // 32-bit uid values are retrieved in two 16-bit parts
+ listValue = retrievedList[2*i] << 16;
+ listValue += retrievedList[2*i+1];
+
+ if ( listValue )
+ {
+ TUid t ( KNullUid );
+ t.iUid = listValue;
+ if( t == aAppUid )
+ {
+ return ETrue;
+ }
+ }
+ else
+ {
+ err = KErrEof;
+ return EFalse;
+ }
+ i++;
+ }
+ return EFalse;
+}
+// ---------------------------------------------------------------------------
+// Adds an override icon to iIcons array in case the same icon
+// isn't there already
+// ---------------------------------------------------------------------------
+//
+TInt CAiScutEngine::AddOverrideIcon( TAiScutIcon &aIcon )
+ {
+ TBool foundExisting = EFalse;
+
+ for ( TInt i = 0; i < iIcons.Count(); i++)
+ {
+ if ( aIcon.iAppUid == iIcons[i].iAppUid &&
+ aIcon.iShortcutType == iIcons[i].iShortcutType &&
+ aIcon.iViewId == iIcons[i].iViewId &&
+ aIcon.iDestination == iIcons[i].iDestination )
+ {
+ foundExisting = ETrue;
+ break;
+ }
+ }
+ if ( !foundExisting )
+ {
+ return iIcons.Append( aIcon );
+ }
+ return KErrNone;
+ }
+// End of File.