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



//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/tflogger.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()
    {
    TFLOGSTRING2("TSY: CMmFaxLineTsy::~CMmFaxLineTsy. Line name: %S",
        &iLineName);

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

    TFLOGSTRING3("TSY: CMmFaxLineTsy::CompleteNotifyIncomingCall - \
        Line name: %S, Call id: %d", &iLineName, callId );

    //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 )
    {
    TFLOGSTRING("TSY: CMmFaxLineTsy::CompleteNotifyDiallingStatus");
    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 )
        {
        TFLOGSTRING("TSY: CMmFaxLineTsy::CompleteNotifyDiallingStatus - \
            GhostCall");
        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
            {
            TFLOGSTRING("TSY: CMmFaxLineTsy::CompleteNotifyDiallingStatus - \
                Dial not found");
            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()
    {
    TFLOGSTRING("TSY: CMmFaxLineTsy::ResetLastIncomingCall");
    iLastIncomingFaxCall = NULL;
    }
    
//  End of File