/*
 * MonitorSieci.h
 *
 * Autor: Pawe Gala
 */

#ifndef MONITORSIECI_H_
#define MONITORSIECI_H_

#include <e32base.h>    // CActive


class MMonitorSieci
    {
public:
    virtual void ZmianaStanuSieci( TBool aSiecDostepna ) = 0;
    
    /**
     * Metoda powinna zwrci ETrue, jeeli monitor ma kontynuowa dziaanie.
     * W przeciwnym wypadku musi zosta zwrcona warto EFalse.
     */
    virtual TBool BladMonitoraSieci( TInt aBlad ) = 0;
    };


class CRepository;

class CMonitorSieci : public CActive
    {
public:        // Konstruktor dwufazowy i destruktor
    static CMonitorSieci* NewL( MMonitorSieci& aMonitorSieci );
    virtual ~CMonitorSieci();
    
public:
    TInt Obserwuj();
    
protected:
    CMonitorSieci( MMonitorSieci& aMonitorSieci );
    void ConstructL();
    
private:    // Odziedziczone z CActive
    void DoCancel();
    void RunL();
    
private:    // Pola
    MMonitorSieci& iMonitorSieci;
    CRepository* iRep;
    };

#endif /* MONITORSIECI_H_ */


/*
 * MonitorSieci.cpp
 *
 * Author: Pawe Gala
 */

#include <centralrepository.h>                // CRepository
#include <coreapplicationuissdkcrkeys.h>    // Identyfikatory dla repozytorium

#include "MonitorSieci.h"


CMonitorSieci* CMonitorSieci::NewL( MMonitorSieci& aMonitorSieci )
    {
    CMonitorSieci* self = new( ELeave ) CMonitorSieci( aMonitorSieci );
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    return self;
    }

CMonitorSieci::CMonitorSieci( MMonitorSieci& aMonitorSieci )
:CActive( EPriorityStandard )
,iMonitorSieci( aMonitorSieci )
    {
    CActiveScheduler::Add( this );
    }

CMonitorSieci::~CMonitorSieci()
    {
    Cancel();
    delete iRep;
    }

void CMonitorSieci::ConstructL()
    {
    iRep = CRepository::NewL( KCRUidCoreApplicationUIs );
    }

TInt CMonitorSieci::Obserwuj()
    {
    TInt blad = KErrInUse;
    if( !IsActive() )
        {
        err = iRep->NotifyRequest( KCoreAppUIsNetworkConnectionAllowed, iStatus );
        SetActive();
        }
    return blad;
    }

void CMonitorSieci::DoCancel()
    {
    iRep->NotifyCancel( KCoreAppUIsNetworkConnectionAllowed );
    }

void CMonitorSieci::RunL()
    {
    TInt blad = iStatus.Int();
    // Zmienna 'blad' powinna zawiera numer klucza obserwowanej
    // zmiennej z repozytorium (w naszym przypadku blad = 1).
    
    if( blad >= 0 )
        {
        TInt stan = -1;
        blad = iRep->Get( KCoreAppUIsNetworkConnectionAllowed, stan );
        
        if( blad == KErrNone )
            {
            iMonitorSieci.ZmianaStanuSieci( stan );
            }
        } 

    TBool kontynuuj = ETrue;
    
    if( blad )
        {
        if( !iMonitorSieci.BladMonitoraSieci( blad ) )
            {
            kontynuuj = EFalse;
            }
        }
    
    // Aby kontynuowa obserwowanie zmiennej KCoreAppUIsNetworkConnectionAllowed,
    // ponownie musimy wywoa metod CRepository::NotifyRequest().
    if( kontynuuj )
        {
        Obserwuj();
        }
    }

// ----------------
// Uycie klasy CMonitorSieci
// ----------------

// Tworzymy obiekt monitora sieci.
iMonitorSieci = CMonitorSieci::NewL( *this );
// Rozpoczynamy obserwowanie dostpnoci sieci.
iMonitorSieci->Obserwuj();
