// The observer class
class MGeocodingObserver 
    {     
    public:
        // client must implement it
        virtual void HandleGeocodingCompletedL( CMnGeocoder& aGeocoder, TInt aError ) = 0;     
    }; 

// The asynchronous operation handler class
class CActiveSelector : public CActive
    {
    public:         
        CActiveSelector( MGeocodingObserver& aObserver );
        ~CActiveSelector();          
        
        // CActive-related methods
 	      void RunL();         
        void DoCancel();
        TInt RunError( TInt aError );          
        
        // Main operations
        
        // geocoding
        void FindCoordinateL( CPosLandmark& aAddress, CMnProvider& aProvider );
        // geocoding with plain string address 
        void FindCoordinateL( const TDesC& aPlainAddress, CMnProvider& aProvider );
        // reverse geocoding
        void FindAddressL( CPosLandmark& aCoordinate, CMnProvider& aProvider );
        
     private:        

        // disconnects from provider, when operation is completed         
        void Reset();
     
     private:         
        MGeocodingObserver&    iObserver;
        CMnGeocoder*           iGeocoder;     
     }; 

CActiveGeocoder::CActiveGeocoder( MObserver& aObserver ) 
:   CActive( CActive::EPriorityStandard ),
    iObserver( aObserver )
    {
    CActiveScheduler::Add( this );
    }

CActiveGeocoder::~CActiveGeocoder()
    {
    Cancel();
    }

void CActiveGeocoder::FindAddressL( CPosLandmark& aCoordinate, CMnProvider& aProvider )
    {
    if ( IsActive() )
        {
        // avoid two simultaneous asynchronous requests
        User::Leave( KErrInUse );
        }
        
    // create connection
    iGeocoder = CMnGeocoder::NewL( aProvider );
    
    // start request
    iGeocoder->FindAddressByCoordinateL( aCoordinate, iStatus );
    SetActive();
    }
    
void CActiveGeocoder::FindCoordinateL( CPosLandmark& aAddress, CMnProvider& aProvider )
    {
    if ( IsActive() )
        {
        // avoid two simultaneous asynchronous requests
        User::Leave( KErrInUse );
        }
        
    // create connection
    iGeocoder = CMnGeocoder::NewL( aProvider );
    
    // start request
    iGeocoder->FindCoordinateByAddressL( aAddress, iStatus );
    SetActive();
    }

void CActiveGeocoder::FindCoordinateL( const TDesC& aPlainAddress, CMnProvider& aProvider )
    {
    if ( IsActive() )
        {
        // avoid two simultaneous asynchronous requests
        User::Leave( KErrInUse );
        }
        
    // create connection
    iGeocoder = CMnGeocoder::NewL( aProvider );
    
    // start request
    iGeocoder->FindCoordinateByAddressL( aPlainAddress, iStatus );
    SetActive();
    }

void CActiveGeocoder::RunL()
    {
    // request is completed, inform observer
    iObserver.HandleGeocodingCompletedL( *iGeocoder, iStatus.Int() );
    Reset(); // disconnect once observer has retrieved result
    }
    
TInt CActiveGeocoder::RunError( TInt /*aError*/ )
    {
    Reset();
    return KErrNone;
    }

void CActiveGeocoder::DoCancel()
    {
    if ( IsActive() && iGeocoder )
        {
        iGeocoder->Cancel();
        }
    Reset();
    }
    
void CActiveGeocoder::Reset()
    {
    delete iGeocoder;
    iGeocoder = NULL;
    }

// Some client's class
class CClient : public CBase, public MGeocodingObserver
    {
    ...
    public: // These methods start various geocoding operations
        void FetchAddressL();
        void FetchCoordinateL();
        void FetchCoordinateByPlainAddressL();
    
    protected: 
        void ConstructL();
    
    protected: // from MGeocodingObserver       
        // this is called by CActiveGeocoder when request done
        void HandleGeocodingCompletedL( CMnGeocoder& aGeocoder, TInt aError );

    private:
        CActiveGeocoder* iGeocoder;
        CMnProvider*     iProvider;
    };
    
void CMnTestClientAppUi::ConstructL()
    {
    ...
    iGeocoder = new (ELeave) CActiveGeocoder( *this );
    
    // iProvider must be initialized to some provider application, 
    // which supports CMnProvider::EServiceGeocoding
    }

void CClientAppUi::FetchAddressL()
    {
    CPosLandmark* landmark = CPosLandmark::NewLC();

    TLocality loc( TCoordinate( 61.5, 23.4, 0 ), 0, 0 );
    landmark->SetPositionL(loc);

    // start operation using pre-chosen provider application
    iGeocoder->FindAddressL( *landmark, *iProvider );

    CleanupStack::PopAndDestroy( landmark );
    }
    
void CClientAppUi::FetchCoordinateL()
    {
    CPosLandmark* landmark = CPosLandmark::NewLC();
    lm->SetPositionFieldL( EPositionFieldCity, _L("Tampere") );

    // start operation using pre-chosen provider application
    iGeocoder->FindCoordinateL( *landmark, *iProvider );

    CleanupStack::PopAndDestroy( landmark );
    }

void CClientAppUi::FetchCoordinateByPlainAddressL()
    {
    _LIT( KPlainAddress, "Visiokatu Tampere Finland" );

    // start operation using pre-chosen provider application
    iGeocoder->FindCoordinateL( KPlainAddress, *iProvider );
    }

void CClientAppUi::HandleGeocodingCompletedL( CMnGeocoder& aGeocoder, TInt aError )
    {
    // selection is done, analyze error code first...
    if ( aError )
        {
        // geocoding failed
        }
    else
        {
        // ... and retrieve result
        CPosLandmark* landmark = CPosLandmark::NewLC();
        aGeocoder.RetrieveGeocodingResultL( *landmark );
        
        // landmark contains requested data: address info or coordinate
        
        CleanupStack::PopAndDestroy( landmark );
        }
    }