/*

* Copyright (c) 2004-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: MPM server implementation

*

*/

/**

@file mpmserver.cpp

Mobility Policy Manager server implementation.

*/

// INCLUDE FILES

#include <commdb.h>

#include <etel3rdparty.h>                // Voice call notification

#include <mmtsy_names.h>                 // KMmTsyModuleName

#include <centralrepository.h>

#include "mpmserver.h"

#include "mpmserversession.h"

#include "mpmconnmonevents.h"

#include "mpmlogger.h"

#include "mpmdtmwatcher.h"

#include "mpmroamingwatcher.h"

#include "mpmdisconnectdlg.h"

#include "mpmconfirmdlgroaming.h"

#include "mpmconfirmdlgstarting.h"

#include "mpmdefaultconnection.h"

#include "mpmcommsdataccess.h"

#include "mpmwlanquerydialog.h"

#include "mpmdialog.h"

#include "mpmprivatecrkeys.h"

#include "mpmcsidwatcher.h"

#include "mpmdatausagewatcher.h"

#include "mpmpropertydef.h"

// ============================= LOCAL FUNCTIONS ===============================

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

// PanicServer 

// Panics the server in case of programming error.

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

//

void PanicServer( TInt aPanic )

    {

    User::Panic( KMPMPanicCategory, aPanic );

    }

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

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

// CMPMServer::NewL

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

//

