/*

* Copyright (c) 2009 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:

*

*/

#include <etelmm.h>

#include <commsdattypesv1_1.h>

#include "cradionetworkinfolistener.h"

#include "mradiosettingssetter.h"

#include "cradioenginelogger.h"

using namespace CommsDat;

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

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

//

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

//

CRadioNetworkInfoListener* CRadioNetworkInfoListener::NewL( MRadioSettingsSetter& aSetter,

                                                            MRadioNetworkChangeObserver* aObserver )

    {

    CRadioNetworkInfoListener* self = new ( ELeave ) CRadioNetworkInfoListener( aSetter, aObserver );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

//

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

//

CRadioNetworkInfoListener::CRadioNetworkInfoListener( MRadioSettingsSetter& aSetter,

                                                      MRadioNetworkChangeObserver* aObserver )

    : CActive( CActive::EPriorityHigh )

    , iSetter( aSetter )

    , iObserver( aObserver )

    , iSubscriberIdPckg( iSubscriberId )

    , iNetworkInfoPckg( iNetworkInfo )

    {

    CActiveScheduler::Add( this );

    }

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

//

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

//

void CRadioNetworkInfoListener::ConstructL()

    {

    LOG_METHOD_AUTO;

#ifndef __WINS__

    iTelephony = CTelephony::NewL();

    // Initialize the default network id and country code directly from CommsDat, as CTelephony cannot be used in synchronous mode

    // and using it in async mode will cause problems in core initialisation, and too much complexity!

    // Get default TSY from database.

    CMDBSession* db = CMDBSession::NewL( CMDBSession::LatestVersion());

    CleanupStack::PushL( db );

    CMDBRecordSet<CCDModemBearerRecord>* set = new ( ELeave ) CMDBRecordSet<CCDModemBearerRecord>( KCDTIdModemBearerRecord );

    CleanupStack::PushL( set );

    set->LoadL( *db );

    TInt index = 0;

    CCDModemBearerRecord* record = static_cast<CCDModemBearerRecord*>( set->iRecords[index++]);

    if ( record->iTsyName.IsNull() && set->iRecords.Count() > index ) // the first item is normally only a template

        {

        record = static_cast<CCDModemBearerRecord*>( set->iRecords[index++]);

        }

    TPtrC name( static_cast<const TDesC&>( record->iTsyName ));

    TBuf<50> tsyName;

    tsyName.Copy( name );

    LOG_FORMAT( "CRadioNetworkInfoListener::ConstructL, TSY name: %S", &tsyName );

    CleanupStack::PopAndDestroy( set );

    CleanupStack::PopAndDestroy( db );

    RTelServer telServer;

    CleanupClosePushL( telServer );

    RMobilePhone mobilePhone;

    CleanupClosePushL( mobilePhone );

    //  Open phone

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

    // TSY module gets automatically unloaded when tel.Close() is called ( and tel is is CU-stack ),

    // so loaded TSY is also leave-safe

    User::LeaveIfError( telServer.LoadPhoneModule( tsyName ));

    // Get number of phones.

    TInt phones( 0 );

    User::LeaveIfError( telServer.EnumeratePhones( phones ));

    LOG_FORMAT( "CRadioNetworkInfoListener::ConstructL, Number of phones=%d", phones );

    // Get phone info of first legal phone.

    TInt legalPhoneIndex = KErrNotFound;

    RTelServer::TPhoneInfo phoneInfo;

    for ( TInt i=0; i<phones && legalPhoneIndex == KErrNotFound; i++)

        {

        if ( telServer.GetPhoneInfo( i, phoneInfo ) == KErrNone )

            {

            if ( phoneInfo.iNetworkType == RTelServer::ENetworkTypeMobileDigital )

                {

                legalPhoneIndex = i;

                }

            }

        }

    User::LeaveIfError( legalPhoneIndex );

    // Open legal phone.

    User::LeaveIfError( mobilePhone.Open( telServer, phoneInfo.iName ));

    TUint32 networkCaps;

    User::LeaveIfError( mobilePhone.GetNetworkCaps( networkCaps ));

    TUint32 identityCaps;

    User::LeaveIfError( mobilePhone.GetIdentityCaps( identityCaps ));

    // Check if we are allowed to get network info.

    if ( networkCaps & RMobilePhone::KCapsGetCurrentNetwork )

        {

        // Gather initial information synchronically.

        RMobilePhone::TMobilePhoneLocationAreaV1 location;

        RMobilePhone::TMobilePhoneNetworkInfoV1 networkInfo;

        RMobilePhone::TMobilePhoneNetworkInfoV1Pckg networkInfoPckg( networkInfo );

        mobilePhone.GetCurrentNetwork( iStatus, networkInfoPckg, location );

        User::WaitForRequest( iStatus );

        CTelephony::TNetworkInfoV1 telephonyNetworkInfo;

        if ( iStatus == KErrNone )

            {

            telephonyNetworkInfo.iMode = static_cast<CTelephony::TNetworkMode>( networkInfo.iMode );

            telephonyNetworkInfo.iCountryCode = networkInfo.iCountryCode;

            telephonyNetworkInfo.iCdmaSID = networkInfo.iCdmaSID;

            telephonyNetworkInfo.iNetworkId = networkInfo.iNetworkId;

            }

        else

            {

            telephonyNetworkInfo.iCountryCode = iSetter.CountryCode();

            telephonyNetworkInfo.iNetworkId = iSetter.NetworkId();

            }

            iNetworkInfoPckg() = telephonyNetworkInfo;

        }

    else

        {

        // Leave if we are not allowed to get network info.

        // Other action could also be considered!!!!

        User::Leave( KErrNotSupported );

        }

    if ( identityCaps & RMobilePhone::KCapsGetSubscriberId )

        {

        TRequestStatus stat;

        RMobilePhone::TMobilePhoneSubscriberId subscriberId;

        mobilePhone.GetSubscriberId( stat, subscriberId );

        User::WaitForRequest( stat );

        CTelephony::TSubscriberIdV1 telephonySubscriberId;

        if ( stat == KErrNone )

            {

            telephonySubscriberId.iSubscriberId = subscriberId;

            }

        else

            {

            telephonySubscriberId.iSubscriberId = iSetter.SubscriberId();

            }

        iSubscriberIdPckg() = telephonySubscriberId;

        }

    CleanupStack::PopAndDestroy( 2, &telServer );

#endif

    // At the end, update the local variables by simulating the "netid changed" event.

    RunL();

    }

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

//

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

//

CRadioNetworkInfoListener::~CRadioNetworkInfoListener()

    {

    Cancel();

#ifndef __WINS__

    delete iTelephony;

#endif

    }

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

//

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

//

TInt CRadioNetworkInfoListener::CompoundNetworkId() const

    {

    LOG_FORMAT( "CRadioNetworkInfoListener::CompoundNetworkId() - %d", iCompoundNetworkId );

    return iCompoundNetworkId;

    }

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

//

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

//

TPtrC CRadioNetworkInfoListener::SubscriberId() const

    {

    TPtrC id = iSubscriberId.iSubscriberId;

    LOG_FORMAT( "CRadioNetworkInfoListener::SubscriberId() - %S", &id );

    return id;

    }

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

//

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

//

TPtrC CRadioNetworkInfoListener::CountryCode() const

    {

    TPtrC countryCode = iSetter.CountryCode();

    LOG_FORMAT( "CRadioNetworkInfoListener::CountryCode() - %S", &countryCode );

    return countryCode;

    }

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

//

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

//

void CRadioNetworkInfoListener::SaveNetworkInfoL()

    {

#ifdef __WINS__

    iNetworkInfo.iCountryCode.Copy( _L("244") );

    iNetworkInfo.iNetworkId.Zero();

#endif

    LOG_FORMAT( "CRadioNetworkInfoListener::SaveNetworkInfoL() - iNetworkInfo.iCountryCode = %S",

                  &iNetworkInfo.iCountryCode );

    User::LeaveIfError( iSetter.SetCountryCode( iNetworkInfo.iCountryCode ) );

    // The compound network identifier is composed of the current network identifier and country code.

    TBuf<KDefaultRealWidth> compoundNetworkId;

    compoundNetworkId.Append( iSetter.CountryCode() );

    if ( iNetworkInfo.iNetworkId.Length() < 2 )

        {

        // Network identifier has only one digit, in which case it must be prepended with a zero.

        compoundNetworkId.AppendNum( 0 );

        }

    compoundNetworkId.Append( iNetworkInfo.iNetworkId );

    TLex lex( compoundNetworkId );

    User::LeaveIfError( lex.Val( iCompoundNetworkId ) );

    if ( iCompoundNetworkId != 0 && iPreviousCompoundNetworkId != iCompoundNetworkId )

        {

        if ( iPreviousCompoundNetworkId != 0 && iObserver )

            {

            iObserver->NetworkIdChanged();

            }

        iPreviousCompoundNetworkId = iCompoundNetworkId;

        }

    }

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

//

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

//

void CRadioNetworkInfoListener::DoCancel()

    {

#ifndef __WINS__

    iTelephony->CancelAsync( CTelephony::ECurrentNetworkInfoChangeCancel );

#endif

    }

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

//

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

//

void CRadioNetworkInfoListener::RunL()

    {

    LOG_FORMAT( "CRadioNetworkInfoListener::RunL() - iStatus.Int() = %d", iStatus.Int() );

#ifndef __WINS__

    iTelephony->NotifyChange( iStatus, CTelephony::ECurrentNetworkInfoChange, iNetworkInfoPckg );

    SetActive();

#endif

    SaveNetworkInfoL();

    }