1 /*

     2 * Copyright (c) 2010 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: Mylocation engine source implementation for location picker

    15 *              and maptile service.

    16 *

    17 */

    18 

    19 // INCLUDE FILES

    20 #include <QFile>

    21 #include <f32file.h>

    22 #include <calchangecallback.h> 

    23 #include <cntitem.h>

    24 #include <cntfldst.h>

    25 #include <EPos_CPosLmDatabaseManager.h>

    26 #include <lbsposition.h>

    27 #include <bautils.h>

    28 #include <f32file.h>

    29 #include <locationservicedefines.h>

    30 #include <e32property.h>

    31 #include "contactsubscriber.h"

    32 #include "calendarsubscriber.h"

    33 #include "mylocationsengine.h"

    34 #include "geocodeupdate.h" //header for GeocodeUpdate class

    35 //handle for CMyLocationsHistoryDbObserver class

    36 #include "mylocationlogger.h"

    37 #if ( defined __WINSCW__ ) || ( defined __WINS__ )

    38 _LIT ( KImageStorageDrive, "C:\\MapTile\\");

    39 #endif

    40 _LIT(KFolderName,":\\MapTile\\");

    41 const TInt KImagePathSize=36;

    42 const TInt KDefaultFilePathSize = 20;

    43 const TUid KMaptileStatusPublish={0x2002680A};

    44 enum TMaptileStatusKeys {EMaptileStatusInteger=0x1};

    45 

    46 //Protocol : [appid-addresstype-maptilestatus]

    47 _LIT8( KMaptileStatusFormat, "%d-%d-%d" );

    48 const TInt KProtocolBufferSize = 16;

    49 

    50 const QString KSpace(" ");

    51 

    52 // ============================ MEMBER FUNCTIONS ===============================

    53 

    54 CMyLocationsEngine* CMyLocationsEngine::NewL()

    55 {

    56     CMyLocationsEngine* self = new (ELeave) CMyLocationsEngine();

    57     CleanupStack::PushL(self);

    58     self->ConstructL();

    59     CleanupStack::Pop(self);

    60     return self;

    61 }

    62 

    63 // -----------------------------------------------------------------------------

    64 // CMyLocationsEngine::ConstructL()

    65 // Symbian 2nd phase constructor can leave.

    66 // -----------------------------------------------------------------------------

    67 //

    68 void CMyLocationsEngine::ConstructL()

    69 {

    70     __TRACE_CALLSTACK;

    71     CActiveScheduler::Add(this);

    72 

    73     //Connection to Landmark DB

    74     iLandmarkDb = CPosLandmarkDatabase::OpenL();

    75     ExecuteAndDeleteLD(iLandmarkDb->InitializeL());

    76 

    77     MYLOCLOGSTRING("Connection to Landmark DB.");

    78     // create CMyLocationsDatabaseManager instance

    79     iMyLocationsDatabaseManager = new (ELeave) CMyLocationsDatabaseManager;

    80     iMyLocationsDatabaseManager->ConstructL();

    81     

    82     MYLOCLOGSTRING("create CMyLocationsDatabaseManager instance");

    83 

    84     TRAPD( error , iMapTileInterface = CMapTileInterface::NewL());

    85     if( error == KErrNone )

    86     {

    87         iMaptileGeocoderPluginAvailable = ETrue;	

    88     }

    89     

    90     MYLOCLOGSTRING("iMapTileInterface = CMapTileInterface::NewL()");

    91     //Maptile Db instance

    92     iMaptileDatabase = CLookupMapTileDatabase::NewL(KMapTileLookupDatabaseName);

    93 

    94     MYLOCLOGSTRING("Maptile Db instance created ");

    95 	

    96     iGeocodeUpdate = new GeocodeUpdate();

    97     iMyLocationThreeAMTimer = CLocationGeoTagTimerAO::NewL(*this);

    98   

    99     iMyLocationThreeAMTimer->StartTimer();

   100     

   101     MYLOCLOGSTRING(" iMyLocationThreeAMTimer = CLocationGeoTagTimerAO::NewL(this)");

   102   

   103     //Create instance of contact manager 

   104     iContactManager = new QContactManager();

   105 

   106     MYLOCLOGSTRING(" start contact db observation ");

   107     StartContactsChangeNotifierL();

   108 

   109     //set the folder path to store maptile

   110     imageFilePath.Zero();

   111     SetFolderPathL();

   112 

   113     TInt status = KErrNone;

   114     iCalSession = CCalSession::NewL();

   115     NotifyChangeL(status);

   116 

   117     // Start listening to landmarks db changes

   118     StartLandmarksChangeNotifier();   

   119     iContactSubscriber = CContactSubscriber::NewL(this);

   120     iCalendarSubscriber = CCalendarSubscriber::NewL(this);

   121     TInt ret = RProperty::Define( KMaptileStatusPublish, EMaptileStatusInteger, RProperty::EByteArray  );

   122 

   123 }

   124 // -----------------------------------------------------------------------------

   125 // CMyLocationsEngine::SetFolderPath()

   126 // set folder path structure

   127 // -----------------------------------------------------------------------------

   128 //

   129 void CMyLocationsEngine::SetFolderPathL()

   130 {

   131     __TRACE_CALLSTACK;

   132     RFs session;

   133     User::LeaveIfError(session.Connect());

   134    

   135     if ( imageFilePath.Length() > 0 && BaflUtils::FolderExists(session, imageFilePath))

   136     {

   137         session.Close();

   138         MYLOCLOGSTRING("Image folder path exists");

   139         return;

   140     }

   141     const TUint EMediaMemoryCard = 0x000014;

   142     imageFilePath.Zero();

   143 #if ( defined __WINSCW__ ) || ( defined __WINS__ )

   144     imageFilePath.Copy(KImageStorageDrive);

   145     MYLOCLOGSTRING("using in  debug mode");

   146 #else        

   147     TVolumeInfo vol;

   148     TInt driveNumber = EDriveE;

   149     TChar driveLetter;

   150     TDriveInfo driveInfo;

   151     TInt error( KErrNone );

   152     error=session.Volume(vol, driveNumber);

   153     MYLOCLOGSTRING1("E drive volume info status -%d",error);

   154     if (error == KErrNone)

   155     {

   156         error = session.Drive(driveInfo, driveNumber);

   157         MYLOCLOGSTRING1("E driveinfo status -%d",error);

   158         switch(driveInfo.iType)

   159         {

   160             case EMediaFlash:

   161             case EMediaHardDisk:

   162             case EMediaNANDFlash:

   163             case EMediaMemoryCard:

   164             case EMediaCdRom:

   165             {

   166                 MYLOCLOGSTRING(" E drive match case");

   167                 session.DriveToChar( driveNumber , driveLetter );

   168                 imageFilePath.Append(driveLetter);

   169                 imageFilePath.Append(KFolderName);

   170                 break;

   171             }

   172             default:

   173             break;

   174 

   175         };

   176     }

   177 

   178     if (!imageFilePath.Length() > 0)

   179     {

   180         driveNumber = EDriveF;

   181         error = session.Volume(vol, driveNumber);

   182         MYLOCLOGSTRING1("F drive volume info status -%d",error);

   183 

   184         if (error == KErrNone)

   185         {

   186             error = session.Drive(driveInfo, driveNumber);

   187             MYLOCLOGSTRING1("F drive info status-%d", error);

   188 

   189             switch (driveInfo.iMediaAtt)

   190             {

   191                 /** Solid-state media. */

   192                 case EMediaFlash:

   193                 case EMediaHardDisk:

   194                 case EMediaNANDFlash:

   195                 case EMediaMemoryCard:

   196                 {

   197                     MYLOCLOGSTRING("F drive exist as this type");

   198                     session.DriveToChar(driveNumber, driveLetter);

   199                     imageFilePath.Append(driveLetter);

   200                     imageFilePath.Append(KFolderName);

   201                     break;

   202                 }

   203 

   204                 default:

   205                 break;

   206 

   207             };

   208         }

   209     }

   210 #endif

   211     if (imageFilePath.Length()>0 && !BaflUtils::FolderExists(session, imageFilePath))

   212     {

   213         session.MkDirAll(imageFilePath);

   214         MYLOCLOGSTRING("folder path does not exist , created ");

   215     }

   216     session.Close();

   217 }

   218 // -----------------------------------------------------------------------------

   219 // CMyLocationsEngine::CMyLocationsEngine()

   220 // C++ default constructor can NOT contain any code, that might leave.

   221 // -----------------------------------------------------------------------------

   222 //

   223 CMyLocationsEngine::CMyLocationsEngine() :

   224             CActive(EPriorityStandard), 

   225             iCalSession(NULL),

   226             iCalView(NULL), 

   227 	        iContactsDb(NULL), 

   228 	        iContactChangeNotifier(NULL), 

   229 			iLandmarkDb(NULL),

   230             iMapTileInterface(NULL),

   231             iMyLocationsDatabaseManager(NULL),

   232             iMaptileDatabase(NULL),

   233             iMyLocationThreeAMTimer(NULL),

   234             iMaptileGeocoderPluginAvailable(EFalse),

   235             iCalenderNotification(NULL),

   236             iContactManager(NULL),

   237             iContactSubscriber(NULL),

   238             iCalendarSubscriber(NULL),

   239             iGeocodeUpdate(NULL),

   240             iLastContactId( -1 ) ,

   241             iLastCalendarId( 0 )

   242 {

   243 

   244 }

   245 

   246 // -----------------------------------------------------------------------------

   247 // CMyLocationsEngine::~CMyLocationsEngine()

   248 // Destructor.

   249 // -----------------------------------------------------------------------------

   250 //

   251 CMyLocationsEngine::~CMyLocationsEngine()

   252 {

   253     __TRACE_CALLSTACK;// delete the member variables.

   254    

   255     Cancel();

   256     

   257     delete iContactChangeNotifier;

   258 

   259     delete iMyLocationsDatabaseManager;

   260 

   261     delete iLandmarkDb;

   262 

   263     delete iContactsDb;

   264    

   265     delete iCalView;

   266 	

   267     delete iCalSession;

   268 	 

   269 	delete iMapTileInterface;

   270 

   271     delete iMaptileDatabase;

   272        

   273     delete iCalenderNotification;

   274     

   275 	delete iMyLocationThreeAMTimer;

   276 		

   277     delete iContactManager;

   278     

   279     delete iContactSubscriber;

   280 

   281     delete iCalendarSubscriber;

   282     

   283     delete iGeocodeUpdate;

   284     

   285     for( TInt index = 0; index < iAddressInfo.Count(); index++ )

   286     {

   287         delete iAddressInfo[index];

   288         iAddressInfo.Remove(index);

   289         iAddressInfo.Compress();

   290     }

   291     

   292     iAddressInfo.Reset();

   293     

   294 }

   295 

   296 // -----------------------------------------------------------------------------

   297 // CMyLocationsEngine::NotifyChangeL()

   298 // Starts calender db create notification to get callbacks. 

   299 // -----------------------------------------------------------------------------

   300 //

   301 void CMyLocationsEngine::NotifyChangeL(TInt &aStatus)

   302 {

   303     __TRACE_CALLSTACK;

   304     

   305     TBufC<KDefaultFilePathSize> defaultFile = iCalSession->DefaultFileNameL();

   306     TChar drive = defaultFile[0];    

   307     TRAP(aStatus, iCalSession->OpenL( defaultFile ));

   308     MYLOCLOGSTRING1("iCalSession->OpenL() status-%d",aStatus);

   309     if ( KErrNone == aStatus )

   310     {

   311         // create a calendar entry view with the opened session

   312         iCalView = CCalEntryView::NewL(*iCalSession);

   313         StartCalenderChangeNotifierL();

   314     }

   315     else

   316     {

   317         if( !iCalenderNotification )

   318         {

   319             iCalenderNotification = CCalenderNotification::NewL( this );

   320         }

   321         

   322         

   323         iCalenderNotification->CheckCalenderDbFileStructure( drive );

   324     }

   325 }

   326 // -----------------------------------------------------------------------------

   327 // CMyLocationsEngine::GetChangeNoficationL()

   328 // To get callbacks through publisher from contact context

   329 // -----------------------------------------------------------------------------

   330 //

   331 void CMyLocationsEngine::GetChangeNotificationL( TInt &aId, TInt& addressType, TInt& addressCount  )

   332 {

   333     __TRACE_CALLSTACK;

   334    

   335     iLastContactId = aId;

   336     

   337     //If the requested id is already in queue, just return

   338     for( TInt index = 0 ; index < iMapTileRequestQueue.Count(); index++ )

   339     {

   340         if( iLastContactId == iMapTileRequestQueue[index]->iUId )

   341         {           

   342             MYLOCLOGSTRING("contact id is in queue");

   343             return;

   344         }

   345     }

   346     

   347     TAppAddressInfo* addressInfo = new (ELeave) TAppAddressInfo;

   348     addressInfo->iUid = aId;

   349     addressInfo->iAddressType =  addressType;

   350     //Memory will be freed when the queue is deleted

   351     if( iAddressInfo.Append(addressInfo) != KErrNone )

   352     {

   353         delete addressInfo;

   354     }

   355     

   356     //Get all 3 adress

   357     if( addressCount > 1 && iAddressInfo.Count() < addressCount )

   358         return;  

   359     

   360     

   361     for( TInt index = 0; index < iAddressInfo.Count(); index++ )

   362     {

   363         TUidSourceType type = static_cast<TUidSourceType>(iAddressInfo[index]->iAddressType );

   364     

   365         //if type is contact

   366         if( type == ESourceContactsPref || type == ESourceContactsWork || 

   367                       type == ESourceContactsHome )

   368         {

   369             QContact contactInfo = iContactManager->contact( iAddressInfo[index]->iUid );

   370             

   371             CPosLandmark *contactAddressLm = NULL;

   372           

   373             TInt itemCount = 0;

   374             

   375             foreach ( QContactAddress address, contactInfo.details<QContactAddress>() )

   376             {

   377                 QStringList context = address.contexts();

   378                 if ( context.isEmpty()  && type ==  ESourceContactsPref ) // no context

   379                 {

   380                     contactAddressLm = GetContactAddressDetailsLC( address );

   381                     itemCount++;

   382                     break;

   383                 }

   384                 else if ( !context.isEmpty() && context.first() == QContactAddress::ContextHome &&

   385                                     type == ESourceContactsHome )

   386                 {

   387                     contactAddressLm = GetContactAddressDetailsLC( address );

   388                     itemCount++;

   389                     break;

   390                 }

   391                 else if ( !context.isEmpty() && context.first() == QContactAddress::ContextWork  && 

   392                                 type == ESourceContactsWork )

   393                 {

   394                     contactAddressLm = GetContactAddressDetailsLC( address );

   395                     itemCount++;

   396                     break;

   397                 }

   398             }

   399 

   400             //Update the entry with inprogress status

   401             TLookupItem lookupItem;

   402             lookupItem.iUid = iAddressInfo[index]->iUid;

   403             lookupItem.iSource = type;

   404             lookupItem.iFilePath.Zero();

   405             lookupItem.iFetchingStatus = EMapTileFetchingInProgress;

   406             iMaptileDatabase->UpdateEntryL( lookupItem );

   407             

   408             //Request for maptile fetching

   409             if( contactAddressLm )

   410             {

   411                 RequestMapTileImageL( *contactAddressLm, type, 

   412                          iAddressInfo[index]->iUid, EContactDbObserverEventContactChanged );

   413             }

   414             

   415             CleanupStack::PopAndDestroy( itemCount );

   416         }

   417     }

   418     for( TInt index = 0; index < iAddressInfo.Count(); index++ )

   419     {

   420 	    //free the allocated memory

   421         delete iAddressInfo[index];

   422 		iAddressInfo.Remove(index);

   423         iAddressInfo.Compress();

   424 	}

   425     

   426     iAddressInfo.Reset();

   427 }

   428 

   429 // -----------------------------------------------------------------------------

   430 // CMyLocationsEngine::SubscribeFromCalendarL()

   431 // To get callbacks through publisher from calendar context

   432 // -----------------------------------------------------------------------------

   433 //

   434 void CMyLocationsEngine::SubscribeFromCalendarL(TInt aId)

   435 {

   436     __TRACE_CALLSTACK;

   437     iLastCalendarId = aId;

   438     for ( int index =0;iMapTileRequestQueue.Count()>index ;index++)

   439     {

   440         if( iLastCalendarId == iMapTileRequestQueue[index]->iUId )

   441         {            

   442             return;

   443         }

   444     }

   445     

   446     CCalEntry* calEntry = NULL;

   447     calEntry = iCalView->FetchL(aId);

   448     CleanupStack::PushL(calEntry);

   449     TPtrC address(calEntry->LocationL());

   450     if( address.Length()>0 )

   451     {

   452         TLookupItem lookupItem;

   453         lookupItem.iUid = aId;

   454         lookupItem.iSource = ESourceCalendar;

   455         lookupItem.iFilePath.Zero();

   456         lookupItem.iFetchingStatus = EMapTileFetchingInProgress;

   457         iMaptileDatabase->UpdateEntryL( lookupItem );

   458         RequestMapTileImageL( address, ESourceCalendar, aId , EChangeModify );

   459     }

   460     CleanupStack::PopAndDestroy(calEntry);

   461 }

   462 // -----------------------------------------------------------------------------

   463 // CMyLocationsEngine::StartCalenderChangeNotifierL()

   464 // Starts calender change notification method to get callbacks when entries are 

   465 // added/modified/deleted in contacts

   466 // -----------------------------------------------------------------------------

   467 //

   468 void CMyLocationsEngine::StartCalenderChangeNotifierL()

   469 {

   470     __TRACE_CALLSTACK;// Get the current time and set Calendar filter to consider entries whose start time

   471     // fall under the timeframe one year past and one year ahead of the current time.

   472     if (iCalSession)

   473     {

   474         MYLOCLOGSTRING("iCalSession is not null");

   475         TTime currentTime;

   476         currentTime.HomeTime();

   477 

   478         TTime startTime = currentTime - TTimeIntervalYears(1);

   479         TTime endTime = currentTime + TTimeIntervalYears(1);

   480 

   481         TCalTime calStartTime;

   482         calStartTime.SetTimeLocalL(startTime);

   483         

   484         MYLOCLOGSTRING("SetTimeLocalL(startTime)");

   485 

   486         TCalTime calEndTime;

   487         calEndTime.SetTimeLocalL(endTime);

   488         

   489         MYLOCLOGSTRING("SetTimeLocalL(endTime)");

   490 

   491         // set the filter for modification tracking

   492         CCalChangeNotificationFilter *filter =

   493                 CCalChangeNotificationFilter::NewL(

   494                         MCalChangeCallBack2::EChangeEntryAll, ETrue,

   495                         CalCommon::TCalTimeRange(calStartTime, calEndTime));

   496         MYLOCLOGSTRING(" CCalChangeNotificationFilter::NewL()");

   497         // 'this' object implements MCalChangeCallBack

   498         iCalSession->StartChangeNotification(*this, *filter);

   499     }

   500 }

   501 

   502 // -----------------------------------------------------------------------------

   503 // CMyLocationsEngine::StartContactsChangeNotifierL()

   504 // Starts contacts change notification method to get callbacks when entries are 

   505 // added/modified/deleted in contacts

   506 // -----------------------------------------------------------------------------

   507 //

   508 void CMyLocationsEngine::StartContactsChangeNotifierL()

   509 {

   510     __TRACE_CALLSTACK;

   511    

   512     iGeocodeUpdate->createContactdb();

   513     iContactsDb = CContactDatabase::OpenL();

   514     // Create CContactChangeNotifier object with 'this' object. 

   515     iContactChangeNotifier = CContactChangeNotifier::NewL(*iContactsDb,this);

   516 }

   517 

   518 // -----------------------------------------------------------------------------

   519 // CMyLocationsEngine::StartLandmarksChangeNotifier()

   520 // Starts landmarks change notification method to get callbacks when entries are added/modified/deleted in landmarks

   521 // -----------------------------------------------------------------------------

   522 //

   523 void CMyLocationsEngine::StartLandmarksChangeNotifier()

   524 {

   525     __TRACE_CALLSTACK;// Resume event listening

   526     iLandmarkDb->NotifyDatabaseEvent(iLmEvent, iStatus);

   527     SetActive();

   528 }

   529 

   530 // -----------------------------------------------------------------------------

   531 // CMyLocationsEngine::CalChangeNotification()

   532 // Callback when there is a change in the calendar database.

   533 // -----------------------------------------------------------------------------

   534 //

   535 

   536 void CMyLocationsEngine::CalChangeNotification(

   537         RArray<TCalChangeEntry>& aChangeItems)

   538 {

   539     __TRACE_CALLSTACK;

   540        

   541     if(iCalenderNotification)

   542     {

   543         delete iCalenderNotification;

   544         iCalenderNotification = NULL;

   545     }

   546     

   547     // get entries associated with this UID

   548     for (int i = 0; i < aChangeItems.Count(); i++)

   549     {

   550 

   551         // Check if this is some undefined change in calendar db. 

   552         if( aChangeItems[0].iChangeType == EChangeUndefined && aChangeItems[0].iEntryType == EChangeEntryAll )

   553         {

   554             // Refresh the calendar related entries in the location and maptiledb.

   555             RefreshCalendarEntryListL();

   556             break;

   557         }

   558         TCalChangeEntry calChangeEntry = aChangeItems[i];

   559         iEventType = calChangeEntry.iChangeType;

   560         switch (calChangeEntry.iChangeType)

   561         {

   562         case EChangeAdd:

   563         {

   564             

   565             TRAP_IGNORE(CalenderEntryAddedL(calChangeEntry));

   566             break;

   567         }

   568 

   569         case EChangeModify:

   570         {

   571             if (iMapTileRequestQueue.Count() > 0)

   572             {

   573                 if (calChangeEntry.iEntryId == iMapTileRequestQueue[0]->iUId)

   574                 {

   575                     return;

   576                 }

   577             }

   578             TRAP_IGNORE( CalenderEntryModifyL(calChangeEntry) ) ;

   579             break;

   580         }

   581         case EChangeDelete:

   582         {

   583             TLookupItem lookupItem;

   584             lookupItem.iSource = ESourceCalendar;

   585             lookupItem.iUid = calChangeEntry.iEntryId;

   586             TRAP_IGNORE(ManipulateMapTileDataBaseL(lookupItem));           

   587             TRAP_IGNORE( UpdateDatabaseL( NULL, 

   588                               calChangeEntry.iEntryId, ESourceCalendar, EEntryDeleted ) );

   589             break;

   590         }

   591         };

   592 

   593     }

   594 }

   595 

   596 // -----------------------------------------------------------------------------

   597 // CMyLocationsEngine::RefreshCalendarEntryListL()

   598 // -----------------------------------------------------------------------------

   599 //

   600 void CMyLocationsEngine::RefreshCalendarEntryListL()

   601 {

   602     //Get all the calendar ids and check its validity. 

   603     //Delete if they are no more valid.

   604     RArray<TUint32> ids;

   605     iMaptileDatabase->GetAllCalendarIdsL( ids );

   606     for( TInt i = 0; i < ids.Count(); i++ )

   607     {

   608         if( !IsCalendarEntryValidL( ids[i] ) )

   609         {

   610             TLookupItem lookupItem;

   611             lookupItem.iSource = ESourceCalendar;

   612             lookupItem.iUid = ids[i];

   613             TRAP_IGNORE( ManipulateMapTileDataBaseL( lookupItem ) );           

   614             TRAP_IGNORE( UpdateDatabaseL( NULL, 

   615                     ids[i], ESourceCalendar, EEntryDeleted ) );

   616         

   617         }        

   618     }

   619 }

   620 

   621 // -----------------------------------------------------------------------------

   622 // CMyLocationsEngine::IsCalendarEntryValidL()

   623 // -----------------------------------------------------------------------------

   624 //

   625 TBool CMyLocationsEngine::IsCalendarEntryValidL( TUint32 aId )

   626 {

   627     return ( ( iCalView->FetchL( aId ) == NULL ) ? EFalse:ETrue );

   628 }

   629 // -----------------------------------------------------------------------------

   630 // CMyLocationsEngine::CalenderEntryAddedL()

   631 // -----------------------------------------------------------------------------

   632 //

   633 void CMyLocationsEngine::CalenderEntryAddedL(TCalChangeEntry aCalChangeEntry)

   634 {

   635     __TRACE_CALLSTACK;

   636     

   637     TUint32 entryId=0;

   638     entryId=aCalChangeEntry.iEntryId;

   639     //create entry in the data base and maintain a fetching state.

   640     TLookupItem lookupItem;

   641     lookupItem.iUid = entryId ;

   642     lookupItem.iSource = ESourceCalendar;

   643     lookupItem.iFilePath.Zero();

   644     lookupItem.iFetchingStatus = EMapTileFetchingInProgress;     

   645     TRAP_IGNORE( iMaptileDatabase->CreateEntryL(lookupItem) );

   646     CCalEntry* calEntry = NULL;

   647     calEntry = iCalView->FetchL( entryId );

   648     CleanupStack::PushL(calEntry);

   649     TPtrC address(calEntry->LocationL());     

   650     if (address.Length() > 0)

   651     {

   652         RequestMapTileImageL( address, ESourceCalendar, entryId , EChangeAdd );

   653     }  

   654     CleanupStack::PopAndDestroy(calEntry);

   655 }

   656 

   657 // -----------------------------------------------------------------------------

   658 // CMyLocationsEngine::CalenderEntryModifyL()

   659 // -----------------------------------------------------------------------------

   660 //

   661 void CMyLocationsEngine::CalenderEntryModifyL(TCalChangeEntry aCalChangeEntry)

   662 {

   663     __TRACE_CALLSTACK;

   664     TUint32 entryId = 0;

   665     entryId = aCalChangeEntry.iEntryId;

   666     TLookupItem lookupItem;

   667     lookupItem.iSource = ESourceCalendar;

   668     lookupItem.iUid = entryId;

   669     CCalEntry* calEntry = NULL;

   670     calEntry = iCalView->FetchL(entryId);

   671     CleanupStack::PushL(calEntry);

   672     if(iGeocodeUpdate->isGeocodeNotAvailable(entryId))

   673     {        

   674         TPtrC address(calEntry->LocationL());

   675         if (iMyLocationsDatabaseManager->CheckIfAddressChanged(address, entryId,

   676                 ESourceCalendar))

   677         {

   678             lookupItem.iFilePath.Zero();

   679             lookupItem.iFetchingStatus = EMapTileFetchingInProgress;

   680             TRAP_IGNORE( iMaptileDatabase->ReSetEntryL(lookupItem) );

   681             if (address.Length() > 0)

   682             {

   683                 RequestMapTileImageL(address, ESourceCalendar, entryId , EChangeModify);

   684             }

   685             else

   686             {

   687                 UpdateDatabaseL(NULL, entryId, ESourceCalendar, EEntryDeleted);

   688             }

   689             if ( lookupItem.iFilePath.Length() > 0 )

   690             {

   691                 iMaptileDatabase->DeleteMapTileL(lookupItem);

   692             }

   693     

   694         }        

   695     }   

   696     CleanupStack::PopAndDestroy(calEntry);

   697 }

   698 

   699 // -----------------------------------------------------------------------------

   700 // CMyLocationsEngine::HandleDatabaseEventL()

   701 // Callback that provides information about the contact database change event.

   702 // -----------------------------------------------------------------------------

   703 //

   704 void CMyLocationsEngine::HandleDatabaseEventL(TContactDbObserverEvent aEvent)

   705 {

   706     __TRACE_CALLSTACK;

   707     

   708     //Forward the event for maptile fetching only if maptile plugin available

   709     if( iMaptileGeocoderPluginAvailable )

   710     {

   711         TriggerMaptileRequestL(aEvent);

   712     }

   713 }

   714 

   715 

   716 // -----------------------------------------------------------------------------

   717 // CMyLocationsEngine::TriggerMaptileRequestL()

   718 // Process the contact address information for fetching maptile.

   719 // -----------------------------------------------------------------------------

   720 //

   721 void CMyLocationsEngine::TriggerMaptileRequestL(TContactDbObserverEvent& aEvent)

   722 {

   723     __TRACE_CALLSTACK;

   724     TLookupItem lookupItem;      

   725     lookupItem.iUid = aEvent.iContactId;

   726     // If contact is deleted delete from mylocations db

   727     if ( aEvent.iType == EContactDbObserverEventContactDeleted || aEvent.iType == EContactDbObserverEventOwnCardDeleted )

   728     {        

   729         //Delete the entries from maptile database

   730         lookupItem.iSource = ESourceContactsPref;

   731         TRAP_IGNORE( ManipulateMapTileDataBaseL(lookupItem));

   732 

   733         lookupItem.iSource = ESourceContactsWork;

   734         TRAP_IGNORE( ManipulateMapTileDataBaseL(lookupItem));

   735         

   736         lookupItem.iSource = ESourceContactsHome;

   737         TRAP_IGNORE( ManipulateMapTileDataBaseL(lookupItem));

   738               

   739         // Delete entries from  mylocation database

   740         TRAP_IGNORE( UpdateDatabaseL( NULL, aEvent.iContactId,

   741                      ESourceContactsPref, EEntryDeleted ));

   742        

   743         TRAP_IGNORE( UpdateDatabaseL( NULL, aEvent.iContactId,

   744                ESourceContactsHome, EEntryDeleted ));

   745 

   746         TRAP_IGNORE( UpdateDatabaseL( NULL, aEvent.iContactId,

   747                                ESourceContactsWork, EEntryDeleted ) );  

   748         

   749         MYLOCLOGSTRING("EContactDbObserverEventContactDeleted ");

   750         return;

   751     }

   752 

   753     //Get the contact item

   754     iEventType = aEvent.iType;

   755     QContact contactInfo = iContactManager->contact( aEvent.iContactId );            

   756     CPosLandmark *preferedAddressLm = NULL;

   757     CPosLandmark *workAddressLm = NULL;

   758     CPosLandmark *homeAddressLm = NULL;

   759     

   760     TInt itemCount = 0;

   761     

   762     foreach ( QContactAddress address, contactInfo.details<QContactAddress>() )

   763     {

   764         QStringList context = address.contexts();

   765         if ( context.isEmpty() ) // no context

   766         {

   767             preferedAddressLm = GetContactAddressDetailsLC( address );

   768             itemCount++;

   769         }

   770         else if ( context.first() == QContactAddress::ContextHome  )

   771         {

   772             homeAddressLm = GetContactAddressDetailsLC( address );

   773             itemCount++;

   774         }

   775         else if ( context.first() == QContactAddress::ContextWork )

   776         {

   777             workAddressLm = GetContactAddressDetailsLC( address );

   778             itemCount++;

   779         }

   780     }

   781    

   782     switch (aEvent.iType)

   783     {

   784         case EContactDbObserverEventContactChanged:

   785         case EContactDbObserverEventOwnCardChanged:

   786         {

   787             MYLOCLOGSTRING("EContactDbObserverEventContactChanged" );

   788             MYLOCLOGSTRING1("iMapTileRequestQueue.Count()-%d",iMapTileRequestQueue.Count() );

   789 

   790             if (iMapTileRequestQueue.Count() > 0)

   791             {

   792                 if (iMapTileRequestQueue[0]->iUId == aEvent.iContactId)

   793                 {

   794                     CleanupStack::PopAndDestroy( itemCount );

   795                     MYLOCLOGSTRING("retrun from geolocation callback" );

   796                     return;

   797                 }

   798             }

   799 

   800             TBuf<KBufSize> landmarkName;

   801             GetContactName(aEvent.iContactId,landmarkName);

   802 

   803             // if default address available, update Mylocations. 

   804             lookupItem.iSource = ESourceContactsPref;

   805             if (preferedAddressLm)

   806             {

   807                 iMyLocationsDatabaseManager->UpdateEntryName( aEvent.iContactId, ESourceContactsPref, 

   808                                      landmarkName );

   809                 MYLOCLOGSTRING("preferedAddressLm address changed" );

   810 

   811                 if ( iMyLocationsDatabaseManager->CheckIfAddressChanged(*preferedAddressLm,

   812                     aEvent.iContactId, ESourceContactsPref) )

   813 

   814                 {

   815                     lookupItem.iFilePath.Zero();

   816                     lookupItem.iFetchingStatus = EMapTileFetchingInProgress;

   817                     TRAP_IGNORE( iMaptileDatabase->ReSetEntryL(lookupItem) );

   818                     

   819                     RequestMapTileImageL(*preferedAddressLm, ESourceContactsPref,

   820                             aEvent.iContactId, iEventType );

   821 

   822                     if ( lookupItem.iFilePath.Length() > 0 )

   823                     {

   824                         iMaptileDatabase->DeleteMapTileL(lookupItem);

   825                     }

   826                     

   827                 }

   828             }

   829             else

   830             {

   831             	TRAP_IGNORE( UpdateDatabaseL( NULL, aEvent.iContactId,

   832                      ESourceContactsPref, EEntryDeleted ));

   833                 TRAP_IGNORE( ManipulateMapTileDataBaseL(lookupItem));

   834                 

   835             }

   836             

   837             // if home address available, update Mylocations.

   838             lookupItem.iSource = ESourceContactsHome;

   839             if (homeAddressLm)

   840             {

   841                 iMyLocationsDatabaseManager->UpdateEntryName( aEvent.iContactId, ESourceContactsHome, 

   842                                      landmarkName );

   843                 MYLOCLOGSTRING("homeAddressLm address changed" );

   844                 if ( iMyLocationsDatabaseManager->CheckIfAddressChanged(*homeAddressLm,

   845                         aEvent.iContactId, ESourceContactsHome) )

   846                 {

   847                     lookupItem.iFilePath.Zero();

   848                     lookupItem.iFetchingStatus = EMapTileFetchingInProgress;

   849                     TRAP_IGNORE( iMaptileDatabase->ReSetEntryL(lookupItem) )

   850                     //remove entry from databse                    

   851                     RequestMapTileImageL(*homeAddressLm, ESourceContactsHome, aEvent.iContactId,

   852                         iEventType);

   853                     if (lookupItem.iFilePath.Length() > 0) 

   854                     {

   855                         iMaptileDatabase->DeleteMapTileL(lookupItem);

   856                     }                 

   857                 }

   858             }

   859             else

   860             {

   861                 TRAP_IGNORE( UpdateDatabaseL( NULL, aEvent.iContactId,

   862                      ESourceContactsHome, EEntryDeleted ));            

   863                 TRAP_IGNORE( ManipulateMapTileDataBaseL(lookupItem));

   864                 

   865             }

   866  

   867 

   868             // if work address available, update Mylocations.

   869             lookupItem.iSource = ESourceContactsWork;

   870             if (workAddressLm)

   871             {

   872             	  iMyLocationsDatabaseManager->UpdateEntryName( aEvent.iContactId, ESourceContactsWork, 

   873                                      landmarkName );

   874 

   875                 MYLOCLOGSTRING("workAddressLm address changed" );

   876                 if ( iMyLocationsDatabaseManager->CheckIfAddressChanged(*workAddressLm,

   877                         aEvent.iContactId, ESourceContactsWork) )

   878                 {

   879                     lookupItem.iFilePath.Zero();

   880                     lookupItem.iFetchingStatus = EMapTileFetchingInProgress;

   881                     TRAP_IGNORE( iMaptileDatabase->ReSetEntryL(lookupItem) )

   882 

   883                     RequestMapTileImageL(*workAddressLm, ESourceContactsWork,

   884                             aEvent.iContactId, iEventType);

   885                     if (lookupItem.iFilePath.Length() > 0) 

   886                     {

   887                         iMaptileDatabase->DeleteMapTileL(lookupItem);

   888                     }

   889                 } 

   890             }

   891             else

   892             {

   893                 TRAP_IGNORE( UpdateDatabaseL( NULL, aEvent.iContactId,

   894                      ESourceContactsWork, EEntryDeleted ));            

   895                 TRAP_IGNORE( ManipulateMapTileDataBaseL(lookupItem));

   896                

   897             }

   898             break;

   899         }    

   900         case EContactDbObserverEventContactAdded:

   901         {

   902             TLookupItem lookupItem;

   903             lookupItem.iUid = aEvent.iContactId;

   904             lookupItem.iFilePath.Zero();

   905             lookupItem.iFetchingStatus = EMapTileFetchingInProgress;

   906             

   907             MYLOCLOGSTRING("EContactDbObserverEventContactAdded" );

   908             if (preferedAddressLm)

   909             {

   910                 //create entry in the data base and maintain a fetching state.

   911                 lookupItem.iSource = ESourceContactsPref;

   912                 iMaptileDatabase->CreateEntryL(lookupItem);

   913                 RequestMapTileImageL(*preferedAddressLm, ESourceContactsPref,

   914                         aEvent.iContactId, iEventType);

   915             }

   916             if (homeAddressLm)

   917             {

   918                 lookupItem.iSource = ESourceContactsHome;

   919                 iMaptileDatabase->CreateEntryL(lookupItem);

   920                 RequestMapTileImageL(*homeAddressLm, ESourceContactsHome,

   921                         aEvent.iContactId, iEventType);

   922             }

   923             if (workAddressLm)

   924             {

   925                 lookupItem.iSource = ESourceContactsWork;

   926                 iMaptileDatabase->CreateEntryL(lookupItem);

   927                 RequestMapTileImageL(*workAddressLm, ESourceContactsWork,

   928                         aEvent.iContactId, iEventType);

   929             }

   930             break;

   931         }

   932 

   933     }

   934  

   935     CleanupStack::PopAndDestroy( itemCount );

   936 

   937 }

   938 

   939 

   940 // -----------------------------------------------------------------------------

   941 // CMyLocationsEngine::RequestMapTileImageL()

   942 // Request to get maptiel

   943 // -----------------------------------------------------------------------------

   944 //

   945 void CMyLocationsEngine::RequestMapTileImageL(const TDesC& aAddressDetails,

   946         const TUidSourceType aAddressType, const TInt32 aUId ,const TInt aEventType)

   947 {

   948     __TRACE_CALLSTACK;

   949     SetFolderPathL();

   950     TBuf<KImagePathSize> mImagePath;

   951     mImagePath.Copy(imageFilePath);

   952  

   953 

   954     CMapTileRequest* mapTileRequest = new (ELeave) CMapTileRequest;

   955 

   956     mapTileRequest->iAddressDetails = aAddressDetails.AllocL();

   957     mapTileRequest->iUId = aUId;

   958     mapTileRequest->iAddressType = aAddressType;

   959     mapTileRequest->iEventType = aEventType;

   960     mapTileRequest->iImagePath.Zero();

   961     mapTileRequest->iImagePath.Copy(mImagePath);

   962     

   963     TInt error = KErrNone;

   964     

   965     if (iMapTileRequestQueue.Count() <= 0)

   966     {

   967         error = iMapTileRequestQueue.Append(mapTileRequest);

   968         if ( KErrNone == error )

   969         {

   970             error = RequestExecute(mapTileRequest);    

   971         }

   972     }

   973     else

   974     {

   975         MYLOCLOGSTRING("Added one more request to request queue" );

   976         error = iMapTileRequestQueue.Append(mapTileRequest);

   977     }

   978     

   979     //If any error , free the allocated memory

   980     if( error != KErrNone )

   981     {

   982         delete mapTileRequest;

   983     }

   984     

   985 }

   986 // -----------------------------------------------------------------------------

   987 // CMyLocationsEngine::RequestMapTileImageL()

   988 // Request to get maptiel

   989 // -----------------------------------------------------------------------------

   990 //

   991 void CMyLocationsEngine::RequestMapTileImageL(CPosLandmark& aLandmark,

   992                     const TUidSourceType aAddressType, const TInt32 aUId,

   993                     const TInt aEventType )

   994 {

   995     __TRACE_CALLSTACK;

   996 

   997     MYLOCLOGSTRING("check folder path existance!");

   998     SetFolderPathL();

   999  

  1000 

  1001     CMapTileRequest* mapTileRequest = new (ELeave) CMapTileRequest;

  1002 

  1003     mapTileRequest->iLandmarkInfo = CPosLandmark::NewL(aLandmark);

  1004     mapTileRequest->iUId = aUId;

  1005     mapTileRequest->iAddressType = aAddressType;

  1006     mapTileRequest->iEventType = aEventType;

  1007     mapTileRequest->iImagePath.Zero();

  1008     mapTileRequest->iImagePath.Copy(imageFilePath);

  1009     MYLOCLOGSTRING1("RequestMapTileImageL() Queue count -%d",iMapTileRequestQueue.Count());

  1010 

  1011     TInt error = KErrNone;

  1012     

  1013     if (iMapTileRequestQueue.Count() <= 0)

  1014        {

  1015            error = iMapTileRequestQueue.Append(mapTileRequest);

  1016            //error = RequestExecute(mapTileRequest);

  1017            if( KErrNone == error  )

  1018            {

  1019                //error = iMapTileRequestQueue.Append(mapTileRequest);

  1020                error = RequestExecute(mapTileRequest);

  1021            }

  1022   

  1023        }

  1024        else

  1025        {

  1026            MYLOCLOGSTRING("Added one more request to request queue" );

  1027            error = iMapTileRequestQueue.Append(mapTileRequest);

  1028        }

  1029     

  1030        //If any error, free the memory allocated

  1031        if( error != KErrNone )

  1032        {

  1033            delete mapTileRequest;

  1034        }

  1035 }

  1036 

  1037 // -----------------------------------------------------------------------------

  1038 // CMyLocationsEngine::RequestExecute()

  1039 // Executes the maptile image processing request

  1040 // -----------------------------------------------------------------------------

  1041 //

  1042 TInt CMyLocationsEngine::RequestExecute( CMapTileRequest* aMapTileRequest)

  1043 {

  1044     __TRACE_CALLSTACK;

  1045     TInt errorCode = KErrNone;

  1046     MYLOCLOGSTRING1("Request address type - %d ",aMapTileRequest->iAddressType);

  1047     switch (aMapTileRequest->iAddressType)

  1048     {

  1049         case ESourceCalendar:

  1050         {

  1051             TRAP(errorCode,iMapTileInterface->GetGeoCodeFromAddressL(*(aMapTileRequest->iAddressDetails),

  1052                             aMapTileRequest->iImagePath, this ));        

  1053             break;

  1054         }

  1055         case ESourceContactsPref:

  1056         case ESourceContactsWork:

  1057         case ESourceContactsHome:

  1058         {

  1059             TRAP(errorCode, iMapTileInterface->GetGeoCodeFromAddressL(aMapTileRequest->iLandmarkInfo,

  1060                             aMapTileRequest->iImagePath, this));            

  1061             break;

  1062         }

  1063         default:

  1064             break;

  1065     };  

  1066 

  1067     return errorCode;

  1068 }

  1069  

  1070 // -----------------------------------------------------------------------------

  1071 // CMyLocationsEngine::GetContactAddressDetailsLC()

  1072 // get locatin details

  1073 // -----------------------------------------------------------------------------

  1074 //

  1075 CPosLandmark* CMyLocationsEngine::GetContactAddressDetailsLC( 

  1076                                    QContactAddress& aContactAddress )

  1077 {

  1078     __TRACE_CALLSTACK;

  1079     CPosLandmark *landmark = NULL;

  1080     

  1081     QString country = aContactAddress.country();

  1082     QString locality = aContactAddress.locality();

  1083     QString street = aContactAddress.street();

  1084     QString region = aContactAddress.region();

  1085     QString postalcode = aContactAddress.postcode();

  1086     

  1087     landmark = CPosLandmark::NewL();

  1088     CleanupStack::PushL(landmark);

  1089     

  1090     if ( !country.isEmpty() )

  1091     {

  1092         TPtrC16 tempText(reinterpret_cast<const TUint16*>(country.utf16()));

  1093         landmark->SetPositionFieldL( EPositionFieldCountry, tempText );

  1094     }

  1095     if ( !locality.isEmpty() )

  1096     {

  1097         TPtrC16 tempText(reinterpret_cast<const TUint16*>(locality.utf16())); 

  1098         landmark->SetPositionFieldL(EPositionFieldCity, tempText);

  1099     }

  1100     if ( !street.isEmpty() )

  1101     { 

  1102         TPtrC16 tempText(reinterpret_cast<const TUint16*>(street.utf16()));

  1103         landmark->SetPositionFieldL(EPositionFieldStreet, tempText);

  1104     }

  1105     if ( !postalcode.isEmpty() )

  1106     {

  1107         TPtrC16 tempText(reinterpret_cast<const TUint16*>(postalcode.utf16()));

  1108         landmark->SetPositionFieldL(EPositionFieldPostalCode, tempText);

  1109     }

  1110 

  1111      return landmark;

  1112 }

  1113 

  1114 // -----------------------------------------------------------------------------

  1115 // CMyLocationsEngine::MapsChangeType()

  1116 // Maps the source's change type to Mylocations entry change type

  1117 // -----------------------------------------------------------------------------

  1118 //

  1119 TEntryChangeType CMyLocationsEngine::MapChangeType(TUidSourceType aSrcType,

  1120         TUint32 aChangeType)

  1121 {

  1122     __TRACE_CALLSTACK;// return value

  1123     TEntryChangeType retVal = EEntryUnknown;

  1124 

  1125     switch (aSrcType)

  1126     {

  1127     // if source type is calendar

  1128     case ESourceCalendar:

  1129     {

  1130         switch( aChangeType )

  1131             {

  1132             case EChangeAdd:

  1133                 retVal = EEntryAdded;

  1134                 break;

  1135             case EChangeDelete: