diff -r 000000000000 -r 79c6a41cd166 idlefw/plugins/sapidataplugin/src/sapidata.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/idlefw/plugins/sapidataplugin/src/sapidata.cpp Thu Dec 17 08:54:17 2009 +0200 @@ -0,0 +1,900 @@ +/* +* 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: Homescreen Data plug-in publisher +* +*/ + +#include +#include +#include +#include + +#include "sapidata.h" +#include "sapidatapluginconst.h" +#include "sapidataobserver.h" +#include "sapidataplugin.h" +// ======== MEMBER FUNCTIONS ======== + +// --------------------------------------------------------------------------- +// Symbian 2nd phase constructor can leave +// --------------------------------------------------------------------------- +// +CContentItem* CContentItem::NewL() + { + CContentItem* self = new (ELeave) CContentItem(); + CleanupStack::PushL( self ); + self->ConstructL(); + CleanupStack::Pop( self ); + return self; + } + +// --------------------------------------------------------------------------- +// Default constructor +// --------------------------------------------------------------------------- +// +CContentItem::CContentItem() + { + } + +// --------------------------------------------------------------------------- +// Symbian 2nd phase constructor can leave +// --------------------------------------------------------------------------- +// +void CContentItem::ConstructL() + { + iId = KErrNotFound; + iName = NULL; + iContentType = NULL; + iType = NULL; + } + +// --------------------------------------------------------------------------- +// Destructor +// Deletes all data created to heap +// --------------------------------------------------------------------------- +// +CContentItem::~CContentItem() + { + delete iName; + delete iContentType; + delete iType; + } + +// --------------------------------------------------------------------------- +// Symbian 2nd phase constructor can leave +// --------------------------------------------------------------------------- +// +CSapiData* CSapiData::NewL(CSapiDataPlugin* aPlugin) + { + CSapiData* self = new (ELeave) CSapiData(); + CleanupStack::PushL( self ); + self->ConstructL(aPlugin); + CleanupStack::Pop( self ); + return self; + } + +// --------------------------------------------------------------------------- +// Default constructor +// --------------------------------------------------------------------------- +// +CSapiData::CSapiData() + { + } + +// --------------------------------------------------------------------------- +// Symbian 2nd phase constructor can leave +// --------------------------------------------------------------------------- +// +void CSapiData::ConstructL(CSapiDataPlugin* aPlugin) + { + iPlugin = aPlugin; + iCommandName = NULL; + iContentId = NULL; + iContentType = NULL; + iUpdateNeeded = EFalse; + } + +// --------------------------------------------------------------------------- +// Destructor +// Deletes all data created to heap +// --------------------------------------------------------------------------- +// +CSapiData::~CSapiData() + { + delete iCommandName; + delete iPublisher; + delete iContentType; + delete iContentId; + + + if(iPubObserver) + { + TRAP_IGNORE(iPubObserver->ReleaseL() ); + delete iPubObserver; + iPubObserver = NULL; + } + if(iContentObserver) + { + TRAP_IGNORE(iContentObserver->ReleaseL() ); + delete iContentObserver; + iContentObserver = NULL; + } + if( iInterface ) + { + iInterface->Close(); + iInterface = NULL; + } + if( iServiceHandler ) + { + iServiceHandler->Reset(); + delete iServiceHandler; + iServiceHandler = NULL; + } + iMenuItems.ResetAndDestroy(); + iMenuTriggers.ResetAndDestroy(); + iItemList.ResetAndDestroy(); + // not owned + iPlugin = NULL; + } + +// --------------------------------------------------------------------------- +// ConfigureL +// --------------------------------------------------------------------------- +// +void CSapiData::ConfigureL(RAiSettingsItemArray& aConfigurations ) + { + HBufC8* serviceName = NULL; + HBufC8* interfaceName = NULL; + + 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 = CnvUtfConverter::ConvertFromUnicodeToUtf8L(confItem.Value()); + } + else if( confItem.Name() == KInterface() ) + { + interfaceName = CnvUtfConverter::ConvertFromUnicodeToUtf8L(confItem.Value()); + } + else if( confItem.Name() == KCommand() ) + { + iCommandName = CnvUtfConverter::ConvertFromUnicodeToUtf8L(confItem.Value()); + } + else if( confItem.Name() == KPublisher16() ) + { + iPublisher = confItem.Value().AllocL(); + } + } + else if ( confItem.Name() == KContentType16() ) + { + HBufC* objectId = confItem.Owner().AllocLC(); + objectId->Des().Delete(0, objectId->LocateReverse(KPluginNameSeprator) + 1); + + CContentItem *conItem = CContentItem::NewL(); + conItem->iName = objectId->AllocL(); + conItem->iContentType = confItem.Value().AllocL(); + conItem->iType = iPlugin->GetTypeL( *objectId ).AllocL(); + conItem->iId = iPlugin->GetIdL(*objectId ); + iItemList.AppendL( conItem ); + + CleanupStack::PopAndDestroy(objectId); + } + } + + iItemCount = iItemList.Count(); + + if( !serviceName || !interfaceName || !iCommandName + || !iContentId || !iPublisher || !iItemCount ) + { + // 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 ) ); + // Interface name + RCriteriaArray criteriaArray; + 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(); + delete interfaceName; + delete serviceName; + + //Gets the menu items from the publisher registry + GetMenuItemsL(); + + iContentObserver = CSapiDataObserver::NewL( iInterface, this ); + iPubObserver = CSapiDataObserver::NewL( iInterface, this ); + } + +void CSapiData::SetContentIdL(const TDesC8& aId) + { + iContentId = CnvUtfConverter::ConvertToUnicodeFromUtf8L(aId); + } +// --------------------------------------------------------------------------- +// GetMenuItemsL +// --------------------------------------------------------------------------- +// +void CSapiData::GetMenuItemsL() + { + if(iInterface && iItemCount > 0) + { + CLiwGenericParamList* outParamList = &iServiceHandler->OutParamListL(); + CLiwDefaultMap* filter = CLiwDefaultMap::NewLC(); + filter->InsertL( KPublisherId, TLiwVariant(iPublisher )); + //append filter to input param + ExecuteCommandL( KPubData, filter, outParamList ); + CleanupStack::PopAndDestroy( filter ); + //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(); + variant.PushL(); + CLiwIterable* iterable = variant.AsIterable(); + iterable->Reset(); + + CLiwDefaultMap *map = CLiwDefaultMap::NewLC(); + //considering publisher is unique reading only first entry + if( iterable->NextL( variant ) ) + { + //extract content map + variant.Get( *map ); + if( map->FindL( KDataMap, variant) ) + { + variant.Get( *map ); + } + } + iterable->Reset(); + variant.Reset(); + if ( map->FindL( KMenuItems, variant ) ) + { + CLiwDefaultMap *menuMap = CLiwDefaultMap::NewLC(); + variant.Get( *menuMap ); + for ( TInt i = 0; i < menuMap->Count(); i++) + { + menuMap->FindL(menuMap->AtL(i), variant ); + HBufC8* menuItem = variant.AsData().AllocLC(); + if ( menuItem->Length()> 0 ) + { + iMenuTriggers.AppendL( menuItem ); + CleanupStack::Pop( menuItem ); + HBufC* triggerName = CnvUtfConverter::ConvertToUnicodeFromUtf8L(menuMap->AtL(i)); + CleanupStack::PushL( triggerName ); + iMenuItems.AppendL( triggerName ); + CleanupStack::Pop( triggerName ); + } + else + { + CleanupStack::PopAndDestroy( menuItem ); + } + variant.Reset(); + } + CleanupStack::PopAndDestroy( menuMap ); + } + CleanupStack::PopAndDestroy( map ); + CleanupStack::PopAndDestroy( &variant ); + } + outParamList->Reset(); + } + } + +// --------------------------------------------------------------------------- +// CreateFilterL +// --------------------------------------------------------------------------- +// +CLiwDefaultMap* CSapiData::CreateFilterLC(const TDesC& aContentType, + const TDesC& aContentId) + { + CLiwDefaultMap* filter = CLiwDefaultMap::NewLC(); + filter->InsertL( KPublisherId, TLiwVariant(iPublisher )); + filter->InsertL( KContentId, TLiwVariant(aContentId )); + filter->InsertL( KContentType, TLiwVariant(aContentType )); + return filter; + } + +// --------------------------------------------------------------------------- +// CreateFilterL +// --------------------------------------------------------------------------- +// +CLiwDefaultMap* CSapiData::CreateFilterLC(const TDesC& aContentType) + { + CLiwDefaultMap* filter = CLiwDefaultMap::NewLC(); + filter->InsertL( KPublisherId, TLiwVariant(iPublisher )); + filter->InsertL( KContentId, TLiwVariant(iContentId )); + filter->InsertL( KContentType, TLiwVariant(aContentType )); + return filter; + } + +// --------------------------------------------------------------------------- +// CreateFilterL +// --------------------------------------------------------------------------- +// +CLiwDefaultMap* CSapiData::CreateFilterLC() + { + CLiwDefaultMap* filter = CLiwDefaultMap::NewLC(); + filter->InsertL( KPublisherId, TLiwVariant(iPublisher )); + filter->InsertL( KContentId, TLiwVariant(iContentId )); + filter->InsertL( KContentType, TLiwVariant(KAll)); + return filter; + } + + +// --------------------------------------------------------------------------- +// Update +// --------------------------------------------------------------------------- +// +TBool CSapiData::CanUpdate( TDesC& aPublisher, TDesC& aContentType, + TDesC& aContentId) + { + TBool res = EFalse; + if( aPublisher == *iPublisher + && aContentId == *iContentId ) + { + if ( aContentType != KAll ) + { + for (TInt i = 0; i < iItemCount ; i++) + { + if ( aContentType == iItemList[i]->iContentType ) + { + res = ETrue; + break; + } + } + } + else + { + res = ETrue; + } + } + else + { + res = EFalse; + } + return res; + } + +// --------------------------------------------------------------------------- +// RemoveL +// --------------------------------------------------------------------------- +// +void CSapiData::RemoveL( MAiContentObserver* aObserver, TDesC& aContentType ) + { + for(TInt index = 0; index < iItemCount; index++) + { + if ( aContentType == iItemList[index]->iContentType ) + { + iPlugin->Clean( aObserver, iItemList[index]->iId ); + } + } + } + + +// --------------------------------------------------------------------------- +// HasMenuItem +// --------------------------------------------------------------------------- +// +TBool CSapiData::HasMenuItem(const TDesC& aMenuItem ) + { + TBool found = EFalse; + for (TInt i = 0; i < iMenuItems.Count(); i++ ) + { + if( aMenuItem == iMenuItems[i] ) + { + found = ETrue; + break; + } + } + return found; + } + +// --------------------------------------------------------------------------- +// PublishL +// --------------------------------------------------------------------------- +// +void CSapiData::PublishL( MAiContentObserver* aObserver, const TDesC& aContentType ) + { + CLiwGenericParamList* outParamList = &iServiceHandler->OutParamListL(); + //Create filter criteria for requested entries in form of LIW map: + CLiwDefaultMap* filter = CreateFilterLC( aContentType ); + ExecuteCommandL( KCpData, filter, outParamList ); + CleanupStack::PopAndDestroy( filter ); + + TInt pos = 0; + outParamList->FindFirst( pos, KResults ); + if( pos != KErrNotFound ) + // results present + { + //extract iterator on results list + TLiwVariant variant = (*outParamList)[pos].Value(); + variant.PushL(); + CLiwIterable* iterable = variant.AsIterable(); + iterable->Reset(); + CLiwDefaultMap *map = CLiwDefaultMap::NewLC(); + + while( iterable->NextL( variant ) ) + { + //extract content map + if( variant.Get( *map ) && + // Find the data map + map->FindL( KDataMap, variant) ) + { + CLiwDefaultMap *datamap = CLiwDefaultMap::NewLC(); + if ( variant.Get( *datamap ) ) + { + PublishDataL(aObserver, datamap); + } + CleanupStack::PopAndDestroy( datamap ); + } + } + CleanupStack::PopAndDestroy( map ); + CleanupStack::PopAndDestroy( &variant ); + } + outParamList->Reset(); + } + +void CSapiData::PublishDataL(MAiContentObserver* aObserver, CLiwDefaultMap* aDataMap ) + { + for(TInt pIndex = 0; pIndex < iItemCount; pIndex++) + { + // result name to find + TLiwVariant variant; + HBufC8* itemName = CnvUtfConverter::ConvertFromUnicodeToUtf8L(*iItemList[pIndex]->iName); + CleanupStack::PushL( itemName ); + if ( aDataMap->FindL( *itemName, variant ) ) + { + TPtrC valPtr; + if( iItemList[pIndex]->iType->Des() == KText ) + { + valPtr.Set( variant.AsDes() ); + iPlugin->PublishTextL( aObserver, iItemList[pIndex]->iId, valPtr ); + } + else if( iItemList[pIndex]->iType->Des() == KImage ) + { + TInt handle = KErrBadHandle; + // read as a image handle + if( ! variant.Get( handle ) ) + { + // no handle, so read as image path + variant.Get( valPtr ); + iPlugin->PublishImageL(aObserver, iItemList[pIndex]->iId, valPtr ); + } + else + { + TInt maskHandle = KErrBadHandle; + //Look for image mask + HBufC8* maskKey = HBufC8::NewLC( itemName->Length() + KMask().Length() ); + TPtr8 maskKeyPtr = maskKey->Des(); + maskKeyPtr.Append( *itemName ); + maskKeyPtr.Append( KMask ); + if ( aDataMap->FindL( maskKeyPtr, variant ) ) + { + variant.Get( maskHandle ); + } + CleanupStack::PopAndDestroy( maskKey ); + iPlugin->PublishImageL(aObserver, iItemList[pIndex]->iId, handle, maskHandle ); + } + } + } + variant.Reset(); + CleanupStack::PopAndDestroy( itemName ); + } + } +// --------------------------------------------------------------------------- +// ExecuteCommandL +// --------------------------------------------------------------------------- +// +void CSapiData::ExecuteCommandL(const TDesC& aRegistry, CLiwDefaultMap* aInFilter, + CLiwGenericParamList* aOutParamList) + { + CLiwGenericParamList* inParamList = &iServiceHandler->InParamListL(); + + 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 initiated + if(iInterface) + { + iInterface->ExecuteCmdL( *iCommandName, *inParamList, *aOutParamList); + } + else + { + User::Leave( KErrNotSupported ); + } + type.Reset(); + item.Reset(); + inParamList->Reset(); + } + +// --------------------------------------------------------------------------- +// ExecuteActionL +// --------------------------------------------------------------------------- +// +void CSapiData::ExecuteActionL(const TDesC& aObjectId, const TDesC& aTrigger ) + { + HBufC8* triggerName = HBufC8::NewLC( KSAPIContentNameMaxLength ); + + CLiwGenericParamList* inParamList = &iServiceHandler->InParamListL(); + CLiwGenericParamList* outParamList = &iServiceHandler->OutParamListL(); + CLiwDefaultMap* filter = NULL; + + 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( KWidget() ); + } + 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( KWidget() ); + } + else + { + //Create filter criteria for requested entries in form of LIW map: + filter = CreateFilterLC( aObjectId ); + } + //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(); + + } + +// --------------------------------------------------------------------------- +// RegisterPublisherObserverL +// --------------------------------------------------------------------------- +// +void CSapiData::RegisterPublisherObserverL() + { + if ( iItemCount > 0) + { + CLiwDefaultMap* pubRegFilter = CreateFilterLC( KAll(), KAll() ); + pubRegFilter->InsertL( KOperation, TLiwVariant( KUpdate ) ); + iPubObserver->RegisterL( pubRegFilter, KPubData() ); + CleanupStack::PopAndDestroy( pubRegFilter ); + } + } + +// --------------------------------------------------------------------------- +// RegisterContentObserverL +// --------------------------------------------------------------------------- +// +void CSapiData::RegisterContentObserverL() + { + if ( iItemCount > 0) + { + CLiwDefaultMap* conRegFilter = CreateFilterLC(); + conRegFilter->InsertL( KOperation, TLiwVariant( KAddUpdateDelete ) ); + iContentObserver->RegisterL( conRegFilter, KCpData() ); + CleanupStack::PopAndDestroy( conRegFilter ); + } + } + +// --------------------------------------------------------------------------- +// RefreshL +// --------------------------------------------------------------------------- +// +void CSapiData::RefreshL( TDesC& aPublisher, TDesC& aContentType, + TDesC& aContentId, TDesC& aOperation ) + { + if ( CanUpdate( aPublisher, aContentType, aContentId ) ) + { + iPlugin->RefreshL( aContentType, aOperation); + } + } + +// --------------------------------------------------------------------------- +// IsPluginActive +// --------------------------------------------------------------------------- +// +TBool CSapiData::IsPluginActive() + { + return iPlugin->IsActive(); + } + +// --------------------------------------------------------------------------- +// PublisherStatusL +// --------------------------------------------------------------------------- +// +void CSapiData::ChangePublisherStatusL(const TDesC& aStatus) + { + CLiwGenericParamList* inParamList = &iServiceHandler->InParamListL(); + CLiwGenericParamList* outParamList = &iServiceHandler->OutParamListL(); + HBufC8* triggerName = CnvUtfConverter::ConvertFromUnicodeToUtf8L(aStatus); + CleanupStack::PushL( triggerName ); + + TLiwGenericParam type( KType, TLiwVariant( KPubData ) ); + inParamList->AppendL( type ); + + CLiwDefaultMap* filter = CreateFilterLC( KWidget() ); + 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 ); + CleanupStack::PopAndDestroy( triggerName ); + inParamList->Reset(); + outParamList->Reset(); + } + +// --------------------------------------------------------------------------- +// ResumeL +// --------------------------------------------------------------------------- +// +void CSapiData::ResumeL() + { + if ( iUpdateNeeded ) + { + iPlugin->PublishL(); + iUpdateNeeded = EFalse; + } + ChangePublisherStatusL( KResume ); + } + +// --------------------------------------------------------------------------- +// SuspendL +// --------------------------------------------------------------------------- +// +void CSapiData::SuspendL() + { + ChangePublisherStatusL( KSuspend ); + } + +// --------------------------------------------------------------------------- +// ActivateL +// --------------------------------------------------------------------------- +// +void CSapiData::ActivateL() + { + ChangePublisherStatusL( KActive ); + } + +// --------------------------------------------------------------------------- +// DeActivateL +// --------------------------------------------------------------------------- +// +void CSapiData::DeActivateL() + { + ChangePublisherStatusL( KDeActive ); + } + +// --------------------------------------------------------------------------- +// OnLineL +// --------------------------------------------------------------------------- +// +void CSapiData::OnLineL() + { + ChangePublisherStatusL( KOnLine ); + } + +// --------------------------------------------------------------------------- +// offLineL +// --------------------------------------------------------------------------- +// +void CSapiData::OffLineL() + { + ChangePublisherStatusL( KOffLine ); + } + +// --------------------------------------------------------------------------- +// InActiveL +// --------------------------------------------------------------------------- +// +void CSapiData::InActiveL() + { + ChangePublisherStatusL( KInActive ); + } + +// --------------------------------------------------------------------------- +// UpdatePublisherStatusL +// --------------------------------------------------------------------------- +// +void CSapiData::UpdatePublisherStatusL( TDesC& aPublisher ) + { + if ( aPublisher == iPublisher ) + { + // Resend the plugin status to publisher + ActivateL(); + if ( iPlugin->IsActive() ) + { + ResumeL(); + } + else + { + SuspendL(); + } + // forward the network status if it uses. + if ( iPlugin->NetworkStatus() == CSapiDataPlugin::EOnline ) + { + OnLineL(); + } + else if ( iPlugin->NetworkStatus() == CSapiDataPlugin::EOffline ) + { + OffLineL(); + } + } + } + +// --------------------------------------------------------------------------- +// ResolveSkinItemId +// --------------------------------------------------------------------------- +// +TBool CSapiData::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 major id + lex.SkipSpace(); + error = lex.Val( abitmapId ); + + // Resolve minor id + lex.SkipSpace(); + error |= lex.Val( aMaskId ); + } + else + { + error = KErrNotFound; + } + } + } + } + return (error == KErrNone ); + } + +// --------------------------------------------------------------------------- +// SetUpdateNeeded +// --------------------------------------------------------------------------- +// +void CSapiData::SetUpdateNeeded(TBool aStatus) + { + iUpdateNeeded = aStatus; + }