/*
* 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: Plug-in main class
*
*/
#include <ecom/implementationproxy.h>
#include <centralrepository.h>
#include <aicontentobserver.h>
#include <aipluginsettings.h>
#include <platform/mw/aiscutuids.hrh>
#include "aiscutpluginprivatecrkeys.h"
#include "aiscutdefs.h"
#include "aiscutcontentmodel.h"
#include "caiscutplugin.h"
#include "caiscutengine.h"
#include "aiscutfactory.h"
#include "caiscutshortcut.h"
#include "debug.h"
const TImplementationProxy KImplementationTable[] =
{
IMPLEMENTATION_PROXY_ENTRY(KImplUidScutPlugin, CAiScutPlugin::NewL)
};
// ======== MEMBER FUNCTIONS ========
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
CAiScutPlugin::CAiScutPlugin()
{
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
void CAiScutPlugin::ConstructL()
{
// Initialize the info which the fw uses to identify the plug-in.
// Fill in only the uid at this point, the fw will send this back with the
// name filled in later through SetPropertyL().
iInfo.iUid.iUid = AI_UID_ECOM_IMPLEMENTATION_CONTENTPUBLISHER_SCUTPLUGIN;
iContent = AiUtility::CreateContentItemArrayIteratorL(KAiScutContent);
iResources = AiUtility::CreateContentItemArrayIteratorL(KAiScutResources);
iEvents = AiUtility::CreateContentItemArrayIteratorL(KAiScutEvents);
CRepository* repository = NULL;
TRAP_IGNORE(repository = CRepository::NewL(KCRUidShortcutItems));
// No leaving code here since 'repository' is not in cleanup stack.
if (repository)
{
// A theme might not contain any publishable shortcuts at all, only
// locked ones. To take this into account we must always delete old
// theme-default settings to make sure the engine won't create any
// unwanted shortcut objects. Any errors that might happen during
// deletion are ignored to make sure the plug-in is kept alive.
TUint32 errorKey;
repository->Delete(KScutCenRepKeyThemeDefault, KScutCenRepKeyMask, errorKey);
}
delete repository;
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
CAiScutPlugin* CAiScutPlugin::NewL()
{
CAiScutPlugin* self = new (ELeave) CAiScutPlugin;
CleanupStack::PushL(self);
self->ConstructL();
CleanupStack::Pop(self);
return self;
}
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
CAiScutPlugin::~CAiScutPlugin()
{
TRAP_IGNORE( DeleteDefaultShortcutsL() );
Release(iContent);
Release(iResources);
Release(iEvents);
delete iEngine;
iObservers.Close();
}
// ---------------------------------------------------------------------------
// Publishes the given shortcut.
// ---------------------------------------------------------------------------
//
void CAiScutPlugin::PublishShortcutsL(RAiShortcutArray& aShortcuts)
{
TInt err = KErrNone;
TInt observers = iObservers.Count();
TInt shortcuts = aShortcuts.Count();
for (TInt i = 0; i < observers; ++i)
{
MAiContentObserver* observer = iObservers[i];
TBool transactionStarted = EFalse;
TInt transactionId = reinterpret_cast<TInt>(this);
err = observer->StartTransaction(transactionId);
if (err != KErrNotSupported)
{
// The observer does not support transactions, check for real errors.
User::LeaveIfError(err);
transactionStarted = ETrue;
}
err = KErrAlreadyExists;
for (TInt j = 0; j < shortcuts; j++)
{
CAiScutShortcut* shortcut = aShortcuts[j];
if (shortcut->NeedsToBePublished())
{
shortcut->Publish(*this, *observer);
err = KErrNone;
}
}
if ( transactionStarted && err == KErrNone )
{
User::LeaveIfError(observer->Commit(transactionId));
}
else if ( transactionStarted )
{
User::LeaveIfError(observer->CancelTransaction(transactionId));
}
}
}
// ---------------------------------------------------------------------------
// Is plug-in suspended or not.
// ---------------------------------------------------------------------------
//
TBool CAiScutPlugin::IsAlive() const
{
return iAlive;
}
// ---------------------------------------------------------------------------
// Resume reason
// ---------------------------------------------------------------------------
//
TAiTransitionReason CAiScutPlugin::ResumeReason() const
{
return iResumeReason;
}
// ---------------------------------------------------------------------------
// From class CAiContentPublisher.
// Resumes the plug-in.
// ---------------------------------------------------------------------------
//
void CAiScutPlugin::Resume(TAiTransitionReason aReason)
{
TRAP_IGNORE(DoResumeL(aReason));
}
// ---------------------------------------------------------------------------
// Resumes the plug-in.
// ---------------------------------------------------------------------------
//
void CAiScutPlugin::DoResumeL(TAiTransitionReason aReason)
{
__PRINT( __DBG_FORMAT( "XAI: CAiScutPlugin::Resume reason %d alive = %d"), aReason, iAlive);
iResumeReason = aReason;
// Reload the engine in case general theme changed or
// the engine has been suspended.
if (aReason == EAiGeneralThemeChanged || !iAlive)
{
// if general theme changed, free engine so that is will be
// loaded again because shortcut icons must be re-created.
FreeEngine();
}
if (!iEngine)
{
iEngine = AiScutFactory::CreateAiScutEngineL(*this);
}
iEngine->ResumeL( (iAlive == EFalse) ||
(
aReason != EAiBacklightOn &&
aReason != EAiBacklightOff &&
aReason != EAiIdleBackground &&
aReason != EAiIdleForeground
),
aReason
);
iAlive = ETrue;
}
// ---------------------------------------------------------------------------
// From class CAiContentPublisher.
// Suspends the plug-in.
// ---------------------------------------------------------------------------
//
void CAiScutPlugin::Suspend(TAiTransitionReason aReason)
{
__PRINT( __DBG_FORMAT( "XAI: CAiScutPlugin::Suspend reason %d"), aReason);
if (iEngine)
{
iEngine->Suspend();
}
iAlive = EFalse;
}
// ---------------------------------------------------------------------------
// From class CAiContentPublisher.
// Frees the plug-in engine.
// ---------------------------------------------------------------------------
//
void CAiScutPlugin::Stop(TAiTransitionReason aReason)
{
__PRINT( __DBG_FORMAT( "XAI: CAiScutPlugin::Stop reason %d"), aReason);
if ( aReason == EAiBackupRestoreStarted )
{
Suspend( aReason );
}
else
{
FreeEngine();
}
}
// ---------------------------------------------------------------------------
// From class CAiContentPublisher.
// Adds the content observer / subscriber to plug-in.
// ---------------------------------------------------------------------------
//
void CAiScutPlugin::SubscribeL(MAiContentObserver& aObserver)
{
iObservers.AppendL(&aObserver);
}
void CAiScutPlugin::DeleteDefaultShortcutsL()
{
// Ignore any errors that might occur when deleting
// the default keys
TUint32 errorKey;
CRepository* cr = CRepository::NewL(KCRUidShortcutItems);
cr->Delete(KScutCenRepKeyThemeDefault, KScutCenRepKeyMask, errorKey);
delete cr;
}
// ---------------------------------------------------------------------------
// From class CAiContentPublisher.
// Configures the plug-in.
// ---------------------------------------------------------------------------
//
void CAiScutPlugin::ConfigureL(RAiSettingsItemArray& aSettings)
{
CRepository* repository = NULL;
TRAPD(err, repository = CRepository::NewL(KCRUidShortcutItems));
if (err == KErrNotFound)
{
// CenRep file is missing from the image, this is a serious error.
User::Leave(err);
}
// Write settings if repository was successfully opened. All other errors
// are ignored to ensure that the plug-in is up and running, even if
// crippled.
// No leaving code here since 'repository' is not in cleanup stack.
if (repository)
{
repository->StartTransaction(CRepository::EConcurrentReadWriteTransaction);
// A theme might not contain any publishable shortcuts at all, only
// locked ones. To take this into account we must always delete old
// theme-default settings to make sure the engine won't create any
// unwanted shortcut objects. Any errors that might happen during
// deletion are ignored to make sure the plug-in is kept alive.
TUint32 errorKey;
repository->Delete(KScutCenRepKeyThemeDefault, KScutCenRepKeyMask, errorKey);
__PRINTS( "XAI: CAiScutPlugin::ConfigureL");
TInt count = aSettings.Count();
if (count > 0)
{
// Write new shortcut definitions.
for (TInt i = 0; i < count; ++i)
{
MAiPluginSettings* settings = aSettings[ i ];
if( settings->AiPluginItemType() == EAiPluginSettingsItem )
{
MAiPluginSettingsItem& item = settings->AiPluginSettingsItem();
TUint32 key = item.Key(); // implicit cast from TInt32 to TUint32.
__PRINT( __DBG_FORMAT( "XAI: %d. key = 0x%x"), i+1, key);
// Add the bit that indicates this is a default shortcut setting.
key |= KScutFlagBitThemeDefault;
// Ignore possible error and keep going.
repository->Create(key, item.Value());
}
}
}
TUint32 info = 0;
repository->CommitTransaction(info);
delete repository;
repository = NULL;
if (iEngine)
{
iEngine->CreateShortcutsL();
iEngine->ResumeL( ETrue, EAiGeneralThemeChanged );
}
}
// We don't need to store the settings so clear the array.
aSettings.ResetAndDestroy();
}
// ---------------------------------------------------------------------------
// From class CAiContentPublisher.
// Returns the extension interface.
// ---------------------------------------------------------------------------
//
TAny* CAiScutPlugin::Extension(TUid aUid)
{
if (aUid == KExtensionUidProperty)
{
return static_cast<MAiPropertyExtension*>(this);
}
else if (aUid == KExtensionUidEventHandler)
{
return static_cast<MAiEventHandlerExtension*>(this);
}
else
{
return NULL;
}
}
// ---------------------------------------------------------------------------
// From class MAiEventHandlerExtension.
// Handles an event sent by the AI framework.
// ---------------------------------------------------------------------------
//
void CAiScutPlugin::HandleEvent(TInt aEvent, const TDesC& aParam)
{
if (iEngine)
{
// We have no way of reporting errors to framework so just ignore them.
TRAP_IGNORE(iEngine->HandleAiEventL(aEvent, aParam));
}
}
// ---------------------------------------------------------------------------
// CAiScutPlugin::HasMenuItem
//
// ---------------------------------------------------------------------------
//
TBool CAiScutPlugin::HasMenuItem(const TDesC16& /*aMenuItem*/)
{
return EFalse;
}
// ---------------------------------------------------------------------------
// From class MAiPropertyExtension
// Returns a plug-in property.
// ---------------------------------------------------------------------------
//
TAny* CAiScutPlugin::GetPropertyL(TInt aProperty)
{
switch (aProperty)
{
case EAiPublisherInfo:
return static_cast<TAiPublisherInfo*>(&iInfo);
case EAiPublisherContent:
return static_cast<MAiContentItemIterator*>(iContent);
case EAiPublisherResources:
return static_cast<MAiContentItemIterator*>(iResources);
case EAiPublisherEvents:
return static_cast<MAiContentItemIterator*>(iEvents);
default:
break;
}
return NULL;
}
// ---------------------------------------------------------------------------
// From class MAiPropertyExtension
// Sets a plug-in property to optimize the content model.
// ---------------------------------------------------------------------------
//
void CAiScutPlugin::SetPropertyL(TInt aProperty, TAny* aValue)
{
if( aProperty == EAiPublisherInfo )
{
ASSERT( aValue );
const TAiPublisherInfo* info(
static_cast<const TAiPublisherInfo*>( aValue ) );
iInfo = *info;
}
}
// ---------------------------------------------------------------------------
//
//
// ---------------------------------------------------------------------------
//
void CAiScutPlugin::FreeEngine()
{
delete iEngine;
iEngine = NULL;
iAlive = EFalse;
}
// ======== GLOBAL FUNCTIONS ========
// ---------------------------------------------------------------------------
//
// ---------------------------------------------------------------------------
//
EXPORT_C const TImplementationProxy* ImplementationGroupProxy(TInt& aTableCount)
{
aTableCount = sizeof(KImplementationTable) / sizeof(TImplementationProxy);
return KImplementationTable;
}
// End of File.