293 { |
293 { |
294 iErrMsg = KIncorrectAsyncReq().AllocL ( ); |
294 iErrMsg = KIncorrectAsyncReq().AllocL ( ); |
295 User::Leave (SErrInvalidServiceArgument ); |
295 User::Leave (SErrInvalidServiceArgument ); |
296 } |
296 } |
297 |
297 |
298 if ( !aCmdName.CompareF(KCancel) && (KLiwOptCancel & aCmdOptions) ) |
298 if (!aCmdName.CompareF(KCancel) && (KLiwOptCancel & aCmdOptions)) |
299 { |
299 { |
300 Cancel (aInParamList, aOutParamList, aCmdOptions, aCallback ); |
300 Cancel(aInParamList, aOutParamList, aCmdOptions, aCallback); |
301 } |
301 } |
302 else |
302 else if (!aCmdName.CompareF(KGetList)) |
303 if ( !aCmdName.CompareF(KGetList) ) |
303 { |
304 { |
304 GetListL(aInParamList, aOutParamList, aCmdOptions, aCallback); |
305 GetListL (aInParamList, aOutParamList, aCmdOptions, aCallback ); |
305 } |
306 } |
306 else if (!aCmdName.CompareF(KAdd)) |
307 else |
307 { |
308 //since no other APIs support async return error if callback is |
308 AddL(aInParamList, aOutParamList, aCmdOptions, aCallback); |
309 //provide |
309 } |
310 if ( aCallback ) |
310 else if (!aCmdName.CompareF(KRemove)) |
311 { |
311 { |
312 iErrMsg = KAsyncNotSupported().AllocL ( ); |
312 RemoveL(aInParamList, aOutParamList, aCmdOptions, aCallback); |
313 User::Leave (SErrInvalidServiceArgument ); |
313 } |
314 } |
314 else if (!aCmdName.CompareF(KOrganise)) |
315 else |
315 { |
316 if ( !aCmdName.CompareF(KAdd) ) |
316 OrganiseL(aInParamList, aOutParamList, aCmdOptions, aCallback); |
317 { |
317 } |
318 AddL (aInParamList, aOutParamList, aCmdOptions, aCallback ); |
318 else if (!aCmdName.CompareF(KImport)) |
319 } |
319 { |
320 else |
320 ImportL(aInParamList, aOutParamList, aCmdOptions, aCallback); |
321 if ( !aCmdName.CompareF(KRemove) ) |
321 } |
322 { |
322 else if (!aCmdName.CompareF(KExport)) |
323 RemoveL (aInParamList, aOutParamList, aCmdOptions, |
323 { |
324 aCallback ); |
324 ExportL(aInParamList, aOutParamList, aCmdOptions, aCallback); |
325 } |
325 } |
326 else |
326 else |
327 if ( !aCmdName.CompareF(KOrganise) ) |
327 //since no other APIs support async return error if callback is |
328 { |
328 //provide |
329 OrganiseL (aInParamList, aOutParamList, |
329 if (aCallback) |
330 aCmdOptions, aCallback ); |
330 { |
331 } |
331 iErrMsg = KAsyncNotSupported().AllocL(); |
332 else |
332 User::Leave(SErrInvalidServiceArgument); |
333 if ( !aCmdName.CompareF(KImport) ) |
333 } |
334 { |
334 else if (!aCmdName.CompareF(KNew)) |
335 ImportL (aInParamList, aOutParamList, |
335 { |
336 aCmdOptions, aCallback ); |
336 NewTemplateL(aInParamList, aOutParamList, aCmdOptions, aCallback); |
337 } |
337 } |
338 else |
338 else |
339 if ( !aCmdName.CompareF(KExport) ) |
339 { |
340 { |
340 // invalid command return error in outparam list |
341 ExportL (aInParamList, aOutParamList, |
341 iErrMsg = KInvalidServiceCmd().AllocL(); |
342 aCmdOptions, aCallback ); |
342 User::Leave(SErrInvalidServiceArgument); |
343 } |
343 } |
344 else |
344 } |
345 if ( !aCmdName.CompareF(KNew) ) |
|
346 { |
|
347 NewTemplateL (aInParamList, |
|
348 aOutParamList, aCmdOptions, |
|
349 aCallback ); |
|
350 } |
|
351 else |
|
352 { |
|
353 // invalid command return error in outparam list |
|
354 iErrMsg = KInvalidServiceCmd().AllocL ( ); |
|
355 User::Leave (SErrInvalidServiceArgument ); |
|
356 } |
|
357 } |
|
358 |
345 |
359 // --------------------------------------------------------------------------- |
346 // --------------------------------------------------------------------------- |
360 // CLandmarkInterface::GetListL(const CLiwGenericParamList& aInParamList, |
347 // CLandmarkInterface::GetListL(const CLiwGenericParamList& aInParamList, |
361 // CLiwGenericParamList& aOutParamList, |
348 // CLiwGenericParamList& aOutParamList, |
362 // TUint aCmdOptions, |
349 // TUint aCmdOptions, |
435 // TUint /*aCmdOptions*/, |
422 // TUint /*aCmdOptions*/, |
436 // MLiwNotifyCallback* /*aCallback*/ ) |
423 // MLiwNotifyCallback* /*aCallback*/ ) |
437 // This function calls the appropriate functions based on the content type. |
424 // This function calls the appropriate functions based on the content type. |
438 // --------------------------------------------------------------------------- |
425 // --------------------------------------------------------------------------- |
439 // |
426 // |
440 void CLandmarkInterface::AddL( const CLiwGenericParamList& aInParamList, |
427 void CLandmarkInterface::AddL(const CLiwGenericParamList& aInParamList, |
441 CLiwGenericParamList& aOutParamList, TUint /*aCmdOptions*/, |
428 CLiwGenericParamList& aOutParamList, TUint aCmdOptions, |
442 MLiwNotifyCallback* /*aCallback*/) |
429 MLiwNotifyCallback* aCallback) |
443 { |
430 { |
444 //Input param List must have contentType and data specified |
431 //Input param List must have contentType and data specified |
445 if ( aInParamList.Count ( )< EIndex2 ) |
432 if (aInParamList.Count() < EIndex2) |
446 { |
433 { |
447 ErrorMessageL (KAdd, KArgsMissing ); |
434 ErrorMessageL(KAdd, KArgsMissing); |
448 iErrMsg->Des().Append (KMissing ); |
435 iErrMsg->Des().Append(KMissing); |
449 //leave since argument is improper |
436 //leave since argument is improper |
450 User::Leave (SErrMissingArgument ); |
437 User::Leave(SErrMissingArgument); |
451 } |
438 } |
452 |
439 |
453 //position to start search in input params |
440 //position to start search in input params |
454 TInt index = 0; |
441 TInt index = 0; |
455 //get content type |
442 //get content type |
456 const TLiwGenericParam* param = &aInParamList[EIndex0]; |
443 const TLiwGenericParam* param = &aInParamList[EIndex0]; |
469 |
456 |
470 TLiwVariant variant(param->Value ( )); |
457 TLiwVariant variant(param->Value ( )); |
471 ValidateParamL (KAdd, KContentType, variant, LIW::EVariantTypeDesC ); |
458 ValidateParamL (KAdd, KContentType, variant, LIW::EVariantTypeDesC ); |
472 TPtrC contentType(variant.AsDes ( )); |
459 TPtrC contentType(variant.AsDes ( )); |
473 |
460 |
474 //Content type is Landmark |
461 //Content type is Landmark |
475 if ( contentType == KLandmark ) |
462 if (contentType == KLandmark) |
476 { |
463 { |
477 AddLandmarksL (aInParamList,aOutParamList ); |
464 AddLandmarksL(aInParamList, aOutParamList, aCmdOptions, aCallback); |
478 } |
465 } |
479 //Content type is Category. |
466 //Content type is Category. |
480 else |
467 else if (contentType == KCategory) |
481 if ( contentType == KCategory ) |
468 { |
482 { |
469 AddCategoryL(aInParamList, aOutParamList, aCmdOptions, aCallback); |
483 AddCategoryL (aInParamList,aOutParamList ); |
470 } |
484 } |
471 else |
485 else |
472 { |
486 { |
473 ErrorMessageL(KAdd, KContentType); |
487 ErrorMessageL (KAdd, KContentType ); |
474 iErrMsg->Des().Append(KInvalid); |
488 iErrMsg->Des().Append (KInvalid ); |
475 //leave since argument is improper |
489 //leave since argument is improper |
476 User::Leave(SErrInvalidServiceArgument); |
490 User::Leave (SErrInvalidServiceArgument ); |
477 } |
491 } |
478 } |
492 } |
|
493 |
479 |
494 // --------------------------------------------------------------------------- |
480 // --------------------------------------------------------------------------- |
495 // CLandmarkInterface::RemoveL(const CLiwGenericParamList& aInParamList, |
481 // CLandmarkInterface::RemoveL(const CLiwGenericParamList& aInParamList, |
496 // CLiwGenericParamList& /*aOutParamList*/, |
482 // CLiwGenericParamList& /*aOutParamList*/, |
497 // TUint /*aCmdOptions*/, |
483 // TUint /*aCmdOptions*/, |
498 // MLiwNotifyCallback* /*aCallback*/ ) |
484 // MLiwNotifyCallback* /*aCallback*/ ) |
499 // This calls the appropriate service function based on the content type. |
485 // This calls the appropriate service function based on the content type. |
500 // --------------------------------------------------------------------------- |
486 // --------------------------------------------------------------------------- |
501 // |
487 // |
502 void CLandmarkInterface::RemoveL( const CLiwGenericParamList& aInParamList, |
488 void CLandmarkInterface::RemoveL(const CLiwGenericParamList& aInParamList, |
503 CLiwGenericParamList& /*aOutParamList*/, TUint /*aCmdOptions*/, |
489 CLiwGenericParamList& aOutParamList, TUint /*aCmdOptions*/, |
504 MLiwNotifyCallback* /*aCallback*/) |
490 MLiwNotifyCallback* aCallback) |
505 { |
491 { |
506 //Input param List must have contentType and data specified |
492 //Input param List must have contentType and data specified |
507 if ( aInParamList.Count ( )< EIndex2 ) |
493 if (aInParamList.Count() < EIndex2) |
508 { |
494 { |
509 ErrorMessageL (KAdd, KArgsMissing ); |
495 ErrorMessageL (KAdd, KArgsMissing ); |
510 iErrMsg->Des().Append (KMissing ); |
496 iErrMsg->Des().Append (KMissing ); |
511 //leave since argument is improper |
497 //leave since argument is improper |
512 User::Leave (SErrMissingArgument ); |
498 User::Leave (SErrMissingArgument ); |
560 } |
546 } |
561 } |
547 } |
562 variant = param->Value ( ); |
548 variant = param->Value ( ); |
563 ValidateParamL (KRemove, KDataFields, variant, LIW::EVariantTypeMap ); |
549 ValidateParamL (KRemove, KDataFields, variant, LIW::EVariantTypeMap ); |
564 const CLiwMap* landmarkMap = variant.AsMap ( ); |
550 const CLiwMap* landmarkMap = variant.AsMap ( ); |
565 CleanupStack::PushL( |
551 CleanupStack::PushL(TCleanupItem(TLiwVariant::VariantCleanup, &variant)); |
566 TCleanupItem( TLiwVariant::VariantCleanup, &variant ) ); |
552 ValidateParamL(KRemove, KId, landmarkMap, LIW::EVariantTypeDesC, ETrue, |
567 ValidateParamL (KRemove, KId, landmarkMap, |
553 variant); |
568 LIW::EVariantTypeDesC, ETrue, variant ); |
554 TPtrC lmPtr(variant.AsDes()); |
569 TPtrC lmPtr(variant.AsDes ( )); |
555 TLex lmparseString(lmPtr); //Get Id as string and convert to TUint32 |
570 TLex lmparseString(lmPtr); //Get Id as string and convert to TUint32 |
556 TPosLmItemId lmid; |
571 TPosLmItemId lmid; |
557 TInt parseErr = lmparseString.Val(lmid, EDecimal); |
572 TInt parseErr = lmparseString.Val (lmid, EDecimal ); |
|
573 TBuf<KMaxIDStringLength> lmIdString(KNullDesC ( )); |
558 TBuf<KMaxIDStringLength> lmIdString(KNullDesC ( )); |
574 if ( !parseErr ) |
559 if ( !parseErr ) |
575 { |
560 { |
576 lmIdString.Num (lmid ); |
561 lmIdString.Num (lmid ); |
577 } |
562 } |
585 if (ValidateParamL (KRemove, KDbUri, landmarkMap, |
570 if (ValidateParamL (KRemove, KDbUri, landmarkMap, |
586 LIW::EVariantTypeDesC, EFalse, variant ) ) |
571 LIW::EVariantTypeDesC, EFalse, variant ) ) |
587 { |
572 { |
588 dbUri.Set (variant.AsDes ( ) ); |
573 dbUri.Set (variant.AsDes ( ) ); |
589 } |
574 } |
590 iService->RemoveItemL (lmid, CLandmarkService::ELandmark, dbUri ); |
575 //Async Call |
|
576 if (aCallback) |
|
577 { |
|
578 //Get the transaction ID |
|
579 TInt32 transactionId(aCallback->GetTransactionID()); |
|
580 CLandmarkCallbackMap* map = new (ELeave) CLandmarkCallbackMap( |
|
581 transactionId, aCallback); |
|
582 CleanupStack::PushL(map); |
|
583 iCallbackMap.AppendL(map); |
|
584 CleanupStack::Pop(map); |
|
585 iService->RemoveItemL(transactionId, lmid, |
|
586 CLandmarkService::ELandmark, dbUri); |
|
587 aOutParamList.AppendL(TLiwGenericParam(KTransactionId, TLiwVariant( |
|
588 TInt32(transactionId)))); |
|
589 } |
|
590 else //sync call |
|
591 { |
|
592 iService->RemoveItemL(lmid, CLandmarkService::ELandmark, dbUri); |
|
593 } |
591 CleanupStack::PopAndDestroy(&variant); |
594 CleanupStack::PopAndDestroy(&variant); |
592 } |
595 } |
593 //Content type is Category. |
596 //Content type is Category. |
594 else |
597 else if (contentType == KCategory) |
595 if ( contentType == KCategory ) |
598 { |
596 { |
599 index = 0; |
597 index = 0; |
600 if (posBased) |
598 if ( posBased ) |
601 { |
599 { |
602 param = &aInParamList[EIndex1]; |
600 param = &aInParamList[EIndex1]; |
603 } |
601 } |
604 else |
602 else |
605 { |
603 { |
606 param = aInParamList.FindFirst(index, KDataFields); |
604 param = aInParamList.FindFirst (index, KDataFields ); |
607 if (!param) |
605 if ( !param ) |
608 { |
606 { |
609 ErrorMessageL(KRemove, KDataFields); |
607 ErrorMessageL (KRemove, KDataFields ); |
610 iErrMsg->Des().Append(KMissing); |
608 iErrMsg->Des().Append (KMissing ); |
611 //leave since argument is improper |
609 //leave since argument is improper |
612 User::Leave(SErrMissingArgument); |
610 User::Leave (SErrMissingArgument ); |
613 } |
611 } |
614 } |
612 } |
615 variant = param->Value(); |
613 variant = param->Value ( ); |
616 ValidateParamL(KRemove, KDataFields, variant, LIW::EVariantTypeMap); |
614 ValidateParamL (KRemove, KDataFields, variant, LIW::EVariantTypeMap ); |
617 const CLiwMap* categoryMap = variant.AsMap(); |
615 const CLiwMap* categoryMap = variant.AsMap ( ); |
618 CleanupStack::PushL(TCleanupItem(TLiwVariant::VariantCleanup, &variant)); |
616 CleanupStack::PushL( |
619 ValidateParamL(KRemove, KId, categoryMap, LIW::EVariantTypeDesC, ETrue, |
617 TCleanupItem( TLiwVariant::VariantCleanup, &variant ) ); |
620 variant); |
618 ValidateParamL (KRemove, KId, categoryMap, |
621 TPtrC catPtr(variant.AsDes()); |
619 LIW::EVariantTypeDesC, ETrue, variant ); |
|
620 TPtrC catPtr(variant.AsDes ( )); |
|
621 TLex catparseString(catPtr); //Get Id as string and convert to TUint32 |
622 TLex catparseString(catPtr); //Get Id as string and convert to TUint32 |
622 TPosLmItemId catid; |
623 TPosLmItemId catid; |
623 TInt parseErr = catparseString.Val (catid, EDecimal ); |
624 TInt parseErr = catparseString.Val (catid, EDecimal ); |
624 TBuf<KMaxIDStringLength> catIdString(KNullDesC ( )); |
625 TBuf<KMaxIDStringLength> catIdString(KNullDesC ( )); |
625 if ( !parseErr ) |
626 if ( !parseErr ) |
636 if (ValidateParamL (KRemove, KDbUri, categoryMap, |
637 if (ValidateParamL (KRemove, KDbUri, categoryMap, |
637 LIW::EVariantTypeDesC, EFalse, variant ) ) |
638 LIW::EVariantTypeDesC, EFalse, variant ) ) |
638 { |
639 { |
639 dbUri.Set (variant.AsDes ( ) ); |
640 dbUri.Set (variant.AsDes ( ) ); |
640 } |
641 } |
641 iService->RemoveItemL (catid, CLandmarkService::ECategory, dbUri ); |
642 //Async Call |
|
643 if (aCallback) |
|
644 { |
|
645 //Get the transaction ID |
|
646 TInt32 transactionId(aCallback->GetTransactionID()); |
|
647 CLandmarkCallbackMap* map = new (ELeave) CLandmarkCallbackMap( |
|
648 transactionId, aCallback); |
|
649 CleanupStack::PushL(map); |
|
650 iCallbackMap.AppendL(map); |
|
651 CleanupStack::Pop(map); |
|
652 iService->RemoveItemL(transactionId, catid, |
|
653 CLandmarkService::ECategory, dbUri); |
|
654 aOutParamList.AppendL(TLiwGenericParam(KTransactionId, TLiwVariant( |
|
655 TInt32(transactionId)))); |
|
656 } |
|
657 else //sync call |
|
658 { |
|
659 iService->RemoveItemL(catid, CLandmarkService::ECategory, dbUri); |
|
660 } |
642 CleanupStack::PopAndDestroy(&variant); |
661 CleanupStack::PopAndDestroy(&variant); |
643 } |
662 } |
644 else |
663 else |
645 { |
664 { |
646 ErrorMessageL (KRemove, KContentType ); |
665 ErrorMessageL (KRemove, KContentType ); |
658 // This calls the appropriate service function for importing landmarks. |
677 // This calls the appropriate service function for importing landmarks. |
659 // --------------------------------------------------------------------------- |
678 // --------------------------------------------------------------------------- |
660 // |
679 // |
661 void CLandmarkInterface::ImportL( const CLiwGenericParamList& aInParamList, |
680 void CLandmarkInterface::ImportL( const CLiwGenericParamList& aInParamList, |
662 CLiwGenericParamList& aOutParamList, TUint /*aCmdOptions*/, |
681 CLiwGenericParamList& aOutParamList, TUint /*aCmdOptions*/, |
663 MLiwNotifyCallback* /*aCallback*/) |
682 MLiwNotifyCallback* aCallback) |
664 { |
683 { |
665 //Input param List must have contentType and importData specified |
684 //Input param List must have contentType and importData specified |
666 if ( aInParamList.Count ( )< EIndex2 ) |
685 if ( aInParamList.Count ( )< EIndex2 ) |
667 { |
686 { |
668 ErrorMessageL (KAdd, KArgsMissing ); |
687 ErrorMessageL (KAdd, KArgsMissing ); |
756 if (ValidateParamL (KImport, KDbUri, importData, LIW::EVariantTypeDesC, |
775 if (ValidateParamL (KImport, KDbUri, importData, LIW::EVariantTypeDesC, |
757 EFalse, variant ) ) |
776 EFalse, variant ) ) |
758 { |
777 { |
759 dbUri.Set (variant.AsDes ( ) ); |
778 dbUri.Set (variant.AsDes ( ) ); |
760 } |
779 } |
761 CPosLmItemIterator* iterator= NULL; |
780 //Async Call |
762 //call the service function for import |
781 if (aCallback) |
763 iService->ImportL (iterator, *parser, dbUri ); |
782 { |
764 CleanupStack::PopAndDestroy (parser ); |
783 //Get the transaction ID |
|
784 TInt32 transactionId(aCallback->GetTransactionID()); |
|
785 CLandmarkCallbackMap* map = new (ELeave) CLandmarkCallbackMap( |
|
786 transactionId, aCallback); |
|
787 CleanupStack::PushL(map); |
|
788 iCallbackMap.AppendL(map); |
|
789 CleanupStack::Pop(map); |
|
790 iService->ImportL(transactionId, *parser, dbUri); |
|
791 aOutParamList.AppendL(TLiwGenericParam(KTransactionId, TLiwVariant( |
|
792 TInt32(transactionId)))); |
|
793 CleanupStack::Pop (parser ); |
|
794 } |
|
795 else //sync call |
|
796 { |
|
797 CPosLmItemIterator* iterator= NULL; |
|
798 //call the service function for import |
|
799 iService->ImportL (iterator, *parser, dbUri ); |
|
800 CleanupStack::PushL(iterator); |
|
801 // if dbURI is not specified retrieve default databse URI |
|
802 if ( dbUri == KNullDesC ) |
|
803 { |
|
804 iService->GetDefaultDbUriL (dbUri ); |
|
805 } |
|
806 //instantiate CLandmarkIterable |
|
807 CLiwIterable* iterable = CLandmarkIterable::NewL (iterator, dbUri ); |
|
808 CleanupStack::Pop(iterator); |
|
809 CleanupClosePushL(*iterable); |
|
810 aOutParamList.AppendL (TLiwGenericParam (KReturnValue, |
|
811 TLiwVariant (iterable ) ) ); |
|
812 CleanupStack::PopAndDestroy(iterable); |
|
813 CleanupStack::PopAndDestroy (parser ); |
|
814 } |
|
815 |
|
816 |
765 CleanupStack::PopAndDestroy (mimeType8 ); |
817 CleanupStack::PopAndDestroy (mimeType8 ); |
766 CleanupStack::PushL(iterator); |
|
767 // if dbURI is not specified retrieve default databse URI |
|
768 if ( dbUri == KNullDesC ) |
|
769 { |
|
770 iService->GetDefaultDbUriL (dbUri ); |
|
771 } |
|
772 //instantiate CLandmarkIterable |
|
773 CLiwIterable* iterable = CLandmarkIterable::NewL (iterator, dbUri ); |
|
774 CleanupStack::Pop(iterator); |
|
775 CleanupClosePushL(*iterable); |
|
776 aOutParamList.AppendL (TLiwGenericParam (KReturnValue, |
|
777 TLiwVariant (iterable ) ) ); |
|
778 CleanupStack::PopAndDestroy(iterable); |
|
779 CleanupStack::PopAndDestroy(&variant); |
818 CleanupStack::PopAndDestroy(&variant); |
780 } |
819 } |
781 else |
820 else |
782 { |
821 { |
783 ErrorMessageL (KImport, KContentType ); |
822 ErrorMessageL (KImport, KContentType ); |
794 // MLiwNotifyCallback* /*aCallback*/ ) |
833 // MLiwNotifyCallback* /*aCallback*/ ) |
795 // This calls the appropriate service function for exporting landmarks. |
834 // This calls the appropriate service function for exporting landmarks. |
796 // --------------------------------------------------------------------------- |
835 // --------------------------------------------------------------------------- |
797 // |
836 // |
798 void CLandmarkInterface::ExportL( const CLiwGenericParamList& aInParamList, |
837 void CLandmarkInterface::ExportL( const CLiwGenericParamList& aInParamList, |
799 CLiwGenericParamList& /*aOutParamList*/, TUint /*aCmdOptions*/, |
838 CLiwGenericParamList& aOutParamList, TUint /*aCmdOptions*/, |
800 MLiwNotifyCallback* /*aCallback*/) |
839 MLiwNotifyCallback* aCallback) |
801 { |
840 { |
802 //Input param List must have contentType and exportData specified |
841 //Input param List must have contentType and exportData specified |
803 if ( aInParamList.Count ( )< EIndex2 ) |
842 if ( aInParamList.Count ( )< EIndex2 ) |
804 { |
843 { |
805 ErrorMessageL (KAdd, KArgsMissing ); |
844 ErrorMessageL (KAdd, KArgsMissing ); |
865 ErrorMessageL (KExport, KDestinationFile ); |
904 ErrorMessageL (KExport, KDestinationFile ); |
866 iErrMsg->Des().Append (KInvalid ); |
905 iErrMsg->Des().Append (KInvalid ); |
867 //leave since argument is improper |
906 //leave since argument is improper |
868 User::Leave (SErrInvalidServiceArgument ); |
907 User::Leave (SErrInvalidServiceArgument ); |
869 } |
908 } |
870 ValidateParamL (KExport, KMimeType, exportData, LIW::EVariantTypeDesC, |
909 |
871 ETrue, variant ); |
|
872 if( variant.AsDes() == KNullDesC ) |
|
873 { |
|
874 ErrorMessageL (KExport, KMimeType ); |
|
875 iErrMsg->Des().Append (KInvalid ); |
|
876 //leave since argument is improper |
|
877 User::Leave (SErrInvalidServiceArgument ); |
|
878 } |
|
879 //instantiate CPosLandmarkEncoder based on mime type. |
|
880 HBufC8* mimeType8 = |
|
881 CnvUtfConverter::ConvertFromUnicodeToUtf8L ( variant.AsDes ( ) ); |
|
882 CleanupStack::PushL( mimeType8 ); |
|
883 CPosLandmarkEncoder* encoder = CPosLandmarkEncoder::NewL ( *mimeType8 ); |
|
884 CleanupStack::PushL (encoder ); |
|
885 CBufBase* exportBuffer = encoder->SetUseOutputBufferL(); |
|
886 CleanupStack::PushL(exportBuffer); |
|
887 ValidateParamL (KExport, KIdList, exportData, |
910 ValidateParamL (KExport, KIdList, exportData, |
888 LIW::EVariantTypeList, ETrue, variant ); |
911 LIW::EVariantTypeList, ETrue, variant ); |
889 const CLiwList* lmList = variant.AsList ( ); |
912 const CLiwList* lmList = variant.AsList ( ); |
890 TInt lmcount = lmList->Count ( ); |
913 TInt lmcount = lmList->Count ( ); |
891 if ( !lmcount ) |
914 if ( !lmcount ) |
927 if (ValidateParamL (KExport, KDbUri, exportData, LIW::EVariantTypeDesC, |
950 if (ValidateParamL (KExport, KDbUri, exportData, LIW::EVariantTypeDesC, |
928 EFalse, variant ) ) |
951 EFalse, variant ) ) |
929 { |
952 { |
930 dbUri.Set (variant.AsDes ( ) ); |
953 dbUri.Set (variant.AsDes ( ) ); |
931 } |
954 } |
932 iService->ExportL (*encoder, landmarkIdArray, dbUri ); |
955 ValidateParamL (KExport, KMimeType, exportData, LIW::EVariantTypeDesC, |
933 ExecuteAndDeleteLD (encoder->FinalizeEncodingL ( ) ); |
956 ETrue, variant ); |
934 //Write to file |
957 if( variant.AsDes() == KNullDesC ) |
|
958 { |
|
959 ErrorMessageL (KExport, KMimeType ); |
|
960 iErrMsg->Des().Append (KInvalid ); |
|
961 //leave since argument is improper |
|
962 User::Leave (SErrInvalidServiceArgument ); |
|
963 } |
|
964 //instantiate CPosLandmarkEncoder based on mime type. |
|
965 HBufC8* mimeType8 = |
|
966 CnvUtfConverter::ConvertFromUnicodeToUtf8L ( variant.AsDes ( ) ); |
|
967 CleanupStack::PushL( mimeType8 ); |
|
968 CPosLandmarkEncoder* encoder = CPosLandmarkEncoder::NewL ( *mimeType8 ); |
|
969 CleanupStack::PushL (encoder ); |
935 ValidateParamL (KExport, KDestinationFile, exportData, |
970 ValidateParamL (KExport, KDestinationFile, exportData, |
936 LIW::EVariantTypeDesC, ETrue, variant ); |
971 LIW::EVariantTypeDesC, ETrue, variant ); |
937 RFs fs; |
972 |
938 User::LeaveIfError(fs.Connect()); |
973 |
939 CleanupClosePushL(fs); |
974 |
940 RFile file; |
975 //Async Call |
941 CleanupClosePushL(file); |
976 if (aCallback) |
942 User::LeaveIfError(file.Create(fs, variant.AsDes(), |
977 { |
943 EFileShareExclusive | EFileStreamText | EFileWrite)); |
978 //Get the transaction ID |
944 TInt size = exportBuffer->Size(); |
979 TInt32 transactionId(aCallback->GetTransactionID()); |
945 for( TInt i = 0; i < size; ++i ) |
980 CLandmarkCallbackMap* map = new (ELeave) CLandmarkCallbackMap( |
946 { |
981 transactionId, aCallback); |
947 file.Write(i,exportBuffer->Ptr(i)); |
982 CleanupStack::PushL(map); |
948 } |
983 iCallbackMap.AppendL(map); |
949 CleanupStack::PopAndDestroy(&file); |
984 CleanupStack::Pop(map); |
950 CleanupStack::PopAndDestroy(&fs); |
985 iService->ExportL(transactionId, *encoder, landmarkIdArray, |
951 CleanupStack::PopAndDestroy (&landmarkIdArray ); |
986 variant.AsDes(), dbUri); |
952 CleanupStack::PopAndDestroy (exportBuffer); |
987 CleanupStack::Pop(encoder ); |
953 CleanupStack::PopAndDestroy (encoder ); |
988 aOutParamList.AppendL(TLiwGenericParam(KTransactionId, TLiwVariant( |
954 CleanupStack::PopAndDestroy (mimeType8 ); |
989 TInt32(transactionId)))); |
|
990 } |
|
991 else //sync call |
|
992 { |
|
993 CBufBase* exportBuffer = encoder->SetUseOutputBufferL(); |
|
994 CleanupStack::PushL(exportBuffer); |
|
995 iService->ExportL (*encoder, landmarkIdArray, dbUri ); |
|
996 ExecuteAndDeleteLD (encoder->FinalizeEncodingL ( ) ); |
|
997 //Write to file |
|
998 RFs fs; |
|
999 User::LeaveIfError(fs.Connect()); |
|
1000 CleanupClosePushL(fs); |
|
1001 RFile file; |
|
1002 CleanupClosePushL(file); |
|
1003 User::LeaveIfError(file.Create(fs, variant.AsDes(), |
|
1004 EFileShareExclusive | EFileStreamText | EFileWrite)); |
|
1005 TInt size = exportBuffer->Size(); |
|
1006 for( TInt i = 0; i < size; ++i ) |
|
1007 { |
|
1008 file.Write(i,exportBuffer->Ptr(i)); |
|
1009 } |
|
1010 CleanupStack::PopAndDestroy(&file); |
|
1011 CleanupStack::PopAndDestroy(&fs); |
|
1012 CleanupStack::PopAndDestroy (exportBuffer); |
|
1013 CleanupStack::PopAndDestroy (encoder ); |
|
1014 } |
|
1015 |
|
1016 CleanupStack::PopAndDestroy (mimeType8 ); |
|
1017 CleanupStack::PopAndDestroy (&landmarkIdArray ); |
955 CleanupStack::PopAndDestroy(&variant); |
1018 CleanupStack::PopAndDestroy(&variant); |
956 } |
1019 } |
957 else |
1020 else |
958 { |
1021 { |
959 ErrorMessageL (KExport, KContentType ); |
1022 ErrorMessageL (KExport, KContentType ); |
969 // TUint /*aCmdOptions*/, |
1032 // TUint /*aCmdOptions*/, |
970 // MLiwNotifyCallback* /*aCallback*/ ) |
1033 // MLiwNotifyCallback* /*aCallback*/ ) |
971 // This calls the appropriate service function for organising landmarks. |
1034 // This calls the appropriate service function for organising landmarks. |
972 // --------------------------------------------------------------------------- |
1035 // --------------------------------------------------------------------------- |
973 // |
1036 // |
974 void CLandmarkInterface::OrganiseL( const CLiwGenericParamList& aInParamList, |
1037 void CLandmarkInterface::OrganiseL(const CLiwGenericParamList& aInParamList, |
975 CLiwGenericParamList& /*aOutParamList*/, TUint /*aCmdOptions*/, |
1038 CLiwGenericParamList& aOutParamList, TUint /*aCmdOptions*/, |
976 MLiwNotifyCallback* /*aCallback*/) |
1039 MLiwNotifyCallback* aCallback) |
977 { |
1040 { |
978 //Input param List must have contentType, filter and operationType specified |
1041 //Input param List must have contentType, filter and operationType specified |
979 if ( aInParamList.Count ( )< EIndex3 ) |
1042 if ( aInParamList.Count ( )< EIndex3 ) |
980 { |
1043 { |
981 ErrorMessageL (KAdd, KOrganiseArgsMissing ); |
1044 ErrorMessageL (KAdd, KOrganiseArgsMissing ); |
1119 } |
1182 } |
1120 variant = param->Value ( ); |
1183 variant = param->Value ( ); |
1121 ValidateParamL (KOrganise, KOperationType, variant, |
1184 ValidateParamL (KOrganise, KOperationType, variant, |
1122 LIW::EVariantTypeDesC ); |
1185 LIW::EVariantTypeDesC ); |
1123 TPtrC operationType = variant.AsDes ( ); |
1186 TPtrC operationType = variant.AsDes ( ); |
1124 if ( operationType == KAssociate ) |
1187 if (operationType != KAssociate && operationType != KDisassociate) |
1125 { |
1188 { |
1126 iService->LinkCategoryToLandmarksL (catid, landmarkIdArray, dbUri ); |
1189 ErrorMessageL(KOrganise, KOperationType); |
1127 } |
1190 iErrMsg->Des().Append(KInvalid); |
1128 else |
1191 //leave since argument is improper |
1129 if ( operationType == KDisassociate ) |
1192 User::Leave(SErrInvalidServiceArgument); |
1130 { |
1193 } |
1131 iService->UnlinkCategoryToLandmarksL (catid, landmarkIdArray, |
1194 //Async Call |
1132 dbUri ); |
1195 if (aCallback) |
1133 } |
1196 { |
1134 else |
1197 //Get the transaction ID |
1135 { |
1198 TInt32 transactionId(aCallback->GetTransactionID()); |
1136 ErrorMessageL (KOrganise, KOperationType ); |
1199 CLandmarkCallbackMap* map = new (ELeave) CLandmarkCallbackMap( |
1137 iErrMsg->Des().Append (KInvalid ); |
1200 transactionId, aCallback); |
1138 //leave since argument is improper |
1201 CleanupStack::PushL(map); |
1139 User::Leave (SErrInvalidServiceArgument ); |
1202 iCallbackMap.AppendL(map); |
1140 } |
1203 CleanupStack::Pop(map); |
|
1204 if (operationType == KAssociate) |
|
1205 { |
|
1206 iService->LinkCategoryToLandmarksL(transactionId, catid, |
|
1207 landmarkIdArray, dbUri); |
|
1208 } |
|
1209 else |
|
1210 { |
|
1211 iService->UnlinkCategoryToLandmarksL(transactionId, catid, |
|
1212 landmarkIdArray, dbUri); |
|
1213 } |
|
1214 aOutParamList.AppendL(TLiwGenericParam(KTransactionId, TLiwVariant( |
|
1215 TInt32(transactionId)))); |
|
1216 } |
|
1217 else //sync call |
|
1218 { |
|
1219 if (operationType == KAssociate) |
|
1220 { |
|
1221 iService->LinkCategoryToLandmarksL(catid, landmarkIdArray, |
|
1222 dbUri); |
|
1223 } |
|
1224 else |
|
1225 { |
|
1226 iService->UnlinkCategoryToLandmarksL(catid, landmarkIdArray, |
|
1227 dbUri); |
|
1228 } |
|
1229 } |
|
1230 |
1141 CleanupStack::PopAndDestroy(&variantDb); |
1231 CleanupStack::PopAndDestroy(&variantDb); |
1142 CleanupStack::PopAndDestroy (&landmarkIdArray ); |
1232 CleanupStack::PopAndDestroy (&landmarkIdArray ); |
1143 CleanupStack::PopAndDestroy(&variant); |
1233 CleanupStack::PopAndDestroy(&variant); |
1144 } |
1234 } |
1145 else |
1235 else |
1393 else |
1483 else |
1394 { |
1484 { |
1395 //Do whatever is default |
1485 //Do whatever is default |
1396 } |
1486 } |
1397 } |
1487 } |
|
1488 //changes for implementing CJSE 2.1 spec :categoryId |
|
1489 if ( ValidateParamL (KGetList, KCategoryIdChanged, filter, |
|
1490 LIW::EVariantTypeDesC, EFalse, variant ) ) |
|
1491 { |
|
1492 TPtrC catPtr(variant.AsDes()); |
|
1493 |
|
1494 TPosLmItemId catid; |
|
1495 TLex catparseString(catPtr); //Get Id as string and convert to TUint32 |
|
1496 TInt parseErr = catparseString.Val (catid, EDecimal ); |
|
1497 if (parseErr) { |
|
1498 ErrorMessageL (KGetList, KMaximumDistance ); |
|
1499 iErrMsg->Des().Append (KInvalid ); |
|
1500 User::Leave (KErrArgument ); |
|
1501 } |
|
1502 |
|
1503 TBuf<KMaxIDStringLength> catIdString(KNullDesC ( )); |
|
1504 if ( !parseErr ) |
|
1505 { |
|
1506 catIdString.Num(catid); |
|
1507 } |
|
1508 CPosLmCategoryCriteria* crit = CPosLmCategoryCriteria::NewLC(); |
|
1509 crit->SetCategoryItemId(catid); |
|
1510 //add to the criteria |
|
1511 //Adding successfully to the criteria will pass the ownership |
|
1512 User::LeaveIfError (criteria->AddArgument (crit)); |
|
1513 CleanupStack::Pop (crit); |
|
1514 } |
|
1515 |
|
1516 //CJSE Changes done |
1398 if ( ValidateParamL (KGetList, KCategoryName, filter, |
1517 if ( ValidateParamL (KGetList, KCategoryName, filter, |
1399 LIW::EVariantTypeDesC, EFalse, variant ) ) |
1518 LIW::EVariantTypeDesC, EFalse, variant ) ) |
1400 { |
1519 { |
1401 TPtrC name( variant.AsDes( ) ); |
1520 TPtrC name( variant.AsDes( ) ); |
1402 if( name != KNullDesC ) |
1521 if( name != KNullDesC ) |
1930 // --------------------------------------------------------------------------- |
2049 // --------------------------------------------------------------------------- |
1931 // CLandmarkInterface::AddLandmarksL(const CLiwGenericParamList& aInParamList ) |
2050 // CLandmarkInterface::AddLandmarksL(const CLiwGenericParamList& aInParamList ) |
1932 // This calls the appropriate service function for adding landmarks. |
2051 // This calls the appropriate service function for adding landmarks. |
1933 // --------------------------------------------------------------------------- |
2052 // --------------------------------------------------------------------------- |
1934 // |
2053 // |
1935 void CLandmarkInterface::AddLandmarksL( const CLiwGenericParamList& aInParamList, |
2054 void CLandmarkInterface::AddLandmarksL( |
1936 CLiwGenericParamList& aOutParamList ) |
2055 const CLiwGenericParamList& aInParamList, |
|
2056 CLiwGenericParamList& aOutParamList, TUint /*aCmdOptions*/, |
|
2057 MLiwNotifyCallback* aCallback) |
1937 { |
2058 { |
1938 //position to start search in input params |
2059 //position to start search in input params |
1939 TInt index = 0; |
2060 TInt index = 0; |
1940 //find if filter is specified |
2061 //find if filter is specified |
1941 const TLiwGenericParam* param = &aInParamList[EIndex1]; |
2062 const TLiwGenericParam* param = &aInParamList[EIndex1]; |
2177 { |
2298 { |
2178 landmark->SetPositionFieldL (EPositionFieldBuildingTelephone, |
2299 landmark->SetPositionFieldL (EPositionFieldBuildingTelephone, |
2179 variant.AsDes ( ) ); |
2300 variant.AsDes ( ) ); |
2180 } |
2301 } |
2181 } |
2302 } |
2182 //checks if the landmark passed is to update an existing lanmark or add a |
2303 //Async Call |
2183 //new landmark. |
2304 if (aCallback) |
2184 if ( update ) |
2305 { |
2185 { |
2306 //Get the transaction ID |
2186 iService->UpdateItemL (*landmark, dbUri ); |
2307 TInt32 transactionId(aCallback->GetTransactionID()); |
2187 } |
2308 CLandmarkCallbackMap* map = new (ELeave) CLandmarkCallbackMap( |
2188 else |
2309 transactionId, aCallback); |
2189 { |
2310 CleanupStack::PushL(map); |
2190 lmid = iService->AddItemL (*landmark, dbUri ); |
2311 iCallbackMap.AppendL(map); |
2191 } |
2312 CleanupStack::Pop(map); |
2192 CleanupStack::PopAndDestroy (landmark ); |
2313 //checks if the landmark passed is to update an existing lanmark or add a |
2193 CleanupStack::PopAndDestroy(&variant); |
2314 //new landmark. |
2194 CleanupStack::PopAndDestroy(&variantDb); |
2315 if (update) |
2195 |
2316 { |
2196 iId = HBufC::NewL(KMaxIDStringLength); |
2317 iService->UpdateItemL(transactionId, *landmark, dbUri); |
2197 iId->Des().Num(lmid,EDecimal); |
2318 } |
2198 aOutParamList.AppendL (TLiwGenericParam (KReturnValue, |
2319 else |
2199 TLiwVariant (iId ) ) ); |
2320 { |
2200 } |
2321 iService->AddItemL(transactionId, *landmark, dbUri); |
|
2322 } |
|
2323 aOutParamList.AppendL(TLiwGenericParam(KTransactionId, TLiwVariant( |
|
2324 TInt32(transactionId)))); |
|
2325 } |
|
2326 else //sync call |
|
2327 { |
|
2328 //checks if the landmark passed is to update an existing lanmark or add a |
|
2329 //new landmark. |
|
2330 if (update) |
|
2331 { |
|
2332 iService->UpdateItemL(*landmark, dbUri); |
|
2333 } |
|
2334 else |
|
2335 { |
|
2336 lmid = iService->AddItemL(*landmark, dbUri); |
|
2337 } |
|
2338 iId = HBufC::NewL(KMaxIDStringLength); |
|
2339 iId->Des().Num(lmid, EDecimal); |
|
2340 aOutParamList.AppendL(TLiwGenericParam(KReturnValue, TLiwVariant(iId))); |
|
2341 } |
|
2342 CleanupStack::PopAndDestroy(landmark); |
|
2343 CleanupStack::PopAndDestroy(&variant); |
|
2344 CleanupStack::PopAndDestroy(&variantDb); |
|
2345 } |
2201 |
2346 |
2202 // --------------------------------------------------------------------------- |
2347 // --------------------------------------------------------------------------- |
2203 // CLandmarkInterface::AddCategoryL(const CLiwGenericParamList& aInParamList) |
2348 // CLandmarkInterface::AddCategoryL(const CLiwGenericParamList& aInParamList) |
2204 // This calls the appropriate service function for adding a category. |
2349 // This calls the appropriate service function for adding a category. |
2205 // --------------------------------------------------------------------------- |
2350 // --------------------------------------------------------------------------- |
2206 // |
2351 // |
2207 void CLandmarkInterface::AddCategoryL(const CLiwGenericParamList& aInParamList, |
2352 void CLandmarkInterface::AddCategoryL(const CLiwGenericParamList& aInParamList, |
2208 CLiwGenericParamList& aOutParamList ) |
2353 CLiwGenericParamList& aOutParamList, TUint /*aCmdOptions*/, |
|
2354 MLiwNotifyCallback* aCallback) |
2209 { |
2355 { |
2210 //position to start search in input params |
2356 //position to start search in input params |
2211 TInt index = 0; |
2357 TInt index = 0; |
2212 //find if filter is specified |
2358 //find if filter is specified |
2213 const TLiwGenericParam* param = &aInParamList[EIndex1]; |
2359 const TLiwGenericParam* param = &aInParamList[EIndex1]; |
2316 } |
2462 } |
2317 category->SetIconL (iconFile, iconIndex, iconMaskIndex ); |
2463 category->SetIconL (iconFile, iconIndex, iconMaskIndex ); |
2318 CleanupStack::PopAndDestroy(&iconVariant); |
2464 CleanupStack::PopAndDestroy(&iconVariant); |
2319 } |
2465 } |
2320 |
2466 |
|
2467 //Async Call |
|
2468 if (aCallback) |
|
2469 { |
|
2470 //Get the transaction ID |
|
2471 TInt32 transactionId(aCallback->GetTransactionID()); |
|
2472 CLandmarkCallbackMap* map = new (ELeave) CLandmarkCallbackMap( |
|
2473 transactionId, aCallback); |
|
2474 CleanupStack::PushL(map); |
|
2475 iCallbackMap.AppendL(map); |
|
2476 CleanupStack::Pop(map); |
|
2477 //checks if the landmark passed is to update an existing lanmark or add a |
|
2478 //new landmark. |
|
2479 if (update) |
|
2480 { |
|
2481 iService->UpdateItemL(transactionId, *category, dbUri); |
|
2482 } |
|
2483 else |
|
2484 { |
|
2485 iService->AddItemL(transactionId, *category, dbUri); |
|
2486 } |
|
2487 aOutParamList.AppendL(TLiwGenericParam(KTransactionId, TLiwVariant( |
|
2488 TInt32(transactionId)))); |
|
2489 } |
|
2490 else //sync call |
|
2491 { |
2321 if ( update ) |
2492 if ( update ) |
2322 { |
2493 { |
2323 iService->UpdateItemL (*category, dbUri ); |
2494 iService->UpdateItemL (*category, dbUri ); |
2324 } |
2495 } |
2325 else |
2496 else |
2326 { |
2497 { |
2327 catid = iService->AddItemL (*category, dbUri ); |
2498 catid = iService->AddItemL (*category, dbUri ); |
2328 } |
2499 } |
|
2500 iId = HBufC::NewL(KMaxIDStringLength); |
|
2501 iId->Des().Num(catid, EDecimal); |
|
2502 aOutParamList.AppendL(TLiwGenericParam(KReturnValue, TLiwVariant(iId))); |
|
2503 } |
2329 |
2504 |
2330 CleanupStack::PopAndDestroy (category ); |
2505 CleanupStack::PopAndDestroy (category ); |
2331 CleanupStack::PopAndDestroy(&variant); |
2506 CleanupStack::PopAndDestroy(&variant); |
2332 CleanupStack::PopAndDestroy(&variantDb); |
2507 CleanupStack::PopAndDestroy(&variantDb); |
2333 |
2508 |
2334 iId = HBufC::NewL(KMaxIDStringLength); |
|
2335 iId->Des().Num(catid,EDecimal); |
|
2336 aOutParamList.AppendL (TLiwGenericParam (KReturnValue, |
|
2337 TLiwVariant (iId ) ) ); |
|
2338 } |
2509 } |
2339 |
2510 |
2340 // --------------------------------------------------------------------------- |
2511 // --------------------------------------------------------------------------- |
2341 // CLandmarkInterface::AddDatabaseL(const CLiwGenericParamList& aInParamList) |
2512 // CLandmarkInterface::AddDatabaseL(const CLiwGenericParamList& aInParamList) |
2342 // This calls the appropriate service function for adding a database. |
2513 // This calls the appropriate service function for adding a database. |