/*

* Copyright (c) 2007-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:  Main class of CS Call Plug-in

*

*/

// EXTERNAL INCLUDES

#include <e32base.h>

#include <mccpconferencecallobserver.h>

#include <mmtsy_names.h>

#include <mccpssobserver.h>

#include <rmmcustomapi.h>

#include <startupdomainpskeys.h>

#include <mccecall.h>

// USER INCLUDES

#include "csprovider.h"

#include "cspvoicecall.h"

#include "cspvideocall.h"

#include "cspetelincomingcallmonitor.h"

#include "cspetelconferencestatusmonitor.h"

#include "cspdtmfprovider.h"

#include "cspconferencecall.h"

#include "cspcallarray.h"

#include "cspservicesettingshandler.h"

#include "cspaudiohandler.h"

#include "cspetelcallwaitingrequester.h"

#include "cspsupplementaryservicesmonitor.h"

#include "cspcipheringstatusmonitor.h"

#include "cspsssettingshandler.h"

#include "cspcalladdedhandler.h"

#include "csppubsublistener.h"

#include "cspcallcommandhandler.h"

#include "cspremotealertingtonelistener.h"

#include "csppanic.pan"

#include "csplogger.h"

#include "cspconsts.h"

const TInt KCSServiceId = 1; 

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

// CSProvider::CSProvider

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

//

CSProvider::CSProvider(): iImplementationUid( KCSPImplementationUid ),

        iCCPObserver( NULL ),

        iSsObserver( NULL ),

        iDTMFProvider( NULL ),

        iIncomingVoiceCallMonitor( NULL ),

        iIncomingDataCallMonitor( NULL ),

        iIncomingAuxCallMonitor( NULL ),

        iCallArray( NULL ),

        iServiceHandler( NULL ),

        iInitialized( EFalse ),

        iCallAddedHandler( NULL ),

        iServiceId( 0 ),

        iAudioHandler( NULL ),

        iCwRequester( NULL ),

        iSsMonitor( NULL ),

        iCipheringStatusMonitor( NULL ),

        iSsSettingsHandler( NULL ),

        iSimStatusListener( NULL ),

        iCallCommandHandler( NULL ),

        iRemoteAlertingToneListener( NULL ),

        iConferenceStatusMonitor( NULL ),

        iConferenceCall( NULL )

    {

    CSPLOGSTRING(CSPOBJECT, "CSProvider::CSProvider");

    }

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

// CSProvider::~CSProvider

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

//

CSProvider::~CSProvider()

    {

    CSPLOGSTRING(CSPOBJECT, "CSProvider::~CSProvider <");

    delete iCallArray;

    if ( iInitialized )

        {

        delete iConferenceStatusMonitor; 

        delete iCallCommandHandler;

        delete iRemoteAlertingToneListener;

        delete iSimStatusListener;

        delete iSsSettingsHandler;

        delete iAudioHandler;        

        delete iSsMonitor;

        delete iCwRequester;

        delete iServiceHandler;

        delete iIncomingVoiceCallMonitor;

        delete iIncomingDataCallMonitor;

        delete iIncomingAuxCallMonitor;

        delete iCallAddedHandler;

        delete iCipheringStatusMonitor;

        delete iDTMFProvider;

        CSPLOGSTRING(CSPOBJECT, "CSProvider::~CSProvider close lines");

        iLineContainer.Close();

        CSPLOGSTRING(CSPOBJECT, "CSProvider::~CSProvider close customapi");

        iMmCustom.Close();

        CSPLOGSTRING(CSPOBJECT, "CSProvider::~CSProvider close conference call");

        iMobileConferenceCall.Close();

        CSPLOGSTRING(CSPOBJECT, "CSProvider::~CSProvider close phone");

        iMobilePhone.Close();

        CSPLOGSTRING(CSPOBJECT, "CSProvider::~CSProvider unload phone");

        iServer.UnloadPhoneModule( KMmTsyModuleName );

        CSPLOGSTRING(CSPOBJECT, "CSProvider::~CSProvider close server session");

        iServer.Close();

        }

    CSPLOGSTRING(CSPOBJECT, "CSProvider::~CSProvider >");

    }

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

// CSProvider::ConstructL

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

//

void CSProvider::ConstructL()

    {

    CSPLOGSTRING(CSPOBJECT, "CSProvider::ConstructL <");

    iCallArray = CSPCallArray::NewL();

    CSPLOGSTRING(CSPOBJECT, "CSProvider::ConstructL >");

    }

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

// CSProvider::NewL

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

//

CSProvider* CSProvider::NewL()

    {

    CSPLOGSTRING(CSPOBJECT, "CSProvider::NewL() <");

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

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    CSPLOGSTRING(CSPOBJECT, "CSProvider::NewL() >");

    return self;

    }

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

