1 /* |
|
2 * Copyright (c) 2008 Nokia Corporation and/or its subsidiary(-ies). |
|
3 * All rights reserved. |
|
4 * This component and the accompanying materials are made available |
|
5 * under the terms of "Eclipse Public License v1.0" |
|
6 * which accompanies this distribution, and is available |
|
7 * at the URL "http://www.eclipse.org/legal/epl-v10.html". |
|
8 * |
|
9 * Initial Contributors: |
|
10 * Nokia Corporation - initial contribution. |
|
11 * |
|
12 * Contributors: |
|
13 * |
|
14 * Description: ?Description |
|
15 * |
|
16 */ |
|
17 |
|
18 |
|
19 #include <liwcommon.h> |
|
20 |
|
21 #include "ccontentmap.h" |
|
22 #include "cpglobals.h" |
|
23 #include "cpdebug.h" |
|
24 #include "cpssqlcommands.h" |
|
25 #include "cpsecuritypolicy.h" |
|
26 |
|
27 // --------------------------------------------------------------------------- |
|
28 // |
|
29 // --------------------------------------------------------------------------- |
|
30 // |
|
31 |
|
32 CContentMap::CContentMap() |
|
33 { |
|
34 |
|
35 } |
|
36 |
|
37 // --------------------------------------------------------------------------- |
|
38 // |
|
39 // --------------------------------------------------------------------------- |
|
40 // |
|
41 void CContentMap::ConstructL() |
|
42 { |
|
43 CCPLiwMap::ConstructL( ); |
|
44 } |
|
45 |
|
46 // --------------------------------------------------------------------------- |
|
47 // |
|
48 // --------------------------------------------------------------------------- |
|
49 // |
|
50 EXPORT_C CContentMap* CContentMap::NewL( ) |
|
51 { |
|
52 CContentMap* self = CContentMap::NewLC( ); |
|
53 CleanupStack::Pop( self ); |
|
54 return self; |
|
55 } |
|
56 |
|
57 // --------------------------------------------------------------------------- |
|
58 // |
|
59 // --------------------------------------------------------------------------- |
|
60 // |
|
61 EXPORT_C CContentMap* CContentMap::NewLC( ) |
|
62 { |
|
63 CContentMap* self = new (ELeave) CContentMap(); |
|
64 self->PushL(); |
|
65 self->ConstructL( ); |
|
66 return self; |
|
67 } |
|
68 |
|
69 // --------------------------------------------------------------------------- |
|
70 // |
|
71 // --------------------------------------------------------------------------- |
|
72 // |
|
73 CContentMap::~CContentMap() |
|
74 { |
|
75 |
|
76 } |
|
77 |
|
78 // --------------------------------------------------------------------------- |
|
79 // |
|
80 // --------------------------------------------------------------------------- |
|
81 // |
|
82 TInt32 CContentMap::AddL( RSqlDatabase aSqlDb, |
|
83 CLiwDefaultList* aNotificationList ) const |
|
84 { |
|
85 CP_DEBUG( _L8("CContentMap::AddL") ); |
|
86 TInt32 id( 0); |
|
87 if ( !GetProperty( KId, id ) ) |
|
88 { |
|
89 FetchIdL( aSqlDb, KSQLFetchId, id ); |
|
90 } |
|
91 if ( id ) |
|
92 { |
|
93 UpdateL( aSqlDb, id, aNotificationList ); |
|
94 } |
|
95 else |
|
96 { |
|
97 id = AddToDbL( aSqlDb, aNotificationList ); |
|
98 } |
|
99 return id; |
|
100 } |
|
101 |
|
102 // --------------------------------------------------------------------------- |
|
103 // |
|
104 // --------------------------------------------------------------------------- |
|
105 // |
|
106 TUint CContentMap::GetListL( RSqlDatabase aSqlDb, |
|
107 CLiwGenericParamList* aList, RArray<TInt32>& aItemsToDelete ) const |
|
108 { |
|
109 CP_DEBUG( _L8("CContentMap::GetListL") ); |
|
110 aItemsToDelete.Reset( ); |
|
111 return CCPLiwMap::GetListL( aSqlDb, KSQLGetList, aList, aItemsToDelete ); |
|
112 } |
|
113 |
|
114 // --------------------------------------------------------------------------- |
|
115 // |
|
116 // --------------------------------------------------------------------------- |
|
117 // |
|
118 void CContentMap::RemoveL( RSqlDatabase aSqlDb, |
|
119 CLiwDefaultList* aNotificationList ) const |
|
120 { |
|
121 CP_DEBUG( _L8("CContentMap::RemoveL") ); |
|
122 //get ids of items to be deleted |
|
123 GetIdsOfRemovedEntriesL( aSqlDb, KSQLGetIds, aNotificationList ); |
|
124 CCPLiwMap::RemoveL( aSqlDb, KSQLDelete ); |
|
125 } |
|
126 |
|
127 // --------------------------------------------------------------------------- |
|
128 // |
|
129 // --------------------------------------------------------------------------- |
|
130 // |
|
131 void CContentMap::SaveQueryResultsL( RSqlStatement& aStmt, |
|
132 CLiwGenericParamList& aList, RArray<TInt32>& aItemsToDelete ) const |
|
133 { |
|
134 CP_DEBUG( _L8("CContentMap::SaveQueryResultsL") ); |
|
135 TInt idIndex = ColumnIndexL( aStmt, KColumnId ); |
|
136 TInt publisherIndex = ColumnIndexL( aStmt, KColumnPublisher ); |
|
137 TInt contentIndex = ColumnIndexL( aStmt, KColumnContent_type ); |
|
138 TInt content_idIndex = ColumnIndexL( aStmt, KColumnContent_id ); |
|
139 TInt expiration_dateIndex = ColumnIndexL( aStmt, KColumnExpiration_date ); |
|
140 TInt acl_Index = ColumnIndexL( aStmt, KColumnAccessList ); |
|
141 TInt data_Index = ColumnIndexL( aStmt, KColumnData ); |
|
142 TInt action_Index = ColumnIndexL( aStmt, KColumnAction ); |
|
143 |
|
144 TBool aclCheckFailed( EFalse ); |
|
145 while ( aStmt.Next( ) == KSqlAtRow ) |
|
146 { |
|
147 TBool securityOk( EFalse ); |
|
148 if( iPolicy ) |
|
149 { |
|
150 TPtrC8 acl; |
|
151 User::LeaveIfError( aStmt.ColumnBinary( acl_Index, acl ) ); |
|
152 securityOk = iPolicy->CheckSecurityL( acl , |
|
153 CCPSecurityPolicy::ERead ); |
|
154 if ( !securityOk ) |
|
155 { |
|
156 aclCheckFailed = ETrue; |
|
157 } |
|
158 } |
|
159 if ( !iPolicy || securityOk ) |
|
160 { |
|
161 TInt32 id = aStmt.ColumnInt( idIndex ) ; |
|
162 TPtrC publisher; |
|
163 User::LeaveIfError( aStmt.ColumnText( publisherIndex, |
|
164 publisher ) ); |
|
165 TPtrC content_type; |
|
166 User::LeaveIfError( aStmt.ColumnText( contentIndex, |
|
167 content_type ) ); |
|
168 TPtrC content_id; |
|
169 User::LeaveIfError( aStmt.ColumnText( content_idIndex, |
|
170 content_id ) ); |
|
171 CLiwDefaultMap* targetMap = CLiwDefaultMap::NewLC( ); |
|
172 targetMap->InsertL( KId, TLiwVariant( id ) ); |
|
173 targetMap->InsertL( KPublisherId, TLiwVariant( publisher ) ); |
|
174 targetMap->InsertL( KContentType, TLiwVariant(content_type ) ); |
|
175 targetMap->InsertL( KContentId, TLiwVariant( content_id ) ); |
|
176 |
|
177 TInt64 expiration_date; |
|
178 expiration_date = aStmt.ColumnInt64( expiration_dateIndex ); |
|
179 if ( ( expiration_date ) |
|
180 &&(IsOutdated( TTime( expiration_date ) )) ) |
|
181 { |
|
182 // add id of item to be deleted to aItemsToDelete array |
|
183 // do not continue getlist operation |
|
184 aItemsToDelete.AppendL( id ); |
|
185 }//if |
|
186 else |
|
187 { |
|
188 // continue getlist operation |
|
189 TPtrC8 data; |
|
190 User::LeaveIfError( aStmt.ColumnBinary( data_Index, data ) ); |
|
191 TPtrC8 action; |
|
192 User::LeaveIfError( aStmt.ColumnBinary( action_Index, action ) ); |
|
193 if( data.Ptr() ) |
|
194 { |
|
195 targetMap->InsertL( KDataMap , TLiwVariant( data ) ); |
|
196 } |
|
197 if( action.Ptr() ) |
|
198 { |
|
199 targetMap->InsertL( KActionMap , TLiwVariant( action ) ); |
|
200 } |
|
201 TLiwGenericParam result( KListMap, TLiwVariant( targetMap )); |
|
202 aList.AppendL( result ); |
|
203 }//else |
|
204 CleanupStack::PopAndDestroy( targetMap ); |
|
205 }// if |
|
206 }//while |
|
207 //leave only if ACL security check for all items failed |
|
208 if ( aclCheckFailed && !aList.Count()) |
|
209 { |
|
210 User::Leave( KErrPermissionDenied ); |
|
211 } |
|
212 } |
|
213 |
|
214 // --------------------------------------------------------------------------- |
|
215 // |
|
216 // --------------------------------------------------------------------------- |
|
217 // |
|
218 void CContentMap::PrepareStmtforAddL( RSqlDatabase aSqlDb, |
|
219 RSqlStatement& aStmt, const TDesC& aQuery ) const |
|
220 { |
|
221 CP_DEBUG( _L8("CContentMap::PrepareStmtforAddL") ); |
|
222 CCPLiwMap::PrepareStmtforAddL( aSqlDb, aStmt, aQuery ); |
|
223 TTime expiration_date( NULL); |
|
224 GetExpirationDateL( expiration_date ); |
|
225 TInt expiration_dateIndex = aStmt.ParameterIndex( KSQLExpiration_date ); |
|
226 if ( expiration_dateIndex != KErrNotFound ) |
|
227 { |
|
228 BindInt64L( aStmt, expiration_dateIndex, expiration_date.Int64() ); |
|
229 } |
|
230 } |
|
231 |
|
232 // --------------------------------------------------------------------------- |
|
233 // |
|
234 // --------------------------------------------------------------------------- |
|
235 // |
|
236 void CContentMap::PrepareStmtforUpdateL( RSqlDatabase aSqlDb, |
|
237 RSqlStatement& aStmt, TInt32 aId ) const |
|
238 { |
|
239 CP_DEBUG( _L8("CContentMap::PrepareStmtforUpdateL") ); |
|
240 TTime expiration_date; |
|
241 TBool isExpirationDate = GetExpirationDateL( expiration_date ); |
|
242 TBool isParameter(EFalse); |
|
243 RBuf query; |
|
244 query.CleanupClosePushL(); |
|
245 query.CreateL( KSQLUpdate().Length( ) ); |
|
246 query.Append( KSQLUpdate ); |
|
247 RBuf8 data; |
|
248 data.CleanupClosePushL(); |
|
249 RBuf8 action; |
|
250 action.CleanupClosePushL(); |
|
251 if ( GetPropertyL( KDataMap, data ) ) |
|
252 { |
|
253 query.ReAllocL( query.Length( ) + KSQLUpdateData().Length( ) ); |
|
254 query.Append( KSQLUpdateData ); |
|
255 isParameter = ETrue; |
|
256 } |
|
257 if ( GetPropertyL( KActionMap, action ) ) |
|
258 { |
|
259 if ( isParameter ) |
|
260 { |
|
261 query.ReAllocL( query.Length( ) + KComma().Length( ) ); |
|
262 query.Append( KComma ); |
|
263 } |
|
264 query.ReAllocL( query.Length( ) + KSQLUpdateAction().Length( ) ); |
|
265 query.Append( KSQLUpdateAction ); |
|
266 isParameter = ETrue; |
|
267 } |
|
268 if ( isExpirationDate ) |
|
269 { |
|
270 if ( isParameter ) |
|
271 { |
|
272 query.ReAllocL( query.Length( ) + KComma().Length( ) ); |
|
273 query.Append( KComma ); |
|
274 } |
|
275 query.ReAllocL( query.Length( ) + KSQLUpdateExpirationDate().Length( ) ); |
|
276 query.Append( KSQLUpdateExpirationDate ); |
|
277 isParameter = ETrue; |
|
278 } |
|
279 if ( !isParameter ) User::Leave( KErrPathNotFound ); |
|
280 query.ReAllocL( query.Length( ) + KSQLUpdateWhere().Length( ) ); |
|
281 query.Append( KSQLUpdateWhere ); |
|
282 |
|
283 User::LeaveIfError( aStmt.Prepare( aSqlDb, query ) ); |
|
284 TInt dataId = aStmt.ParameterIndex( KSQLId ); |
|
285 BindIntL( aStmt, dataId, aId ); |
|
286 |
|
287 if ( data.Length( ) ) |
|
288 { |
|
289 TInt dataIndex = aStmt.ParameterIndex( KSQLData ); |
|
290 BindBinaryL( aStmt, dataIndex, data ); |
|
291 } |
|
292 if ( action.Length( ) ) |
|
293 { |
|
294 TInt actionIndex = aStmt.ParameterIndex( KSQLAction ); |
|
295 BindBinaryL( aStmt, actionIndex, action ); |
|
296 } |
|
297 if ( isExpirationDate ) |
|
298 { |
|
299 TInt expiration_dateIndex = |
|
300 aStmt.ParameterIndex( KSQLExpiration_date ); |
|
301 BindInt64L( aStmt, expiration_dateIndex, |
|
302 expiration_date.Int64( ) ); |
|
303 |
|
304 } |
|
305 CleanupStack::PopAndDestroy( &action ); |
|
306 CleanupStack::PopAndDestroy( &data ); |
|
307 CleanupStack::PopAndDestroy( &query ); |
|
308 } |
|
309 // --------------------------------------------------------------------------- |
|
310 // |
|
311 // --------------------------------------------------------------------------- |
|
312 // |
|
313 void CContentMap::UpdateL( RSqlDatabase aSqlDb, TInt32 aId, |
|
314 CLiwDefaultList* aNotificationList ) const |
|
315 { |
|
316 CP_DEBUG( _L8("CContentMap::UpdateL") ); |
|
317 RSqlStatement stmt; |
|
318 CleanupClosePushL( stmt ); |
|
319 CLiwDefaultMap* changeInfoMap = CLiwDefaultMap::NewLC( ); |
|
320 FetchIdsL( aId, KSQLFetchIds, changeInfoMap, aSqlDb ); |
|
321 if ( aNotificationList ) |
|
322 { |
|
323 changeInfoMap->InsertL( KType, TLiwVariant( KCpData ) ); |
|
324 aNotificationList->AppendL( TLiwVariant( changeInfoMap ) ); |
|
325 } |
|
326 CleanupStack::PopAndDestroy( changeInfoMap ); |
|
327 PrepareStmtforUpdateL( aSqlDb, stmt, aId ); |
|
328 if ( stmt.Exec( ) <= 0 ) |
|
329 { |
|
330 User::Leave( KErrNotFound ); |
|
331 } |
|
332 CleanupStack::PopAndDestroy( &stmt ); |
|
333 } |
|
334 |
|
335 // --------------------------------------------------------------------------- |
|
336 // |
|
337 // --------------------------------------------------------------------------- |
|
338 // |
|
339 TInt32 CContentMap::AddToDbL( RSqlDatabase aSqlDb, |
|
340 CLiwDefaultList* aNotificationList ) const |
|
341 { |
|
342 CP_DEBUG( _L8("CContentMap::AddToDbL") ); |
|
343 RSqlStatement stmt; |
|
344 CleanupClosePushL( stmt ); |
|
345 PrepareStmtforAddL( aSqlDb, stmt, KSQLInsert ); |
|
346 |
|
347 TInt dataIndex = stmt.ParameterIndex( KSQLData ); |
|
348 TInt actionIndex = stmt.ParameterIndex( KSQLAction ); |
|
349 TInt aclIndex = stmt.ParameterIndex( KSQLAccessList ); |
|
350 |
|
351 RBuf8 data; |
|
352 data.CleanupClosePushL(); |
|
353 GetPropertyL( KDataMap, data ) ; |
|
354 BindBinaryL( stmt, dataIndex, data ); |
|
355 |
|
356 RBuf8 action; |
|
357 action.CleanupClosePushL(); |
|
358 GetPropertyL( KActionMap, action ) ; |
|
359 BindBinaryL( stmt, actionIndex, action ); |
|
360 |
|
361 RBuf8 acl; |
|
362 acl.CleanupClosePushL(); |
|
363 if( !GetPropertyL( KAccessList , acl ) ) |
|
364 { |
|
365 iPolicy->GetDefaultSecurityL( acl ); |
|
366 } |
|
367 |
|
368 BindBinaryL( stmt, aclIndex, acl ); |
|
369 if ( stmt.Exec( ) <= 0 ) |
|
370 { |
|
371 User::Leave( KErrGeneral ); |
|
372 } |
|
373 |
|
374 TSqlScalarFullSelectQuery id_query(aSqlDb); |
|
375 TInt32 ret( 0); |
|
376 ret = id_query.SelectIntL( KSQLGetLastInsertId ); |
|
377 |
|
378 if ( aNotificationList ) |
|
379 { |
|
380 RBuf publisher; |
|
381 publisher.CleanupClosePushL(); |
|
382 RBuf contentType; |
|
383 contentType.CleanupClosePushL(); |
|
384 RBuf contentId; |
|
385 contentId.CleanupClosePushL(); |
|
386 GetPropertyL( KPublisherId, publisher ) ; |
|
387 GetPropertyL( KContentType, contentType ); |
|
388 GetPropertyL( KContentId, contentId ); |
|
389 CLiwDefaultMap* changeInfoMap = CLiwDefaultMap::NewLC( ); |
|
390 changeInfoMap->InsertL( KId, TLiwVariant( ret ) ); |
|
391 changeInfoMap->InsertL( KType, TLiwVariant( KCpData ) ); |
|
392 changeInfoMap->InsertL( KPublisherId, TLiwVariant( publisher ) ); |
|
393 changeInfoMap->InsertL( KContentType, TLiwVariant( contentType ) ); |
|
394 changeInfoMap->InsertL( KContentId, TLiwVariant( contentId ) ); |
|
395 changeInfoMap->InsertL( KOperation, TLiwVariant( KOperationAdd ) ); |
|
396 aNotificationList->AppendL( TLiwVariant( changeInfoMap ) ); |
|
397 CleanupStack::PopAndDestroy( changeInfoMap ) ; |
|
398 CleanupStack::PopAndDestroy( &contentId ) ; |
|
399 CleanupStack::PopAndDestroy( &contentType ) ; |
|
400 CleanupStack::PopAndDestroy( &publisher ) ; |
|
401 } |
|
402 |
|
403 CleanupStack::PopAndDestroy( &acl ) ; |
|
404 CleanupStack::PopAndDestroy( &action ) ; |
|
405 CleanupStack::PopAndDestroy( &data ) ; |
|
406 CleanupStack::PopAndDestroy( &stmt ) ; |
|
407 return ret; |
|
408 } |
|
409 |
|
410 // --------------------------------------------------------------------------- |
|
411 // |
|
412 // --------------------------------------------------------------------------- |
|
413 // |
|
414 void CContentMap::AppendSortL( RBuf& aQuery, const TCPSortOrder& aSort ) const |
|
415 { |
|
416 CP_DEBUG( _L8("CContentMap::AppendSortL") ); |
|
417 switch ( aSort ) |
|
418 { |
|
419 case ECPPublisher: |
|
420 aQuery.ReAllocL( aQuery.Length( ) + KSQLOrderPublisher().Length( ) ); |
|
421 aQuery.Append( KSQLOrderPublisher ); |
|
422 break; |
|
423 case ECPContent: |
|
424 aQuery.ReAllocL( aQuery.Length( ) + KSQLOrderContent().Length( ) ); |
|
425 aQuery.Append( KSQLOrderContent ); |
|
426 break; |
|
427 default: |
|
428 aQuery.ReAllocL( aQuery.Length( ) + KSQLOrderRecent().Length( ) ); |
|
429 aQuery.Append( KSQLOrderRecent ); |
|
430 break; |
|
431 } |
|
432 } |
|
433 |
|
434 // --------------------------------------------------------------------------- |
|
435 // |
|
436 // --------------------------------------------------------------------------- |
|
437 // |
|
438 TBool CContentMap::IsOutdated( const TTime aExpirationTime ) const |
|
439 { |
|
440 CP_DEBUG( _L8("CContentMap::IsOutdated") ); |
|
441 TBool result(EFalse); |
|
442 TTime currentTime(0); |
|
443 currentTime.HomeTime( ); |
|
444 if ( currentTime>aExpirationTime ) |
|
445 { |
|
446 result = ETrue; |
|
447 } |
|
448 return result; |
|
449 } |
|
450 |
|
451 // --------------------------------------------------------------------------- |
|
452 // |
|
453 // --------------------------------------------------------------------------- |
|
454 // |
|
455 void CContentMap::IsDataMapL() const |
|
456 { |
|
457 TInt pos( 0 ); |
|
458 const TLiwGenericParam* paramForValue = iMap->FindFirst( pos, KDataMap ); |
|
459 if ( pos != KErrNotFound ) |
|
460 { |
|
461 if( paramForValue->Value().TypeId() != LIW::EVariantTypeDesC8 ) |
|
462 { |
|
463 User::Leave( KErrBadName ); |
|
464 } |
|
465 } |
|
466 else |
|
467 { |
|
468 User::Leave( KErrPathNotFound ); |
|
469 } |
|
470 } |
|
471 |
|
472 // --------------------------------------------------------------------------- |
|
473 // |
|
474 // --------------------------------------------------------------------------- |
|
475 // |
|
476 TBool CContentMap::GetExpirationDateL( TTime& aResult ) const |
|
477 { |
|
478 CP_DEBUG( _L8("CContentMap::GetExpirationDateL") ); |
|
479 TInt pos( 0); |
|
480 TBool result(EFalse); |
|
481 const TLiwGenericParam* param= NULL; |
|
482 param = iMap->FindFirst( pos, KExpirationDate ); |
|
483 if ( KErrNotFound != pos ) |
|
484 { |
|
485 if ( !param->Value().Get( aResult ) ) |
|
486 User::Leave( KErrArgument ); |
|
487 result = ETrue; |
|
488 } |
|
489 return result; |
|
490 } |
|
491 |
|
492 // --------------------------------------------------------------------------- |
|
493 // |
|
494 // --------------------------------------------------------------------------- |
|
495 // |
|
496 void CContentMap::IsValidForDeleteL() const |
|
497 { |
|
498 CP_DEBUG( _L8("CContentMap::IsValidFilterL") ); |
|
499 TInt err( KErrNone ); |
|
500 TInt32 id( 0 ); |
|
501 if( GetProperty( KId, id ) && ( id < 1 ) ) |
|
502 { |
|
503 err = KErrArgument; |
|
504 } |
|
505 else if( !IsId() && PropertyExists( KId ) ) |
|
506 { |
|
507 err = KErrBadName; |
|
508 } |
|
509 |
|
510 if( err == KErrNone && !IsId( ) && !( IsPublisherNameL( ) |
|
511 || IsContentTypeL( ) || IsContentIdL() ) ) |
|
512 { |
|
513 err = KErrPathNotFound; |
|
514 } |
|
515 |
|
516 if( err != KErrNone ) |
|
517 { |
|
518 User::Leave( err ); |
|
519 } |
|
520 } |
|
521 |
|
522 // --------------------------------------------------------------------------- |
|
523 // |
|
524 // --------------------------------------------------------------------------- |
|
525 // |
|
526 void CContentMap::IsValidForGetListL() const |
|
527 { |
|
528 CP_DEBUG( _L8("CContentMap::IsValidForGetListL") ); |
|
529 TInt err( KErrNone ); |
|
530 TInt32 id( 0 ); |
|
531 if( GetProperty( KId, id ) && ( id < 1 ) ) |
|
532 { |
|
533 err = KErrArgument; |
|
534 } |
|
535 else if( !IsId() && PropertyExists( KId ) ) |
|
536 { |
|
537 err = KErrBadName; |
|
538 } |
|
539 |
|
540 if( err != KErrNone ) |
|
541 { |
|
542 User::Leave( err ); |
|
543 } |
|
544 } |
|
545 |
|
546 // --------------------------------------------------------------------------- |
|
547 // |
|
548 // --------------------------------------------------------------------------- |
|
549 // |
|
550 TBool CContentMap::ActivateActionSupport( ) const |
|
551 { |
|
552 return EFalse; |
|
553 } |
|
554 |
|
555 // --------------------------------------------------------------------------- |
|
556 // |
|
557 // --------------------------------------------------------------------------- |
|
558 // |
|
559 TBool CContentMap::GetActivateInfo( ) const |
|
560 { |
|
561 return EFalse; |
|
562 } |
|
563 |
|