/*

* Copyright (c) 2008-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: Handling of the MPM interface.

 *

*/

/**

 @file s60mpmrequests.cpp

 Handling of the MPM interface.

 */

// Project includes

#include "s60mpmrequests.h"

#include "s60mcpr.h"

#include "s60mpmnotifications.h"

// Namespace

using namespace S60MCPRMPMOperations;

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

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

// CMPMPolicyRequests::NewL

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

//

CMPMPolicyRequests* CMPMPolicyRequests::NewL( MMPMPolicyNotificationUser& aUser )

    {

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

    CleanupStack::PushL( self );

    self->ConstructL( aUser );

    CleanupStack::Pop( self );

    return self;

    }

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

// CMPMPolicyRequests::PolicyNotification

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

//

void CMPMPolicyRequests::PolicyNotification( TMpmNotification& aNotification )

    {

    if ( !iCommitedToDeleteItself )

        {

        S60MCPRLOGSTRING1( "S60MCPR::CMPMPolicyRequests<%x>::PolicyNotification() forwarding call tocalling MCPR", this )

        iPolicyNotificationsUser->PolicyNotification( aNotification );

        }

    }

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

// CMPMPolicyRequests::RequestDelete

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

//

void CMPMPolicyRequests::RequestDelete()

    {

    iCommitedToDeleteItself = ETrue;

    // Either we have pending requests

    // (we always have at least notifications if we're connected.)

    //

    if ( iPolicyRequests.Count() > 0 )

        {

        S60MCPRLOGSTRING2( "S60MCPR::CMPMPolicyRequests<%x>::RequestDelete() %d pending requests,  IssueRequest", this, iPolicyRequests.Count() )

        IssueRequest();

        }

    // Or we are free to delete this.

    //

    else

        {

        S60MCPRLOGSTRING1( "S60MCPR::CMPMPolicyRequests<%x>::RequestDelete() IssueDeleteRequest", this )

        IssueDeleteRequest();

        }

    }

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

// CMPMPolicyRequests::CMPMPolicyRequests

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

//

CMPMPolicyRequests::CMPMPolicyRequests() :

                                    CActive( EPriorityStandard ),

                                    iCommitedToDeleteItself( EFalse ),

                                    iReconnectTimerRunning( EFalse ),

                                    iReconnectTimeout( KMPMInitialReconnectTimeout )

    {

    S60MCPRLOGSTRING1( "S60MCPR::CMPMPolicyRequests<%x>::CMPMPolicyRequests()", this )

    CActiveScheduler::Add( this );

    iConnId = (TConnectionId)this;

    }

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

// CMPMPolicyRequests::~CMPMPolicyRequests

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

//

CMPMPolicyRequests::~CMPMPolicyRequests()

    {

    //LOG( ESockLog::Printf(KESockMetaConnectionTag, _L8("CMPMPolicyRequests<%x>::~CMPMPolicyRequests"), this ); )

    S60MCPRLOGSTRING1( "S60MCPR::CMPMPolicyRequests<%x>::~CMPMPolicyRequests()", this )

    __ASSERT_ALWAYS(!IsActive(), User::Panic(KS60MCprPanic, KPanicInvalidCActiveUsage));

    __ASSERT_DEBUG(iPolicyRequests.Count() == 0, User::Panic(KS60MCprPanic, KPanicInvalidCActiveUsage));

    // Clean up all objects in the list

    // Normally there shouldn't be any.

    TInt count = iPolicyRequests.Count();

    for (TInt i = 0; i < count; i++)

        {

        S60MCPRLOGSTRING2( "S60MCPR::CMPMPolicyRequests<%x>::~CMPMPolicyRequests() deleting request %d", 

                           this, (TInt)iPolicyRequests[i].iRequestType )

        // Delete prefs

        delete iPolicyRequests[i].iConnPref;

        delete iPolicyRequests[i].iPolicyPref;

        // PolicyRequest owns this class and can delete it.

        // MCPR must have cancelled its activity when this happens.

        delete iPolicyRequests[i].iUser;

        }

    // Reset the array.

    iPolicyRequests.Close();

    // Close the MPM handle 

    if ( iMpm.Connected() )

        {

        S60MCPRLOGSTRING1( "S60MCPR::CMPMPolicyRequests<%x>::~CMPMPolicyRequests() closing MPM session", this )

        iMpm.Close();

        }

    if ( iReconnectTimerRunning )

        {

        Cancel();

        iReconnectTimer.Close();

        }

    }

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

// CMPMPolicyRequests::ConstructL

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

//

