/*

* Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description: Mylocation engine source implementation for location picker

*              and maptile service.

*

*/

// INCLUDE FILES

#include <f32file.h>

#include <calchangecallback.h> 

#include <cntitem.h>

#include <CNTFLDST.H>

#include <EPos_CPosLmDatabaseManager.h>

#include <lbsposition.h>

#include <bautils.h>

#include <f32file.h>

#include "mylocationsengine.h"

#include "mylocationsdefines.h"

#include "geocodeupdate.h" //header for CGeocodeUpdate class

//handle for CMyLocationsHistoryDbObserver class

#include "mylocationlogger.h"

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

_LIT ( KImageStorageDrive, "C:\\Maptile\\");

#endif

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

const TInt KImagePathSize=36;

const TInt KBufSize=256;

const TInt KDefaultFilePathSize = 20;

// separator

_LIT( KSeparator, ",");

_LIT(KContactPrefered, "Contact Prefered");

_LIT(KContactHome, "Contact Home");

_LIT(KContactWork, "Contact Work");

_LIT(KPNGType, ".png");

_LIT(KSingleSpace, " ");

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

CMyLocationsEngine* CMyLocationsEngine::NewL()

{

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

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

}

// -----------------------------------------------------------------------------

// CMyLocationsEngine::ConstructL()

// Symbian 2nd phase constructor can leave.

// -----------------------------------------------------------------------------

//

void CMyLocationsEngine::ConstructL()

{

    __TRACE_CALLSTACK;

    CActiveScheduler::Add(this);

    //Connection to Landmark DB

    iLandmarkDb = CPosLandmarkDatabase::OpenL();

    ExecuteAndDeleteLD(iLandmarkDb->InitializeL());

    MYLOCLOGSTRING("Connection to Landmark DB.");

    // create CMyLocationsDatabaseManager instance

    iMyLocationsDatabaseManager = new (ELeave) CMyLocationsDatabaseManager;

    iMyLocationsDatabaseManager->ConstructL();

    MYLOCLOGSTRING("create CMyLocationsDatabaseManager instance");

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

    if( error == KErrNone )

    {

        iMaptileGeocoderPluginAvailable = ETrue;	

    }

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

    //Maptile Db instance

    iMaptileDatabase = CLookupMapTileDatabase::NewL(KMapTileLookupDatabaseName);

    MYLOCLOGSTRING("Maptile Db instance created ");

    iAddressCompare = CAddressComparision::NewL();

    MYLOCLOGSTRING(" start contact db observation ");

    StartContactsChangeNotifierL();

    MYLOCLOGSTRING(" start landmark db observation ");

    StartLandmarksChangeNotifier();

    //set the folder path to store maptile

    imageFilePath.Zero();

    SetFolderPathL();

    TInt status;

    iCalSession = CCalSession::NewL();

    NotifyChangeL(status);

}

// -----------------------------------------------------------------------------

// CMyLocationsEngine::SetFolderPath()

// set folder path structure

// -----------------------------------------------------------------------------

//

void CMyLocationsEngine::SetFolderPathL()

{

    __TRACE_CALLSTACK;

    RFs session;

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

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

    {

        session.Close();

        MYLOCLOGSTRING("Image folder path exists");

        return;

    }

    const TUint EMediaMemoryCard = 0x000014;

    imageFilePath.Zero();

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

    imageFilePath.Copy(KImageStorageDrive);

    MYLOCLOGSTRING("using in  debug mode");

#else        

    TVolumeInfo vol;

    TInt driveNumber = EDriveE;

    TChar driveLetter;

    TDriveInfo driveInfo;

    TInt error( KErrNone );

    error=session.Volume(vol, driveNumber);

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

    if (error == KErrNone)

    {

        error = session.Drive(driveInfo, driveNumber);

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

        switch(driveInfo.iType)

        {

            case EMediaFlash:

            case EMediaHardDisk:

            case EMediaNANDFlash:

            case EMediaMemoryCard:

            case EMediaCdRom:

            {

                MYLOCLOGSTRING(" E drive match case");

                session.DriveToChar( driveNumber , driveLetter );

                imageFilePath.Append(driveLetter);

                imageFilePath.Append(KFolderName);

                break;

            }

            default:

            break;

        };

    }

    if (!imageFilePath.Length() > 0)

    {

        driveNumber = EDriveF;

        error = session.Volume(vol, driveNumber);

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

        if (error == KErrNone)

        {

            error = session.Drive(driveInfo, driveNumber);

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

            switch (driveInfo.iMediaAtt)

            {

                /** Solid-state media. */

                case EMediaFlash:

                case EMediaHardDisk:

                case EMediaNANDFlash:

                case EMediaMemoryCard:

                {

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

                    session.DriveToChar(driveNumber, driveLetter);

                    imageFilePath.Append(driveLetter);

                    imageFilePath.Append(KFolderName);

                    break;

                }

                default:

                break;

            };

        }

    }

#endif

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

    {

        session.MkDirAll(imageFilePath);

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

    }

    session.Close();

}

