/*

* 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:  Implementation of the GPS Watcher

*

*/

// INCLUDE FILES

#include <e32base.h>

#include <e32svr.h>

#include "GPSWatcher.h"

#include "GPSTimeUpdater.h"

#include "DRMClock.h"

#include "drmlog.h"

// Wait time in microseconds: wait 5 minutes

const TInt KGpsDefaultWaitTime = 300000000;

const TInt KMaxRetryCounter = 20;

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

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

// CGPSWatcher::CGPSWatcher

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

// might leave.

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

//   

CGPSWatcher::CGPSWatcher( CDRMClock* aClock ) :

	CTimer(EPriorityHigh),

	iClock( aClock ),

	iRetryCounter( 0 )

	{

	CActiveScheduler::Add(this);

	}

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

// CGPSWatcher::~CGPSWatcher

// C++ destructor

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

// 

CGPSWatcher::~CGPSWatcher()

	{

	Cancel();

	delete iTimeUpdater; 

	iTimeUpdater = 0; 

	iPosServer.Close();

	}

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

// CGPSWatcher::NewL

// Two-phased constructor

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

//

CGPSWatcher* CGPSWatcher::NewL( CDRMClock* aClock )

	{

	CGPSWatcher* self = new (ELeave) CGPSWatcher( aClock );

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

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

// CGPSWatcher::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CGPSWatcher::ConstructL()

	{

	CTimer::ConstructL();

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

	// Immediately subscribe for module status events

	iStatusEvent.SetRequestedEvents(TPositionModuleStatusEventBase::EEventDeviceStatus);

	Subscribe();

	// Check initial state

	CheckModules();

	}

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

// CGPSWatcher::Subscribe

// Subscribe to position events

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

//

void CGPSWatcher::Subscribe()

	{

	iPosServer.NotifyModuleStatusEvent(iStatusEvent, iStatus);

	SetActive();

	}

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

// CGPSWatcher::RunL

// Inherited from CActive

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

//

void CGPSWatcher::RunL()

	{

	// If there are errors just leave and stop watching:    

	DRMLOG2(_L("CGPSWatcher::RunL: error: '%d'"), iStatus.Int());   

	// If we already updated the time:

	if( iTimeUpdater && iTimeUpdater->TimeReceived() )

	    {

	    DRMLOG( _L("CGPSWatcher::RunL: time updater exists, time received, deleting"));    

	    iClock->Notify( CDRMClock::ENotifyGPSTimeReceived );    

	    DRMLOG( _L("CGPSWatcher::RunL: object deleted, returning"));

	    return;    

	    }

	// The server was killed:

    if( iStatus.Int() == KErrServerTerminated )

        {

        if( iRetryCounter > KMaxRetryCounter )

            {

            DRMLOG( _L("CGPSWatcher::RunL: Maximum retries reached, stopping watcher.") );    

            iClock->Notify( CDRMClock::ENotifyGPSTimeReceived );

            return;         

            }    

	    // If there are errors just leave and stop watching:    

	    DRMLOG2(_L("CGPSWatcher::RunL: server terminated, waiting '%d' microseconds"), KGpsDefaultWaitTime);               

        After( TTimeIntervalMicroSeconds32(KGpsDefaultWaitTime) );

        return;    

        }	  

	Subscribe();

	TPositionModuleStatusEventBase::TModuleEvent occurredEvents = iStatusEvent.OccurredEvents();

	DRMLOG2(_L("CGPSWatcher::RunL: occurredEvents = 0x%X"), occurredEvents);

	// If time updater is not running, check module statuses

	if(!iTimeUpdater)

		CheckModules();

	}

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

// CGPSWatcher::DoCancel

// Inherited from CActive

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

//

void CGPSWatcher::DoCancel()

	{

	iPosServer.CancelRequest(EPositionServerNotifyModuleStatusEvent);

	}

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

// CGPSWatcher::RunError

// Inherited from CActive

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

//

TInt CGPSWatcher::RunError( TInt /*aError*/ )

    {

    // ignore errors    

    return KErrNone;    

    }

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

// CGPSWatcher::CheckModules

// Check what modules are present and act accordingly

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

//

void CGPSWatcher::CheckModules()

	{

	// Get number of modules

	TUint numModules;

	if(iPosServer.GetNumModules(numModules)!=KErrNone || !numModules)

		return;

	// Collect all active and satellite capable modules

	TFullName moduleName;

	RPointerArray<TPositionModuleInfo> satelliteModules;

	TPositionModuleInfo *moduleInfo(0);

	for(TUint i=0; i<numModules; i++)

		{

		if(!moduleInfo)

			{

			moduleInfo = new TPositionModuleInfo;

			if(!moduleInfo)

			    {   

				continue;

			    }

			}

		// Get module info from the server

		if(iPosServer.GetModuleInfoByIndex(i, *moduleInfo) != KErrNone)

		    {

			continue;

            }

		// Check if the module is internal and satellite capable		

		if(! (moduleInfo->DeviceLocation() & TPositionModuleInfo::EDeviceInternal) ||

		   ! (moduleInfo->Capabilities() & TPositionModuleInfo::ECapabilitySatellite) )

			{

			// Not internal or satellite capable

			continue;

			}

		// Get module status

		TPositionModuleStatus moduleStatus;

		if(iPosServer.GetModuleStatus(moduleStatus, moduleInfo->ModuleId()) != KErrNone)

		    {

			continue;

		    }

		// Check if the module is active

		if(moduleStatus.DeviceStatus() != TPositionModuleStatus::EDeviceActive) 

		    {

			continue;

		    }

		moduleInfo->GetModuleName(moduleName);

		DRMLOG6( _L("Module %d: id=0x%08X, name = %S, cap=0x%08X, status=%d"), i, moduleInfo->ModuleId().iUid, &moduleName, moduleInfo->Capabilities(), moduleStatus.DeviceStatus());

		// Active internal satellite device, try to append in the array

		if(satelliteModules.Append(moduleInfo) == KErrNone)

		    {

			moduleInfo = 0;

		    }

		}

	delete moduleInfo;

	if(satelliteModules.Count())

		{

		DRMLOG( _L("Active satellite module available") );    

		// We have an active satellite module available

		TPositionModuleId moduleId = satelliteModules[0]->ModuleId();

		// Just allocating/deleting the time updater will do the trick

		iTimeUpdater = CGPSTimeUpdater::New(iPosServer, moduleId, iClock);

		}

	else

		{

		DRMLOG( _L("No active satellite modules available") );    

		// Delete time updater since no active GPS anymore

		delete iTimeUpdater; iTimeUpdater = 0;

		}

	satelliteModules.ResetAndDestroy();

	satelliteModules.Close();

	}