// CSProvider::NotifySsEvent

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

//

void CSProvider::NotifySsEvent( 

                    RMmCustomAPI::TSsTypeAndMode& aSsTypeAndMode,

                    RMmCustomAPI::TSsInfo& aSsInfo )

    {

    CSPLOGSTRING(CSPINT, "CSProvider::NotifySsEvent <");

    const TDesC& addr = KNullDesC;

    switch( aSsTypeAndMode.iSsType )

        {

        case RMmCustomAPI::ESsAllSs:

            {

            CSPLOGSTRING(CSPINT, "CSProvider::NotifySsEvent ESsAllSs");

            if( iSsSettingsHandler )

                {

                TInt cugIndex( aSsInfo.iCugIndex );

                if ( iSsSettingsHandler->IsValueValidCugIndex( cugIndex ) ) 

                    {

                    CSPLOGSTRING(CSPINT, "CSProvider::NotifySsEvent CallCugEventOccurred");

                    iSsObserver->CallCugEventOccurred(  

                            MCCPSsObserver::ECCPSsShowIncCallGroupIndex );

                    }  

                else 

                    {

                    CSPLOGSTRING2(CSPERROR, 

                            "CSProvider::NotifySsEvent err invalid cug index %d", cugIndex );

                    }

                }

            break; 

            }

        case RMmCustomAPI::ESsRegPassword:

        case RMmCustomAPI::ESsClip:

        case RMmCustomAPI::ESsClir:

        case RMmCustomAPI::ESsCnap:

        case RMmCustomAPI::ESsColp:

        case RMmCustomAPI::ESsColr:

            {

            CSPLOGSTRING(CSPINT, "CSProvider::NotifySsEvent Discarding");

            break; 

            }

        case RMmCustomAPI::ESsCallWaiting:

            {

            CSPLOGSTRING(CSPINT, "CSProvider::NotifySsEvent ESsCallWaiting");

            iSsObserver->CallForwardEventOccurred( 

                                MCCPSsObserver::ESsCallWaiting,

                                addr );

            break; 

            }        

        case RMmCustomAPI::ESsAllForwardings:

        case RMmCustomAPI::ESsForwUncond:

        case RMmCustomAPI::ESsForwBusy:

        case RMmCustomAPI::ESsForwNoReply:

        case RMmCustomAPI::ESsForwNoReach:

        case RMmCustomAPI::ESsAllCondForwardings:

            {

            switch( aSsInfo.iForwMode )

                {

                case RMmCustomAPI::ESsIncCallIsForw:

                    iSsObserver->CallForwardEventOccurred( 

                                        MCCPSsObserver::ECCPSsIncCallIsForw,

                                        addr );

                    break;

                case RMmCustomAPI::ESsIncCallForwToC:

                    iSsObserver->CallForwardEventOccurred( 

                                        MCCPSsObserver::ECCPSsIncCallForwToC,

                                        addr );

                    break;

                case RMmCustomAPI::ESsOutCallForwToC:

                    iSsObserver->CallForwardEventOccurred( 

                                        MCCPSsObserver::ECCPSsOutCallForwToC,

                                        addr );

                    break;

                default:

                    {

                    HandleDivertOrBarring( addr, aSsTypeAndMode );

                    break; 

                    }

                }

            break;

            }

        case RMmCustomAPI::ESsAllBarrings:  

        case RMmCustomAPI::ESsBarrAllOut:

        case RMmCustomAPI::ESsBarrOutInter:

        case RMmCustomAPI::ESsBarrOutInterExcHome:

        case RMmCustomAPI::ESsOutgoingBarrServ:

            {            

            iSsObserver->BarringEventOccurred( 

                                    MCCPSsObserver::ECCPSsOutgoingCallBarred );

            break;

            }

        case RMmCustomAPI::ESsBarrAllIn:

        case RMmCustomAPI::ESsBarrAllInRoam:

        case RMmCustomAPI::ESsIncomingBarrServ:

            {            

            iSsObserver->BarringEventOccurred( 

                                    MCCPSsObserver::ECCPSsIncomingCallBarred );

            break;

            }

        default:

            {

            CSPLOGSTRING(CSPINT, "CSProvider::NotifySsEvent Unknown SS");

            break; 

            }

        }

    CSPLOGSTRING(CSPINT, "CSProvider::NotifySsEvent >");    

    }

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

// CSProvider::InitializeL for testing purposes

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

//

void CSProvider::InitializeL( const MCCPObserver& aObserver,

                              const MCCPSsObserver& aSsObserver,

                              CSPAudioHandlerBase* aAudioHandler )

    {

    if (!iAudioHandler)

        {        

        iAudioHandler = aAudioHandler;

        }

    InitializeL( aObserver, aSsObserver );    

    }

