/*

* 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 <es_sock_partner.h>

#include <CoreApplicationUIsSDKCRKeys.h>

#include "mpmserver.h"

#include "mpmserversession.h"

#include "mpmconnmonevents.h"

#include "mpmlogger.h"

#include "mpmdtmwatcher.h"

#include "mpmroamingwatcher.h"

#include "mpmconfirmdlgroaming.h"

#include "mpmconfirmdlgstarting.h"

#include "mpmcommsdataccess.h"

#include "mpmprivatecrkeys.h"

#include "mpmcsidwatcher.h"

#include "mpmdatausagewatcher.h"

#include "mpmpropertydef.h"

#include "mpmconnpermquerytimer.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 ), 

      iRoamingQueue( NULL ), 

      iStartingQueue( 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 );

    err = iTelServer.Connect();

    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( );

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

    iRoamingQueue->Reset();

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

    iStartingQueue->Reset();

    // Create central repository watcher and start it

    iMpmCsIdWatcher = CMpmCsIdWatcher::NewL();

    iMpmCsIdWatcher->StartL();

    // Create another central repository watcher and start it

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

    if (duwErr == KErrNone)

        {

        iMpmDataUsageWatcher->StartL();

        }

    else

        {

        iMpmDataUsageWatcher = NULL;

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

        }

    // Read dedicated clients from the central repository

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

    CleanupStack::PushL( repository );

    TUint32 baseKey = KMpmDedicatedClientBase;

    TInt value;

    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 );

    }

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

// CMPMServer::~CMPMServer

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

//

CMPMServer::~CMPMServer()

    {

	if ( iRoamingToWlanPeriodic )

        {

        iRoamingToWlanPeriodic->Cancel();

		delete iRoamingToWlanPeriodic;

        }

    if ( iRoamingQueue )

        {

        iRoamingQueue->ResetAndDestroy();

        }

    delete iRoamingQueue;

    if ( iStartingQueue )

        {

        iStartingQueue->ResetAndDestroy();

        }

    delete iStartingQueue;

    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 iMpmCsIdWatcher;    

    delete iMpmDataUsageWatcher;    

    iDedicatedClients.Close();

    delete iCommsDatAccess;

    delete iConnPermQueryTimer;

    }

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

// 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, into TActiveBMConn

    TActiveBMConn conn;

    conn.iConnInfo.iConnId = aConnId;

    conn.iConnInfo.iSnap   = aSnap;

    conn.iConnInfo.iIapId  = aIapId;

    conn.iConnInfo.iState  = aState;

    conn.iConnInfo.iAppUid = aSession.AppUid();

    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();

            }

        }

#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,

    {

    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;

        }

#ifdef _DEBUG

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

    // 

    DumpActiveBMConns();

#endif // _DEBUG

    }

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

// CMPMServer::RemoveBMConnection

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

//

void CMPMServer::RemoveBMConnection( const TConnectionId aConnId,

    {

    MPMLOGSTRING2( "CMPMServer::RemoveBMConnection - aConnId = 0x%x", 

        aConnId )

    // This time we are browsing the array from the end to the beginning, 

    // because removing one element from array affects index numbering.

        {

        if ( iActiveBMConns[i].iConnInfo.iConnId == aConnId )

            {

            // If Connection Id found, remove it. 

            iActiveBMConns.Remove( i );

            }

        }

#ifdef _DEBUG

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

    // 

    DumpActiveBMConns();

#endif // _DEBUG

    }

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