Mercurial Mercurial > oss > MCL > sf > mw > homescreensrv / comparison
summary | shortlog | changelog | graph | tags | bookmarks | branches | files | changeset | file | latest | revisions | annotate | diff | comparison | raw | help
Find changesets by keywords (author, files, the commit message), revision number or hash, or revset expression.
contentpublishingsrv/contentpublishingserver/cpserver/src/cpserverdatamanager.cpp
branchRCL_3
changeset 14 15e4dd19031c
parent 12 502e5d91ad42
child 15 a0713522ab97
equal deleted inserted replaced
12:502e5d91ad42 14:15e4dd19031c 
    36 // C++ destructor
 
    36 // C++ destructor
 
    37 // ---------------------------------------------------------------------------
 
    37 // ---------------------------------------------------------------------------
 
    38 //
 
    38 //
 
    39 CCPDataManager::~CCPDataManager()
 
    39 CCPDataManager::~CCPDataManager()
 
    40     {
 
    40     {
 
       
    41     delete iActionDataCache;
 
    41     iNotificationsArray.Close( );
 
    42     iNotificationsArray.Close( );
 
    42     delete iStorage;
 
    43     delete iStorage;
 
    43     }
 
    44     }
 
    44 
    45 
    45 // ---------------------------------------------------------------------------
 
    46 // ---------------------------------------------------------------------------
 
    83     CP_DEBUG( _L8("CCPDataManager::ConstructL()") );
 
    84     CP_DEBUG( _L8("CCPDataManager::ConstructL()") );
 
    84     if ( !aBool )
 
    85     if ( !aBool )
 
    85         {
 
    86         {
 
    86         iStorage = StorageFactory::NewDatabaseL( );
 
    87         iStorage = StorageFactory::NewDatabaseL( );
 
    87         }
 
    88         }
 
       
    89     iActionDataCache = CCPActionDataCache::NewL();
 
    88     }
 
    90     }
 
    89 
    91 
    90 // ---------------------------------------------------------------------------
 
    92 // ---------------------------------------------------------------------------
 
    91 // 
    93 // 
    92 // ---------------------------------------------------------------------------
 
    94 // ---------------------------------------------------------------------------
 
    96     CP_DEBUG( _L8("CCPDataManager::AddDataL()") );
 
    98     CP_DEBUG( _L8("CCPDataManager::AddDataL()") );
 
    97     __ASSERT_DEBUG( iStorage , User::Panic( _L("cpserver"), 0 ) );
 
    99     __ASSERT_DEBUG( iStorage , User::Panic( _L("cpserver"), 0 ) );
 
    98 
   100 
    99     CCPLiwMap* getlistmap = CreateMapForGetlistLC( aMap );
 
   101     CCPLiwMap* getlistmap = CreateMapForGetlistLC( aMap );
 
   100 
   102 
       
   103     iActionDataCache->HandleCacheRemoveL( &aMap );
 
       
   104     
   101     TBool activateMap = aMap.GetActivateInfo();
 
   105     TBool activateMap = aMap.GetActivateInfo();
 
   102     TBool activateDB ( EFalse );
 
   106     TBool activateDB ( EFalse );
 
   103     TBool activateSupport =aMap.ActivateActionSupport( );
 
   107     TBool activateSupport =aMap.ActivateActionSupport( );
 
   104    	
   108    	
   105    	if( activateSupport )
 
   109    	if( activateSupport )
 
   156     }
 
   160     }
 
   157 // ---------------------------------------------------------------------------
 
   161 // ---------------------------------------------------------------------------
 
   158 // 
   162 // 
   159 // ---------------------------------------------------------------------------
 
   163 // ---------------------------------------------------------------------------
 
   160 //
 
   164 //
 
   161 TInt CCPDataManager::GetActionL( const CCPLiwMap& aMap,
 
   165 TInt CCPDataManager::GetActionsL( const CCPLiwMap& aMap, TBool aEnableCache,
 
   162     CLiwGenericParamList& aOutParamList, CLiwDefaultList* aNotificationList )
 
   166     CLiwGenericParamList& aOutParamList, CLiwDefaultList* aNotificationList )
 
   163     {
 
   167     {
 
   164     CP_DEBUG( _L8("CCPDataManager::GetActionL()") );
 
   168     CP_DEBUG( _L8("CCPDataManager::GetActionL()") );
 
   165     __ASSERT_DEBUG( iStorage , User::Panic( _L("cpserver"), 0 ) );
 
   169     __ASSERT_DEBUG( iStorage , User::Panic( _L("cpserver"), 0 ) );
 
   166 
   170 
   167     CLiwGenericParamList* paramList = CLiwGenericParamList::NewLC( );
 
   171     CLiwGenericParamList* paramList = CLiwGenericParamList::NewLC( );
 
   168     TInt result( KErrNone );
 
   172     TInt result( KErrNone );
 
   169     TRAP( result, iStorage->GetListL( &aMap, *paramList ) );
 
       
   170     RBuf8 actionTrigger;
 
       
   171     actionTrigger.CleanupClosePushL();
 
       
   172     
   173     
   173     if ( aMap.GetPropertyL( KActionTrigger, actionTrigger ) )
 
   174     CLiwDefaultList* actionTriggers = aMap.GetActionTriggersLC();
 
   174         {
 
   175     
       
   176     if ( actionTriggers )
 
       
   177         {
 
       
   178         TBool cacheable = iActionDataCache->IsCacheableL( &aMap );
 
       
   179         if (aEnableCache && cacheable && iActionDataCache->ExistL( &aMap ))
 
       
   180             {
 
       
   181             iActionDataCache->GetL( &aMap, paramList );
 
       
   182             }
 
       
   183         else 
       
   184             {
 
       
   185             TRAP( result, iStorage->GetListL( &aMap, *paramList ) );
 
       
   186             if ( aEnableCache && cacheable && result == KErrNone )
 
       
   187                 {
 
       
   188                 iActionDataCache->AppendL(paramList);
 
       
   189                 }
 
       
   190             }
 
       
   191         
   175         const TLiwGenericParam* param;
 
   192         const TLiwGenericParam* param;
 
   176     	TInt pos( 0);
 
   193     	TInt pos( 0);
 
   177     	
   194     	
   178         param = paramList->FindFirst( pos, KListMap );
 
   195         param = paramList->FindFirst( pos, KListMap );
 
   179         //at least one param should be valid to preceed
 
   196         //at least one param should be valid to preceed
 
   180         if ( !param || pos == KErrNotFound )
 
   197         if ( !param || pos == KErrNotFound )
 
   181         	{
 
   198         	{
 
   182         	BuildDefaultChangeInfoL(&aMap, aNotificationList);
 
   199         	BuildDefaultChangeInfoL(&aMap, actionTriggers, aNotificationList);
 
   183         	}
 
   200         	}
 
   184         
   201         
   185         //iteration through paramList items
 
   202         //iteration through paramList items
 
   186     	while ( param && pos != KErrNotFound )
 
   203     	while ( param && pos != KErrNotFound )
 
   187     		{
 
   204     		{
 
   188     		BuildChangeInfoL( &aMap, param, aNotificationList );
 
   205     		BuildChangeInfoL( &aMap, actionTriggers, param, 
   189     		FillActionParamListL( aOutParamList, param, actionTrigger );
 
   206     		        aNotificationList );
 
       
   207     		FillActionParamListL( aOutParamList, param, actionTriggers );
 
   190     		param = paramList->FindNext( pos, KListMap );
 
   208     		param = paramList->FindNext( pos, KListMap );
 
   191     		}
 
   209     		}
 
   192         }
 
   210         }
 
   193     else
 
   211     else
 
   194         {
 
   212         {
 
   195         User::Leave( KErrNotFound );
 
   213         User::Leave( KErrNotFound );
 
   196         }
 
   214         }
 
   197     CleanupStack::PopAndDestroy( &actionTrigger );
 
   215     
       
   216     CleanupStack::PopAndDestroy( actionTriggers );
 
   198     CleanupStack::PopAndDestroy( paramList );
 
   217     CleanupStack::PopAndDestroy( paramList );
 
   199     return result;
 
   218     return result;
 
   200     }
 
   219     }
 
   201 
   220 
   202 
   221 
   205 // ---------------------------------------------------------------------------
 
   224 // ---------------------------------------------------------------------------
 
   206 //
 
   225 //
 
   207 void CCPDataManager::FillActionParamListL( 
   226 void CCPDataManager::FillActionParamListL( 
   208 		CLiwGenericParamList& aOutParamList, 
   227 		CLiwGenericParamList& aOutParamList, 
   209 		const TLiwGenericParam* aParam,
 
   228 		const TLiwGenericParam* aParam,
 
   210 		RBuf8 & aActionTrigger)
 
   229 		const CLiwDefaultList* aActionTriggers)
 
   211 	{
 
   230 	{
 
   212     CP_DEBUG( _L8("CCPDataManager::FillActionParamListL()") );
 
   231     CP_DEBUG( _L8("CCPDataManager::FillActionParamListL()") );
 
   213     __ASSERT_DEBUG( iStorage , User::Panic( _L("cpserver"), 0 ) );
 
   232     __ASSERT_DEBUG( iStorage , User::Panic( _L("cpserver"), 0 ) );
 
   214 		
   233 		
   215 	RBuf8 actionBinaries;
 
   234 	RBuf8 actionBinaries;
 
   217 	ExtractActionL(  aParam, actionBinaries );
 
   236 	ExtractActionL(  aParam, actionBinaries );
 
   218 
   237 
   219 	RDesReadStream str(actionBinaries);
 
   238 	RDesReadStream str(actionBinaries);
 
   220 	CleanupClosePushL( str );
 
   239 	CleanupClosePushL( str );
 
   221 	CLiwDefaultMap* actionMap = CLiwDefaultMap::NewLC( str );
 
   240 	CLiwDefaultMap* actionMap = CLiwDefaultMap::NewLC( str );
 
   222 	ExtractTriggerL( aOutParamList, actionMap, aActionTrigger );
 
   241 
       
   242     TLiwVariant trigger;
 
       
   243     trigger.PushL();
 
       
   244     TInt count = aActionTriggers->Count();
 
       
   245 	for ( TInt i = 0; i<count; i++ )
 
       
   246 	    {
 
       
   247 	    trigger.Reset();
 
       
   248 	    aActionTriggers->AtL( i,trigger );
 
       
   249 	    ExtractTriggerL( aOutParamList, actionMap, trigger.AsData());
 
       
   250 	    }
 
       
   251     CleanupStack::PopAndDestroy(&trigger);
 
   223 
   252 
   224 	CleanupStack::PopAndDestroy( actionMap );
 
   253 	CleanupStack::PopAndDestroy( actionMap );
 
   225 	CleanupStack::PopAndDestroy( &str );
 
   254 	CleanupStack::PopAndDestroy( &str );
 
   226 	CleanupStack::PopAndDestroy( &actionBinaries );
 
   255 	CleanupStack::PopAndDestroy( &actionBinaries );
 
   227 	}
 
   256 	}
 
   271 //
 
   300 //
 
   272 void CCPDataManager::RemoveDataL( const CCPLiwMap& aMap )
 
   301 void CCPDataManager::RemoveDataL( const CCPLiwMap& aMap )
 
   273     {
 
   302     {
 
   274     CP_DEBUG( _L8("CCPDataManager::RemoveData()") );
 
   303     CP_DEBUG( _L8("CCPDataManager::RemoveData()") );
 
   275     __ASSERT_DEBUG( iStorage , User::Panic( _L("cpserver"), 0 ) );
 
   304     __ASSERT_DEBUG( iStorage , User::Panic( _L("cpserver"), 0 ) );
 
       
   305     iActionDataCache->HandleCacheRemoveL( &aMap );
 
   276     iStorage->RemoveL( &aMap );
 
   306     iStorage->RemoveL( &aMap );
 
   277     }
 
   307     }
 
   278 
   308 
   279 // ---------------------------------------------------------------------------
 
   309 // ---------------------------------------------------------------------------
 
   280 //
 
   310 //
 
   454 // -----------------------------------------------------------------------------
 
   484 // -----------------------------------------------------------------------------
 
   455 // 
   485 // 
   456 // -----------------------------------------------------------------------------
 
   486 // -----------------------------------------------------------------------------
 
   457 //    
   487 //    
   458 void CCPDataManager::BuildChangeInfoL( const CCPLiwMap* aMap, 
   488 void CCPDataManager::BuildChangeInfoL( const CCPLiwMap* aMap, 
       
   489         const CLiwDefaultList* aActionTriggers,
 
   459 		const TLiwGenericParam* aParam,	
   490 		const TLiwGenericParam* aParam,	
   460 		CLiwDefaultList* aChangeInfoList )
 
   491 		CLiwDefaultList* aChangeInfoList )
 
   461 	{
 
   492 	{
 
   462 	TLiwVariant resultVar = aParam->Value();
 
   493 	TLiwVariant resultVar = aParam->Value();
 
   463 	if ( resultVar.TypeId() == EVariantTypeMap )
 
   494 	if ( resultVar.TypeId() == EVariantTypeMap )
 
   464         {
 
   495         {
 
   465         resultVar.PushL();
 
   496         for ( TInt i = 0; i<aActionTriggers->Count(); i++ )
 
   466         CLiwDefaultMap* changeInfoMap = CLiwDefaultMap::NewLC(); 
   497             {
 
       
   498             resultVar.PushL();
 
       
   499             CLiwDefaultMap* changeInfoMap = CLiwDefaultMap::NewLC(); 
       
   500         
       
   501             CopyVariantL(KId, resultVar.AsMap(), changeInfoMap );
 
       
   502             CopyVariantL(KPublisherId, resultVar.AsMap(), changeInfoMap );
 
       
   503             CopyVariantL(KContentType, resultVar.AsMap(), changeInfoMap );
 
       
   504             CopyVariantL(KContentId, resultVar.AsMap(), changeInfoMap );
 
       
   505             CopyVariantL(KFlag, resultVar.AsMap(), changeInfoMap );
 
       
   506             CopyVariantL(KType, aMap, changeInfoMap );
 
       
   507     
       
   508             TLiwVariant trigger;
 
       
   509             trigger.PushL();
 
       
   510             aActionTriggers->AtL(i,trigger);
 
       
   511             changeInfoMap->InsertL(KActionTrigger, trigger);
 
       
   512             CopyActionTrigger16L(trigger,changeInfoMap);
 
       
   513             CleanupStack::PopAndDestroy(&trigger);
 
       
   514             
       
   515             changeInfoMap->InsertL( KOperation, TLiwVariant( KOperationExecute ) );
 
       
   516         
       
   517             aChangeInfoList->AppendL( TLiwVariant( changeInfoMap ) );
 
       
   518             CleanupStack::PopAndDestroy( changeInfoMap );
 
       
   519             CleanupStack::PopAndDestroy( &resultVar );
 
       
   520             }
 
       
   521         }
 
       
   522 	}
 
       
   523 
       
   524 
       
   525 // -----------------------------------------------------------------------------
 
       
   526 // 
       
   527 // -----------------------------------------------------------------------------
 
       
   528 //    
       
   529 void CCPDataManager::BuildDefaultChangeInfoL( const CCPLiwMap* aMap, 
       
   530         const CLiwDefaultList* aActionTriggers,
 
       
   531 		CLiwDefaultList* aChangeInfoList )
 
       
   532 	{
 
       
   533 	for ( TInt i = 0; i<aActionTriggers->Count(); i++ )
 
       
   534 	    {
 
       
   535 	    CLiwDefaultMap* changeInfoMap = CLiwDefaultMap::NewLC(); 
   467 	
   536 	
   468         CopyVariantL(KId, resultVar.AsMap(), changeInfoMap );
 
   537 	    CopyVariantL(KId, aMap, changeInfoMap );
 
   469         CopyVariantL(KPublisherId, resultVar.AsMap(), changeInfoMap );
 
   538         CopyVariantL(KPublisherId, aMap, changeInfoMap );
 
   470         CopyVariantL(KContentType, resultVar.AsMap(), changeInfoMap );
 
   539         CopyVariantL(KContentType, aMap, changeInfoMap );
 
   471         CopyVariantL(KContentId, resultVar.AsMap(), changeInfoMap );
 
   540         CopyVariantL(KContentId, aMap, changeInfoMap );
 
   472         CopyVariantL(KFlag, resultVar.AsMap(), changeInfoMap );
 
   541         CopyVariantL(KFlag, aMap, changeInfoMap );
 
   473         CopyVariantL(KType, aMap, changeInfoMap );
 
   542         CopyVariantL(KType, aMap, changeInfoMap );
 
   474         CopyVariantL(KActionTrigger, aMap, changeInfoMap );
 
   543         
   475         CopyActionTrigger16L( aMap, changeInfoMap );
 
   544         TLiwVariant trigger;
 
   476 	
   545         trigger.PushL();
 
       
   546         aActionTriggers->AtL(i,trigger);
 
       
   547         changeInfoMap->InsertL(KActionTrigger, trigger);
 
       
   548         CopyActionTrigger16L(trigger,changeInfoMap);
 
       
   549         CleanupStack::PopAndDestroy(&trigger);
 
       
   550         
   477         changeInfoMap->InsertL( KOperation, TLiwVariant( KOperationExecute ) );
 
   551         changeInfoMap->InsertL( KOperation, TLiwVariant( KOperationExecute ) );
 
   478 	
   552         
   479         aChangeInfoList->AppendL( TLiwVariant( changeInfoMap ) );
 
   553         aChangeInfoList->AppendL( TLiwVariant( changeInfoMap ) );
 
   480         CleanupStack::PopAndDestroy( changeInfoMap );
 
   554         CleanupStack::PopAndDestroy( changeInfoMap );
 
   481         CleanupStack::PopAndDestroy( &resultVar );
 
   555 	    }
 
   482         }
 
       
   483 	}
 
       
   484 
       
   485 
       
   486 // -----------------------------------------------------------------------------
 
       
   487 // 
       
   488 // -----------------------------------------------------------------------------
 
       
   489 //    
       
   490 void CCPDataManager::BuildDefaultChangeInfoL( const CCPLiwMap* aMap, 
       
   491 		CLiwDefaultList* aChangeInfoList )
 
       
   492 	{
 
       
   493 	CLiwDefaultMap* changeInfoMap = CLiwDefaultMap::NewLC(); 
       
   494 	
       
   495 	CopyVariantL(KId, aMap, changeInfoMap );
 
       
   496 	CopyVariantL(KPublisherId, aMap, changeInfoMap );
 
       
   497 	CopyVariantL(KContentType, aMap, changeInfoMap );
 
       
   498 	CopyVariantL(KContentId, aMap, changeInfoMap );
 
       
   499 	CopyVariantL(KFlag, aMap, changeInfoMap );
 
       
   500 	CopyVariantL(KType, aMap, changeInfoMap );
 
       
   501 	CopyVariantL(KActionTrigger, aMap, changeInfoMap );
 
       
   502 	CopyActionTrigger16L( aMap, changeInfoMap );
 
       
   503 	
       
   504 	changeInfoMap->InsertL( KOperation, TLiwVariant( KOperationExecute ) );
 
       
   505 	
       
   506 	aChangeInfoList->AppendL( TLiwVariant( changeInfoMap ) );
 
       
   507 	CleanupStack::PopAndDestroy( changeInfoMap );
 
       
   508 	}
 
   556 	}
 
   509 
   557 
   510 // -----------------------------------------------------------------------------
 
   558 // -----------------------------------------------------------------------------
 
   511 //
 
   559 //
 
   512 // -----------------------------------------------------------------------------
 
   560 // -----------------------------------------------------------------------------
 
   557 	{
 
   605 	{
 
   558 	TLiwVariant variant;
 
   606 	TLiwVariant variant;
 
   559 	variant.PushL();
 
   607 	variant.PushL();
 
   560 	if ( aInMap->FindL( KActionTrigger(), variant ) )
 
   608 	if ( aInMap->FindL( KActionTrigger(), variant ) )
 
   561 		{
 
   609 		{
 
   562 
   610 		CopyActionTrigger16L(variant,aOutMap);
 
   563 		TPtrC8 result8( KNullDesC8 );
 
       
   564 		if( variant.Get( result8 ) )
 
       
   565 			{
 
       
   566 			RBuf actionTrigger;
 
       
   567 			actionTrigger.CleanupClosePushL();
 
       
   568 			actionTrigger.Assign( 
       
   569 					EscapeUtils::ConvertToUnicodeFromUtf8L( result8 ) );
 
       
   570 
       
   571 			variant.Reset();
 
       
   572 			variant.Set( actionTrigger );
 
       
   573 			CleanupStack::PopAndDestroy( &actionTrigger );
 
       
   574 			}
 
       
   575 		
       
   576 		aOutMap->InsertL( KActionTrigger16(), variant );
 
       
   577 		}
 
   611 		}
 
   578 	CleanupStack::PopAndDestroy( &variant );
 
   612 	CleanupStack::PopAndDestroy( &variant );
 
   579 	}
 
   613 	}
 
   580 
   614 
       
   615 // -----------------------------------------------------------------------------
 
       
   616 // 
       
   617 // -----------------------------------------------------------------------------
 
       
   618 //   
       
   619 void CCPDataManager::CopyActionTrigger16L( const TLiwVariant& aVariant, 
       
   620         CLiwDefaultMap* aOutMap )
 
       
   621     {
 
       
   622     if( aVariant.TypeId() == EVariantTypeDesC8 )
 
       
   623         {
 
       
   624         TLiwVariant variant;
 
       
   625         variant.PushL();
 
       
   626         RBuf desc16;
 
       
   627         desc16.CleanupClosePushL();
 
       
   628         desc16.Assign( 
       
   629                 EscapeUtils::ConvertToUnicodeFromUtf8L( aVariant.AsData()) );
 
       
   630         variant.Set( desc16 );
 
       
   631         aOutMap->InsertL(KActionTrigger16(),variant);
 
       
   632         CleanupStack::PopAndDestroy( &desc16 );
 
       
   633         CleanupStack::PopAndDestroy( &variant );
 
       
   634         }
 
       
   635     }
 
       
   636
MCL/sf/mw/homescreensrv