void CMPMPolicyRequests::ConstructL( MMPMPolicyNotificationUser& aUser )

    {

    // Force MPMNotifications to go through CMPMPolicyRequests

    iPolicyNotificationsUser = &aUser;

    iPolicyNotifications = CMPMPolicyNotifications::NewL( *(MMPMPolicyNotificationUser*)this, 

                                                          iMpm );

    S60MCPRLOGSTRING2( "S60MCPR::CMPMPolicyRequests<%x>::ConstructL() using iPolicyNotifications<%x>", 

                       this, iPolicyNotifications )

    }

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

// CMPMPolicyRequests::IAPConnectionStartedL

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

//

void CMPMPolicyRequests::IAPConnectionStartedL( const TUint32 aIapId )

    {

    S60MCPRLOGSTRING2( "S60MCPR::CMPMPolicyRequests<%x>::IAPConnectionStartedL() IAP %d", this, aIapId )

    CreatePolicyRequestL( EPolicyRequestIAPConnectionStarted, aIapId );

    }

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

// CMPMPolicyRequests::IAPConnectionStoppedL

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

//

void CMPMPolicyRequests::IAPConnectionStoppedL( const TUint32 aIapId )

    {

    S60MCPRLOGSTRING2( "S60MCPR::CMPMPolicyRequests<%x>::IAPConnectionStoppedL() IAP %d", this, aIapId )

    CreatePolicyRequestL( EPolicyRequestIAPConnectionStopped, aIapId );

    }

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

// CMPMPolicyRequests::ApplicationJoinsConnectionL

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

//

void CMPMPolicyRequests::ApplicationJoinsConnectionL( const TUint32 aIapId )

    {

    // Can't use CreatePolicyRequest() here because this could

    // be the first call to MPM.

    PolicyRequest policydata = PolicyRequest();

    policydata.iRequestType = EPolicyRequestApplicationJoinsConnection;

    policydata.iConnId      = iConnId;

    policydata.iIapId       = aIapId;

    // Add request to array of uncompleted requests

    iPolicyRequests.AppendL( policydata );

    S60MCPRLOGSTRING2( "S60MCPR::CMPMPolicyRequests<%x>::ApplicationJoinsConnectionL() IAP %d", this, aIapId )

    // Submit it.

    IssueRequest();

    }

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

// CMPMPolicyRequests::ApplicationLeavesConnectionL

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

//

void CMPMPolicyRequests::ApplicationLeavesConnectionL( const TUint32 aIapId )

    {

    S60MCPRLOGSTRING2( "S60MCPR::CMPMPolicyRequests<%x>::ApplicationLeavesConnectionL() IAP %d", this, aIapId )

    CreatePolicyRequestL( EPolicyRequestApplicationLeavesConnection, aIapId );

    }

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

// CMPMPolicyRequests::ApplicationLeavesConnectionL

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

//

void CMPMPolicyRequests::ApplicationConnectionEndsL()

    {

    // This is only a notification. Thus, if the session doesn't exist, don't create one

    if ( !iMpm.Connected() )

        {

        return;

        }

    S60MCPRLOGSTRING1( "S60MCPR::CMPMPolicyRequests<%x>::ApplicationConnectionEndsL() IAP %d", this )

    PolicyRequest policydata = PolicyRequest();

    policydata.iRequestType  = EPolicyRequestApplicationConnectionEnds;

    policydata.iConnId       = iConnId;

//    policydata.iIapId               = aIapId;

    // Nothing to cleanup so it's ok to Leave in AppendL

    // Add request to array of uncompleted requests

    iPolicyRequests.AppendL( policydata );

    // Submit it.

    IssueRequest();

    }

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

// CMPMPolicyRequests::RegisterPreferredIAPNotificationL

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

//

void CMPMPolicyRequests::RegisterPreferredIAPNotificationL()

    {

    S60MCPRLOGSTRING1( "S60MCPR::CMPMPolicyRequests<%x>::RegisterPreferredIAPNotificationL()", this )

    PolicyRequest policydata = PolicyRequest();

    policydata.iRequestType  = EPolicyRequestRegisterPrefIAPNotif;

    policydata.iConnId       = iConnId;

    // Add request to array of uncompleted requests

    iPolicyRequests.AppendL( policydata );

    // Submit it.

    IssueRequest();

    }

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

// CMPMPolicyRequests::UnregisterPreferredIAPNotificationL

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

//

void CMPMPolicyRequests::UnregisterPreferredIAPNotificationL()

    {

    // Sanity check that we're still in business. 

    if ( !iMpm.Connected() )

        {

        return;

        }

    S60MCPRLOGSTRING1( "S60MCPR::CMPMPolicyRequests<%x>::UnregisterPreferredIAPNotificationL()", this )

    PolicyRequest policydata = PolicyRequest();

    policydata.iRequestType  = EPolicyRequestUnregisterPrefIAPNotif;

    policydata.iConnId       = iConnId;

    // Add request to array of uncompleted requests

    iPolicyRequests.AppendL( policydata );

    // Submit it.

    IssueRequest();

    }

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

