// 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 FILES

#include "cmmlinetsy.h"

#include "cmmphonetsy.h"

#include "cmmcalltsy.h"

#include "cmmlinelist.h"

#include "cmmcalllist.h"

#include "cmmtsyreqhandlestore.h"

#include "MmTsy_numberOfSlots.h"

#include <ctsy/pluginapi/cmmdatapackage.h>

#include <et_struct.h>

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

CMmLineTsy::CMmLineTsy()

    {

    }

void CMmLineTsy::ConstructL()

    {

    //Initialise miscellaneous internal attributes

    InitInternalAttributesL();

    // Create and store a Call Object for incoming calls.

    TInt ret = CreateCallObjectForIncomingCall();

    if ( KErrNone != ret )

        {

        //if this fails, incoming calls cannot be called -> leave

        User::Leave( KErrNoMemory );

        }

    //create req handle store

    iTsyReqHandleStore = CMmTsyReqHandleStore::NewL( 

        EMultimodeLineMaxNumOfRequests, iLineReqHandles );

    }

CMmLineTsy::~CMmLineTsy()

    {

    //delete req handle store

    delete iTsyReqHandleStore;

    //delete incoming call object

    if ( iCallForIncomingCall )

        {

        iCallForIncomingCall->Close();

        }

    // Remove all calls still open from this line

    iMmPhone->CallList()->RemoveCallsByLine( &iLineName );

    //Inform phone that this line has been removed.

    iMmPhone->RemoveLine( iLineName );

    iMmPhone = NULL;

    iCallForIncomingCall = NULL;

    iRetLineStatus = NULL;

    iRetCaps = NULL;

    iRetIncomingCallName = NULL;

    iRetCallAdded = NULL;

    iRetMobileLineStatus = NULL;

    iTsyReqHandleStore = NULL;

    iMessageManager = NULL;

    }

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

// CMmLineTsy::OpenNewObjectByNameL

// Returns a pointer to an existing call. The TSY classes must not use this 

// method. This method is called when the client uses RCall::OpenExistingCall 

// method.

// (other items were commented in a header).

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

//

CTelObject* CMmLineTsy::OpenNewObjectByNameL(

    const TDesC& aName )

    {

    TName mmCallName( aName );

    CMmCallTsy* mmCall = iMmPhone->CallList()->GetMmCallByName( &mmCallName );

    //if not found, Leave...

    if ( NULL == mmCall )

        {

        User::Leave( KErrNotFound );

        }

    else

        {

        //Update iUnownedCallObject flag

        mmCall->SetUnownedCallObjectFlag( EFalse );

        }

    return mmCall;

    }

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

// CMmLineTsy::InitInternalAttributesL

// Initialises miscellaneous internal attributes.

// (other items were commented in a header).

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

//

void CMmLineTsy::InitInternalAttributesL()

    {

    // Set object attributes

    iLineStatus = RCall::EStatusIdle;    

    iMobileLineStatus = RMobileCall::EStatusIdle;

    //reset the name for answering call

    iNameOfCallForAnswering.Zero();

    iNumCalls = 0;    // Number of calls created from line;

    iCallSequenceNumber = 0;    // The sequence number for the calls

    }

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

// CMmLineTsy::CallObjectForIncomingCall

// This method returns a Call object that is used for a new incoming call. 

// If there are no incoming calls this method creates a new call object.

// (other items were commented in a header).

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

//

CMmCallTsy* CMmLineTsy::CallObjectForIncomingCall()

    {

    CMmCallTsy* callForIncomingCall = NULL;

    if ( iCallForIncomingCall == NULL )

        {

        CreateCallObjectForIncomingCall();

        }

    callForIncomingCall = iCallForIncomingCall;

    return callForIncomingCall;

    }

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

// CMmLineTsy::ReqModeL

// ReqModeL is called from the server's CTelObject::ReqAnalyserL in order to 

// check the type of request it has

// (other items were commented in a header).

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

//

