/*

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

    {

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

    iInitialized = EFalse;

    }

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

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

    TBuf<10> addr;

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

    }

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

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

    CleanupStack::Pop( call );    

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

    return call;

    }

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

// CSProvider::ReleaseEmergencyCall

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

//

TInt CSProvider::ReleaseEmergencyCall( MCCPEmergencyCall& aCall )

    {

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

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

    iCallArray->Remove( call );

    delete call;

    return KErrNone;

    }

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

// CSProvider::NewConferenceL

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

//

MCCPConferenceCall* CSProvider::NewConferenceL( 

                        const TUint32 /*aServiceId*/,

                        const MCCPConferenceCallObserver& aObserver )

    {   

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

    if ( !iConferenceCall )

        {

        iConferenceCall = CSPConferenceCall::NewL( 

                                    iMobilePhone, *iCallArray, iServiceId );    

        iConferenceCall->AddObserverL( aObserver );

        }

    else 

        {

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

                Error conference already exists");

        User::Leave( KErrAlreadyExists ); 

        }

    CSPLOGSTRING(CSPREQOUT, "CSProvider::NewConferenceL >");

    return iConferenceCall;

    }