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

//

//INCLUDES

#include "cmmfaxlinetsy.h"

#include "cmmphonetsy.h"

#include "cmmfaxcalltsy.h"

#include "cmmcallextinterface.h"

#include "cmmlinelist.h"

#include "cmmcalllist.h"

#include "cmmtsyreqhandlestore.h"

#include "cmmmessagemanagerbase.h"

#include <ctsy/pluginapi/cmmdatapackage.h>

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

CMmFaxLineTsy::CMmFaxLineTsy()

    {

    }

CMmFaxLineTsy* CMmFaxLineTsy::NewL(

    CMmPhoneTsy* aMmPhone,

    RMobilePhone::TMobileService aMode,

    const TDesC& aName,

    CMmMessageManagerBase* aMessageManager )

    {

    CMmFaxLineTsy* mmLineTsy = NULL;

    if ( aMmPhone != NULL && aMode == RMobilePhone::EFaxService )

        {

        mmLineTsy = new ( ELeave ) CMmFaxLineTsy();

        CleanupClosePushL( *mmLineTsy );

        mmLineTsy->iMmPhone  = aMmPhone;    

        mmLineTsy->iLineName = aName;

        mmLineTsy->iLineMode = aMode;

        mmLineTsy->iMessageManager = aMessageManager;

        mmLineTsy->ConstructL();

        CleanupStack::Pop();

        }

    return mmLineTsy;

    }

CMmFaxLineTsy::~CMmFaxLineTsy()

    {

    iLastIncomingFaxCall = NULL;

    }

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

// CMmFaxLineTsy::OpenNewObjectL

// This method creates a new name for a call and opens a new  call. This  

// methodis called when the client uses RCall::OpenNewCall method. Currently 

// the maximum number of opened calls from tsy is 20.

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

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

//

CTelObject* CMmFaxLineTsy::OpenNewObjectL(

    TDes& aNewName )

    {

    CMmFaxCallTsy* mmCall = NULL;

    // mmfax: Fax client expects that it get's the existing call object,

    // not the new one..

    if ( iLastIncomingFaxCall )

        {

        aNewName.Copy(iLastIncomingFaxCall->CallName());

        iLastIncomingFaxCall = NULL;

        mmCall = reinterpret_cast<CMmFaxCallTsy*>(

            OpenNewObjectByNameL(aNewName) );

        return mmCall;

        }

    //Logic here to prevent creation of unlimited amount of call objects

    //by clients. The proposed maximum amount of call objects is 20:

    //

    //  - 2 voice call object (1 for each line for incoming calls

    //  - 1 data call object (for incoming data call)

    //  - 1 emergency call object

    //  - 1+7 call objects for Confence call (max number of CC participants)

    //  - phonebook 1

    //  - javaphone 1

    //  - WTA 1

    //  - voice mail box 1

    //  - csd 1

    //  - fax 1

    //  - 3rd party 2

    //

    //Incoming calls can not be created if the maximum number is exceeded!

    if ( KMaxNumberOfCallObjectsFromTsy 

            > iMmPhone->CallList()->GetNumberOfObjects() )

        {

        CreateNewCallName( aNewName );

        mmCall = CMmFaxCallTsy::NewL(

            iMmPhone, this, iLineMode, aNewName, iMessageManager );

        iNameOfLastCallAdded = aNewName;

        // Add the new call to the list of calls

        TInt ret = iMmPhone->CallList()->AddObject( mmCall );

        if ( KErrNone != ret )

            {

            //If call cannot be added to CallList -> leave with KErrNoMemory

            //CallList has to have information about every call.

            mmCall->Close();

            mmCall = NULL;

            User::Leave( KErrNoMemory );

            }

        else

            {

            CompleteNotifyCallAdded( aNewName );

            }

        }

    else

        {

        User::Leave( KErrAccessDenied );

        }

    return mmCall;

    }

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

// CMmFaxLineTsy::InitInternalAttributesL

// Initialises miscellaneous internal attributes.

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

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

//

void CMmFaxLineTsy::InitInternalAttributesL()

    {

    CMmLineTsy::InitInternalAttributesL();

    // The line supports data connections.

    iLineCaps.iFlags = RLine::KCapsFax | RLine::KCapsEventIncomingCall;

    }

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