CTelObject::TReqMode CMmLineTsy::ReqModeL(

    const TInt aIpc )

    {

    CTelObject::TReqMode ret( 0 );    // default return value

    switch( aIpc )

        {

        // Non-flow control requests

        // All disabled

        // TSYs wishing to implement their own buffering algorithm will place

        // all requests in this category. This category will also be used by

        // the RecoverDataPort request that must be passed to the TSY to

        // indicate that it may use the communications port after a loan.

        //Get methods that do not use DOS and return immediately.

        //Flow control not required.

        case EEtelLineGetStatus:

        case EEtelLineGetCaps:

        case EEtelLineGetCallInfo:

        case EEtelLineGetInfo:

        case EEtelLineGetHookStatus:

        case EMobileLineGetMobileLineStatus:

        //Other methods that do not use DOS and return immediately.

        //Flow control not required.

        case EEtelLineEnumerateCall:

        //Methods that can propably take a long time and cannot therefore be

        //flow controlled. Solution: All these methods must check req handle

        //table before handling the request. In case that the request table

        //indicates that same method has been called and has not been

        //completed, the method should return KErrServerBusy.

            break;

        // Flow Controlled Services

        // KReqModeFlowControlObeyed

        // Commands that change the state of the phone, e.g. clearing the AoC

        // counter; are commands that the TSY should only deal with one at

        // a time.

        //    ret = KReqModeFlowControlObeyed;

        //    break;

        // ReqModePostImmediately

        // Requests that notify a client about a change of state, where the

        // TSY needs to distinguish between different clients.

            //ret=KReqModeRePostImmediately;

            //break;

        // KReqModeMultipleCompletionEnabled

        // (a) commands that may take some time, but which the TSY can handle

        // more than one of concurrently, or 

        // (b) notifications that the TSY does not wish to be re-posted

        // immediately, so the server does no buffering.

            //ret=KReqModeMultipleCompletionEnabled;

            //break;

        // KReqModeMultipleCompletionEnabled | KReqModeFlowControlObeyed

        // A command that may take some time and which the TSY can only deal 

        // with one at a time.

            //ret = KReqModeMultipleCompletionEnabled |

            //    KReqModeFlowControlObeyed;

            //break;

        // Notification Requests

        // KReqModeMultipleCompletionEnabled | ReqModePostImmediately

        // Requests that notify a client about a change of state.

        // Since these requests do not require the issuing of any modem

        // commands, they do not have to obey flow control. The TSY never

        // gets more than one of these outstanding per CTelObject.

        case EEtelLineNotifyStatusChange:

        case EEtelLineNotifyCallAdded:

        case EETelLineCapsChangeNotification:

        case EEtelLineNotifyHookChange:

        case EEtelLineNotifyIncomingCall:

        case EMobileLineNotifyMobileLineStatusChange:

            ret = KReqModeMultipleCompletionEnabled |

                KReqModeRePostImmediately;

            break;

        // Cancel Requests

        //It is not necessary to include the Cancel methods in ReqModeL at all

        //The ETel server never calls ReqModeL with a Cancel IPC.

        //Other variations of return values are unusable

        // Default: Call CLineBase's ReqModeL.

        default:

            ret = CLineBase::ReqModeL( aIpc );

            break;

        }

    return ret;

    }

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

// CMmLineTsy::ExtFunc

// TRAP's all CMmLineTsy related MM API requests in cases that they fail. This 

// method functions only as a centralized TRAP for the DoExtFuncL method that 

// does the actual mapping of IPC number to TSY method call.

// (other items were commented in a header).

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

//

TInt CMmLineTsy::ExtFunc(

    const TTsyReqHandle aTsyReqHandle,

    const TInt aIpc,

    const TDataPackage& aPackage )

    {

    TInt ret( KErrNone );

    TInt trapError( KErrNone );

    //reset last tsy request type

    iReqHandleType = EMultimodeLineReqHandleUnknown;

    //Original code continues here.

    TRAP( trapError, ret = DoExtFuncL( aTsyReqHandle, aIpc, aPackage ); );

    if ( trapError != KErrNone )

        {

        // Object cannot be created.

        ReqCompleted( aTsyReqHandle, trapError );

        }

    else if ( ret != KErrNone )

        {

        ReqCompleted( aTsyReqHandle, ret );

        }

    //save request handle

    if ( EMultimodeLineReqHandleUnknown != iReqHandleType )

        {

        iTsyReqHandleStore->SetTsyReqHandle( iReqHandleType, aTsyReqHandle );

        }

    return KErrNone;

    }

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