// -----------------------------------------------------------------------------

// CMyLocationsEngine::CMyLocationsEngine()

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

// -----------------------------------------------------------------------------

//

CMyLocationsEngine::CMyLocationsEngine() :

    CActive(EPriorityStandard), iCalSession(NULL), iCalView(NULL), iContactsDb(

            NULL), iContactChangeNotifier(NULL), iLandmarkDb(NULL),

            iMapTileInterface(NULL), iMyLocationsDatabaseManager(NULL),

            iMaptileDatabase(NULL), iAddressCompare(NULL),

            iMaptileGeocoderPluginAvailable(EFalse),iCalenderNotification(NULL)

{

}

// -----------------------------------------------------------------------------

// CMyLocationsEngine::~CMyLocationsEngine()

// Destructor.

// -----------------------------------------------------------------------------

//

CMyLocationsEngine::~CMyLocationsEngine()

{

    __TRACE_CALLSTACK;// delete the member variables.

    delete iContactChangeNotifier;

    delete iMyLocationsDatabaseManager;

    delete iLandmarkDb;

    delete iContactsDb;

    delete iCalView;

    delete iCalSession;

	delete iMapTileInterface;

    delete iMaptileDatabase;

    delete iAddressCompare;

    delete iCalenderNotification;

}

// -----------------------------------------------------------------------------

// CMyLocationsEngine::NotifyChangeL()

// Starts calender db create notification to get callbacks. 

// -----------------------------------------------------------------------------

//

void CMyLocationsEngine::NotifyChangeL(TInt &aStatus)

{

    __TRACE_CALLSTACK;

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

    TChar drive = defaultFile[0];

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

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

    if ( KErrNone == aStatus )

    {

        // create a calendar entry view with the opened session

        iCalView = CCalEntryView::NewL(*iCalSession);

        StartCalenderChangeNotifierL();

    }

    else

    {

        if( !iCalenderNotification )

        {

            iCalenderNotification = CCalenderNotification::NewL( this );

        }

        iCalenderNotification->CheckCalenderDbFileStructure( drive );

    }

}

// -----------------------------------------------------------------------------

// CMyLocationsEngine::StartCalenderChangeNotifierL()

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

// added/modified/deleted in contacts

// -----------------------------------------------------------------------------

//

void CMyLocationsEngine::StartCalenderChangeNotifierL()

{

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

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

    if (iCalSession)

    {

        MYLOCLOGSTRING("iCalSession is not null");

        TTime currentTime;

        currentTime.HomeTime();

        TTime startTime = currentTime - TTimeIntervalYears(1);

        TTime endTime = currentTime + TTimeIntervalYears(1);

        TCalTime calStartTime;

        calStartTime.SetTimeLocalL(startTime);

        MYLOCLOGSTRING("SetTimeLocalL(startTime)");

        TCalTime calEndTime;

        calEndTime.SetTimeLocalL(endTime);

        MYLOCLOGSTRING("SetTimeLocalL(endTime)");

        // set the filter for modification tracking

        CCalChangeNotificationFilter *filter =

                CCalChangeNotificationFilter::NewL(

                        MCalChangeCallBack2::EChangeEntryAll, ETrue,

                        CalCommon::TCalTimeRange(calStartTime, calEndTime));

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

        // 'this' object implements MCalChangeCallBack

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

    }

}

// -----------------------------------------------------------------------------

// CMyLocationsEngine::StartContactsChangeNotifierL()

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

// added/modified/deleted in contacts

// -----------------------------------------------------------------------------

//

void CMyLocationsEngine::StartContactsChangeNotifierL()

{

    __TRACE_CALLSTACK;

    GeocodeUpdate::CreateContactdb();

    iContactsDb = CContactDatabase::OpenL();

    // Create CContactChangeNotifier object with 'this' object. 

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

}

// -----------------------------------------------------------------------------

// CMyLocationsEngine::StartLandmarksChangeNotifier()

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

// -----------------------------------------------------------------------------

//

void CMyLocationsEngine::StartLandmarksChangeNotifier()

{

    __TRACE_CALLSTACK;// Resume event listening

    iLandmarkDb->NotifyDatabaseEvent(iLmEvent, iStatus);

    SetActive();

}

// -----------------------------------------------------------------------------

// CMyLocationsEngine::CalChangeNotification()

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

// -----------------------------------------------------------------------------

//

void CMyLocationsEngine::CalChangeNotification(

        RArray<TCalChangeEntry>& aChangeItems)

