diff -r 000000000000 -r 79c6a41cd166 idlefw/plugins/wrtdataplugin/src/wrtdata.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/idlefw/plugins/wrtdataplugin/src/wrtdata.cpp Thu Dec 17 08:54:17 2009 +0200 @@ -0,0 +1,707 @@ +/* +* Copyright (c) 2005-2007 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: +* Profile plug-in publisher +* +*/ + +#include +#include +#include + + +#include "wrtdata.h" +#include "wrtdatapluginconst.h" +#include "wrtdataobserver.h" +#include "wrtdataplugin.h" +// ======== MEMBER FUNCTIONS ======== + +// --------------------------------------------------------------------------- +// Symbian 2nd phase constructor can leave +// --------------------------------------------------------------------------- +// +CWrtData* CWrtData::NewL(CWrtDataPlugin* aPlugin) + { + CWrtData* self = new (ELeave) CWrtData(); + CleanupStack::PushL( self ); + self->ConstructL(aPlugin); + CleanupStack::Pop( self ); + return self; + } + +// --------------------------------------------------------------------------- +// Default constructor +// --------------------------------------------------------------------------- +// +CWrtData::CWrtData() + { + } + +// --------------------------------------------------------------------------- +// Symbian 2nd phase constructor can leave +// --------------------------------------------------------------------------- +// +void CWrtData::ConstructL(CWrtDataPlugin* aPlugin) + { + iPlugin = aPlugin; + iCommandName = HBufC8::NewL( KWRTContentValueMaxLength ); + } + +// --------------------------------------------------------------------------- +// Destructor +// Deletes all data created to heap +// --------------------------------------------------------------------------- +// +CWrtData::~CWrtData() + { + if( iCommandName ) + { + delete iCommandName; + iCommandName = NULL; + } + if(iObserver) + { + TRAP_IGNORE(iObserver->ReleaseL() ); + delete iObserver; + iObserver = NULL; + } + if( iInterface ) + { + iInterface->Close(); + iInterface = NULL; + } + if( iServiceHandler ) + { + iServiceHandler->Reset(); + delete iServiceHandler; + iServiceHandler = NULL; + } + if ( iContentId ) + { + delete iContentId; + iContentId = NULL; + } + iMenuItems.ResetAndDestroy(); + iMenuTriggers.ResetAndDestroy(); + // not owned + iPlugin = NULL; + } + +// --------------------------------------------------------------------------- +// ConfigureL +// --------------------------------------------------------------------------- +// +void CWrtData::ConfigureL(RAiSettingsItemArray& aConfigurations ) + { + HBufC8* serviceName = HBufC8::NewLC( KWRTContentValueMaxLength ); + HBufC8* interfaceName = HBufC8::NewLC( KWRTContentValueMaxLength ); + + // Interface name + RCriteriaArray criteriaArray; + + TInt count = aConfigurations.Count(); + + for(TInt i = 0;iAiPluginConfigurationItem(); + // if owner is plugin then it (key,value) is for plugin configurations items + if(confItem.Owner() == KPlugin()) + { + if(confItem.Name() == KService()) + { + serviceName->Des().Copy(confItem.Value()); + } + else if( confItem.Name() == KInterface() ) + { + interfaceName->Des().Copy(confItem.Value()); + } + else if( confItem.Name() == KCommand() ) + { + iCommandName->Des().Copy(confItem.Value()); + } + else if( confItem.Name() == KMenuItem16() ) + { + iMenuItems.AppendL( confItem.Value().AllocL() ); + } + else if( confItem.Name() == KPubData() ) + { + iContentId = confItem.Value().AllocL(); + } + } + } + + if( !( serviceName->Des().Length() >= 0 && interfaceName->Des().Length() >= 0 + && iCommandName->Des().Length() >= 0 ) ) + { + // No service to offer without plugin configurations + User::Leave( KErrNotSupported ); + } + + iServiceHandler = CLiwServiceHandler::NewL(); + + // for convenience keep pointers to Service Handler param lists + CLiwGenericParamList* inParamList = &iServiceHandler->InParamListL(); + CLiwGenericParamList* outParamList = &iServiceHandler->OutParamListL(); + + CLiwCriteriaItem* criteriaItem = CLiwCriteriaItem::NewLC( KLiwCmdAsStr, *interfaceName , *serviceName ); + criteriaItem->SetServiceClass( TUid::Uid( KLiwClassBase ) ); + criteriaArray.AppendL( criteriaItem ); + + + // attach Liw criteria + iServiceHandler->AttachL( criteriaArray ); + iServiceHandler->ExecuteServiceCmdL( *criteriaItem, *inParamList, *outParamList ); + + CleanupStack::PopAndDestroy(criteriaItem); + criteriaArray.Reset(); + + // extract CPS interface from output params + TInt pos( 0 ); + outParamList->FindFirst( pos, *interfaceName ); + if( pos != KErrNotFound ) + { + //iInterface is MLiwInterface* + iInterface = (*outParamList)[pos].Value().AsInterface(); + User::LeaveIfNull( iInterface ); + } + else + { + User::Leave( KErrNotFound ); + } + inParamList->Reset(); + outParamList->Reset(); + CleanupStack::PopAndDestroy( interfaceName ); + CleanupStack::PopAndDestroy( serviceName ); + + //Gets the menu items from the publisher registry + GetMenuItemsL(); + + iObserver = CWrtDataObserver::NewL( iInterface, this ); + } + +// --------------------------------------------------------------------------- +// GetMenuItemsL +// --------------------------------------------------------------------------- +// +void CWrtData::GetMenuItemsL() + { + if(iInterface) + { + TInt confindex( 0 ); + + CLiwDefaultMap *outDataMap = CLiwDefaultMap::NewLC(); + CLiwDefaultMap* filter = CreateFilterLC( ); + //append filter to input param + ExecuteCommandL( filter, outDataMap, KPubData ); + CleanupStack::PopAndDestroy( filter ); + + TLiwVariant variant; + TInt pos = outDataMap->FindL( KMenuItems, variant ) ; + + if ( pos ) + { + CLiwDefaultMap *menuMap = CLiwDefaultMap::NewLC(); + variant.Get( *menuMap ); + for ( TInt i = 0; i < menuMap->Count(); i++) + { + menuMap->FindL(menuMap->AtL(i), variant ); + HBufC8* value = HBufC8::NewL( KWRTContentValueMaxLength ); + CleanupStack::PushL( value ); + TPtr8 valPtr = value->Des(); + variant.Get( valPtr); + if ( valPtr.Length() > 0 ) + { + iMenuTriggers.AppendL( value ); + CleanupStack::Pop( value ); + HBufC16* triggerName = HBufC16::NewLC( KWRTContentNameMaxLength ); + triggerName->Des().Copy( menuMap->AtL(i) ); + iMenuItems.AppendL( triggerName ); + CleanupStack::Pop( triggerName ); + } + else + { + CleanupStack::PopAndDestroy( value ); + } + variant.Reset(); + } + CleanupStack::PopAndDestroy( menuMap ); + } + variant.Reset(); + CleanupStack::PopAndDestroy( outDataMap ); + } + } + +// --------------------------------------------------------------------------- +// CreateFilterL +// --------------------------------------------------------------------------- +// +CLiwDefaultMap* CWrtData::CreateFilterLC() + { + CLiwDefaultMap* filter = CLiwDefaultMap::NewLC(); + filter->InsertL( KPublisherId, TLiwVariant( KWRTPublisher )); + filter->InsertL( KContentType, TLiwVariant( KTemplateWidget )); + filter->InsertL( KContentId, TLiwVariant( iContentId )); + return filter; + } + +// --------------------------------------------------------------------------- +// HasMenuItem +// --------------------------------------------------------------------------- +// +TBool CWrtData::HasMenuItem(const TDesC16& aMenuItem ) + { + TBool found = EFalse; + for (TInt i = 0; i < iMenuItems.Count(); i++ ) + { + if( aMenuItem == iMenuItems[i] ) + { + found = ETrue; + break; + } + } + return found; + } + +// --------------------------------------------------------------------------- +// PublishAllL +// --------------------------------------------------------------------------- +// +void CWrtData::PublishAllL( MAiContentObserver* aObserver ) + { + PublishL( aObserver ); + } + +// --------------------------------------------------------------------------- +// PublishL +// --------------------------------------------------------------------------- +// +void CWrtData::PublishL( MAiContentObserver* aObserver ) + { + CLiwDefaultMap *outDataMap = CLiwDefaultMap::NewLC(); + //Create filter criteria for requested entries in form of LIW map: + CLiwDefaultMap* filter = CreateFilterLC(); + ExecuteCommandL( filter, outDataMap, KCpData ); + CleanupStack::PopAndDestroy( filter ); + TInt id = KErrNotFound; + TLiwVariant variant; + if ( outDataMap->FindL( KImage1, variant ) ) + { + TInt handle = KErrBadHandle; + TUint uintHandle = 0; + TPtrC16 valPtr; + if ( variant.Get( uintHandle ) ) + { + handle = uintHandle; + } + else if ( !variant.Get( handle ) ) + { + handle = KErrBadHandle; + } + // read as a image handle + if( handle == KErrBadHandle ) + { + // no handle, so read as image path + variant.Get( valPtr ); + iPlugin->PublishImageL(aObserver, EImage1, valPtr ); + } + else + { + TInt maskHandle = KErrBadHandle; + //Look for image mask + if ( outDataMap->FindL( KImageMask, variant ) ) + { + variant.Get( maskHandle ); + } + iPlugin->PublishImageL(aObserver, EImage1, handle, maskHandle ); + } + } + + variant.Reset(); + CleanupStack::PopAndDestroy( outDataMap ); + } + +// --------------------------------------------------------------------------- +// ExecuteCommandL +// --------------------------------------------------------------------------- +// +void CWrtData::ExecuteCommandL(CLiwDefaultMap* aInFilter, CLiwDefaultMap* aOutDataMap, const TDesC16& aRegistry ) + { + CLiwGenericParamList* inParamList = &iServiceHandler->InParamListL(); + CLiwGenericParamList* outParamList = &iServiceHandler->OutParamListL(); + + TLiwGenericParam type( KType, TLiwVariant( aRegistry ) ); + inParamList->AppendL( type ); + + //append filter to input param + TLiwGenericParam item( KFilter, TLiwVariant( aInFilter )); + inParamList->AppendL( item ); + + // execute service.It is assumed that iInterface is already initiatedd + if(iInterface) + { + iInterface->ExecuteCmdL( *iCommandName, *inParamList, *outParamList); + } + else + { + User::Leave( KErrNotSupported ); + } + type.Reset(); + item.Reset(); + inParamList->Reset(); + + //extracts data map + TInt pos = 0; + outParamList->FindFirst( pos, KResults ); + if( pos != KErrNotFound ) + // results present + { + //extract iterator on results list + TLiwVariant variant = (*outParamList)[pos].Value(); + CLiwIterable* iterable = variant.AsIterable(); + iterable->Reset(); + + //get next result + if( iterable->NextL( variant ) ) + { + //extract content map + CLiwDefaultMap *map = CLiwDefaultMap::NewLC(); + variant.Get( *map ); + if( map->FindL( KDataMap, variant) ) + { + variant.Get( *aOutDataMap ); + } + CleanupStack::PopAndDestroy( map ); + } + iterable->Reset(); + variant.Reset(); + } + outParamList->Reset(); + } + +// --------------------------------------------------------------------------- +// ExecuteActionL +// --------------------------------------------------------------------------- +// +void CWrtData::ExecuteActionL(const TDesC& aObjectId, const TDesC& aTrigger ) + { + HBufC8* triggerName = HBufC8::NewLC( KWRTContentNameMaxLength ); + + CLiwGenericParamList* inParamList = &iServiceHandler->InParamListL(); + CLiwGenericParamList* outParamList = &iServiceHandler->OutParamListL(); + CLiwDefaultMap* filter = NULL; + TInt confindex (0); + + triggerName->Des().Copy(aTrigger); + if ( aObjectId == KPubData ) + { + // this trigger belongs to publisher registery. + // in such case it is assumed that all the items in the widgets + // belongs to same publisher, type and id. + TLiwGenericParam cptype( KType, TLiwVariant( KPubData ) ); + inParamList->AppendL( cptype ); + cptype.Reset(); + // use the first item configuration to create the filter + filter = CreateFilterLC(); + } + else + { + if ( aObjectId == KMenuItem16 ) + { + TInt pos = KErrNotFound; + for (TInt i = 0; i < iMenuItems.Count(); i++) + { + if ( aTrigger == iMenuItems[i] ) + { + pos = i; + break; + } + } + if( pos == KErrNotFound ) + { + // No such menu items + CleanupStack::PopAndDestroy( triggerName ); + return; + } + triggerName->Des().Copy( iMenuTriggers[pos]->Des() ); + filter = CreateFilterLC(); + } + else + { + //Create filter criteria for requested entries in form of LIW map: + filter = CreateFilterLC(); + } + //append type to inparam list + TLiwGenericParam cptype( KType, TLiwVariant( KCpData ) ); + inParamList->AppendL( cptype ); + cptype.Reset(); + } + + filter->InsertL( KActionTrigger, TLiwVariant( triggerName->Des() ) ); + //append filter to input param + TLiwGenericParam item( KFilter, TLiwVariant( filter ) ); + inParamList->AppendL( item ); + iInterface->ExecuteCmdL( KExecuteAction, *inParamList, *outParamList ); + + CleanupStack::PopAndDestroy( filter ); + CleanupStack::PopAndDestroy( triggerName ); + item.Reset(); + + inParamList->Reset(); + outParamList->Reset(); + + } + +// --------------------------------------------------------------------------- +// RegisterL +// --------------------------------------------------------------------------- +// +void CWrtData::RegisterL() + { + CLiwDefaultMap* filter = CreateFilterLC(); + filter->InsertL( KOperation, TLiwVariant( KAddUpdateDelete ) ); + iObserver->RegisterL(filter); + CleanupStack::PopAndDestroy( filter ); + } + +// --------------------------------------------------------------------------- +// RefreshL +// --------------------------------------------------------------------------- +// +void CWrtData::RefreshL( TDesC& aPublisher, TDesC& aContentType, + TDesC& aContentId, TDesC& aOperation ) + { + if ( aPublisher == KWRTPublisher() && aContentType == KTemplateWidget() + && aContentId == iContentId ) + { + iPlugin->RefreshL( aOperation); + } + } + +// --------------------------------------------------------------------------- +// IsPluginActive +// --------------------------------------------------------------------------- +// +TBool CWrtData::IsPluginActive() + { + return iPlugin->IsActive(); + } + +// --------------------------------------------------------------------------- +// PublisherStatusL +// --------------------------------------------------------------------------- +// +void CWrtData::ChangePublisherStatusL(const TDesC& aStatus) + { + if( iContentId == NULL ) + { + return; + } + HBufC8* triggerName = HBufC8::NewLC(KWRTContentNameMaxLength); + triggerName->Des().Copy(aStatus); + + CLiwGenericParamList* inParamList = &iServiceHandler->InParamListL(); + CLiwGenericParamList* outParamList = &iServiceHandler->OutParamListL(); + + TLiwGenericParam type( KType, TLiwVariant( KPubData ) ); + inParamList->AppendL( type ); + + CLiwDefaultMap* filter = CreateFilterLC(); + filter->InsertL(KActionTrigger, TLiwVariant(triggerName->Des()) ); + + TLiwGenericParam item( KFilter, TLiwVariant( filter )); + inParamList->AppendL( item ); + + if(iInterface) + { + iInterface->ExecuteCmdL( KExecuteAction, *inParamList, *outParamList); + } + else + { + User::Leave( KErrNotSupported ); + } + CleanupStack::PopAndDestroy( filter ); + + inParamList->Reset(); + outParamList->Reset(); + CleanupStack::PopAndDestroy( triggerName ); + } + +// --------------------------------------------------------------------------- +// ResumeL +// --------------------------------------------------------------------------- +// +void CWrtData::ResumeL() + { + ChangePublisherStatusL( KResume ); + } + +// --------------------------------------------------------------------------- +// SuspendL +// --------------------------------------------------------------------------- +// +void CWrtData::SuspendL() + { + ChangePublisherStatusL( KSuspend ); + } + +// --------------------------------------------------------------------------- +// ActivateL +// --------------------------------------------------------------------------- +// +void CWrtData::ActivateL() + { + ChangePublisherStatusL( KActive ); + } + +// --------------------------------------------------------------------------- +// DeActivateL +// --------------------------------------------------------------------------- +// +void CWrtData::DeActivateL() + { + ChangePublisherStatusL( KDeActive ); + } + +// --------------------------------------------------------------------------- +// OnLineL +// --------------------------------------------------------------------------- +// +void CWrtData::OnLineL() + { + ChangePublisherStatusL( KOnLine ); + } + +// --------------------------------------------------------------------------- +// offLineL +// --------------------------------------------------------------------------- +// +void CWrtData::OffLineL() + { + ChangePublisherStatusL( KOffLine ); + } + +// --------------------------------------------------------------------------- +// InActiveL +// --------------------------------------------------------------------------- +// +void CWrtData::InActiveL() + { + ChangePublisherStatusL( KInActive ); + } + +// --------------------------------------------------------------------------- +// UpdatePublisherStatusL +// --------------------------------------------------------------------------- +// +void CWrtData::UpdatePublisherStatusL() + { + // Resent the plugin status to publisher + ActivateL(); + if ( iPlugin->IsActive() ) + { + ResumeL(); + } + else + { + SuspendL(); + } + // forward the network status if it uses. + if ( iPlugin->NetworkStatus() == CWrtDataPlugin::EOnline ) + { + OnLineL(); + } + else if ( iPlugin->NetworkStatus() == CWrtDataPlugin::EOffline ) + { + OffLineL(); + } + } + +// --------------------------------------------------------------------------- +// ResolveSkinItemId +// --------------------------------------------------------------------------- +// +TBool CWrtData::ResolveSkinIdAndMifId( const TDesC& aPath, TAknsItemID& aItemId, + TInt& abitmapId, TInt& aMaskId, TDes& aFilename ) + { + // Syntax: skin( ):mif(filename bimapId maskId) + TInt error = KErrNotFound; + TInt pos = aPath.FindF( KSkin ); + if( pos != KErrNotFound ) + { + // Skip skin token + pos += KSkin().Length(); + + // Initialize lexer + TLex lex( aPath.Mid( pos ) ); + lex.SkipSpace(); + + // Check left parenthesis + if (lex.Get() == KLeftParenthesis ) + { + //lex.SkipSpace(); + + TInt majorId( 0 ); + TInt minorId( 0 ); + + // Resolve major id + error = lex.Val( majorId ); + + // Resolve minor id + lex.SkipSpace(); + error |= lex.Val( minorId ); + + // initilize skin item id object + aItemId.Set( majorId, minorId ); + } + } + + if( (error == KErrNone && aPath.FindF( KColon ) != KErrNotFound ) + || ( error == KErrNotFound ) ) + { + error = KErrNotFound; + pos = aPath.FindF( KMif ); + if ( pos != KErrNotFound ) + { + pos += KMif().Length(); + // Initialize lexer + TLex lex( aPath.Mid( pos ) ); + lex.SkipSpace(); + + // Check left parenthesis + if (lex.Get() == KLeftParenthesis ) + { + lex.SkipSpaceAndMark(); + lex.SkipCharacters(); + // Resolve MifFile name + aFilename.Copy(lex.MarkedToken()); + if( aFilename.Length()!= 0) + { + // Resolve bitmap id + lex.SkipSpace(); + error = lex.Val( abitmapId ); + + // Resolve mask id + // dont return error if it is not found, that is ok + lex.SkipSpace(); + lex.Val( aMaskId ); + } + else + { + error = KErrNotFound; + } + } + } + } + return (error == KErrNone ); + }