// CMmFaxLineTsy::CreateCallObjectForIncomingCall

// This function creates and stores a Call object that is used for a incoming 

// call.

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

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

//

TInt CMmFaxLineTsy::CreateCallObjectForIncomingCall()

    {

    TInt trapError( KErrNone );

    TInt result = CMmPhoneTsy::EMultimodePhoneOutOfMemory;

    if ( !iCallForIncomingCall )

        {

        TName newName;

        CreateNewCallName( newName );

        TRAP( trapError,

            iCallForIncomingCall = CMmFaxCallTsy::NewL(

                iMmPhone, this, iLineMode, newName, iMessageManager );

            );

        if ( trapError == KErrNone ) 

            {

            iNameOfLastCallAdded = newName;

            // Don't add the new call to the list of calls yet. Will be

            // added when incoming call has been received...

            result = KErrNone;

            }

        }

    return result;

    }

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

// CMmFaxLineTsy::CreateGhostCallObject

// This method creates a Call object for the Ghost call. A ghost call is a  

// call that has been initiated bypassing the ETel.

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

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

//

CMmCallTsy* CMmFaxLineTsy::CreateGhostCallObject(

    TInt aCallId,

    RMobilePhone::TMobileService,

    RMobileCall::TMobileCallStatus aCallStatus )

    {

    TInt trapError( KErrNone );

    TName newName;

    CreateNewCallName( newName );

    CMmFaxCallTsy* mmCall = NULL;

    TRAP( trapError,

        mmCall = CMmFaxCallTsy::NewL(

            iMmPhone, this, iLineMode, newName, iMessageManager );

        );

    if ( KErrNone == trapError && NULL != mmCall )

        {

        //set call ID

        mmCall->SetCallId( aCallId );

        //set call status

        if( aCallStatus >= RMobileCall::EStatusDialling )

            {

            //Status is allways set to dialing. If call is alredy

            //e.g. connecting, missed status changes are simulated.

            mmCall->SetCallStatus(

                RCall::EStatusDialling, RMobileCall::EStatusDialling );

            }

        //set call caps

        mmCall->SetCallCaps( RCall::KCapsFax | RCall::KCapsHangUp );

        //set call direction to MO call

        mmCall->SetCallDirection( RMobileCall::EMobileOriginated );

        //set flag indicating that this is a ghost call

        mmCall->SetGhostCall( ETrue );

        //save name of the last added call

        iNameOfLastCallAdded = mmCall->CallName();

        }

    return mmCall;

    }

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

// CMmFaxLineTsy::CompleteNotifyIncomingCall

// This method is used to notify to the client about the incoming call. Basic 

// information: one Call object is allocated in the boot-up for incoming call. 

// When an incoming call occurs the call object will be given to the client 

// that answers the call. Therefore we have to create a new call object for 

// the next incoming call. In case that we are out of memory, the next 

// incoming call cannot be received! General error message about OutOfMemory  

// situation is sent to the client. 

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

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

//