// From CConvergedCallProvider

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

// CSProvider::InitializeL

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

//

void CSProvider::InitializeL( const MCCPObserver& aObserver,

                              const MCCPSsObserver& aSsObserver )

    {

    CSPLOGSTRING(CSPOBJECT, "CSProvider::InitializeL <");

    if ( iInitialized )

        {

        CSPLOGSTRING(CSPOBJECT, 

                "CSProvider::InitializeL() Error already initialized");

        User::Leave( KErrAlreadyExists );

        }

    iInitialized = ETrue;

    CreateEtelConnectionsL();

    iServiceHandler = CSPServiceSettingsHandler::NewL();

    TInt readErr = iServiceHandler->ReadCSServiceId( iServiceId );

    if ( readErr )

        {

        CSPLOGSTRING(CSPERROR, "CSProvider::InitializeL()\

                ERROR COULD NOT READ SERVICE ID FOR CS-PLUGIN ");

        CSPLOGSTRING(CSPERROR, "CSProvider::InitializeL() \

                Please ensure that SPSettings is initialized corretly! ");

        iServiceId = KCSServiceId; 

        }

    // Save CCP observer as pointer-type member 

    const MCCPCSObserver& obs = static_cast<const MCCPCSObserver&>(aObserver);

    iCCPObserver = const_cast<MCCPCSObserver*>(&obs);

    // Save CCP SS observer as pointer-type member 

    const MCCPSsObserver& ssObs = static_cast<const MCCPSsObserver&>(aSsObserver);

    iSsObserver = const_cast<MCCPSsObserver*>(&ssObs);

    RPhone::TLineInfo lineInfo;

    __ASSERT_ALWAYS( iMobilePhone.GetLineInfo( 0, lineInfo )

        == KErrNone, Panic( ECSPPanicNoEtel ) );

    // Open Lines. At least voice line must be opened.

    __ASSERT_ALWAYS( iLineContainer.Open( iMobilePhone, iServiceId ) == KErrNone,

        Panic( ECSPPanicNoEtel ) );

    RMobileLine& voiceLine = iLineContainer.LineByType( 

                                RCSPLineContainer::ECSPLineSpeech );

    // Create and start incoming voice call monitor for primary line

    iIncomingVoiceCallMonitor = CSPEtelIncomingCallMonitor::NewL( *this, 

                                      voiceLine,

                                      RCSPLineContainer::ECSPLineSpeech );

    iIncomingVoiceCallMonitor->StartMonitoring();

    // Create and start incoming data call monitor for data line    

    RMobileLine& dataLine = iLineContainer.LineByType( RCSPLineContainer::ECSPLineData );

    iIncomingDataCallMonitor = CSPEtelIncomingCallMonitor::NewL( *this, dataLine,

                                      RCSPLineContainer::ECSPLineData );

    iIncomingDataCallMonitor->StartMonitoring();

    // Create and start incoming call monitor for auxilary line    

    RMobileLine& auxLine = iLineContainer.LineByType( RCSPLineContainer::ECSPLineAuxSpeech );

    iIncomingAuxCallMonitor = CSPEtelIncomingCallMonitor::NewL( *this, auxLine,

                                      RCSPLineContainer::ECSPLineAuxSpeech );

    iIncomingAuxCallMonitor->StartMonitoring();

    iCwRequester = CSPEtelCallWaitingRequester::NewL( iMobilePhone );

    // Start conference call monitor for monitoring external conference creation  

    iConferenceStatusMonitor = CSPEtelConferenceStatusMonitor::NewL( *this, 

                                    iMobileConferenceCall );

    iConferenceStatusMonitor->StartMonitoring();

    CSPLOGSTRING(CSPOBJECT, "CSProvider::InitializeL create DTMF provider");

    iDTMFProvider = CSPDTMFProvider::NewL( iMobilePhone, iMmCustom );

    // Create and start ciphering status monitor    

    iCipheringStatusMonitor = CSPCipheringStatusMonitor::NewL( iMmCustom, *this );

    iCipheringStatusMonitor->StartMonitoring();

    // Create audio handler

    CSPLOGSTRING(CSPOBJECT, "CSProvider::InitializeL create audio handler");

    if (!iAudioHandler)

        {

        iAudioHandler = CSPAudioHandler::NewL();

        }

    // Create call added handler for listening ext call creation

    iCallAddedHandler = CSPCallAddedHandler::NewL( 

        obs, 

        iLineContainer, 

        *iCallArray,

        *this,

        *iAudioHandler );

    iSimStatusListener = CSPPubSubListener::NewL( 

        KPSUidStartup, 

        KPSSimStatus, 

        this );

    HandleSIMStatusL();

    iRemoteAlertingToneListener = 

        CSPRemoteAlertingToneListener::NewL( iMmCustom, *this );

    iRemoteAlertingToneListener->StartListening();

    iCallCommandHandler = CSPCallCommandHandler::NewL();

    CSPLOGSTRING(CSPOBJECT, "CSProvider::InitializeL >");

    }

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

// CSProvider::NewCallL creates MO call.

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

//

MCCPCall* CSProvider::NewCallL( const CCCPCallParameters& aCallParameters,

                                const TDesC& aRemoteParty, 

                                const MCCPCallObserver& aObserver )

    {

    CSPLOGSTRING(CSPREQIN, "CSProvider::NewCallL <");

    const CCCECallParameters& parameters = 

        reinterpret_cast<const CCCECallParameters&> (aCallParameters);

    TUint32 serviceId = aCallParameters.ServiceId();

    if ( serviceId != iServiceId )

        {

        CSPLOGSTRING(CSPERROR, "CSProvider::NewCallL ERROR, service id not acceptable!");

        User::Leave( ECCPErrorInvalidPhoneNumber );

        }

    RCSPLineContainer::TCSPLineId lineId = 

        iLineContainer.ResolveLineIdL( parameters );

    RMobileLine& line = iLineContainer.LineByType( lineId );

    CSPCall* call = NULL;

    if ( RCSPLineContainer::ECSPLineSpeech == lineId ||

         RCSPLineContainer::ECSPLineAuxSpeech == lineId )

        {

        call = CSPVoiceCall::NewL( const_cast<TDesC16&>(aRemoteParty), 

                            line, 

                            ETrue,

                            parameters,

                            *this,

                            EFalse );

        CleanupStack::PushL( call );

        }

    // Create CSPDataCall object for data/video call

    else if ( RCSPLineContainer::ECSPLineData == lineId )

        {

        call = CSPVideoCall::NewL( 

                            const_cast<TDesC16&>(aRemoteParty),

                            line, ETrue, parameters,

                            *this );

        CleanupStack::PushL( call );

        }

    else if ( RCSPLineContainer::ECSPLineFax == lineId )

        {

        CSPLOGSTRING(CSPERROR, 

            "CSProvider::NewCallL ERROR FAX is unsupported call type");

        User::Leave( KErrNotSupported );

        }

    if ( aRemoteParty.Length() == 0 )

        {

        CSPLOGSTRING(CSPERROR, "CSProvider::NewCallL ERROR: aRemoteParty.Length ==0");

        User::Leave( ECCPErrorInvalidPhoneNumber );

        }

    call->AddObserverL( aObserver );        

    TInt err = iCallArray->Add( call );

    User::LeaveIfError( err );

    call->SetAudioHandler( iAudioHandler );

    CleanupStack::Pop( call );

    CSPLOGSTRING(CSPOBJECT, "CSProvider::NewCallL >");

    return call;

    }

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

// CSProvider::ReleaseCall

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

//

TInt CSProvider::ReleaseCall( MCCPCall& aCall )

    {

    CSPLOGSTRING2(CSPREQIN, "CSProvider::ReleaseCall %d", &aCall);

    CSPCall* call = static_cast<CSPCall*>(&aCall);

    TInt err = iCallArray->Remove( call );

    if ( err == KErrNone )

        {

        delete call;

        }

    return err;

    }

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

// CSProvider::NewEmergencyCallL

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

//

MCCPEmergencyCall* CSProvider::NewEmergencyCallL( const TUint32 aServiceId,

                                                  const TDesC& aAddress,

                                           const MCCPCallObserver& aObserver )

    {

    CSPLOGSTRING(CSPOBJECT, "CSProvider::NewEmergencyCallL <");

    RMobileLine& voiceLine = iLineContainer.LineByType( 

                                    RCSPLineContainer::ECSPLineSpeech );

    TBuf8<KCCEBearerMaxSize> emptyBearer;

    TBuf<KCCESubAddressMaxSize> emptySubAddress;

    CCCECallParameters* tmpParams = CCCECallParameters::NewL();

    CleanupStack::PushL( tmpParams );

    tmpParams->SetServiceId(aServiceId);

    CSPVoiceCall* call = CSPVoiceCall::NewL( aAddress,

                                             voiceLine,

                                             ETrue,

                                             *tmpParams,

                                             *this,

                                             ETrue);

    CleanupStack::PopAndDestroy( tmpParams );

    CleanupStack::PushL( call );

    call->AddObserverL( aObserver );

    TInt err = iCallArray->Add( call );

    User::LeaveIfError( err );

    call->SetAudioHandler( iAudioHandler );