CMPMServer* CMPMServer::NewL()

    {

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

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CMPMServer::CMPMServer

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

//

CMPMServer::CMPMServer()

    : CPolicyServer( CPolicyServer::EPriorityStandard, KMPMPolicy ),

      iEvents( NULL ), 

      iTSYLoaded( EFalse ),

      iPacketServLoaded( EFalse ), 

      iDtmWatcher( NULL ), 

      iWLANScanRequired( EFalse ), 

      iDisconnectQueue( NULL ), 

      iRoamingQueue( NULL ), 

      iStartingQueue( NULL ),

      iWlanQueryQueue( NULL ),

      iConnectDialogQueue( NULL ),

      iDefaultConnection( NULL ), 

      iConnectionCounter( 0 )

    {

    }

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

// CMPMServer::ConstructL

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

//

void CMPMServer::ConstructL()

    {

    // identify ourselves and open for service

    MPMLOGSTRING( "MPMServer is starting" )

    StartL( KMPMServerName );

    // Connect to ETel server

    // The RTelServer::Connect() might not always work with the first trial,

    // because of a coding error related to using semaphores in the method.

    TInt err( KErrNotReady );

    TInt a = 0;

    while( a < KPhoneRetryCount && err != KErrNone )

        {

        User::After( KPhoneRetryTimeout );

        err = iTelServer.Connect();

        a++;       

        }

    User::LeaveIfError( err );

    // Try to load phone.tsy

    TBuf< KCommsDbSvrMaxColumnNameLength > tsyName;

    tsyName.Copy( KMmTsyModuleName );

    err = iTelServer.LoadPhoneModule( tsyName );

    if ( err == KErrNone )

        {

        iTSYLoaded = ETrue;

        // Phone info can be retrieved with value 0 if there is only 1 phone

        RTelServer::TPhoneInfo info;

        User::LeaveIfError( iTelServer.GetPhoneInfo( 0, info ) );

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

        // Open packet service

        err = iPacketService.Open( iMobilePhone );

        if ( err == KErrNone )

            {

            iPacketServLoaded = ETrue;

            iDtmWatcher = CMPMDtmWatcher::NewL( iPacketService );

            }

#ifdef _DEBUG

        else

            {

            MPMLOGSTRING2( 

                "CMPMServer::ConstructL iPacketService.Open error: %d", err )  

            }

#endif // _DEBUG

        }

    iRoamingWatcher = CMPMRoamingWatcher::NewL(iMobilePhone);

    iCommsDatAccess = CMPMCommsDatAccess::NewL( );

    iDisconnectQueue = new ( ELeave ) CArrayPtrFlat<CMPMDisconnectDlg>( KGranularity );

    iDisconnectQueue->Reset();

    iRoamingQueue = new ( ELeave ) CArrayPtrFlat<CMPMConfirmDlgRoaming>( KGranularity );

    iRoamingQueue->Reset();

    iStartingQueue = new ( ELeave ) CArrayPtrFlat<CMPMConfirmDlgStarting>( KGranularity ); 

    iStartingQueue->Reset();

    iWlanQueryQueue = new ( ELeave ) CArrayPtrFlat<CMPMWlanQueryDialog>( KGranularity );

    iWlanQueryQueue->Reset();

    iConnectDialogQueue = new ( ELeave ) CArrayPtrFlat<CMPMDialog>( KGranularity );

    iConnectDialogQueue->Reset();

    iDefaultConnection = CMPMDefaultConnection::NewL( this );    

    // Create central repository watcher and start it

    iMpmCsIdWatcher = CMpmCsIdWatcher::NewL();

    iMpmCsIdWatcher->StartL();

    // Create another central repository watcher and start it

    // TODO: Trapped, because currently it may fatally leave in HW.

    // (Possibly because of the capability updates of data usage watcher's CR-keys.)

    TRAPD( duwErr, iMpmDataUsageWatcher = CMpmDataUsageWatcher::NewL( this ) );

    if (duwErr == KErrNone)

        {

        iMpmDataUsageWatcher->StartL();

        }

    else

        {

        iMpmDataUsageWatcher = NULL;

        MPMLOGSTRING( "CMPMServer::ConstructL: CMpmDataUsageWatcher::NewL() failed!" )

        }

    // Define P&S keys (snap & iap) for the user connection

    TInt ret = RProperty::Define( KMPMUserConnectionCategory,

                                  KMPMPSKeyUserConnectionSnap,

                                  KMPMUserConnectionSnapType,

                                  KMPMUserConnectionReadPolicy,

                                  KMPMUserConnectionWritePolicy );

    if ( (ret != KErrNone) && (ret != KErrAlreadyExists) )

        {

        User::Leave(err);

        }

    ret = RProperty::Define( KMPMUserConnectionCategory,

                             KMPMPSKeyUserConnectionIap,

                             KMPMUserConnectionIapType,

                             KMPMUserConnectionReadPolicy,

                             KMPMUserConnectionWritePolicy );

    if ( (ret != KErrNone) && (ret != KErrAlreadyExists) )

        {

        User::Leave(err);

        }

    // Set initial values for the keys

    User::LeaveIfError(RProperty::Set( KMPMUserConnectionCategory,

                                       KMPMPSKeyUserConnectionSnap,

                                       0 ));

    User::LeaveIfError(RProperty::Set( KMPMUserConnectionCategory,

                                       KMPMPSKeyUserConnectionIap,

                                       0 ));

    // Read dedicated clients from the central repository

    CRepository* repository = CRepository::NewL( KCRUidMPM );

    CleanupStack::PushL( repository );

    TUint32 baseKey = KMpmDedicatedClientBase;

    TInt value;

    ret = KErrNone;

    while ( ret == KErrNone )

        {

        ret = repository->Get ( baseKey, value );

        if ( ret == KErrNone )

            {

            iDedicatedClients.AppendL( value );

            MPMLOGSTRING2( "CMPMServer::ConstructL: Dedicated client id: %d", value)

            }

        baseKey++;

        }

    CleanupStack::PopAndDestroy ( repository );

    // Define P&S keys for the connection dialogs

    ret = RProperty::Define( KMPMActiveConnectionCategory,

                             KMPMPSKeyActiveConnectionIap,

                             KMPMActiveConnectionIapType,

                             KMPMActiveConnectionReadPolicy,

                             KMPMActiveConnectionWritePolicy );

    if ( (ret != KErrNone) && (ret != KErrAlreadyExists) )

        {

        User::Leave(err);

        }

    ret = RProperty::Define( KMPMActiveConnectionCategory,

                             KMPMPSKeyActiveConnectionSnap,

                             KMPMActiveConnectionSnapType,

                             KMPMActiveConnectionReadPolicy,

                             KMPMActiveConnectionWritePolicy );

    if ( (ret != KErrNone) && (ret != KErrAlreadyExists) )

        {

        User::Leave(err);

        }

    ret = RProperty::Define( KMPMActiveConnectionCategory,

                             KMPMPSKeyActiveConnectionBearer,

                             KMPMActiveConnectionBearerType,

                             KMPMActiveConnectionReadPolicy,

                             KMPMActiveConnectionWritePolicy );

    if ( (ret != KErrNone) && (ret != KErrAlreadyExists) )

        {

        User::Leave(err);

        }

    PublishActiveConnection();

    }

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

// CMPMServer::~CMPMServer

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

//

CMPMServer::~CMPMServer()

    {

    if ( iDisconnectQueue )

        {

        iDisconnectQueue->ResetAndDestroy();

        }

    delete iDisconnectQueue;

    if ( iRoamingQueue )

        {

        iRoamingQueue->ResetAndDestroy();

        }

    delete iRoamingQueue;

    if ( iStartingQueue )

        {

        iStartingQueue->ResetAndDestroy();

        }

    delete iStartingQueue;

    while ( iWlanQueryQueue && iWlanQueryQueue->Count() > 0 )

        {

        iWlanQueryQueue->Delete( 0 );

        }

    delete iWlanQueryQueue;

    if ( iConnectDialogQueue )

        {

        iConnectDialogQueue->ResetAndDestroy();

        }

    delete iConnectDialogQueue;

    delete iEvents;

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

        {

        iBlackListIdList[i].Close();

        }

    iActiveBMConns.Close();

    iSessions.Close();

    delete iDtmWatcher;

    delete iRoamingWatcher;

    // Close "global" ETEL objects

    if ( iPacketServLoaded )

        {

        iPacketService.Close();

        }    

    iMobilePhone.Close();

    iTelServer.Close();

    delete iDefaultConnection;

    delete iMpmCsIdWatcher;    

    delete iMpmDataUsageWatcher;    

    iDedicatedClients.Close();

    delete iCommsDatAccess;    

    }

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

// CMPMServer::NewSessionL

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

//

CSession2* CMPMServer::NewSessionL(

    const TVersion& aVersion,

    const RMessage2& /*aMessage*/) const

    {

    MPMLOGSTRING( "CMPMServer::NewSessionL" )

    // Check we're the right version

    if ( !User::QueryVersionSupported(TVersion(KMPMServerMajorVersionNumber,

                                               KMPMServerMinorVersionNumber,

                                               KMPMServerBuildVersionNumber ),

                                     aVersion ) )

        {

        User::Leave( KErrNotSupported );

        }

    CSession2* session = CMPMServerSession::NewL( 

                             *const_cast<CMPMServer*>( this ));

    return session;

    }

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

// CMPMServer::PanicClient

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

//

void CMPMServer::PanicClient(

    const TInt aPanic) const

    {

    // let's have a look before we panic the client

    __DEBUGGER()

    // ok, go for it

    RThread clientThread;

    TInt err = Message().Client( clientThread );

    if ( err == KErrNone )

        {

        clientThread.Panic( KMPMServerName, aPanic );

        clientThread.Close();

        }

    }

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

// CMPMServer::AppendBMConnection

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

//

void CMPMServer::AppendBMConnection( const TConnectionId aConnId, 

                                     const TUint32       aSnap,

                                     const TUint32       aIapId, 

                                     TConnectionState    aState,

                                     CMPMServerSession&  aSession )

    {

    MPMLOGSTRING3(

        "CMPMServer::AppendBMConnection - aConnId = 0x%x, aSnap = %i",

        aConnId, aSnap )

    // Set the Connection Id, SNAP, Iap Id and connection state

    // 

    TConnectionInfo connInfo;

    connInfo.iConnId = aConnId;

    connInfo.iSnap   = aSnap;

    connInfo.iIapId  = aIapId;

    connInfo.iState  = aState;

    // Package into TActiveBMConn //TODO Redundant.. remove the other one.

    // 

    TActiveBMConn conn;

    conn.iConnInfo          = connInfo;

    TInt index1 = iActiveBMConns.Find( conn, TActiveBMConn::MatchConnInfo );

    if ( index1 == KErrNotFound )

        {

        // If this connInfo is not yet there, insert it at the end of array

        //

        iActiveBMConns.Append( conn );

        }

    else

        {

        // connInfo already active, check whether Connection Id is there

        //

        if ( index1 < iActiveBMConns.Count() )

            {

            // Set the Iap Id and connection state

            // 

            iActiveBMConns[index1].iConnInfo.iIapId = aIapId;

            iActiveBMConns[index1].iConnInfo.iState = aState;

            iActiveBMConns[index1].iConnInfo.iAppUid = aSession.AppUid();

            }

        }

    if ( aState == EStarted )

        {

        TInt ret = KErrNone;

        TRAP ( ret, UpdateActiveConnectionL( aSession ) );

        if ( ret != KErrNone )

            {

            iActiveBearerType = EMPMBearerTypeNone;

            iActiveIapId = 0;

            iActiveSnapId = 0;            

            }

        }

#ifdef _DEBUG

    // Dump array of active connections to log in order to support testing.

    // 

    DumpActiveBMConns();

#endif // _DEBUG

    }

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

// CMPMServer::ResetBMConnection

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

//

void CMPMServer::ResetBMConnection( const TConnectionId aConnId,

                                    const TUint32       aIapId,

                                    CMPMServerSession&  aSession )

    {

    MPMLOGSTRING3(

        "CMPMServer::ResetBMConnection - aConnId = 0x%x, aIapId = %i", 

        aConnId, aIapId )

    // Get the current connection SNAP for this Connection Id

    //

    TUint32 snap = GetBMSnap( aConnId );

    // Set the Connection Id and SNAP

    // 

    TConnectionInfo connInfo;

    connInfo.iConnId = aConnId;

    connInfo.iSnap   = snap;

    // Set the Iap Id 

    // 

    TActiveBMConn conn;

    conn.iConnInfo          = connInfo;

    conn.iConnInfo.iIapId   = aIapId;

    TInt index1 = iActiveBMConns.Find( conn, TActiveBMConn::MatchConnInfo );

    if ( ( index1 != KErrNotFound ) && ( index1 < iActiveBMConns.Count() ) )

//       && ( aIapId == iActiveBMConns[index1].iConnInfo.iIapId ) )

        {

        // If connInfo found, reset the Iap Id as zero and 

        // update connection state as EIdle.

        // 

        // It is expected that MPM keeps the Connection Id and SNAP 

        // relationship in a database entry and that this entry survives 

        // a roaming event (an ApplicationLeavesConnection call).

        //

        iActiveBMConns[index1].iConnInfo.iIapId = 0;

        iActiveBMConns[index1].iConnInfo.iState = EIdle;

        // Change state of P&S keys if needed

        TInt ret = KErrNone;

        TRAP ( ret, UpdateActiveConnectionL( aSession ) );

        if ( ret != KErrNone )

            {

            iActiveBearerType = EMPMBearerTypeNone;

            iActiveIapId = 0;

            iActiveSnapId = 0;            

            }

        }

#ifdef _DEBUG

    // Dump array of active connections to log in order to support testing.