iStatusUpdater( NULL ),

	iGpsStatus( CPosIntGpsHwStatus::EStatusUnknown )

    iTimeUpdaters.ResetAndDestroy();

	iActiveSatelliteModules.ResetAndDestroy();

    delete iStatusUpdater;

    TRequestStatus* status = &iStatus;    	    

    // Create the status updater

    iStatusUpdater = CPosIntGpsHwStatus::NewL(*this);

    // Get the status manually, if we can, it's ok if we cant

    TRAP_IGNORE( iStatusUpdater->GetStatusL( iGpsStatus ) );

    if( !IsActive() )

        {

        SetActive();    

        }

    User::RequestComplete(status, KErrNone);   

// CGPSWatcher::OnStatusUpdateEvent

// Inherited from MPosIntGpsHwStatusObserver

void CGPSWatcher::OnStatusUpdateEvent(CPosIntGpsHwStatus::TIntGpsHwStatus aStatus, TInt aError)

    {

    TRequestStatus* status = &iStatus;    

    // store the status from the Gps:

    iGpsStatus = aStatus;

    User::RequestComplete(status, aError);

    if( !IsActive() )

        {        

        SetActive();

        }    

    }

    TInt error = KErrNone;

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

    switch( iGpsStatus )

        // GPS HW is used and is receiving location fixes.

        case CPosIntGpsHwStatus::EStatusOn:

            DRMLOG(_L("CGPSWatcher::RunL: CPosIntGpsHwStatus::EStatusOn: Checking modules"));

            // No active modules, check again:

            if( !iActiveSatelliteModules.Count() )

                {

                DRMLOG(_L("CGPSWatcher::RunL: CPosIntGpsHwStatus::EStatusOn: No active modules in list Checking modules"));    

                error = CheckModules();    

                }

            // if we have some or found some check the satellites for updates:    

            if( !error && iActiveSatelliteModules.Count() )

                {

                DRMLOG2(_L("CGPSWatcher::RunL: CPosIntGpsHwStatus::EStatusOn: Active modules available (%d), check satellites"), iActiveSatelliteModules.Count());                     

                // Get the time update:

                CheckSatellites();   

                }

            else

                {

                DRMLOG2(_L("CGPSWatcher::RunL: CPosIntGpsHwStatus::EStatusOn: Still no active modules in list or error (%d) occurred"), error);                     

                }        

            break;  

        // GPS HW is used and is searching for location.

        case CPosIntGpsHwStatus::EStatusActive:

            // Get a list of active GPS modules:

            DRMLOG(_L("CGPSWatcher::RunL: CPosIntGpsHwStatus::EStatusActive: Checking modules"));

            // return value not important:

            CheckModules();

            break;

        case CPosIntGpsHwStatus::EStatusUnknown:

        case CPosIntGpsHwStatus::EStatusOff:

            // Clear the list of modules:

            DRMLOG2(_L("CGPSWatcher::RunL: CPosIntGpsHwStatus::EStatusUnknown,Off or default: (%d) Checking modules"), iGpsStatus);            

            iActiveSatelliteModules.ResetAndDestroy();  

            iTimeUpdaters.ResetAndDestroy();         

        default:

            // Do nothing    

            break;   

        }		

TInt CGPSWatcher::CheckModules()

	TUint numModules = 0;

	TPositionModuleInfo* moduleInfo = NULL;

	TInt error = KErrNone;

	RPositionServer posServer;

	// Destroy the old list:

	iActiveSatelliteModules.ResetAndDestroy();

	// open connection to the positioning server:	    

    error = posServer.Connect();		    

	if( error )

	    {

	    return error;    

	    }	    

    error = posServer.GetNumModules( numModules );		    

	if(error || !numModules)

	    {

        DRMLOG2(_L("CheckModules: modules available (%d)"), numModules);	  

        DRMLOG2(_L("CheckModules: error code (%d)"), error);	          

		return KErrNotFound;

        }

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

            if( !moduleInfo )

                {

                // in practice OOM situation

                posServer.Close();    

                return KErrNoMemory;    

                }

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

        DRMLOG(_L("CheckModules: Checking for internal & satellite capable"));	

		// Get module status and check if the module is actually active:

        DRMLOG(_L("CheckModules: Checking module status"));	

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

		// Check if the module is active or ready as all might not use the active state:

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

		     moduleStatus.DeviceStatus() == TPositionModuleStatus::EDeviceReady) ) 

        DRMLOG(_L("CheckModules: Module is ready or active"));	

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

		    // Set this to 0 so that on the next round a new one will be created

		    // old one will be in the list:   

            DRMLOG2(_L("CheckModules: Appended modules to list available (%d) active now available"), iActiveSatelliteModules.Count());		     

	// There is a module created which was not added, delete it.	

	if( moduleInfo )

	    {

	    delete moduleInfo;

	    moduleInfo = NULL;    

	    }	

	// close connection to the positioning server:    

	posServer.Close();

	return KErrNone;

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

// CGPSWatcher::CheckSatellites()

// Check what modules are present and act accordingly

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

//

void CGPSWatcher::CheckSatellites()

    {

    CGPSTimeUpdater* updater = NULL;

    iTimeUpdaters.ResetAndDestroy();

    // Start as many updaters as needed:    

    for( TInt i = 0; i < iActiveSatelliteModules.Count(); i++ )

        {

        updater = CGPSTimeUpdater::New( iActiveSatelliteModules[i]->ModuleId(), iClock );

        if( updater )

            {

            if( iTimeUpdaters.Append(updater) ) 

                {

                delete updater;

                updater = NULL;    

                }

            }

        }    

    }

// End of File