/*

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

#include "reversegeocoderplugin.h"

using namespace MdeConstants;

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

const TUid KReverseGeoCodeUid = {0x2002DD12};

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

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

                        iTagCreator(NULL),

                        iASW(NULL),

                        iTagPendingHandlerFlag(EFalse),

                        iRevGeocoderPlugin(NULL)

#ifdef LOC_GEOTAGGING_CELLID	

						,iGeoConverter(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

        iTagCreator = CTagCreator::NewL();

        iSessionReady = ETrue;

        iTagCreator->SetSession( iMdeSession );

        }

    else

        {

        iMdeSessionOwnFlag = ETrue;

        iASW = new (ELeave) CActiveSchedulerWait();

        iMdeSession = CMdESession::NewL( *this );

        //for creating tags

        iTagCreator = CTagCreator::NewL();

        iASW->Start();

        delete iASW;

        iASW = NULL;

        }

    //for reverse geocoding (geo-tagging)

    if (!iRevGeocoderPlugin)

            {

		   TRAP_IGNORE(

            iRevGeocoderPlugin = reinterpret_cast<CReverseGeoCoderPlugin*>(

               REComSession::CreateImplementationL(KReverseGeoCodeUid, iDtorKey));)

            if(iRevGeocoderPlugin)

            	{

               	iRevGeocoderPlugin->AddObserverL(*this); 

              }

            }

    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;

		}

	if(iLocationQuery)

		{

		iLocationQuery->RemoveObserver(*this);

		iLocationQuery->Cancel();

		delete iLocationQuery;

		}

	if(iTagQuery)

		{

		iTagQuery->RemoveObserver(*this);

		iTagQuery->Cancel();

		delete iTagQuery;

		}	

    delete iRevGeocoderPlugin;

    iRevGeocoderPlugin = NULL;

    REComSession::DestroyedImplementation(iDtorKey);	

    if(iMdeSessionOwnFlag)

        {

    	delete iMdeSession;

        delete iASW;

        }

    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 ( iMdeSessionOwnFlag && iASW && iASW->IsStarted() )

        {

        iASW->AsyncStop();

        }

    if ( KErrNone == aError )

        {

        iSessionReady = ETrue;

        iTagCreator->SetSession( iMdeSession );

        }

    else if(iMdeSessionOwnFlag)

        {

        delete iMdeSession;

        iMdeSession = NULL;

        }

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

    }

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

// CInternalGeoTagger::HandleSessionError

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

//

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

    {

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

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

        {

        iASW->AsyncStop();

        }

    iSessionReady = EFalse;

    if(iMdeSessionOwnFlag)

    	{

	    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.

                if(iRevGeocoderPlugin)

    			    {

                    TRAP_IGNORE( 

    				iRevGeocoderPlugin->GetAddressByCoordinateL

    				   ( iLocationData.iPosition, iConnectionOption ) );

    				}

    			else

    			    {

                    IterateNextLocation();  //Go through next location

    			    }

    			}

    		else

    		    {

        		if ( iLocationData.iNetworkInfo.iCellId > 0 && 

        				iLocationData.iNetworkInfo.iLocationAreaCode > 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)

                       {

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

                       }

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

        }

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

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

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

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

    if ( cellProp && lacProp && countryProp && networkProp)

        {

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

        iLocationData.iNetworkInfo.iLocationAreaCode = lacProp->Uint32ValueL();

        iLocationData.iNetworkInfo.iCountryCode = countryProp->TextValueL();

        iLocationData.iNetworkInfo.iNetworkId = networkProp->TextValueL();

        }

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

    }

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

// CInternalGeoTagger::LocationTagExists()

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

//

TBool CInternalGeoTagger::LocationTagExists()

    {

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

    TBool tagFound = EFalse;

    TInt error = KErrNone;

    const TInt count = iTagQuery->Count();

    for ( TInt i = 0; i < count; i++ )

        {

        CMdERelation& relation =  static_cast<CMdERelation&>( iTagQuery->ResultItem( i ) );

        TItemId tagId = relation.RightObjectId(); 

        CMdEObject* object = NULL;

        TRAP_IGNORE( object = iMdeSession->GetObjectL( tagId ) );

        error = object->Uri().Find( KCountry );

        if ( error == KErrNone )

            {

            i = count;

            tagFound = ETrue;

            }

        }