// CMPMPolicyRequests::ApplicationIgnoredTheCarrierL

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

//

void CMPMPolicyRequests::ApplicationIgnoredTheCarrierL( const TUint32 aIapId )

    {

    S60MCPRLOGSTRING1( "S60MCPR::CMPMPolicyRequests<%x>::ApplicationIgnoredTheCarrierL()", this )

    CreatePolicyRequestL( EPolicyRequestApplicationIgnoredTheCarrier, aIapId );

    }

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

// CMPMPolicyRequests::ApplicationMigratesToCarrierL

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

//

void CMPMPolicyRequests::ApplicationMigratesToCarrierL( const TUint32 aIapId )

    {

    S60MCPRLOGSTRING1( "S60MCPR::CMPMPolicyRequests<%x>::ApplicationMigratesToCarrierL()", this )

    CreatePolicyRequestL( EPolicyRequestApplicationMigratesToCarrier, aIapId );

    }

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

// CMPMPolicyRequests::ApplicationRejectedTheCarrierL

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

//

void CMPMPolicyRequests::ApplicationRejectedTheCarrierL( const TUint32 aIapId )

    {

    S60MCPRLOGSTRING1( "S60MCPR::CMPMPolicyRequests<%x>::ApplicationRejectedTheCarrierL()", this )

    CreatePolicyRequestL( EPolicyRequestApplicationRejectedTheCarrier, aIapId );

    }

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

// CMPMPolicyRequests::ApplicationAcceptedTheCarrierL

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

//

void CMPMPolicyRequests::ApplicationAcceptedTheCarrierL( const TUint32 aIapId)

    {

    S60MCPRLOGSTRING1( "S60MCPR::CMPMPolicyRequests<%x>::ApplicationAcceptedTheCarrierL()", this )

    CreatePolicyRequestL( EPolicyRequestApplicationAcceptedTheCarrier, aIapId );

    }

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

// CMPMPolicyRequests::ChooseBestIAP

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

//

void CMPMPolicyRequests::ChooseBestIAPL( TConnPref*             aConnPref,

                                        const TUid&             aAppUid,

                                        TConnPref*              aPolicyPref,

                                        MMPMPolicyRequestsUser* aUser )

    {

    S60MCPRLOGSTRING1( "S60MCPR::CMPMPolicyRequests<%x>::ChooseBestIAPL()", this )

    // Define policydata

    PolicyRequest policydata = PolicyRequest();

    policydata.iRequestType         = EPolicyRequestChooseBestIAP;

    policydata.iConnId              = iConnId;

    policydata.iAppUid              = aAppUid;

    // Heap allocated objects

    policydata.iConnPref            = aConnPref;

    policydata.iPolicyPref          = aPolicyPref;

    policydata.iUser                = aUser;

    // Nothing to cleanup so it's ok to Leave in AppendL

    // Heap allocated objects are on callers responsibility if we Leave.

    // Add it to the array of uncompleted requests

    iPolicyRequests.AppendL( policydata );

    IssueRequest();

    }

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

// CMPMPolicyRequests::CancelReselectBestIAP()

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

//

void CMPMPolicyRequests::CancelReselectBestIAP()

    {

    S60MCPRLOGSTRING1( "S60MCPR::CMPMPolicyRequests<%x>::CancelReselectBestIAPL()", this )

    ASSERT( iPolicyRequests.Count() > 0 );

    CancelRequest( EMPMReselectBestIAP );

    }

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

// CMPMPolicyRequests::CancelChooseBestIAPL()

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

//

void CMPMPolicyRequests::CancelChooseBestIAPL()

    {

    S60MCPRLOGSTRING1( "S60MCPR::CMPMPolicyRequests<%x>::CancelChooseBestIAPL()", this )

    ASSERT( iPolicyRequests.Count() > 0 );

    CancelRequest( EMPMChooseBestIAP );

    }

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

// CMPMPolicyRequests::CancelProcessError()

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

//

void CMPMPolicyRequests::CancelProcessError()

    {

    S60MCPRLOGSTRING1( "S60MCPR::CMPMPolicyRequests<%x>::CancelProcessErrorL()", this )

    ASSERT( iPolicyRequests.Count() > 0 );

    CancelRequest( EMPMProcessError );

    }

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

// CMPMPolicyRequests::ReselectIAPL()

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

//