void CMmFaxLineTsy::CompleteNotifyIncomingCall(

    CMmDataPackage* aDataPackage )

    {

    TInt callId( -1 );

    RMobilePhone::TMobileService callMode( RMobilePhone::EVoiceService );

    CCallDataPackage* callDataPackage =

        reinterpret_cast<CCallDataPackage*>(aDataPackage);

    callDataPackage->GetCallIdAndMode( callId, callMode ); 

    //reset req handle. Returns the deleted req handle

    TTsyReqHandle reqHandle = iTsyReqHandleStore->ResetTsyReqHandle(

        EMultimodeLineNotifyIncomingCall );

    CMmFaxCallTsy* mmCall = NULL;

    // Check if notification is requested

    if ( EMultimodeLineReqHandleUnknown != reqHandle )

        {

        mmCall = reinterpret_cast<CMmFaxCallTsy*>(

            CallObjectForIncomingCall() );

        if ( mmCall )

            {

            // Add the new call to the list of calls

            TInt ret = iMmPhone->CallList()->AddObject( mmCall );

            if ( KErrNone == ret )

                {

                //set flag indicating that this is a unowned incoming call

                mmCall->SetUnownedCallObjectFlag( ETrue );

                // Set call ID

                mmCall->SetCallId( callId );

                // Set call direction to EMobileTerminated

                mmCall->SetCallDirection( RMobileCall::EMobileTerminated );

                // Add answer capability and remove dial capability to

                // existing call capabilities

                TUint32 callCaps = mmCall->CallCaps();

                callCaps |= RCall::KCapsAnswer; 

                callCaps &= ~RCall::KCapsDial;

                mmCall->SetCallCaps( callCaps );

                //set data to gsm extension

                //( direction added because not uppdated in messagehandler)

                mmCall->ActiveCallExtension()->SetMobileCallData(

                    aDataPackage, RMobileCall::EMobileTerminated );

                // mmfax: Save ptr to last incoming fax call, so that

                // it can be used to open right call object for fax.

                iLastIncomingFaxCall = mmCall;

                iNameOfCallForAnswering = mmCall->CallName();

                *iRetIncomingCallName = mmCall->CallName(); 

                iCallForIncomingCall = NULL;

                iNumCalls++;

                ReqCompleted( reqHandle, KErrNone );

                // Create and store a new Call Object for incoming call.

                CreateCallObjectForIncomingCall();

                RMobileCall::TMobileCallStatus status(

                    RMobileCall::EStatusRinging );

                CCallDataPackage dataPackage;

                dataPackage.SetCallIdAndMode( callId, callMode );

                dataPackage.PackData( &status );

                }

            else

                {

                //call object could not be added to the call list. Incoming 

                //call cannot be received.

                ReqCompleted( reqHandle, KErrNoMemory );

                }

            }

        else

            {

            //call object could not be get. Incoming call cannot be received.

            //General error message about OutOfMemory situation has been sent

            //to the client.

            ReqCompleted( reqHandle, KErrNoMemory );

            }

        }

    }

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

// CMmFaxLineTsy::CompleteNotifyDiallingStatus

// This method notifies line that a call has entered Dialling state. It means

// that Call ID should be saved and in case of ghost call a new call object

// should be created.

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

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

//

void CMmFaxLineTsy::CompleteNotifyDiallingStatus(

    CMmDataPackage* aDataPackage )

    {

    TInt callId( -1 );

    TBool ghostCall( EFalse );

    RMobilePhone::TMobileService callMode( RMobilePhone::EFaxService );

    CCallDataPackage* callData 

        = reinterpret_cast<CCallDataPackage*>(aDataPackage);

    callData->GetCallIdAndMode( callId, callMode );

    CMmFaxCallTsy* mmCall = reinterpret_cast<CMmFaxCallTsy*>(

        iMmPhone->CallList()->GetMmCallByMode( callMode ) );

    if ( NULL == mmCall )

        {

        ghostCall = ETrue;

        }

    else

        {

        TBool result( EFalse );

        //now we have to check, if this is a ghost call

        result = mmCall->IsServiceLocallyRequested(

            CMmCallTsy::EMultimodeCallDial );

        if ( result )

            {

            for ( TInt i = 0; i < iMmPhone->CallList()->GetNumberOfObjects(); 

                i++ )

                {    

                mmCall = reinterpret_cast<CMmFaxCallTsy*>(

                    iMmPhone->CallList()->GetMmCallByIndex(i) );

                if ( mmCall->ServiceRequested(

                        CMmCallTsy::EMultimodeCallDial ) )

                    {

                    mmCall->SetCallId( callId );

                    mmCall->CompleteNotifyMobileCallInfoChange( 

                        aDataPackage );

                    break;   

                    }

                }

            }

        else

            {

            ghostCall = ETrue;

            }

        }

    //Ghost call handling starts here

    if ( ghostCall )

        {

        //complete call added notification directly from here

        CompleteNotifyAddBypassingCall( aDataPackage ); 

        }

    }

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

// CMmFaxLineTsy::ResetLastIncomingCall

// This method sets iLastIncomingFaxCall to NULL

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

//

void CMmFaxLineTsy::ResetLastIncomingCall()

    {

    iLastIncomingFaxCall = NULL;

    }

//  End of File