// CMmLineTsy::DoExtFuncL

// ExtFunc is called by the server when it has a "extended", i.e. non-core  

// ETel request for the TSY. To process a request handle, request type and 

// request  data are passed to the TSY. 

// (other items were commented in a header).

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

//

TInt CMmLineTsy::DoExtFuncL(

    const TTsyReqHandle aTsyReqHandle,

    const TInt aIpc,

    const TDataPackage& aPackage )

    {

    TInt ret ( KErrNone );

    TAny* dataPtr = aPackage.Ptr1();

    // The request data has to extracted from TDataPackage and the TAny* 

    // pointers have to be "cast" to the expected request data type

    switch ( aIpc )

        {

      // Mobile Line Status

        // Get Mobile Line Status

        case EMobileLineGetMobileLineStatus:

            ret = GetMobileLineStatus( aTsyReqHandle,

            REINTERPRET_CAST( RMobileCall::TMobileCallStatus*, dataPtr ) );

            break;

        //Notify Change of Mobile Line Status

        case EMobileLineNotifyMobileLineStatusChange:

            ret = NotifyMobileLineStatusChange(

            REINTERPRET_CAST( RMobileCall::TMobileCallStatus*, dataPtr ) );

            break;

        default:

            ret = KErrNotSupported;

            break;

        }

    return ret;

    }

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

// CMmLineTsy::CreateNewCallName

// Creates a new name for the call, which is the name of the line followed by 

// a call sequence number.

// (other items were commented in a header).

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

//

TInt CMmLineTsy::CreateNewCallName(

    TDes& aNewName )

    {

    // buffer for the name

    TBuf<KMaxName> buf;

    // append line name first

    buf.Append( iLineName );

    // append call sequence number next

    buf.AppendNum( IncrementCallSequenceNumber() );

    // copy the created name

    aNewName.Copy( buf );

    return KErrNone;

    }

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

// CMmLineTsy::IncrementCallSequenceNumber

// Returns the sequence number of the call created from this line. This 

// sequence number will be resetted when this line object is deleted. TInt 

// allows the value to increment to the value 2^32. 

// (other items were commented in a header).

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

//

TUint CMmLineTsy::IncrementCallSequenceNumber()

    {

    // increment call sequence number

    iCallSequenceNumber++;

    return iCallSequenceNumber;

    }

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

// CMmLineTsy::EnumerateCall

// This CORE API method returns the number of calls opened from a line. The 

// number of calls will be stored in the aCount pointer.

// (other items were commented in a header).

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

//

TInt CMmLineTsy::EnumerateCall(

    const TTsyReqHandle aTsyReqHandle,

    TInt* aCount )

    {

    *aCount = iNumCalls;

    ReqCompleted( aTsyReqHandle, KErrNone );

    return KErrNone;

    }

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

// CMmLineTsy::DecrementNumberOfCalls

// Decrements number of calls opened from a line by one.

// (other items were commented in a header).

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

//

void CMmLineTsy::DecrementNumberOfCalls()

    {

    if ( iNumCalls > 0 )

        {

        iNumCalls--;

        }

    }

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

// CMmLineTsy::NotifyStatusChange

// This CORE API method provides notification about a change in the line 

// status

// (other items were commented in a header).

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

//

TInt CMmLineTsy::NotifyStatusChange(

    const TTsyReqHandle aTsyReqHandle,

    RCall::TStatus* aLineStatus )

    {

    iRetLineStatus = aLineStatus;

    iTsyReqHandleStore->SetTsyReqHandle( EMultimodeLineNotifyStatusChange,

        aTsyReqHandle );

    return KErrNone;

    }

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

