/*

* Copyright (c) 2009 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:  A class responsible for geotagging of media files in background.

*

*/

#include <e32cmn.h> 

#include <lbserrors.h>

#include <lbssatellite.h>

#include <ecom.h>

#include "locationmanagerdebug.h"

#include "mdeconstants.h"

#include "mdesession.h"

#include "cinternalgeotagger.h"

using namespace MdeConstants;

_LIT ( KCountry, "country:");   // country:india 

const TReal64 KZeroLatLon (0.000000 );

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

// CInternalGeoTagger::NewL

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

//

EXPORT_C CInternalGeoTagger* CInternalGeoTagger::NewL( CMdESession* aMdeSession,

            MGeoTaggerObserver* aObserver )

    {

    CInternalGeoTagger* self = 

            new (ELeave) CInternalGeoTagger( aMdeSession, aObserver );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CInternalGeoTagger::CInternalGeoTagger

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

//  

CInternalGeoTagger::CInternalGeoTagger( CMdESession* aMdeSession,

        MGeoTaggerObserver* aObserver )

                        : iMdeSession(aMdeSession),

                        iLocationQuery(NULL),

                        iRelationQuery(NULL),

                        iTagQuery(NULL),

                        iIndex(0),

                        iSessionReady( EFalse ),

                        iObserver( aObserver ),

                        iASW(NULL),

                        iTagPendingHandlerFlag(EFalse)

#ifdef LOC_GEOTAGGING_CELLID

						,iGeoConverter(NULL)

#endif						

#ifdef LOC_REVERSEGEOCODE

                        ,iTagCreator(NULL)

                        ,iRevGeocoderPlugin(NULL)

#endif						

    {

    iMdeSessionOwnFlag = (iMdeSession == NULL);

    }

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

// CInternalGeoTagger::ConstructL

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

//    

void CInternalGeoTagger::ConstructL()

    {

    LOG("CInternalGeoTagger::ConstructL ,begin");

    if(iMdeSession != NULL)

        {

		LOG("Not owning mds session");

        iMdeSessionOwnFlag = EFalse;

        //object is not owning iMdeSession

        iSessionReady = ETrue;

#ifdef LOC_REVERSEGEOCODE

        iTagCreator = CTagCreator::NewL();

        iTagCreator->SetSession( iMdeSession );

#endif //LOC_REVERSEGEOCODE

        }

    else

        {

        iMdeSessionOwnFlag = ETrue;

        iASW = new (ELeave) CActiveSchedulerWait();

        iMdeSession = CMdESession::NewL( *this );

        //for creating tags

#ifdef LOC_REVERSEGEOCODE

        iTagCreator = CTagCreator::NewL();

#endif

        iASW->Start();

        delete iASW;

        iASW = NULL;

        }

    //for reverse geocoding (geo-tagging)

#ifdef LOC_REVERSEGEOCODE

#endif //LOC_REVERSEGEOCODE

    LOG("CInternalGeoTagger::ConstructL ,end");

    }

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

// CInternalGeoTagger::~CInternalGeoTagger

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

//    

CInternalGeoTagger::~CInternalGeoTagger()

    {  

    LOG("CInternalGeoTagger::~CInternalGeoTagger ,begin");

#ifdef LOC_GEOTAGGING_CELLID

    if(iGeoConverter)

        {

        delete iGeoConverter;

        iGeoConverter = NULL;

        }

#endif    

	if(iRelationQuery)

		{

		iRelationQuery->RemoveObserver(*this);

		iRelationQuery->Cancel();

		delete iRelationQuery;

		iRelationQuery = NULL;

		}

	if(iLocationQuery)

		{

		iLocationQuery->RemoveObserver(*this);

		iLocationQuery->Cancel();

		delete iLocationQuery;

		iLocationQuery = NULL;

		}

	if(iTagQuery)

		{

		iTagQuery->RemoveObserver(*this);

		iTagQuery->Cancel();

		delete iTagQuery;

		iTagQuery = NULL;

		}	

#ifdef LOC_REVERSEGEOCODE

    delete iTagCreator;

    iTagCreator = NULL;

    delete iRevGeocoderPlugin;

    iRevGeocoderPlugin = NULL;

#endif //LOC_REVERSEGEOCODE

    if(iMdeSessionOwnFlag)

        {

    	delete iMdeSession;

    	iMdeSession = NULL; 

        delete iASW;

        iASW = NULL;

        }

    LOG("CInternalGeoTagger::~CInternalGeoTagger ,end");

    }

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

// CInternalGeoTagger::CreateGeoTags

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

//

void CInternalGeoTagger::CreateGeoTagsL( const TConnectionOption aOption )

    {  

    LOG("CInternalGeoTagger::CreateGeoTagsL ,begin");

    if ( !IsSessionReady() )

        {

        User::Leave( KErrNotReady );

        }

    iConnectionOption = aOption;

    iIndex = 0;

    GetAllLocationsL();

    LOG("CInternalGeoTagger::CreateGeoTagsL ,end");

    }

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

// CInternalGeoTagger::HandleSessionOpened

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

//

void CInternalGeoTagger::HandleSessionOpened(CMdESession& /*aSession*/, TInt aError)

    {

    LOG("CInternalGeoTagger::HandleSessionOpened ,begin");

    if ( iASW && iASW->IsStarted() )

        {

        iASW->AsyncStop();

        }

    if ( KErrNone == aError )

        {

        iSessionReady = ETrue;

#ifdef LOC_REVERSEGEOCODE

        iTagCreator->SetSession( iMdeSession );

#endif

        }

    else 

        {

        delete iMdeSession;

        iMdeSession = NULL;

        }

    LOG("CInternalGeoTagger::HandleSessionOpened ,end");

    }

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

// CInternalGeoTagger::HandleSessionError

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

//

void CInternalGeoTagger::HandleSessionError(CMdESession& /*aSession*/, TInt /*aError*/)

    {

    LOG("CInternalGeoTagger::HandleSessionError ,begin");

    if (iASW && iASW->IsStarted() )

        {

        iASW->AsyncStop();

        }

    iSessionReady = EFalse;

	delete iMdeSession;

	iMdeSession = NULL;

    LOG("CInternalGeoTagger::HandleSessionError ,end");

    }

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

// CInternalGeoTagger::IsSessionReady

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

//

TBool CInternalGeoTagger::IsSessionReady()

    {

    return iSessionReady;

    }

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

// CInternalGeoTagger::GetRelationObjectsL()

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

//

void CInternalGeoTagger::GetRelationObjectsL(TItemId aLocID)

	{

    LOG("CInternalGeoTagger::GetRelationObjectsL ,begin");

	CMdENamespaceDef& namespaceDef = iMdeSession->GetDefaultNamespaceDefL();

	CMdEObjectDef& imageObjDef = namespaceDef.GetObjectDefL( Image::KImageObject );

	if(iRelationQuery)

		{

		iRelationQuery->RemoveObserver(*this);

		iRelationQuery->Cancel();

		delete iRelationQuery;

    	iRelationQuery = NULL;

		}

    iRelationQuery = iMdeSession->NewRelationQueryL( namespaceDef, this );

    User::LeaveIfNull( iRelationQuery );

    iRelationQuery->SetResultMode( EQueryResultModeItem );

    // both left and right condition must match

    CMdERelationCondition& filterCond = iRelationQuery->Conditions().

    		AddRelationConditionL( ERelationConditionSideRight );

    // left one must be any image object.

    filterCond.LeftL().AddObjectConditionL( imageObjDef );

    // right one must be this location object 

    filterCond.RightL().AddObjectConditionL( aLocID );

    iRelationQuery->FindL(); // results to a call to HandleQueryCompleted()

    LOG("CInternalGeoTagger::GetRelationObjectsL ,end");

	}

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

// CInternalGeoTagger::HandleQueryNewResults()

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

//

void CInternalGeoTagger::HandleQueryNewResults(CMdEQuery& /*aQuery*/, TInt /*aFirstNewItemIndex*/, 

		TInt /*aNewItemCount*/)

	{

	LOG("CInternalGeoTagger::HandleQueryNewResults ,begin");

	}

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

// CInternalGeoTagger::HandleQueryCompleted()

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

//

void CInternalGeoTagger::HandleQueryCompleted(CMdEQuery& aQuery, TInt aError)

    {

    LOG("CInternalGeoTagger::HandleQueryCompleted ,begin");

    TInt count = aQuery.Count();

    LOG1("CInternalGeoTagger::HandleQueryCompleted count: %d", count);

    if ( &aQuery == iLocationQuery )

        {

        if ( count )

            {

            iLocationId = iLocationQuery->ResultId( iIndex++ );

            TRAP_IGNORE( GetRelationObjectsL( iLocationId ) );

            }

        else 

            {

            iIndex = 0;

            iObserver->GeoTaggingCompleted( aError );

            if(iTagPendingHandlerFlag)

                {

                iTagPendingHandlerFlag = EFalse;

                iObserver->PendingGeoTagReqComplete(KErrNone);

                }

            }  

        }

    else if ( &aQuery == iRelationQuery )

        {

        //if it is a relation query, then update gps info of location object.

        if ( iRelationQuery->Count() )

            {

            TInt err = KErrNone;

            TRAP(err, StartGeoTaggingL( ) );              

            if(err != KErrNone)

                {

                IterateNextLocation();

                }

            }

        else

            {

            IterateNextLocation();

            }

        }

    else if ( &aQuery == iTagQuery )

        {

        if ( LocationTagExists() )  //nothing to do for this location

            {

            IterateNextLocation();  //Go through next location

            }

        else   //do reverse geocoding

            {          

            if(iTagPendingHandlerFlag)

                {

                iIndex = 0;

                iTagPendingHandlerFlag = EFalse;

                iObserver->PendingGeoTagReqComplete(KErrNotFound);

                return;

                }

            //Find the address for this geo-coordinate

            if(GPSInfoExists())

                {

                // GPS info exist go for reverse geo coding.

#ifdef LOC_REVERSEGEOCODE

                if(iRevGeocoderPlugin)

    			    {

                    TRAP_IGNORE( 

    				iRevGeocoderPlugin->GetAddressByCoordinateL

    				   ( iLocationData.iPosition, iConnectionOption ) );

    				}

    			else

#endif //LOC_REVERSEGEOCODE

    			    {

                    IterateNextLocation();  //Go through next location

    			    }

    			}

    		else

    		    {

        		if ( iLocationData.iNetworkInfo.iCellId > 0 && 

        				iLocationData.iNetworkInfo.iCountryCode.Length() > 0 &&

        				iLocationData.iNetworkInfo.iNetworkId.Length() > 0 )

        			{

        			// valid n/w information.. go for cell id based geo coding.

#ifdef LOC_GEOTAGGING_CELLID

                    TInt err = KErrNone;

                    if(iGeoConverter == NULL)

                       {

                       TRAP(err, iGeoConverter = CGeoConverter::NewL(*this));

                       }

                    if(err == KErrNone && iGeoConverter != NULL)

                       {

                       // there is no field to store type of network. 

                       // but it's safe to take decission based on area code.

                       if(iLocationData.iNetworkInfo.iLocationAreaCode > 0)

                           {

                           LOG("Valid areacode. Treat as GSM n/w");

                           iLocationData.iNetworkInfo.iAccess = CTelephony::ENetworkAccessGsm;

                           }

                       else

                           {

                           LOG("Areacode is 0. Treat as 3G n/w");

                           iLocationData.iNetworkInfo.iAccess = CTelephony::ENetworkAccessUtran;

                           }

                       TRAP(err, iGeoConverter->ConvertL(iLocationData.iNetworkInfo);)

                       }

                    LOG1("Error - %d", err);

                   if(err != KErrNone)

                       {

                       HandleConversionError(err);	

                       }

#else

                    IterateNextLocation();  //Go through next location

#endif                    

        			}

        		else

        		    {

                    IterateNextLocation();  //Go through next location

        		    }

    		    }

            }

        }

    LOG("CInternalGeoTagger::HandleQueryCompleted ,end");

    }

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

// CInternalGeoTagger::GPSInfoExists()

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

//

TBool CInternalGeoTagger::GPSInfoExists()

    {

    LOG("CInternalGeoTagger::GPSInfoExists");

    TBool gpsInfoExists = EFalse;

    if ( !Math::IsNaN( iLocationData.iPosition.Latitude() ) && 

                !Math::IsNaN( iLocationData.iPosition.Longitude() ) &&

                KZeroLatLon != iLocationData.iPosition.Latitude() && 

                KZeroLatLon != iLocationData.iPosition.Longitude() )  //lat, long is there

        {

		LOG("Valid lat/lon\n");

        gpsInfoExists = ETrue;

        }

    return gpsInfoExists;

    }

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

// CInternalGeoTagger::StartGeoTagging()

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

//

void CInternalGeoTagger::StartGeoTaggingL( )

    {       

    LOG("CInternalGeoTagger::StartGeoTaggingL ,start");

    GetLocationInfoL();

    CMdERelation& relation = iRelationQuery->Result( 0 );

    GetTagsL( relation.LeftObjectId() );

	LOG("CInternalGeoTagger::StartGeoTaggingL ,end");

    }

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

// CInternalGeoTagger::GetLocationInfoL()

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

//

void CInternalGeoTagger::GetLocationInfoL()

    {

    LOG("CInternalGeoTagger::GetLocationInfoL, begin");

    CMdENamespaceDef& namespaceDef = iMdeSession->GetDefaultNamespaceDefL();

    CMdEObjectDef& locationObjectDef = namespaceDef.GetObjectDefL( Location::KLocationObject );

    CMdEPropertyDef& latitudeDef = locationObjectDef.GetPropertyDefL( 

                                        Location::KLatitudeProperty );

    CMdEPropertyDef& longitudeDef = locationObjectDef.GetPropertyDefL( 

                                        Location::KLongitudeProperty );

    CMdEPropertyDef& cellIdDef = locationObjectDef.GetPropertyDefL( 

                                        Location::KCellIdProperty );

    CMdEPropertyDef& lacCodeDef = locationObjectDef.GetPropertyDefL( 

                                        Location::KLocationAreaCodeProperty );

    CMdEPropertyDef& countryCodeDef = locationObjectDef.GetPropertyDefL( 

                                        Location::KCountryCodeProperty );

    CMdEPropertyDef& networkCodeDef = locationObjectDef.GetPropertyDefL( 

                                        Location::KNetworkCodeProperty );

    CMdEObject* locationObject = NULL;

    CMdEProperty* latProp = NULL;

    CMdEProperty* lonProp = NULL;

    CMdEProperty* cellProp = NULL;

    CMdEProperty* lacProp = NULL;

    CMdEProperty* countryProp = NULL;

    CMdEProperty* networkProp = NULL;

    locationObject = iMdeSession->GetObjectL( iLocationId, locationObjectDef );

    locationObject->Property( latitudeDef, latProp, 0 );

    locationObject->Property( longitudeDef, lonProp, 0 );

    if ( latProp && lonProp )

        {

        iLocationData.iPosition.SetCoordinate( latProp->Real64ValueL(), 

                                               lonProp->Real64ValueL() );

        }

    else

        {

        iLocationData.iPosition.SetCoordinate( KZeroLatLon, 

                                               KZeroLatLon );

        }

    locationObject->Property( cellIdDef, cellProp, 0 );

    locationObject->Property( lacCodeDef, lacProp, 0 );

    locationObject->Property( countryCodeDef, countryProp, 0 );

    locationObject->Property( networkCodeDef, networkProp, 0 );

    if ( cellProp && countryProp && networkProp)

        {

        iLocationData.iNetworkInfo.iCellId = cellProp->Uint32ValueL();