void CMPMPolicyRequests::ReselectIAPL( TConnPref* aPolicyPref,

                                       MMPMPolicyRequestsUser* aUser )

    {

    S60MCPRLOGSTRING1( "S60MCPR::CMPMPolicyRequests<%x>::ReselectIAPL()", this )

    //Call MPM to get the list of potential IAPs for the connection

    //

    PolicyRequest policydata = PolicyRequest();

    policydata.iRequestType = EPolicyRequestReselectBestIAP;

    policydata.iConnId      = iConnId;

    policydata.iPolicyPref  = aPolicyPref;

    policydata.iUser        = aUser;

    // Add it to the array of uncompleted requests

    iPolicyRequests.AppendL( policydata );

    IssueRequest();

    }

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

// CMPMPolicyRequests::ProcessErrorL

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

//

void CMPMPolicyRequests::ProcessErrorL( TInt& anError,

                                        MMPMPolicyRequestsUser* aUser )

    {

    S60MCPRLOGSTRING2( "S60MCPR::CMPMPolicyRequests<%x>::ProcessErrorL() %d", this, anError )

    // insert into array of pending policy request

    PolicyRequest policydata = PolicyRequest();

    policydata.iRequestType = EPolicyRequestProcessError;

    policydata.iError       = anError;

    policydata.iConnId      = iConnId;

    policydata.iUser        = aUser;

    // Add it to the array of uncompleted requests

    iPolicyRequests.AppendL( policydata );

    IssueRequest();

    }

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

// CMPMPolicyRequests::IssueDeleteRequest

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

//

void CMPMPolicyRequests::IssueDeleteRequest()

    {

    ASSERT( !IsActive() );

    // Always cancel & delete policynotifications.

    if ( iMpm.Connected() && iPolicyNotifications->IsActive() )

        {

        S60MCPRLOGSTRING1( "S60MCPR::CMPMPolicyRequests<%x>::IssueDeleteRequest() Asynch", this )

        iPolicyNotifications->CancelRequestAndDestroyD( &iStatus );

        iPolicyNotifications = NULL;

        SetActive();

        }

    else if ( iPolicyNotifications )

        {

        S60MCPRLOGSTRING1( "S60MCPR::CMPMPolicyRequests<%x>::IssueDeleteRequest() Immediate", this )

        iPolicyNotifications->CancelRequestAndDestroyD();

        iPolicyNotifications = NULL;

        delete this;

        }

    else

        {

        S60MCPRLOGSTRING1( "S60MCPR::CMPMPolicyRequests<%x>::IssueDeleteRequest() Invalid state", this )

        }

    }

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

// CMPMPolicyRequests::IssueRequest

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

//

void CMPMPolicyRequests::IssueRequest()

    {

    // If we have a pending request, back off.

    //

    if ( IsActive() || iPolicyRequests.Count() == 0 )

        {

        S60MCPRLOGSTRING1( "S60MCPR::CMPMPolicyRequests<%x>::IssueRequest() Unnecessary call, back off", this )

        return;

        }

    if ( !iMpm.Connected() )

        {

        PolicyRequest policydata = PolicyRequest();

        policydata.iRequestType  = EPolicyRequestConnect;

        // OK because default granularity is 8 and this is done when first request arrives.

        iPolicyRequests.Insert(policydata, 0);

        }

    S60MCPRLOGSTRING2( "S60MCPR::CMPMPolicyRequests<%x>::IssueRequest() iRequestType %d", this, (TInt)iPolicyRequests[0].iRequestType )

    //

    // else we submit a new one.

    switch ( iPolicyRequests[0].iRequestType )

        {

        case EPolicyRequestConnect:

            {

            iMpm.Connect( iStatus );

            SetActive();

            break;

            }

        case EPolicyRequestChooseBestIAP:

            {

            //LOG(ESockLog::Printf(KESockMetaConnectionTag, _L8("\tcall MPM ChooseBestIAP")));

            iMpm.ChooseBestIAP( ( *iPolicyRequests[0].iConnPref ),

                                iPolicyRequests[0].iConnId,

                                iPolicyRequests[0].iAppUid,

                                ( *iPolicyRequests[0].iPolicyPref ),

                                iStatus );

            SetActive();

            break;

            }

        case EPolicyRequestReselectBestIAP:

            {

            iMpm.ReselectBestIAP( iPolicyRequests[0].iConnId,

                                  ( *iPolicyRequests[0].iPolicyPref ),

                                  iStatus );

            SetActive();

            break;

            }

        case EPolicyRequestIAPConnectionStarted:

            {

            iMpm.IAPConnectionStarted( iPolicyRequests[0].iIapId,

                                       iPolicyRequests[0].iConnId,

                                       iStatus );

            SetActive();

            break;

            }

        case EPolicyRequestIAPConnectionStopped:

            {

            iMpm.IAPConnectionStopped( iPolicyRequests[0].iIapId,

                                       iPolicyRequests[0].iConnId,

                                       iStatus );