{

    __TRACE_CALLSTACK;

    if(iCalenderNotification)

    {

        delete iCalenderNotification;

        iCalenderNotification = NULL;

    }

    // get entries associated with this UID

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

    {

        TCalChangeEntry calChangeEntry = aChangeItems[i];

        iEventType = calChangeEntry.iChangeType;

        switch (calChangeEntry.iChangeType)

        {

        case EChangeAdd:

        {

            TRAP_IGNORE(CalenderEntryAddedL(calChangeEntry));

            break;

        }

        case EChangeModify:

        {

            TLookupItem lookupItem;

            lookupItem.iSource = ESourceCalendar;

            lookupItem.iUid = calChangeEntry.iEntryId;

            //TODO: comapare address and then delete 

            TRAP_IGNORE( iMaptileDatabase->DeleteEntryL(lookupItem) );

            TRAP_IGNORE( CalenderEntryAddedL(calChangeEntry) );

            break;

        }

        case EChangeDelete:

        {

            TLookupItem lookupItem;

            lookupItem.iSource = ESourceCalendar;

            lookupItem.iUid = calChangeEntry.iEntryId;

           TRAP_IGNORE( iMaptileDatabase->DeleteEntryL(lookupItem));

            break;

        }

        };

    }

}

void CMyLocationsEngine::CalenderEntryAddedL(TCalChangeEntry aCalChangeEntry)

{

    __TRACE_CALLSTACK;

    CCalEntry* calEntry = NULL;

    calEntry = iCalView->FetchL(aCalChangeEntry.iEntryId);

    TPtrC address(calEntry->LocationL());

    if(address.Length()>0)

    {        

        RequestMapTileImageL(address,ESourceCalendar, aCalChangeEntry.iEntryId);

    }

    delete calEntry;

}

// -----------------------------------------------------------------------------

// CMyLocationsEngine::HandleDatabaseEventL()

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

// -----------------------------------------------------------------------------

//

void CMyLocationsEngine::HandleDatabaseEventL(TContactDbObserverEvent aEvent)

{

    __TRACE_CALLSTACK;

    HandlelandmarkDatabaseL(aEvent);

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

    if( iMaptileGeocoderPluginAvailable )

    {

        TriggerMaptileRequestL(aEvent);

    }

}

// -----------------------------------------------------------------------------

// CMyLocationsEngine::HandlelandmarkDatabaseL()

// Process the contact database event and updates the landmark database

// -----------------------------------------------------------------------------

//

void CMyLocationsEngine::HandlelandmarkDatabaseL(

        TContactDbObserverEvent& aEvent)

{

    __TRACE_CALLSTACK;// If contact is modified or added, update the mylocations db

    if (aEvent.iType == EContactDbObserverEventContactChanged || aEvent.iType

            == EContactDbObserverEventContactAdded)

    {

        //Get the contact item

        CContactItem* contactItem =

                iContactsDb->ReadContactL(aEvent.iContactId);

        if (contactItem)

        {

            CleanupStack::PushL(contactItem);

            // Get the default/prefered address details

            CPosLandmark *preferedAddressLm = GetContactLocationDetailsLC(

                    contactItem, EAddressPref);

            // Get the work address details

            CPosLandmark *workAddressLm = GetContactLocationDetailsLC(

                    contactItem, EAddressWork);

            // Get the home address details

            CPosLandmark *homeAddressLm = GetContactLocationDetailsLC(

                    contactItem, EAddressHome);

            // if the contact item has no validated address (preferef, home or work)

            if (!preferedAddressLm && !workAddressLm && !homeAddressLm)

            {

                if (aEvent.iType == EContactDbObserverEventContactChanged)

                {

                    // If the contact is a modified one and it might already exist in

                    // mylocations db, so delete it

                    iMyLocationsDatabaseManager->UpdateDatabaseL(NULL,

                            aEvent.iContactId, ESourceContactsPref,

                            EEntryDeleted);

                    iMyLocationsDatabaseManager->UpdateDatabaseL(NULL,

                            aEvent.iContactId, ESourceContactsWork,

                            EEntryDeleted);

                    iMyLocationsDatabaseManager->UpdateDatabaseL(NULL,

                            aEvent.iContactId, ESourceContactsHome,

                            EEntryDeleted);

                }

            }

            else

            {

                // There is atleast one valid address present.       

                // Get the TEntryChangeType for contacts.

                TEntryChangeType changeType = MapChangeType(

                        ESourceContactsPref, aEvent.iType);

                // if home address available, update Mylocations.  

                if (homeAddressLm)

                {

                    iMyLocationsDatabaseManager->UpdateDatabaseL(homeAddressLm,

                            aEvent.iContactId, ESourceContactsHome, changeType);

                    CleanupStack::PopAndDestroy(homeAddressLm);

                }

                // if work address available, update Mylocations.  

                if (workAddressLm)

                {

                    iMyLocationsDatabaseManager->UpdateDatabaseL(workAddressLm,

                            aEvent.iContactId, ESourceContactsWork, changeType);

                    CleanupStack::PopAndDestroy(workAddressLm);

                }

                // if prefered address available, update Mylocations.  

                if (preferedAddressLm)

                {

                    iMyLocationsDatabaseManager->UpdateDatabaseL(

                            preferedAddressLm, aEvent.iContactId,

                            ESourceContactsPref, changeType);

                    CleanupStack::PopAndDestroy(preferedAddressLm);

                }

            }

            // Pop and destroy the contactItem

            CleanupStack::PopAndDestroy(contactItem);

        }

    }

    else if (aEvent.iType == EContactDbObserverEventContactDeleted)

    {