|
1 /* |
|
2 * Copyright (c) 2002 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 the License "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: CLandmarkService class implementation |
|
15 * |
|
16 */ |
|
17 |
|
18 |
|
19 #include <epos_hposlmdatabaseinfo.h> |
|
20 #include <epos_cposlmdatabasemanager.h> |
|
21 #include <epos_cposlandmarkparser.h> |
|
22 #include <epos_cposlandmarkencoder.h> |
|
23 #include <epos_cposlmitemiterator.h> |
|
24 #include <epos_cposlandmarkdatabase.h> |
|
25 #include <epos_cposlandmarksearch.h> |
|
26 #include <epos_cposlmcategorymanager.h> |
|
27 #include "landmarkservice.h" |
|
28 #include "clandmarkcmdgetcategories.h" |
|
29 #include "clandmarkcmdgetlandmarks.h" |
|
30 #include "clandmarkmanagehandlers.h" |
|
31 #include "clandmarkfilter.h" |
|
32 #include "clandmarkmanageobjects.h" |
|
33 #include "mlandmarkobserver.h" |
|
34 |
|
35 //CONSTANTS |
|
36 _LIT(KProtocolSeparator, "://"); |
|
37 _LIT(KLocalProtocol, "file"); |
|
38 |
|
39 // ============================ MEMBER FUNCTIONS =============================== |
|
40 |
|
41 // ----------------------------------------------------------------------------- |
|
42 // CLandmarkService::NewL() |
|
43 // Two-phased constructor. |
|
44 // ----------------------------------------------------------------------------- |
|
45 // |
|
46 EXPORT_C CLandmarkService* CLandmarkService::NewL() |
|
47 { |
|
48 CLandmarkService* self = CLandmarkService::NewLC(); |
|
49 CleanupStack::Pop( self ); |
|
50 return self; |
|
51 } |
|
52 |
|
53 // ----------------------------------------------------------------------------- |
|
54 // CLandmarkService::NewL() |
|
55 // Two-phased constructor. |
|
56 // ----------------------------------------------------------------------------- |
|
57 // |
|
58 EXPORT_C CLandmarkService* CLandmarkService::NewLC() |
|
59 { |
|
60 CLandmarkService* self = new (ELeave) CLandmarkService(); |
|
61 CleanupStack::PushL( self ); |
|
62 self->ConstructL(); |
|
63 return self; |
|
64 } |
|
65 |
|
66 // ----------------------------------------------------------------------------- |
|
67 // CLandmarkService::ConstructL() |
|
68 // Symbian 2nd phase constructor can leave. |
|
69 // ----------------------------------------------------------------------------- |
|
70 // |
|
71 void CLandmarkService::ConstructL( ) |
|
72 { |
|
73 #ifdef _DEBUG |
|
74 User::LeaveIfError (iLog.Connect ( ) ); |
|
75 iLog.CreateLog (_L("landmarks"),_L("log.txt"),EFileLoggingModeOverwrite ); |
|
76 iLog.Write (_L("CLandmarkService::ConstructL()") ); |
|
77 #endif |
|
78 |
|
79 iDatabaseManager = CPosLmDatabaseManager::NewL ( ); |
|
80 iManageHandler = CLandmarkManageHandlers::NewL ( ); |
|
81 SetActiveL(KNullDesC); |
|
82 } |
|
83 |
|
84 // ----------------------------------------------------------------------------- |
|
85 // CLandmarkService::CLandmarkService() |
|
86 // C++ default constructor can NOT contain any code, that might leave. |
|
87 // ----------------------------------------------------------------------------- |
|
88 // |
|
89 CLandmarkService::CLandmarkService( ) |
|
90 { |
|
91 } |
|
92 |
|
93 // ----------------------------------------------------------------------------- |
|
94 // CLandmarkService::~CLandmarkService() |
|
95 // Destructor. |
|
96 // ----------------------------------------------------------------------------- |
|
97 // |
|
98 CLandmarkService::~CLandmarkService( ) |
|
99 { |
|
100 #ifdef _DEBUG |
|
101 iLog.Write (_L("CLandmarkService::~CLandmarkService()") ); |
|
102 iLog.CloseLog ( ); |
|
103 iLog.Close ( ); |
|
104 #endif |
|
105 |
|
106 delete iManageObjects; |
|
107 delete iDatabaseManager; |
|
108 delete iManageHandler; |
|
109 ReleaseLandmarkResources ( ); |
|
110 } |
|
111 |
|
112 // ----------------------------------------------------------------------------- |
|
113 // CLandmarkService::ImportL( CPosLmItemIterator*& aIterator, |
|
114 // CPosLandmarkParser& aLandmarkParser, TDesC& aDatabaseUri ) const |
|
115 // Imports landmarks parsed from the input file to the given database. |
|
116 // ----------------------------------------------------------------------------- |
|
117 // |
|
118 EXPORT_C void CLandmarkService::ImportL( CPosLmItemIterator*& aIterator, |
|
119 CPosLandmarkParser& aLandmarkParser, const TDesC& aDatabaseUri ) |
|
120 { |
|
121 #ifdef _DEBUG |
|
122 iLog.Write(_L("CLandmarkService::ImportL")); |
|
123 #endif |
|
124 |
|
125 CLandmarkHandler* handler = iManageHandler->GetHandlerL(aDatabaseUri); |
|
126 if ( !handler ) |
|
127 { |
|
128 handler = iManageHandler->CreateHandlerL(aDatabaseUri); |
|
129 } |
|
130 CPosLandmarkDatabase* db = handler->LandmarkDatabaseHandle(); |
|
131 CPosLmOperation* op = db->ImportLandmarksL(aLandmarkParser, |
|
132 CPosLandmarkDatabase::EDefaultOptions); |
|
133 CleanupStack::PushL(op); |
|
134 op->ExecuteL(); |
|
135 aIterator = db->ImportedLandmarksIteratorL(op); |
|
136 CleanupStack::PopAndDestroy(op); |
|
137 |
|
138 #ifdef _DEBUG |
|
139 iLog.Write(_L("CLandmarkService::ImportL:Exit")); |
|
140 #endif |
|
141 } |
|
142 |
|
143 // ----------------------------------------------------------------------------- |
|
144 // CLandmarkService::ExportL( CPosLandmarkEncoder* aLandmarkEncoder, |
|
145 // const RArray<TPosLmItemId>& aLandmarkIdArray, const TDesC& aDatabaseUri ) |
|
146 // Exports a list of landmarks from database to a file. |
|
147 // ----------------------------------------------------------------------------- |
|
148 // |
|
149 EXPORT_C void CLandmarkService::ExportL( CPosLandmarkEncoder& aLandmarkEncoder, |
|
150 const RArray<TPosLmItemId>& aLandmarkIdArray, const TDesC& aDatabaseUri ) const |
|
151 { |
|
152 CLandmarkHandler* handler = iManageHandler->GetHandlerL(aDatabaseUri); |
|
153 if (!handler) |
|
154 { |
|
155 handler = iManageHandler->CreateHandlerL(aDatabaseUri); |
|
156 } |
|
157 CPosLandmarkDatabase* db = handler->LandmarkDatabaseHandle(); |
|
158 ExecuteAndDeleteLD(db->ExportLandmarksL(aLandmarkEncoder,aLandmarkIdArray, |
|
159 CPosLandmarkDatabase::EIncludeCategories)); |
|
160 } |
|
161 |
|
162 // ----------------------------------------------------------------------------- |
|
163 // CLandmarkService::GetListL( CPosLmItemIterator*& aIterator, |
|
164 // const CLandmarkFilter* aFilter, const TDesC& aDatabaseUri ) const |
|
165 // Get a list of Landmarks/Categories from Database synchronously based on filter. |
|
166 // ----------------------------------------------------------------------------- |
|
167 // |
|
168 EXPORT_C void CLandmarkService::GetListL( CPosLmItemIterator*& aIterator, |
|
169 CLandmarkFilter& aFilter, const TDesC& aDatabaseUri ) const |
|
170 { |
|
171 CLandmarkHandler* handler = iManageHandler->GetHandlerL(aDatabaseUri); |
|
172 if ( !handler ) |
|
173 { |
|
174 handler = iManageHandler->CreateHandlerL(aDatabaseUri); |
|
175 } |
|
176 CPosLandmarkSearch* search = handler->LandmarkSearchHandle(); |
|
177 search->SetMaxNumOfMatches(aFilter.MaximumMatches()); |
|
178 if ( aFilter.IsLandmark() ) |
|
179 { |
|
180 ExecuteAndDeleteLD(search->StartLandmarkSearchL(aFilter.Criteria(), |
|
181 aFilter.LmSortPref(),aFilter.PreviousMatches())); |
|
182 } |
|
183 else |
|
184 { |
|
185 ExecuteAndDeleteLD(search->StartCategorySearchL(aFilter.Criteria(), |
|
186 aFilter.CatSortPref(),aFilter.PreviousMatches())); |
|
187 } |
|
188 aIterator = search->MatchIteratorL(); |
|
189 } |
|
190 |
|
191 // ----------------------------------------------------------------------------- |
|
192 // CLandmarkService::GetListL( CDesCArray*& aDatabaseList, |
|
193 // const TDesC& aProtocol ) const |
|
194 // Get a list of Landmark databases. |
|
195 // ----------------------------------------------------------------------------- |
|
196 // |
|
197 EXPORT_C void CLandmarkService::GetListL (CDesCArray*& aDatabaseList, |
|
198 const TDesC& aProtocol) const |
|
199 { |
|
200 if ( aProtocol != KNullDesC ) |
|
201 { |
|
202 aDatabaseList = iDatabaseManager->ListDatabasesLC(aProtocol); |
|
203 } |
|
204 else |
|
205 { |
|
206 aDatabaseList = iDatabaseManager->ListDatabasesLC(); |
|
207 } |
|
208 CleanupStack::Pop(aDatabaseList); |
|
209 } |
|
210 |
|
211 // ----------------------------------------------------------------------------- |
|
212 // CLandmarkService::GetListL( TInt32 aTransactionId, |
|
213 // CLandmarkFilter* aFilter,const TDesC & aDatabaseUri ) |
|
214 // Get a list of Landmarks/catgeories from Database asynchronously based on filter. |
|
215 // ----------------------------------------------------------------------------- |
|
216 // |
|
217 EXPORT_C void CLandmarkService::GetListL( TInt32 aTransactionId, |
|
218 CLandmarkFilter& aFilter, const TDesC& aDatabaseUri ) |
|
219 { |
|
220 #ifdef _DEBUG |
|
221 iLog.Write(_L("CLandmarkService::GetListL: Landmark: Async")); |
|
222 #endif |
|
223 |
|
224 CLandmarkHandler* handler = iManageHandler->GetHandlerL(aDatabaseUri); |
|
225 if ( !handler ) |
|
226 { |
|
227 handler = iManageHandler->CreateHandlerL(aDatabaseUri); |
|
228 } |
|
229 |
|
230 //Leave if observer has not been set for the async call. |
|
231 if ( !iObserver ) |
|
232 { |
|
233 User::Leave(KErrGeneral); |
|
234 } |
|
235 |
|
236 if ( !iManageObjects ) |
|
237 { |
|
238 iManageObjects = CLandmarkManageObjects::NewL(); |
|
239 } |
|
240 |
|
241 if ( aFilter.IsLandmark() ) |
|
242 { |
|
243 CLandmarkCmdBase* getLm = CLandmarkCmdGetLandmarks::NewLC(iObserver, |
|
244 iManageObjects); |
|
245 getLm->StartL(handler,aTransactionId,aFilter); |
|
246 iManageObjects->AppendL(getLm); |
|
247 CleanupStack::Pop(getLm); |
|
248 #ifdef _DEBUG |
|
249 iLog.Write(_L("CLandmarkService::GetListL: Landmark: Async: Exit")); |
|
250 #endif |
|
251 } |
|
252 else |
|
253 { |
|
254 CLandmarkCmdBase* getCat = CLandmarkCmdGetCategories::NewLC(iObserver, |
|
255 iManageObjects); |
|
256 getCat->StartL(handler,aTransactionId,aFilter); |
|
257 iManageObjects->AppendL(getCat); |
|
258 CleanupStack::Pop(getCat); |
|
259 #ifdef _DEBUG |
|
260 iLog.Write(_L("CLandmarkService::GetListL: Category: Async: Exit")); |
|
261 #endif |
|
262 } |
|
263 } |
|
264 |
|
265 // ----------------------------------------------------------------------------- |
|
266 // CLandmarkService::AddItemL( CPosLandmark& aLandmark,const TDesC& aDatabaseUri) |
|
267 // Adds a landmark to the given database. |
|
268 // ----------------------------------------------------------------------------- |
|
269 // |
|
270 EXPORT_C TPosLmItemId CLandmarkService::AddItemL( CPosLandmark& aLandmark, |
|
271 const TDesC& aDatabaseUri ) |
|
272 { |
|
273 #ifdef _DEBUG |
|
274 iLog.Write(_L("CLandmarkService::AddItemL: Landmark")); |
|
275 #endif |
|
276 |
|
277 CLandmarkHandler* handler = iManageHandler->GetHandlerL(aDatabaseUri); |
|
278 if ( !handler ) |
|
279 { |
|
280 handler = iManageHandler->CreateHandlerL(aDatabaseUri); |
|
281 } |
|
282 CPosLandmarkDatabase* db = handler->LandmarkDatabaseHandle(); |
|
283 |
|
284 #ifdef _DEBUG |
|
285 iLog.Write(_L("CLandmarkService::AddItemL: Landmark:Exit")); |
|
286 #endif |
|
287 |
|
288 return db->AddLandmarkL(aLandmark); |
|
289 } |
|
290 |
|
291 // ----------------------------------------------------------------------------- |
|
292 // CLandmarkService::AddItemL( CPosLandmarkCategory& aCategory,const TDesC& aDatabaseUri ) |
|
293 // Adds a landmark category to the given database. |
|
294 // ----------------------------------------------------------------------------- |
|
295 // |
|
296 EXPORT_C TPosLmItemId CLandmarkService::AddItemL( CPosLandmarkCategory& aCategory, |
|
297 const TDesC& aDatabaseUri ) |
|
298 { |
|
299 #ifdef _DEBUG |
|
300 iLog.Write(_L("CLandmarkService::AddItemL: Category")); |
|
301 #endif |
|
302 |
|
303 CLandmarkHandler* handler = iManageHandler->GetHandlerL(aDatabaseUri); |
|
304 if ( !handler ) |
|
305 { |
|
306 handler = iManageHandler->CreateHandlerL(aDatabaseUri); |
|
307 } |
|
308 CPosLmCategoryManager* cat = handler->CategoryManagerHandle(); |
|
309 |
|
310 #ifdef _DEBUG |
|
311 iLog.Write(_L("CLandmarkService::AddItemL: Category: Exit")); |
|
312 #endif |
|
313 |
|
314 return cat->AddCategoryL(aCategory); |
|
315 } |
|
316 // ----------------------------------------------------------------------------- |
|
317 // CLandmarkService::AddItemL( CPosLandmarkCategory& aCategory,const TDesC& aDatabaseUri ) |
|
318 // Adds a landmark category to the given database. |
|
319 // ----------------------------------------------------------------------------- |
|
320 // |
|
321 EXPORT_C void CLandmarkService::AddItemL( const TDesC& aDatabaseUri ) |
|
322 { |
|
323 #ifdef _DEBUG |
|
324 iLog.Write(_L("CLandmarkService::AddItemL: Database")); |
|
325 #endif |
|
326 |
|
327 HPosLmDatabaseInfo* dbInfo = HPosLmDatabaseInfo::NewLC(aDatabaseUri); |
|
328 if ( ELocalDatabase == GetDbTypeFromUri ( aDatabaseUri ) ) |
|
329 { |
|
330 iDatabaseManager->CreateDatabaseL(*dbInfo); |
|
331 } |
|
332 else |
|
333 { |
|
334 iDatabaseManager->RegisterDatabaseL(*dbInfo); |
|
335 } |
|
336 CleanupStack::PopAndDestroy(dbInfo); |
|
337 |
|
338 #ifdef _DEBUG |
|
339 iLog.Write(_L("CLandmarkService::AddItemL: Database: Exit")); |
|
340 #endif |
|
341 } |
|
342 |
|
343 // ----------------------------------------------------------------------------- |
|
344 // CLandmarkService::UpdateItemL( const CPosLandmark& aLandmark, |
|
345 // const TDesC& aDatabaseUri ) |
|
346 // Updates a landmark in the given database. |
|
347 // ----------------------------------------------------------------------------- |
|
348 // |
|
349 EXPORT_C void CLandmarkService::UpdateItemL( const CPosLandmark& aLandmark, |
|
350 const TDesC& aDatabaseUri ) |
|
351 { |
|
352 #ifdef _DEBUG |
|
353 iLog.Write(_L("CLandmarkService::UpdateItemL: Landmark")); |
|
354 #endif |
|
355 |
|
356 CLandmarkHandler* handler = iManageHandler->GetHandlerL(aDatabaseUri); |
|
357 if ( !handler ) |
|
358 { |
|
359 handler = iManageHandler->CreateHandlerL(aDatabaseUri); |
|
360 } |
|
361 CPosLandmarkDatabase* db = handler->LandmarkDatabaseHandle(); |
|
362 db->UpdateLandmarkL(aLandmark); |
|
363 |
|
364 #ifdef _DEBUG |
|
365 iLog.Write(_L("CLandmarkService::UpdateItemL: Landmark:Exit")); |
|
366 #endif |
|
367 } |
|
368 |
|
369 // ----------------------------------------------------------------------------- |
|
370 // CLandmarkService::UpdateItemL( const CPosLandmarkCategory& aCategory, |
|
371 // const TDesC& aDatabaseUri ) |
|
372 // Updates a landmark Category in the given database. |
|
373 // ----------------------------------------------------------------------------- |
|
374 // |
|
375 EXPORT_C void CLandmarkService::UpdateItemL( const CPosLandmarkCategory& aCategory, |
|
376 const TDesC& aDatabaseUri ) |
|
377 { |
|
378 #ifdef _DEBUG |
|
379 iLog.Write(_L("CLandmarkService::UpdateItemL: Category")); |
|
380 #endif |
|
381 |
|
382 CLandmarkHandler* handler = iManageHandler->GetHandlerL(aDatabaseUri); |
|
383 if ( !handler ) |
|
384 { |
|
385 handler = iManageHandler->CreateHandlerL(aDatabaseUri); |
|
386 } |
|
387 CPosLmCategoryManager* cat = handler->CategoryManagerHandle(); |
|
388 cat->UpdateCategoryL(aCategory); |
|
389 |
|
390 #ifdef _DEBUG |
|
391 iLog.Write(_L("CLandmarkService::UpdateItemL: Category; Exit")); |
|
392 #endif |
|
393 } |
|
394 |
|
395 // ----------------------------------------------------------------------------- |
|
396 // CLandmarkService::UpdateItemL( TPosLmDatabaseSettings aSettings, const TDesC& aDatabaseUri ) |
|
397 // Updates the database information in the given database. |
|
398 // ----------------------------------------------------------------------------- |
|
399 // |
|
400 EXPORT_C void CLandmarkService::UpdateItemL( TPosLmDatabaseSettings aSettings, |
|
401 const TDesC& aDatabaseUri ) |
|
402 { |
|
403 #ifdef _DEBUG |
|
404 iLog.Write(_L("CLandmarkService::UpdateItemL: Database")); |
|
405 #endif |
|
406 |
|
407 //while modifying database settings drive letter in database uri |
|
408 //should always be specified in uppercase. |
|
409 HBufC* dburi = aDatabaseUri.AllocLC(); |
|
410 //set modifiable pointer. |
|
411 TPtr modifyuri = dburi->Des(); |
|
412 |
|
413 TInt offset = aDatabaseUri.Find(KProtocolSeparator); |
|
414 if(offset>=0) |
|
415 { |
|
416 //get drive letter |
|
417 TChar drive = modifyuri[offset+KProtocolSeparator.iTypeLength]; |
|
418 //make drive uppercase. |
|
419 drive.UpperCase(); |
|
420 modifyuri[offset+KProtocolSeparator.iTypeLength] = drive; |
|
421 } |
|
422 else |
|
423 { |
|
424 //get drive letter at index-0 |
|
425 TChar drive = modifyuri[0]; |
|
426 //make drive uppercase. |
|
427 drive.UpperCase(); |
|
428 modifyuri[0] = drive; |
|
429 } |
|
430 |
|
431 iDatabaseManager->ModifyDatabaseSettingsL(*dburi,aSettings); |
|
432 CleanupStack::PopAndDestroy(dburi); |
|
433 #ifdef _DEBUG |
|
434 iLog.Write(_L("CLandmarkService::UpdateItemL: Database: Exit")); |
|
435 #endif |
|
436 } |
|
437 |
|
438 // ----------------------------------------------------------------------------- |
|
439 // CLandmarkService::LandmarkLC( const TPosLmItemId& aLandmarkId, |
|
440 // const TDesC& aDatabaseUri ) |
|
441 // Retrieves a landmark from the database. |
|
442 // ----------------------------------------------------------------------------- |
|
443 // |
|
444 EXPORT_C CPosLandmark* CLandmarkService::LandmarkLC( const TPosLmItemId& aLandmarkId, |
|
445 const TDesC& aDatabaseUri ) const |
|
446 { |
|
447 CPosLandmark* landmark = NULL; |
|
448 CleanupStack::PushL(landmark); |
|
449 CLandmarkHandler* handler = iManageHandler->GetHandlerL(aDatabaseUri); |
|
450 if ( !handler ) |
|
451 { |
|
452 handler = iManageHandler->CreateHandlerL(aDatabaseUri); |
|
453 } |
|
454 CPosLandmarkDatabase* db = handler->LandmarkDatabaseHandle(); |
|
455 CPosLmItemIterator* iterator = db->LandmarkIteratorL(); |
|
456 CleanupStack::PushL(iterator); |
|
457 TPosLmItemId lmId; |
|
458 while ( (lmId = iterator->NextL()) != KPosLmNullItemId ) |
|
459 { |
|
460 if ( aLandmarkId == lmId ) |
|
461 { |
|
462 CleanupStack::PopAndDestroy(iterator); |
|
463 CleanupStack::Pop(landmark); |
|
464 return db->ReadLandmarkLC(lmId); |
|
465 } |
|
466 } |
|
467 CleanupStack::PopAndDestroy(iterator); |
|
468 return landmark; |
|
469 } |
|
470 |
|
471 // ----------------------------------------------------------------------------- |
|
472 // CLandmarkService::CategoryLC( const TPosLmItemId& aCategoryId, |
|
473 // const TDesC& aDatabaseUri ) |
|
474 // Retrieves a category from the database. |
|
475 // ----------------------------------------------------------------------------- |
|
476 // |
|
477 EXPORT_C CPosLandmarkCategory* CLandmarkService::CategoryLC( |
|
478 const TPosLmItemId& aCategoryId, const TDesC& aDatabaseUri ) const |
|
479 { |
|
480 CPosLandmarkCategory* category = NULL; |
|
481 CleanupStack::PushL(category); |
|
482 CLandmarkHandler* handler = iManageHandler->GetHandlerL(aDatabaseUri); |
|
483 if ( !handler ) |
|
484 { |
|
485 handler = iManageHandler->CreateHandlerL(aDatabaseUri); |
|
486 } |
|
487 CPosLmCategoryManager* cat = handler->CategoryManagerHandle(); |
|
488 CPosLmItemIterator* iterator = cat->CategoryIteratorL(); |
|
489 CleanupStack::PushL(iterator); |
|
490 TPosLmItemId catId; |
|
491 while ( (catId = iterator->NextL()) != KPosLmNullItemId ) |
|
492 { |
|
493 if ( aCategoryId == catId ) |
|
494 { |
|
495 CleanupStack::PopAndDestroy(iterator); |
|
496 CleanupStack::Pop(category); |
|
497 return cat->ReadCategoryLC(catId); |
|
498 } |
|
499 } |
|
500 CleanupStack::PopAndDestroy(iterator); |
|
501 return category; |
|
502 } |
|
503 |
|
504 // ----------------------------------------------------------------------------- |
|
505 // CLandmarkService::RemoveItemL( TPosLmItemId aItemId, |
|
506 // TBool aItemIsLandmark, const TDesC& aDatabaseUri ) |
|
507 // Removes a landmark/ landmark category from the given database |
|
508 // ----------------------------------------------------------------------------- |
|
509 // |
|
510 EXPORT_C void CLandmarkService::RemoveItemL( TPosLmItemId aItemId, |
|
511 TPosItem aItemIsLandmark, const TDesC& aDatabaseUri ) |
|
512 { |
|
513 #ifdef _DEBUG |
|
514 iLog.Write(_L("CLandmarkService::RemoveItemL")); |
|
515 #endif |
|
516 |
|
517 CLandmarkHandler* handler = iManageHandler->GetHandlerL(aDatabaseUri); |
|
518 if ( !handler ) |
|
519 { |
|
520 handler = iManageHandler->CreateHandlerL(aDatabaseUri); |
|
521 } |
|
522 if ( aItemIsLandmark ) |
|
523 { |
|
524 CPosLandmarkDatabase* db = handler->LandmarkDatabaseHandle(); |
|
525 db->RemoveLandmarkL(aItemId); |
|
526 } |
|
527 else |
|
528 { |
|
529 CPosLmCategoryManager* cat = handler->CategoryManagerHandle(); |
|
530 ExecuteAndDeleteLD(cat->RemoveCategoryL(aItemId)); |
|
531 } |
|
532 |
|
533 #ifdef _DEBUG |
|
534 iLog.Write(_L("CLandmarkService::RemoveItemL:exit")); |
|
535 #endif |
|
536 } |
|
537 |
|
538 // ----------------------------------------------------------------------------- |
|
539 // CLandmarkService::RemoveItemL( const TDesC& aDatabaseUri ) |
|
540 // Removes the given database. |
|
541 // ----------------------------------------------------------------------------- |
|
542 // |
|
543 EXPORT_C void CLandmarkService::RemoveItemL( const TDesC& aDatabaseUri ) |
|
544 { |
|
545 #ifdef _DEBUG |
|
546 iLog.Write(_L("CLandmarkService::RemoveItemL: Database")); |
|
547 #endif |
|
548 |
|
549 if ( ELocalDatabase == GetDbTypeFromUri (aDatabaseUri) ) |
|
550 { |
|
551 // will leave with KErrInUse if it is in use. |
|
552 iDatabaseManager->DeleteDatabaseL(aDatabaseUri); |
|
553 } |
|
554 else |
|
555 { |
|
556 // this is for remote databases and it will remove this |
|
557 // database from being listed. |
|
558 iDatabaseManager->UnregisterDatabaseL(aDatabaseUri); |
|
559 } |
|
560 |
|
561 #ifdef _DEBUG |
|
562 iLog.Write(_L("CLandmarkService::RemoveItemL: Database: Exit")); |
|
563 #endif |
|
564 } |
|
565 |
|
566 // ----------------------------------------------------------------------------- |
|
567 // CLandmarkService::SetActiveL( const TDesC& aDatabaseUri ) |
|
568 // sets the given database as default. |
|
569 // ----------------------------------------------------------------------------- |
|
570 // |
|
571 EXPORT_C void CLandmarkService::SetActiveL( const TDesC& aDatabaseUri ) |
|
572 { |
|
573 #ifdef _DEBUG |
|
574 iLog.Write(_L("CLandmarkService::SetActiveL: Database")); |
|
575 #endif |
|
576 |
|
577 CLandmarkHandler* handler = iManageHandler->GetHandlerL(aDatabaseUri); |
|
578 if ( !handler ) |
|
579 { |
|
580 handler = iManageHandler->CreateHandlerL(aDatabaseUri); |
|
581 } |
|
582 iManageHandler->SetDefaultHandler(handler); |
|
583 |
|
584 #ifdef _DEBUG |
|
585 iLog.Write(_L("CLandmarkService::SetActiveL: Database: Exit")); |
|
586 #endif |
|
587 } |
|
588 |
|
589 // ----------------------------------------------------------------------------- |
|
590 // CLandmarkService::LinkCategoryToLandmarksL( TPosLmItemId aCategoryId, |
|
591 // RArray< TPosLmItemId >& aLandmarkIdArray, const TDesC& aDatabaseUri ) |
|
592 // associates a category to a set of landmarks. |
|
593 // ----------------------------------------------------------------------------- |
|
594 // |
|
595 EXPORT_C void CLandmarkService::LinkCategoryToLandmarksL ( TPosLmItemId aCategoryId, |
|
596 RArray<TPosLmItemId>& aLandmarkIdArray, const TDesC& aDatabaseUri ) |
|
597 { |
|
598 #ifdef _DEBUG |
|
599 iLog.Write(_L("CLandmarkService::LinkCategoryToLandmarksL")); |
|
600 #endif |
|
601 |
|
602 CLandmarkHandler* handler = iManageHandler->GetHandlerL(aDatabaseUri); |
|
603 if ( !handler ) |
|
604 { |
|
605 handler = iManageHandler->CreateHandlerL(aDatabaseUri); |
|
606 } |
|
607 CPosLmCategoryManager* cat = handler->CategoryManagerHandle(); |
|
608 ExecuteAndDeleteLD(cat->AddCategoryToLandmarksL(aCategoryId,aLandmarkIdArray)); |
|
609 |
|
610 #ifdef _DEBUG |
|
611 iLog.Write(_L("CLandmarkService::LinkCategoryToLandmarksL: Exit")); |
|
612 #endif |
|
613 } |
|
614 |
|
615 // ----------------------------------------------------------------------------- |
|
616 // CLandmarkService::UnlinkCategoryToLandmarksL( TPosLmItemId aCategoryId, |
|
617 // RArray< TPosLmItemId >& aLandmarkIdArray, const TDesC& aDatabaseUri ) |
|
618 // associates a category to a set of landmarks. |
|
619 // ----------------------------------------------------------------------------- |
|
620 // |
|
621 EXPORT_C void CLandmarkService::UnlinkCategoryToLandmarksL ( |
|
622 TPosLmItemId aCategoryId, RArray<TPosLmItemId>& aLandmarkIdArray, |
|
623 const TDesC& aDatabaseUri ) |
|
624 { |
|
625 #ifdef _DEBUG |
|
626 iLog.Write(_L("CLandmarkService::UnlinkCategoryToLandmarksL")); |
|
627 #endif |
|
628 |
|
629 CLandmarkHandler* handler = iManageHandler->GetHandlerL(aDatabaseUri); |
|
630 if ( !handler ) |
|
631 { |
|
632 handler = iManageHandler->CreateHandlerL(aDatabaseUri); |
|
633 } |
|
634 CPosLmCategoryManager* cat = handler->CategoryManagerHandle(); |
|
635 ExecuteAndDeleteLD(cat->RemoveCategoryFromLandmarksL(aCategoryId,aLandmarkIdArray)); |
|
636 |
|
637 #ifdef _DEBUG |
|
638 iLog.Write(_L("CLandmarkService::UnlinkCategoryToLandmarksL: Exit")); |
|
639 #endif |
|
640 } |
|
641 |
|
642 // ----------------------------------------------------------------------------- |
|
643 // CLandmarkService::RegisterObserver( MLandmarkObserver* aObserver ) |
|
644 // Register an observer for aynsc method. |
|
645 // ----------------------------------------------------------------------------- |
|
646 // |
|
647 EXPORT_C void CLandmarkService::RegisterObserver( MLandmarkObserver* aObserver ) |
|
648 { |
|
649 if ( iObserver ) |
|
650 { |
|
651 delete iObserver; |
|
652 iObserver = NULL; |
|
653 } |
|
654 iObserver = aObserver; |
|
655 } |
|
656 |
|
657 // ----------------------------------------------------------------------------- |
|
658 // CLandmarkService::Cancel( TInt32 aTransactionId ) |
|
659 // Cancel an ongoing async request. |
|
660 // ----------------------------------------------------------------------------- |
|
661 // |
|
662 EXPORT_C void CLandmarkService::Cancel( TInt32 aTransactionId ) const |
|
663 { |
|
664 if ( iManageObjects ) |
|
665 { |
|
666 iManageObjects->CancelObject(aTransactionId); |
|
667 } |
|
668 } |
|
669 |
|
670 // ----------------------------------------------------------------------------- |
|
671 // CLandmarkService::GetDefaultDbUri( TPtrC& aDefaultDbUri ) const |
|
672 // Gets the deafult Database URI. |
|
673 // ----------------------------------------------------------------------------- |
|
674 // |
|
675 EXPORT_C void CLandmarkService::GetDefaultDbUriL( TPtrC& aDefaultDbUri ) const |
|
676 { |
|
677 CLandmarkHandler* handler = iManageHandler->GetHandlerL(KNullDesC); |
|
678 if ( handler ) |
|
679 { |
|
680 handler->GetDatabaseUri(aDefaultDbUri); |
|
681 } |
|
682 } |
|
683 // ----------------------------------------------------------------------------- |
|
684 // CLandmarkService::GetDbTypeFromUri( const TDesC& aDbUri ) |
|
685 // returns type of database. |
|
686 // ----------------------------------------------------------------------------- |
|
687 // |
|
688 CLandmarkService::TDatabaseType CLandmarkService::GetDbTypeFromUri( |
|
689 const TDesC& aDbUri ) const |
|
690 { |
|
691 CLandmarkService::TDatabaseType type = ERemoteDatabase; |
|
692 TInt offset = aDbUri.Find (KProtocolSeparator ); |
|
693 if ( KErrNotFound == offset ) |
|
694 { |
|
695 type = ELocalDatabase; |
|
696 } |
|
697 else |
|
698 { |
|
699 const TPtrC DbProtocol = aDbUri.Left (offset ); |
|
700 if ( DbProtocol == KLocalProtocol ) |
|
701 { |
|
702 type = ELocalDatabase; |
|
703 } |
|
704 } |
|
705 return type; |
|
706 } |
|
707 |
|
708 // End of File |