/*

* Copyright (c) 2002 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:   Mobile signal strength handler implementation

*

*/

// INCLUDE FILES

#include <mmtsy_names.h>

#include "CNcnMobileSignalStrengthHandler.h"

#include "MNcnSignalStrengthObserver.h"

#include "NcnDebug.h"

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

// CNcnMobileSignalStrengthHandler::NewL

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

CNcnMobileSignalStrengthHandler* CNcnMobileSignalStrengthHandler::NewL( )

    {

    CNcnMobileSignalStrengthHandler* self = new (ELeave) CNcnMobileSignalStrengthHandler();

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CNcnMobileSignalStrengthHandler::~CNcnMobileSignalStrengthHandler

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

CNcnMobileSignalStrengthHandler::~CNcnMobileSignalStrengthHandler()

    {

    Cancel();

    // close session handles

    iMobilePhone.Close();

    iTelServer.Close();    

    }

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

// CNcnMobileSignalStrengthHandler::CNcnMobileSignalStrengthHandler

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

CNcnMobileSignalStrengthHandler::CNcnMobileSignalStrengthHandler() :

    CActive( EPriorityNormal )

    {

    // empty

    }

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

// CNcnMobileSignalStrengthHandler::ConstructL

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

void CNcnMobileSignalStrengthHandler::ConstructL()

    {

    // add AO to scheduler

    CActiveScheduler::Add( this );

    // initialize sessions

    InitializeSessionsL();

    }

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

// CNcnMobileSignalStrengthHandler::RunL

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

void CNcnMobileSignalStrengthHandler::RunL()

    {

    NCN_RDEBUG( _L("CNcnMobileSignalStrengthHandler::RunL") );

    // if operation completed successfully

    if( iStatus.Int() == KErrNone )

        {

        NCN_RDEBUG_INT( _L("CNcnMobileSignalStrengthHandler::RunL - Signal strength updated to %d"),

            iSignalStrength );

        NotifyObserver();

        }

    // if observing is still active reissue the notification request    

    if( iObserving )

        {

        NCN_RDEBUG( _L("CNcnMobileSignalStrengthHandler::RunL - NotifySignalStrengthChange") );

       // request

        iMobilePhone.NotifySignalStrengthChange( iStatus, iSignalStrength, iBars );

        // activate

        SetActive();

        }

    }

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

// CNcnMobileSignalStrengthHandler::RunError

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

TInt CNcnMobileSignalStrengthHandler::RunError( TInt aError )

    {

    return aError;

    }

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

// CNcnMobileSignalStrengthHandler::DoCancel

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

void CNcnMobileSignalStrengthHandler::DoCancel()

    {

    // cancel notification request

    // if we're observing

    if( iObserving )

        {

        iMobilePhone.CancelAsyncRequest( EMobilePhoneNotifySignalStrengthChange );

        }    

    }

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

// CNcnMobileSignalStrengthHandler::ObservingSupported

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

TBool CNcnMobileSignalStrengthHandler::ObservingSupported()

    {

    TUint32 caps;

    iMobilePhone.GetSignalCaps( caps );

    return ( caps & RMobilePhone::KCapsNotifySignalStrengthChange );

    }

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

// CNcnMobileSignalStrengthHandler::RequestsSupported

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

TBool CNcnMobileSignalStrengthHandler::RequestsSupported()

    {

    TUint32 caps;

    iMobilePhone.GetSignalCaps( caps );

    return ( caps & RMobilePhone::KCapsGetSignalStrength );

    }

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

// CNcnMobileSignalStrengthHandler::SetSignalStrengthObserverL

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

void CNcnMobileSignalStrengthHandler::SetSignalStrengthObserverL(

    MNcnSignalStrengthObserver* aObserver )

    {

    // leave if observing is not supported

    if( !ObservingSupported() )

        {

        User::Leave( KErrNotSupported );

        }

    iObserver = aObserver;

    }

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

// CNcnMobileSignalStrengthHandler::StartObservingL

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

void CNcnMobileSignalStrengthHandler::StartObservingL()

    {

    // leave if observing is not supported

    if( !ObservingSupported() )

        {

        User::Leave( KErrNotSupported );

        }        

    // update signal str

    TRAPD( err, UpdateSignalStrengthL() );

    // check operation

    if( err != KErrNone )

        {        

        NCN_RDEBUG_INT( _L("CNcnMobileSignalStrengthHandler::StartObservingL - Failed to initialize signal strength (err = %d)"),

            err );

        iSignalStrength = 0;

        }

    else

        {

        NCN_RDEBUG_INT( _L("CNcnMobileSignalStrengthHandler::StartObservingL - Signal strength initialized to %d"),

            iSignalStrength );

        }

    // update state

    iObserving = ETrue;

    // Notify current observer about signal strength

    NotifyObserver();

    // request for notification    

    iMobilePhone.NotifySignalStrengthChange( iStatus, iSignalStrength, iBars );

    // activate

    SetActive();                            

    }

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

// CNcnMobileSignalStrengthHandler::StopObservingL

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

void CNcnMobileSignalStrengthHandler::StopObservingL()

    {

    if( !iObserving )

        {

        User::Leave( KErrGeneral );

        }

    // cancel the request    

    Cancel();

    // update state

    iObserving = EFalse;

    }

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

// CNcnMobileSignalStrengthHandler::SignalStrengthL

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

TInt CNcnMobileSignalStrengthHandler::SignalStrengthL()

    {

    // leave if requests are not supported

    if( !RequestsSupported() )

        {

        User::Leave( KErrNotSupported );

        }

    // if we're not observing we have to update the value manually,

    // otherwise value is up-to-date    

    if( !iObserving )

        {

        UpdateSignalStrengthL();

        }

    // return the current value

    return iSignalStrength;        

    }

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

// CNcnMobileSignalStrengthHandler::BarValueL

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

TInt CNcnMobileSignalStrengthHandler::BarValueL()

    {

    // leave if requests are not supported

    if( !RequestsSupported() )

        {

        User::Leave( KErrNotSupported );

        }

    // if we're not observing we have to update the value manually,

    // otherwise value is up-to-date    

    if( !iObserving )

        {

        UpdateSignalStrengthL();

        }

    // return the current value

    return iBars;      

    }

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

// CNcnMobileSignalStrengthHandler::InitializeSessionsL

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

void CNcnMobileSignalStrengthHandler::InitializeSessionsL()

    {

    // connect to tel server

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

    RTelServer::TPhoneInfo phoneInfo;

    TInt numPhone;

    // load tsy module and get number of phones

    User::LeaveIfError( iTelServer.LoadPhoneModule( KMmTsyModuleName ) );

    User::LeaveIfError( iTelServer.EnumeratePhones( numPhone) );

    // find the correct phone

    for (TInt i(0); i < numPhone; i++)

        {

        TName tsyName;

        User::LeaveIfError( iTelServer.GetPhoneInfo( i, phoneInfo ) );

        User::LeaveIfError( iTelServer.GetTsyName( i,tsyName ) );

        if ( tsyName.CompareF( KMmTsyModuleName ) == 0)

            {

            break;

            }

        }

    // open mobile phone session    

    User::LeaveIfError( iMobilePhone.Open( iTelServer, phoneInfo.iName ) );        

    }

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

// CNcnMobileSignalStrengthHandler::UpdateSignalStrengthL

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

void CNcnMobileSignalStrengthHandler::UpdateSignalStrengthL()

    {

    // only update the value if requests are supported

    if( RequestsSupported() )

        {

        TRequestStatus status;                

        // get signal strength

        iMobilePhone.GetSignalStrength( status, iSignalStrength, iBars );

        // Wait for request since we need to be able to supply

        // the signal strength from syncrhonous access method (we

        // have to wait somewhere anyway)

        User::WaitForRequest( status );

        NCN_RDEBUG_INT( _L("CNcnMobileSignalStrengthHandler::UpdateSignalStrengthL - GetSignalStrength returned with %d"),

            status.Int() );

        // leave if error was encountered

        User::LeaveIfError( status.Int() );

        }

    }

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

// CNcnMobileSignalStrengthHandler::NotifyObserver

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

void CNcnMobileSignalStrengthHandler::NotifyObserver()

    {

    // notify observer, if set

    if( iObserver )

        {

        TRAP_IGNORE( iObserver->SignalStrengthAndBarUpdatedL( iSignalStrength, iBars ) );

        }

    }

//  End of File