// Copyright (c) 2006-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 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/tflogger.h>
#include <ctsy/pluginapi/cmmdatapackage.h>
#include <et_struct.h>


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

CMmLineTsy::CMmLineTsy()
    {
    }

void CMmLineTsy::ConstructL()
    {
    TFLOGSTRING("TSY: 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()
    {
    TFLOGSTRING2("TSY: CMmLineTsy::~CMmLineTsy. Line name: %S", &iLineName);

    //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 )
    {
    TFLOGSTRING2("TSY: CMmLineTsy::OpenNewObjectByNameL %S", &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 )
    {
    TFLOGSTRING2("TSY: CMmLineTsy::ReqModeL IPC:%d",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 )
    {
    TFLOGSTRING3("TSY: CMmLineTsy::DoExtFuncL IPC:%d Handle:%d", aIpc, \
        aTsyReqHandle);

    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 || 
                            tempCoreStatus == RCall::EStatusDialling )
                        {
                        tempCoreStatus = RCall::EStatusConnecting;
                        }
                    //update mobile status
                    if ( tempMobileStatus == RMobileCall::EStatusIdle ||
                         tempMobileStatus == RMobileCall::EStatusDialling ||
                         tempMobileStatus == RMobileCall::EStatusHold )
                        {
                        tempMobileStatus = mobileStatus;
                        }
                    break;
                case RMobileCall::EStatusDisconnecting:
                    //update core status
                    if ( tempCoreStatus == RCall::EStatusIdle )
                        {
                        tempCoreStatus = RCall::EStatusHangingUp;
                        }
                    if ( tempMobileStatus == RMobileCall::EStatusIdle )
                        {
                        tempMobileStatus = mobileStatus;
                        }
                    break;
                case RMobileCall::EStatusWaitingAlternatingCallSwitch:
                    if ( tempMobileStatus == RMobileCall::EStatusIdle )
                        {
                        tempMobileStatus = mobileStatus;
                        }
                    break;
                case RMobileCall::EStatusHold:
                    if ( tempMobileStatus == RMobileCall::EStatusIdle || 
                         tempMobileStatus == 
                            RMobileCall::EStatusDisconnecting )
                        {
                        tempCoreStatus = iLineStatus;
                        tempMobileStatus = mobileStatus;
                        }
                    break;
                case RMobileCall::EStatusIdle:
                case RMobileCall::EStatusReconnectPending:
                case RMobileCall::EStatusDisconnectingWithInband:
                case RMobileCall::EStatusTransferring:
                case RMobileCall::EStatusTransferAlerting:
                default:
                    break;
                }
            }
        }

    //check if core status has changed
    if ( tempCoreStatus != iLineStatus )
        {
        coreStatusChanged = ETrue;
        iLineStatus = tempCoreStatus;
        }

    //check if mobile status has changed
    if ( tempMobileStatus != iMobileLineStatus )
        {
        mobileStatusChanged = ETrue;
        iMobileLineStatus = tempMobileStatus;
        }

    //get core status change notification req handle
    TTsyReqHandle iNotifyStatusChangeHandle = iTsyReqHandleStore->
                GetTsyReqHandle( EMultimodeLineNotifyStatusChange );

    //if req handle available and status changed
    if ( ( iNotifyStatusChangeHandle > 0 ) && coreStatusChanged )
        {
        *iRetLineStatus = iLineStatus; 
        iTsyReqHandleStore->ResetTsyReqHandle(
            EMultimodeLineNotifyStatusChange );
        ReqCompleted( iNotifyStatusChangeHandle, ret );
        }

    //get mobile status change notification req handle
    TTsyReqHandle iNotifyMobileLineStatusChangeHandle = iTsyReqHandleStore->
        GetTsyReqHandle( EMultimodeLineMobileLineStatusChange );

    //if req handle available and status changed
    if ( iNotifyMobileLineStatusChangeHandle > 0 
        && ( coreStatusChanged || mobileStatusChanged ) )
        {
        *iRetMobileLineStatus = iMobileLineStatus; 
        iTsyReqHandleStore->ResetTsyReqHandle(
            EMultimodeLineMobileLineStatusChange );
        ReqCompleted( iNotifyMobileLineStatusChangeHandle, ret );
        }
    }

// ---------------------------------------------------------------------------
// CMmLineTsy::GetHookStatus
// This CORE API method retrieves the current hook status. Method is not 
// currently supported,
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
TInt CMmLineTsy::GetHookStatus(
    const TTsyReqHandle aTsyReqHandle,
    RCall::THookStatus* )
    {
    ReqCompleted( aTsyReqHandle, KErrNotSupported );
    return KErrNone;
    }

// ---------------------------------------------------------------------------
// CMmLineTsy::GetInfo
// This CORE API method retrieves the current line information.
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
TInt CMmLineTsy::GetInfo(
    const TTsyReqHandle aTsyReqHandle,
    RLine::TLineInfo* aLineInfo )
    {
    // The current hook status.
    aLineInfo->iHookStatus = RCall::EHookStatusUnknown; 
    // The current line status.
    aLineInfo->iStatus = iLineStatus;
    // The name of the last call created on the line.
    aLineInfo->iNameOfLastCallAdded = iNameOfLastCallAdded;
    // The name of the call to which a new incoming call will be directed.
    aLineInfo->iNameOfCallForAnswering = iNameOfCallForAnswering;
 
    ReqCompleted( aTsyReqHandle, KErrNone );
    return KErrNone;
    }

// ---------------------------------------------------------------------------
// CMmLineTsy::LineInfo
// This method retrieves the current line information. The method is used by 
// MmPhone object.
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
RPhone::TLineInfo CMmLineTsy::LineInfo() const
    {        
    // Line info
    RPhone::TLineInfo lineInfo;
    // The current line status.
    lineInfo.iStatus = iLineStatus;
    // line capabilities
    lineInfo.iLineCapsFlags = iLineCaps.iFlags;
    // line name
    lineInfo.iName = iLineName;

    return lineInfo;
    }

// ---------------------------------------------------------------------------
// CMmLineTsy::NotifyCapsChange
// This CORE API method provides notification of a change in the line 
// capabilities.
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
TInt CMmLineTsy::NotifyCapsChange(
    const TTsyReqHandle aTsyReqHandle,
    RLine::TCaps* aCaps )
    {
    // On return, contains the new line capabilities
    iRetCaps = aCaps;
    iTsyReqHandleStore->SetTsyReqHandle( EMultimodeLineCapsChangeNotification,
        aTsyReqHandle );
    
    return KErrNone;
    }

// ---------------------------------------------------------------------------
// CMmLineTsy::NotifyCapsChangeCancel
// This CORE API method cancels an "line capabilities change" notification 
// request, placed using the NotifyCapsChange() method.
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
TInt CMmLineTsy::NotifyCapsChangeCancel(
    const TTsyReqHandle aTsyReqHandle )
    {
    iRetCaps = NULL;
    iTsyReqHandleStore->ResetTsyReqHandle(
        EMultimodeLineCapsChangeNotification );
    ReqCompleted( aTsyReqHandle, KErrCancel );

    return KErrNone;
    }

// ---------------------------------------------------------------------------
// CMmLineTsy::CompleteNotifyCapsChange
// This method is used to notify to the client about the capabilities change.
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
void CMmLineTsy::CompleteNotifyCapsChange()
    {
    //reset req handle. Returns the deleted req handle
    TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( 
        EMultimodeLineCapsChangeNotification );

    if ( EMultimodeLineReqHandleUnknown != reqHandle )
        {
        *iRetCaps = iLineCaps; 
        ReqCompleted( reqHandle, KErrNone );
        }
    }

// ---------------------------------------------------------------------------
// CMmLineTsy::NotifyIncomingCall
// This CORE API method is used to notify a client when an incoming call is 
// detected.
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
TInt CMmLineTsy::NotifyIncomingCall(
    const TTsyReqHandle aTsyReqHandle,
    TName* aName )
    {
    // On notification, contains the name of the incoming call.
    iRetIncomingCallName = aName;    
    iTsyReqHandleStore->SetTsyReqHandle( EMultimodeLineNotifyIncomingCall,
         aTsyReqHandle );
    return KErrNone;
    }

// ---------------------------------------------------------------------------
// CMmLineTsy::NotifyIncomingCallCancel
// This CORE API method cancels an outstanding incoming call notification, 
// placed with the NotifyIncomingCall() method.
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
TInt CMmLineTsy::NotifyIncomingCallCancel(
    const TTsyReqHandle aTsyReqHandle )
    {
    iRetIncomingCallName = NULL;
    iTsyReqHandleStore->ResetTsyReqHandle( EMultimodeLineNotifyIncomingCall );
    ReqCompleted( aTsyReqHandle, KErrCancel );
    return KErrNone;    
    }

// ---------------------------------------------------------------------------
// CMmLineTsy::NotifyCallAdded
// This CORE API method provides notification that a new call has been added 
// to the line.
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
TInt CMmLineTsy::NotifyCallAdded(
    const TTsyReqHandle aTsyReqHandle,
    TName* aName )
    {
    TFLOGSTRING2("TSY: CMmLineTsy::NotifyCallAdded requested by client, \
        lineMode:%d", iLineMode);
    // On return, contains the name of the new call.
    iRetCallAdded = aName;    
    iTsyReqHandleStore->SetTsyReqHandle( EMultimodeLineNotifyCallAdded,
        aTsyReqHandle );
    return KErrNone;
    }

// ---------------------------------------------------------------------------
// CMmLineTsy::NotifyCallAddedCancel
// This CORE API method cancels an outstanding "new call added" notification 
// request, placed using the NotifyCallAdded() method.(other items were 
// commented in a header).
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
TInt CMmLineTsy::NotifyCallAddedCancel(
    const TTsyReqHandle aTsyReqHandle )
    {
    TFLOGSTRING("TSY: CMmLineTsy::NotifyCallAddedCancel requested by client");
    iRetCallAdded = NULL;
    iTsyReqHandleStore->ResetTsyReqHandle( EMultimodeLineNotifyCallAdded );
    ReqCompleted( aTsyReqHandle, KErrCancel );
    return KErrNone;    
    }

// ---------------------------------------------------------------------------
// CMmLineTsy::CompleteNotifyCallAdded
// This CORE API method is used to notify to the client that a call has been 
// added to the line. NOTE: Type is not defined because this method may be 
// called when incoming call occurs or when a call object has been created. 
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
void CMmLineTsy::CompleteNotifyCallAdded(const TDesC& aName )    
    {
    TFLOGSTRING3("TSY: CMmLineTsy::CompleteNotifyCallAdded entered, \
    CALL ADDED, Call name: %S, Call mode: %d", &aName, iLineMode );

    //reset req handle. Returns the deleted req handle
    TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle( 
                                EMultimodeLineNotifyCallAdded );

    iNumCalls++;

    if ( EMultimodeLineReqHandleUnknown != reqHandle )
        {
        TFLOGSTRING("TSY: CMmLineTsy::CompleteNotifyCallAdded, Completed!");
        *iRetCallAdded = aName;
        ReqCompleted( reqHandle, KErrNone );
        }
    }

// ---------------------------------------------------------------------------
// CMmLineTsy::GetCaps
// This CORE API method retrieves the line capabilities.
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
TInt CMmLineTsy::GetCaps(
    const TTsyReqHandle aTsyReqHandle,
    RLine::TCaps* aCaps )
    {
    *aCaps = iLineCaps;
    ReqCompleted( aTsyReqHandle, KErrNone );
    return KErrNone;
    }

// ---------------------------------------------------------------------------
// CMmLineTsy::GetStatus
// This CORE API method returns core line status information.
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
TInt CMmLineTsy::GetStatus(
    const TTsyReqHandle aTsyReqHandle,
    RCall::TStatus* aStatus )
    {    
    *aStatus = iLineStatus;
    ReqCompleted( aTsyReqHandle, KErrNone );
    return KErrNone;
    }

// ---------------------------------------------------------------------------
// CMmLineTsy::NotifyHookChange
// This CORE API method provides notification when the hook status changes. 
// Feature is not supported.
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
TInt CMmLineTsy::NotifyHookChange(
    const TTsyReqHandle aTsyReqHandle,
    RCall::THookStatus* )
    {    
    ReqCompleted( aTsyReqHandle, KErrNotSupported );
    return KErrNone;
    }

// ---------------------------------------------------------------------------
// CMmLineTsy::NotifyHookChangeCancel
// This CORE API method cancels an outstanding hook change notification req
// placed using the NotifyHookChange() method. Feature is not supported.
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
TInt CMmLineTsy::NotifyHookChangeCancel(
    const TTsyReqHandle aTsyReqHandle )
    {    
    ReqCompleted( aTsyReqHandle, KErrNotSupported );
    return KErrNone;
    }

// ---------------------------------------------------------------------------
// CMmLineTsy::GetCallInfo
// This CORE API method returns information about a call. 
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
TInt CMmLineTsy::GetCallInfo(
    const TTsyReqHandle aTsyReqHandle,
    TCallInfoIndex* aCallInfoIndex )
    {
    TFLOGSTRING3("TSY: CMmLineTsy::GetCallInfo - Line name: %S, Index: %d",
        &iLineName, aCallInfoIndex->iIndex );

    TInt ret( KErrNotFound );

    // Check if the call object can be found from call list by index
    CMmCallTsy* mmCall = REINTERPRET_CAST( CMmCallTsy*, 
            iMmPhone->CallList()->GetMmCallByIndexAndLine( 
                aCallInfoIndex->iIndex, &iLineName ) );

    // If call object was found, fill the client pointer with call information
    if ( mmCall )
        {
        aCallInfoIndex->iInfo.iCallName      = mmCall->CallName();
        aCallInfoIndex->iInfo.iStatus        = mmCall->Status();
        aCallInfoIndex->iInfo.iCallCapsFlags = mmCall->CallCaps();

        TFLOGSTRING3("TSY: CMmLineTsy::GetCallInfo - Call name: %S, Status: %d",
            &aCallInfoIndex->iInfo.iCallName, aCallInfoIndex->iInfo.iStatus );

        ret = KErrNone;
        }

    ReqCompleted( aTsyReqHandle, ret );
    return KErrNone;
    }

// ---------------------------------------------------------------------------
// CMmLineTsy::CancelService
// CancelService is called by the server when it is "cleaning-up" any still 
// outstanding asynchronous requests before closing a client's sub-session. 
// This will happen if a client closes its R-class handle without cancelling 
// outstanding asynchronous requests. Core API requests are directed to the 
// LineBase. 
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
TInt CMmLineTsy::CancelService(
    const TInt aIpc, 
    const TTsyReqHandle aTsyReqHandle )
    {
    TInt ret( KErrNone );
    
    // When the clients close their sub-sessions (eg. by calling RLine::Close)
    // they may not have cancelled all their outstanding asynchronous requests 
    // before closing.  It is up to the ETel server to clean up in this 
    // situation, so the server will find the list of outstanding requests 
    // related to that sub-session object and pass these outstanding IPC 
    // request numbers, one at a time, to the CancelService method in the TSY.

    switch ( aIpc )
        {
        //TSY has started a request and it is not possible to then cancel
        //this request. The best thing for the TSY to do in this case is to
        //proceed as though the Cancel never happened. The server's call to
        //the TSY cancel function will return synchronously. The TSY then
        //continues to wait for the original acknowledgement and when it
        //receives it, the TSY will complete the original request.
        //case XXX
        //    break;

        //Cancel methods that are not supported
        //case XXX:
        //    ret = KErrNotSupported;
        //    break;

        //Notification Cancels, no special requirements.
        case EMobileLineNotifyMobileLineStatusChange:
            ret =  NotifyMobileLineStatusChangeCancel( aTsyReqHandle );
            break;
        //Everything is taken care in the method implementation.
        //Just direct the request to the method.
        //case XXX:
        //    ret = XXXCancel( aTsyReqHandle );
        //    break;

        default:
            return CLineBase::CancelService( aIpc, aTsyReqHandle );
        }

    return ret;
    }

// ---------------------------------------------------------------------------
// CMmLineTsy::RegisterNotification
// RegisterNotification is called when the server recognises that this 
// notification is being posted for the first time on this sub-session object. 
// It enables the TSY to "turn on" any regular notification messages that it 
// may receive from DOS. Currently does not really do anything but returns  
// KErrNone to ETel server in case of known notification request type. 
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
TInt CMmLineTsy::RegisterNotification(
    const TInt aIpc )
    {    
    TInt ret( KErrNone );

    switch ( aIpc )
        {
        case EEtelLineNotifyStatusChange:
        case EEtelLineNotifyCallAdded:
        case EETelLineCapsChangeNotification:
        case EEtelLineNotifyHookChange:
        case EEtelLineNotifyIncomingCall:
        case EMobileLineNotifyMobileLineStatusChange:
            ret = KErrNone;
            break;
        default:
            // Unknown or invalid IPC
            ret = KErrNotSupported;
        }
    return ret;
    }

// ---------------------------------------------------------------------------
// CMmLineTsy::DeregisterNotification
// DeregisterNotification is called when the server recognises that this 
// notification will not be posted again because the last client to have a 
// handle on this sub-session object has just closed the handle. It enables 
// TSY to "turn off" any regular notification messages that it may receive 
// from DOS. Currently does not really do anything but returns KErrNone to  
// ETel server in case of known notification request type. 
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
TInt CMmLineTsy::DeregisterNotification(
    const TInt aIpc )
    {
    TInt ret( KErrNone );

    switch ( aIpc )
        {
        case EEtelLineNotifyStatusChange:
        case EEtelLineNotifyCallAdded:
        case EETelLineCapsChangeNotification:
        case EEtelLineNotifyHookChange:
        case EEtelLineNotifyIncomingCall:
        case EMobileLineNotifyMobileLineStatusChange:
            ret = KErrNone;
            break;
        default:
            // Unknown or invalid IPC
            ret = KErrNotSupported;
        }
    return ret;
    }

// ---------------------------------------------------------------------------
// CMmLineTsy::NumberOfSlotsL
// NumberOfSlotsL is called by the server when it is registering a new 
// NOTIFICATION. It enables the TSY to tell the server how many buffer slots 
// to allocate for "repost immediately" notifications that may trigger before 
// clients collect them.
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
TInt CMmLineTsy::NumberOfSlotsL(
    const TInt aIpc )
    {    
    //There is a buffer in the ETel server for each type of NOTIFICATION and
    //the size of the buffer is determined by the TSY. When the ETel server
    //discovers that a request is "repost immediately" it will ask the TSY how
    //big a buffer it wants by calling CTelObject::NumberOfSlotsL( ).
    //
    //It is up to the TSY developer's judgement how many buffer slots this
    //method returns for each notification. If there is a danger that a
    //particular notification could trigger frequently and in rapid succession
    //(e.g. call group change notification) then at least 10 or 20 slots may
    //be required. For a notification that triggers rarely, perhaps 1 or 2
    //slots is enough.
    //
    //So if the ETel server has stored a few occurrences of a particular
    //notification, when a client subsequently calls that notification request
    //the ETel server will complete the client's request with the saved data.
    
    TInt numberOfSlots( 1 );

    switch ( aIpc )
        {
        case EEtelLineNotifyStatusChange:
            numberOfSlots = KMmLineStatusChangeSlots;
            break;
        case EEtelLineNotifyCallAdded:
            numberOfSlots = KMmLineCallAddedSlots;
            break;
        case EETelLineCapsChangeNotification:
            numberOfSlots = KMmLineCapsChangeSlots;
            break;
        case EEtelLineNotifyHookChange:
            numberOfSlots = KMmLineHookChangeSlots;
            break;
        case EEtelLineNotifyIncomingCall:
            numberOfSlots = KMmLineIncomingCallSlots;
            break;
        case EMobileLineNotifyMobileLineStatusChange:
            numberOfSlots = KMmLineMobileLineStatusChangeSlots;
            break;
        default:  
            // Unknown or invalid Line IPC
            User::Leave( KErrNotSupported );
            break;
        }
    return numberOfSlots;
    }

// ---------------------------------------------------------------------------
// CMmLineTsy::LineMode
// Returns line mode.
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
RMobilePhone::TMobileService CMmLineTsy::LineMode() const
    {
    return iLineMode;
    }

// ---------------------------------------------------------------------------
// CMmLineTsy::LineName
// Returns line name.
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
TName CMmLineTsy::LineName() const
    {
    return iLineName;
    }

// ---------------------------------------------------------------------------
// CMmLineTsy::GetMobileLineStatus
// Returns the current status of the line through the aStatus argument. The 
// possible line states map to the call states (see MM API spec) so that a 
// line that has one or more calls opened from it will have a status defined 
// by this table.
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
TInt CMmLineTsy::GetMobileLineStatus(
    const TTsyReqHandle aTsyReqHandle,
    RMobileCall::TMobileCallStatus* aStatus )
    {
    *aStatus = iMobileLineStatus;
    ReqCompleted( aTsyReqHandle, KErrNone );
    return KErrNone;
    }

// ---------------------------------------------------------------------------
// CMmLineTsy::NotifyMobileLineStatusChange
// Allows a client to be notified when the mobile line changes state. The 
// request completes when the line changes state, the new state being copied 
// to the aStatus parameter.
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
TInt CMmLineTsy::NotifyMobileLineStatusChange(
    RMobileCall::TMobileCallStatus* aStatus )
    {
    iRetMobileLineStatus = aStatus;
    iReqHandleType = EMultimodeLineMobileLineStatusChange;
    return KErrNone;
    }

// ---------------------------------------------------------------------------
// CMmLineTsy::NotifyMobileLineStatusChangeCancel
// Cancels an outstanding asynchronous NotifyMobileLineStatusChange request.
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
TInt CMmLineTsy::NotifyMobileLineStatusChangeCancel(
    const TTsyReqHandle aTsyReqHandle )
    {
    iRetMobileLineStatus = NULL;
    iTsyReqHandleStore->ResetTsyReqHandle(
        EMultimodeLineMobileLineStatusChange );
    ReqCompleted( aTsyReqHandle, KErrCancel );
    return KErrNone;
    }

// ---------------------------------------------------------------------------
// CMmLineTsy::CompleteNotifyAddBypassingCall
// Handles ghost call object creation and initialisation. Also notifies 
// clients about the ghost call (using NotifyCallAdded method)
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
void CMmLineTsy::CompleteNotifyAddBypassingCall(
    CMmDataPackage* aDataPackage )
    {
    TInt callId( -1 );
    RMobilePhone::TMobileService callMode( RMobilePhone::EVoiceService );
    RMobileCall::TMobileCallInfoV1* mobileCallInfo;

    const CCallDataPackage* callData = 
        reinterpret_cast<const CCallDataPackage*>(aDataPackage);

    callData->GetCallIdAndMode( callId, callMode );
    callData->UnPackData ( &mobileCallInfo );

    if ( mobileCallInfo->iStatus == RMobileCall::EStatusDialling ||
         mobileCallInfo->iStatus == RMobileCall::EStatusConnecting ||
         mobileCallInfo->iStatus == RMobileCall::EStatusConnected )
        {
        TFLOGSTRING2("TSY: CMmLineTsy::CompleteNotifyAddBypassingCall, \
            CALL INITIATED - NOT REQUESTED BY ETEL's CLIENT, Call ID: %d",
            callId );

        //create new call object
        CMmCallTsy* mmGhostCall = CreateGhostCallObject(
            callId, callMode, mobileCallInfo->iStatus );

        if ( mmGhostCall )
            {
            // Add the new call to the list of calls
            TInt ret( iMmPhone->CallList()->AddObject( mmGhostCall ) );

            if ( KErrNone == ret )
                {
                mmGhostCall->CompleteNotifyMobileCallInfoChange( 
                    aDataPackage );
                CompleteNotifyStatusChange();
                //inform ETel client that someone is creating a MO call
                CompleteNotifyCallAdded( mmGhostCall->CallName() );
                mmGhostCall->SetGhostCall( ETrue );
                }
            else
                {
                delete mmGhostCall;
                }
            }
        }
    else
        {
        TFLOGSTRING3("TSY: CMmLineTsy::CompleteNotifyAddBypassingCall, \
            CALL NOT INITIATED - Call ID:%d, Call status:%d", 
            callId, mobileCallInfo->iStatus);
        }
    }

#ifdef TF_LOGGING_ENABLED
// ---------------------------------------------------------------------------
// CMmLineTsy::ReqCompleted
// Overloads CTelObject::ReqCompleted for logging purposes. It prints the 
// aTsyReqHandle and aError variable in the log file and then calls 
// CTelObject::ReqCompleted.
// (other items were commented in a header).
// ---------------------------------------------------------------------------
//
void CMmLineTsy::ReqCompleted(
    const TTsyReqHandle aTsyReqHandle,
    const TInt aError )
    {
    TFLOGSTRING3("TSY: CMmLineTsy::ReqCompleted Handle:%d Error:%d", 
        aTsyReqHandle, aError);

    CTelObject::ReqCompleted(aTsyReqHandle,aError);        
    }

#endif


//  End of File