// CMmLineTsy::NotifyStatusChangeCancel

// This CORE API method cancels an outstanding line status change notification 

// request, placed using the NotifyStatusChange() method.

// (other items were commented in a header).

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

//

TInt CMmLineTsy::NotifyStatusChangeCancel(

    const TTsyReqHandle aTsyReqHandle )

    {

    iRetLineStatus = NULL;

    iTsyReqHandleStore->ResetTsyReqHandle( EMultimodeLineNotifyStatusChange );

    ReqCompleted( aTsyReqHandle, KErrCancel );

    return KErrNone;

    }

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

// CMmLineTsy::CompleteNotifyStatusChange

// This method is used to notify to the client about the line status change. 

// This method should only be called by the CMmCallTsy's 

// CompleteNotifyStatusChange method to guaratee that this is functioning 

// right. 

// (other items were commented in a header).

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

//

void CMmLineTsy::CompleteNotifyStatusChange()

    {

    TInt ret( KErrNone );

    TBool coreStatusChanged( EFalse );

    TBool mobileStatusChanged( EFalse );

    RCall::TStatus tempCoreStatus( RCall::EStatusIdle );

    RMobileCall::TMobileCallStatus tempMobileStatus( 

        RMobileCall::EStatusIdle );

    TInt numberOfObjectsInCallList = iMmPhone->CallList()->

        GetNumberOfObjects();

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

        {

        CMmCallTsy* mmCall = iMmPhone->CallList()->GetMmCallByIndex(i);

        //check that the call object has been opened from this line

        if ( mmCall->Line() == this )

            {

            RMobileCall::TMobileCallStatus mobileStatus 

                = mmCall->MobileCallStatus();

            switch( mobileStatus )

                {

                case RMobileCall::EStatusUnknown:

                    tempCoreStatus = RCall::EStatusUnknown;

                    tempMobileStatus = RMobileCall::EStatusUnknown;

                    //get out of loop, resulting status is unknown...

                    i = numberOfObjectsInCallList;

                    break;

                case RMobileCall::EStatusConnected:

                    tempCoreStatus = RCall::EStatusConnected;

                    tempMobileStatus = RMobileCall::EStatusConnected;

                    //get out of loop, resulting status is unknown...

                    i = numberOfObjectsInCallList;

                    break;

                case RMobileCall::EStatusRinging:

                    //update core status

                    if ( tempCoreStatus == RCall::EStatusIdle )

                        {

                        tempCoreStatus = RCall::EStatusRinging;

                        }

                    //update mobile status

                    if ( tempMobileStatus == RMobileCall::EStatusIdle || 

                         tempMobileStatus == RMobileCall::EStatusHold)

                        {

                        tempMobileStatus = mobileStatus;

                        }

                    break;

                case RMobileCall::EStatusDialling:

                    if ( tempCoreStatus == RCall::EStatusIdle )

                        {

                        tempCoreStatus = RCall::EStatusDialling;

                        }

                    //update mobile status

                    if ( tempMobileStatus == RMobileCall::EStatusIdle || 

                         tempMobileStatus == RMobileCall::EStatusHold)

                        {

                        tempMobileStatus = mobileStatus;

                        }

                    break;

                case RMobileCall::EStatusAnswering:

                    if ( tempCoreStatus == RCall::EStatusIdle ||

                         tempCoreStatus == RCall::EStatusRinging )

                        {

                        tempCoreStatus = RCall::EStatusAnswering;

                        }

                    //update mobile status

                    if ( tempMobileStatus == RMobileCall::EStatusIdle || 

                         tempMobileStatus == RMobileCall::EStatusRinging ||

                         tempMobileStatus == RMobileCall::EStatusHold )

                        {

                        tempMobileStatus = mobileStatus;

                        }

                    break;

                case RMobileCall::EStatusConnecting:

                    if ( tempCoreStatus == RCall::EStatusIdle ||