/*

* 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 <QFile>

#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 <locationservicedefines.h>

#include <e32property.h>

#include "contactsubscriber.h"

#include "calendarsubscriber.h"

#include "mylocationsengine.h"

#include "geocodeupdate.h" //header for GeocodeUpdate 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 KDefaultFilePathSize = 20;

const TUid KMaptileStatusPublish={0x2002680A};

enum TMaptileStatusKeys {EMaptileStatusInteger=0x1};

//Protocol : [appid-addresstype-maptilestatus]

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

const TInt KProtocolBufferSize = 16;

const QString KSpace(" ");

// ============================ 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 ");

    iGeocodeUpdate = new GeocodeUpdate();

    iMyLocationThreeAMTimer = CLocationGeoTagTimerAO::NewL(*this);

    iMyLocationThreeAMTimer->StartTimer();

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

    //Create instance of contact manager 

    iContactManager = new QContactManager();

    MYLOCLOGSTRING(" start contact db observation ");

    StartContactsChangeNotifierL();

    //set the folder path to store maptile

    imageFilePath.Zero();

    SetFolderPathL();

    TInt status = KErrNone;

    iCalSession = CCalSession::NewL();

    NotifyChangeL(status);

    // Start listening to landmarks db changes

    StartLandmarksChangeNotifier();   

    iContactSubscriber = CContactSubscriber::NewL(this);

    iCalendarSubscriber = CCalendarSubscriber::NewL(this);

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

}

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

// 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),

            iMyLocationThreeAMTimer(NULL),

            iMaptileGeocoderPluginAvailable(EFalse),

            iCalenderNotification(NULL),

            iContactManager(NULL),

            iContactSubscriber(NULL),

            iCalendarSubscriber(NULL),

            iGeocodeUpdate(NULL),

            iLastContactId( -1 ) ,

            iLastCalendarId( 0 )

{

}

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

// CMyLocationsEngine::~CMyLocationsEngine()

// Destructor.

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

//

CMyLocationsEngine::~CMyLocationsEngine()

{

    __TRACE_CALLSTACK;// delete the member variables.

    Cancel();

    delete iContactChangeNotifier;

    delete iMyLocationsDatabaseManager;

    delete iLandmarkDb;

    delete iContactsDb;

    delete iCalView;

    delete iCalSession;

	delete iMapTileInterface;

    delete iMaptileDatabase;

    delete iCalenderNotification;

	delete iMyLocationThreeAMTimer;

    delete iContactManager;

    delete iContactSubscriber;

    delete iCalendarSubscriber;

    delete iGeocodeUpdate;

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

    {

        delete iAddressInfo[index];

        iAddressInfo.Remove(index);

        iAddressInfo.Compress();

    }

    iAddressInfo.Reset();

}

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

// 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::GetChangeNoficationL()

// To get callbacks through publisher from contact context

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

//

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

{

    __TRACE_CALLSTACK;

    iLastContactId = aId;

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

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

    {

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

        {           

            MYLOCLOGSTRING("contact id is in queue");

            return;

        }

    }

    TAppAddressInfo* addressInfo = new (ELeave) TAppAddressInfo;

    addressInfo->iUid = aId;

    addressInfo->iAddressType =  addressType;

    //Memory will be freed when the queue is deleted

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

    {

        delete addressInfo;

    }

    //Get all 3 adress

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

        return;  

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

    {

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

        //if type is contact

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

                      type == ESourceContactsHome )

        {

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

            CPosLandmark *contactAddressLm = NULL;

            TInt itemCount = 0;

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

            {

                QStringList context = address.contexts();

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

                {

                    contactAddressLm = GetContactAddressDetailsLC( address );

                    itemCount++;

                    break;

                }

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

                                    type == ESourceContactsHome )

                {

                    contactAddressLm = GetContactAddressDetailsLC( address );

                    itemCount++;

                    break;

                }

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

                                type == ESourceContactsWork )

                {

                    contactAddressLm = GetContactAddressDetailsLC( address );

                    itemCount++;

                    break;

                }

            }

            //Update the entry with inprogress status

            TLookupItem lookupItem;

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

            lookupItem.iSource = type;

            lookupItem.iFilePath.Zero();

            lookupItem.iFetchingStatus = EMapTileFetchingInProgress;

            iMaptileDatabase->UpdateEntryL( lookupItem );

            //Request for maptile fetching

            if( contactAddressLm )

            {

                RequestMapTileImageL( *contactAddressLm, type, 

                         iAddressInfo[index]->iUid, EContactDbObserverEventContactChanged );

            }

            CleanupStack::PopAndDestroy( itemCount );

        }

    }

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

    {

	    //free the allocated memory

        delete iAddressInfo[index];

		iAddressInfo.Remove(index);

        iAddressInfo.Compress();

	}

    iAddressInfo.Reset();

}

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

// CMyLocationsEngine::SubscribeFromCalendarL()

// To get callbacks through publisher from calendar context

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

//

void CMyLocationsEngine::SubscribeFromCalendarL(TInt aId)

{

    __TRACE_CALLSTACK;

    iLastCalendarId = aId;

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

    {

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

        {            

            return;

        }

    }

    CCalEntry* calEntry = NULL;

    calEntry = iCalView->FetchL(aId);

    CleanupStack::PushL(calEntry);

    TPtrC address(calEntry->LocationL());

    if( address.Length()>0 )

    {

        TLookupItem lookupItem;

        lookupItem.iUid = aId;

        lookupItem.iSource = ESourceCalendar;

        lookupItem.iFilePath.Zero();

        lookupItem.iFetchingStatus = EMapTileFetchingInProgress;

        iMaptileDatabase->UpdateEntryL( lookupItem );

        RequestMapTileImageL( address, ESourceCalendar, aId , EChangeModify );

    }

    CleanupStack::PopAndDestroy(calEntry);

}

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

// 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;

    iGeocodeUpdate->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();

}