/*
* 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: Implements class CSPVideoCall which provides video call
* functionality
*
*/
#include <etelmm.h>
#include <etel.h>
#include <mccpcallobserver.h>
#include <rmmcustomapi.h>
#include "cspvideocall.h"
#include "cspetelcallrequester.h"
#include "cspetelcalleventmonitor.h"
#include "cspetelcallstatusmonitor.h"
#include "cspetelvideocallcapsmonitor.h"
#include "csplogger.h"
#include "csppanic.pan"
#include "cspconsts.h"
#include "mcspcommoninfo.h"
// ---------------------------------------------------------------------------
// CSPVideoCall::NewL Two phased construction.
// ---------------------------------------------------------------------------
//
CSPVideoCall* CSPVideoCall::NewL( const TDesC& aName,
RMobileLine& aLine, TBool aMobileOriginated,
const CCCECallParameters& aParams,
MCSPCommonInfo& aCommonInfo )
{
CSPLOGSTRING(CSPOBJECT, "CSPVideoCall::NewL <");
CSPVideoCall* self = new (ELeave) CSPVideoCall( aLine, aMobileOriginated,
aName, aCommonInfo );
CleanupStack::PushL( self );
self->ConstructL( aParams );
CleanupStack::Pop( self );
CSPLOGSTRING(CSPOBJECT, "CSPVideoCall::NewL >");
return self;
}
// ---------------------------------------------------------------------------
// CSPVideoCall::~CSPVideoCall
// ---------------------------------------------------------------------------
//
CSPVideoCall::~CSPVideoCall()
{
CSPLOGSTRING(CSPOBJECT, "CSPVideoCall::~CSPVideoCall <");
// Stop monitoring events
delete iConnectionHandler;
delete iVideoCallCapsMonitor;
CSPLOGSTRING(CSPOBJECT, "CSPVideoCall::~CSPVideoCall >");
}
// ---------------------------------------------------------------------------
// CSPVideoCall::NotifyCallStateChanged
// Notifies observers about state changes
// ---------------------------------------------------------------------------
//
void CSPVideoCall::NotifyCallStateChanged(
MCCPCallObserver::TCCPCallState aState )
{
CSPLOGSTRING2(CSPINT, "CSPVideoCall::NotifyCallStateChanged %d", aState);
TInt errorCode( KErrNone );
iNextCallState = aState;
if ( aState == MCCPCallObserver::ECCPStateConnected &&
iParams->CallType() == CCPCall::ECallTypeVideo &&
!iConnectionHandler->ConnectionInitialized() )
{
// When connected message is received, call object must first open
// the socket connection and loan data port
CSPLOGSTRING(CSPINT,
"CSPVideoCall::NotifyCallStateChanged initializing connection");
errorCode = iConnectionHandler->InitializeConnection();
__ASSERT_ALWAYS( errorCode == KErrNone,
Panic( ECSPPanicDataConnectionInitError ) );
}
else if ( aState == MCCPCallObserver::ECCPStateIdle &&
iParams->CallType() == CCPCall::ECallTypeVideo )
{
// When idle message is received one can close the
// socket connections.
CSPLOGSTRING(CSPINT,
"CSPVideoCall::NotifyCallStateChanged releasing connection");
iConnectionHandler->ReleaseConnection();
}
// Connected notify is not sent for video call before connection has
// been initialized.
if ( aState == MCCPCallObserver::ECCPStateConnected &&
iParams->CallType() == CCPCall::ECallTypeVideo &&
!iConnectionHandler->ConnectionInitialized() )
{
CSPLOGSTRING(CSPINT,
"CSPVideoCall::NotifyCallStateChanged connection not initialized");
}
else
{
CSPLOGSTRING(CSPINT,
"CSPVideoCall::NotifyCallStateChanged notifying state change");
CSPCall::NotifyCallStateChanged( aState );
}
}
// ---------------------------------------------------------------------------
// CSPVideoCall::NotifyCallStateChangedWithInband
// Notifies observers about state changes
// ---------------------------------------------------------------------------
//
void CSPVideoCall::NotifyCallStateChangedWithInband(
MCCPCallObserver::TCCPCallState aState )
{
CSPLOGSTRING2(CSPINT,
"CSPVideoCall::NotifyCallStateChangedWithInband %d", aState);
iNextCallState = aState;
CSPCall::NotifyCallStateChangedWithInband( aState );
}
// ---------------------------------------------------------------------------
// CSPVideoCall::ConnectionReady
// ---------------------------------------------------------------------------
//
void CSPVideoCall::ConnectionReady( TName aDataPortName )
{
CSPLOGSTRING3(CSPINT, "CSPVideoCall::ConnectionReady \
state = %d, next state: %d", iCallState, iNextCallState);
// If still connecting
if ( iNextCallState == MCCPCallObserver::ECCPStateConnected )
{
NotifyCallEventOccurred( MCCPCallObserver::ECCPCSDataPortLoaned );
NotifyCallStateChanged( iNextCallState );
iCommonInfo.NotifyDataPortName( aDataPortName );
}
}
// ---------------------------------------------------------------------------
// CSPVideoCall::ConnectionEstablishingFailed
// ---------------------------------------------------------------------------
//
void CSPVideoCall::ConnectionEstablishingFailed(TInt /*aErr*/)
{
CSPLOGSTRING(CSPERROR, "CSPVideoCall::ConnectionEstablishingFailed");
CSPCall::NotifyErrorOccurred( ECCPErrorVideoCallSetupFailed );
}
// ---------------------------------------------------------------------------
// CSPVideoCall::VideoCallCapsChanged
// Receives data call caps changed notification from Etel data call caps monitor
// ---------------------------------------------------------------------------
//
void CSPVideoCall::DataCallCapsChanged( RMobileCall::TMobileCallDataCapsV1& aCaps )
{
CSPLOGSTRING(CSPINT, "CSPVideoCall::DataCallCapsChanged");
if ( aCaps.iProtocolCaps == RMobileCall::KCapsIsdnMultimedia )
{
CSPLOGSTRING(CSPINT, "CSPVideoCall::DataCallCapsChanged type=video");
iParams->SetCallType( CCPCall::ECallTypeVideo );
}
else
{
CSPLOGSTRING(CSPINT, "CSPVideoCall::DataCallCapsChanged type=voice");
iParams->SetCallType( CCPCall::ECallTypeCSVoice );
}
}
// ---------------------------------------------------------------------------
// Branches dial requests according to the flag.
// ---------------------------------------------------------------------------
//
TInt CSPVideoCall::DialFdnCond( TBool aFdnCheck )
{
CSPLOGSTRING(CSPREQIN, "CSPVideoCall::DialFdnCond <");
TInt err(KErrNone);
SetDefaultCallParameters();
// Update internal call params
iCommonInfo.InitializeDataCallParameters( iDataCallParams );
// Set the call state to dialling
if ( iCall.SubSessionHandle() )
{
CSPLOGSTRING(CSPINT, "CSPVideoCall::DialFdnCond make request");
if ( aFdnCheck )
{
err = iRequester->MakeDialRequest(
iDataCallParamsPckg, iRemotePartyNumber );
}
else
{
err = iRequester->MakeDialNoFdnCheckRequest(
iDataCallParamsPckg, iRemotePartyNumber );
}
if ( err != KErrNone )
{
CSPLOGSTRING2(CSPERROR,
"CSPVideoCall::DialFdnCond ERROR with Dial request: %d", err );
}
}
else
{
CSPLOGSTRING2(CSPERROR, "CSPVideoCall::DialFdnCond() ERROR with iCall session: %d", &iCall );
err = KErrGeneral;
}
CSPLOGSTRING(CSPINT, "CSPVideoCall::DialFdnCond() >");
return err;
}
// ---------------------------------------------------------------------------
// From class MCCPCSCall
// CSPVideoCall::SwitchAlternatingCall
// ---------------------------------------------------------------------------
//
TInt CSPVideoCall::SwitchAlternatingCall()
{
CSPLOGSTRING(CSPREQIN, "CSPVideoCall::GetMobileCallInfo");
return KErrNotSupported;
}
// ---------------------------------------------------------------------------
// From class MCCPCSCall
// CSPVideoCall::GetMobileDataCallCaps
// ---------------------------------------------------------------------------
//
TInt CSPVideoCall::GetMobileDataCallCaps( TDes8& aCaps ) const
{
CSPLOGSTRING(CSPREQIN, "CSPVideoCall::GetMobileDataCallCaps");
return iVideoCallCapsMonitor->GetMobileDataCallCaps( aCaps );
}
// ---------------------------------------------------------------------------
// From class MCCPCall
// CSPVideoCall::IsSecured
// ---------------------------------------------------------------------------
//
TBool CSPVideoCall::IsSecured() const
{
CSPLOGSTRING(CSPREQIN, "CSPVideoCall::IsSecured");
return CSPCall::IsSecured();
}
// ---------------------------------------------------------------------------
// CSPVideoCall::CSPVideoCall
// ---------------------------------------------------------------------------
//
CSPVideoCall::CSPVideoCall( RMobileLine& aLine,
TBool aMobileOriginated,
const TDesC& aName,
MCSPCommonInfo& aCommonInfo ) :
CSPCall( aLine, aMobileOriginated, aName,
aCommonInfo, EFalse ),
iDataCallParams(),
iDataCallParamsPckg (iDataCallParams)
{
CSPLOGSTRING(CSPOBJECT, "CSPVideoCall::CSPVideoCall");
}
// ---------------------------------------------------------------------------
// CSPVideoCall::ConstructL
// Constructing CSPVideoCall for MT call.
// ---------------------------------------------------------------------------
//
void CSPVideoCall::ConstructL( const CCCECallParameters& aParams )
{
CSPLOGSTRING(CSPOBJECT, "CSPVideoCall::ConstructL <");
CSPCall::ConstructL( aParams );
iConnectionHandler = CSPVideoCallConnectionHandler::NewL( *this, iCall );
iVideoCallCapsMonitor = CSPEtelVideoCallCapsMonitor::NewL( *this, iCall );
iVideoCallCapsMonitor->StartMonitoring();
// Update call type info only for MT call.
if ( !iMobileOriginated )
{
CSPLOGSTRING(CSPOBJECT, "CSPVideoCall::ConstructL() selecting call type for MT call");
CCPCall::TCallType callType = SelectCallTypeFromProtocolCaps();
iParams->SetCallType( callType );
}
// Filter out illegal requests
if ( !CCPCall::ECallTypeVideo == iParams->CallType() )
{
CSPLOGSTRING(CSPERROR, "CSPVideoCall::ConstructL() error invalid call type");
User::Leave( KErrArgument );
}
CSPLOGSTRING(CSPOBJECT, "CSPVideoCall::ConstructL >");
}
// -----------------------------------------------------------------------------
// Set default call parameters.
// -----------------------------------------------------------------------------
//
void CSPVideoCall::SetDefaultCallParameters()
{
// Set common call default parameters
iDataCallParams.iSpeakerControl = RMobileCall::EMonitorSpeakerControlAlwaysOn;
iDataCallParams.iSpeakerVolume = RMobileCall::EMonitorSpeakerVolumeMedium;
iDataCallParams.iInterval = KCSPDefaultInterval;
iDataCallParams.iWaitForDialTone = RMobileCall::EDialToneNoWait;
iDataCallParams.iIdRestrict = RMobileCall::EIdRestrictDefault;
iDataCallParams.iAutoRedial = KCSPDefaultAutoRedial;
// Set video call parameters
iDataCallParams.iService = RMobileCall::EServiceDataCircuitSync;
iDataCallParams.iSpeed = RMobileCall::ESpeed64000;
iDataCallParams.iProtocol = RMobileCall::EProtocolIsdnMultimedia;
iDataCallParams.iQoS = RMobileCall::EQoSTransparent;
iDataCallParams.iRLPVersion = RMobileCall::ERLPNotRequested;
iDataCallParams.iModemToMSWindowSize = 0x00;
iDataCallParams.iMSToModemWindowSize = 0x00;
iDataCallParams.iAckTimer = 0x00;
iDataCallParams.iRetransmissionAttempts = 0x00;
iDataCallParams.iResequencingPeriod = 0x00;
iDataCallParams.iV42bisReq = RMobileCall::EV42bisNeitherDirection;
iDataCallParams.iV42bisCodewordsNum = 0x00;
iDataCallParams.iV42bisMaxStringLength = 0x00;
iDataCallParams.iUseEdge = EFalse;
}
// ---------------------------------------------------------------------------
// CSPVideoCall::SelectCallTypeFromProtocolCaps
// ---------------------------------------------------------------------------
//
CCPCall::TCallType CSPVideoCall::SelectCallTypeFromProtocolCaps()
{
CSPLOGSTRING(CSPREQIN, "CSPVideoCall::SelectCallTypeFromProtocolCaps <");
iVideoCallCapsMonitor->UpdateProtocolCaps();
TUint protocolCaps = iVideoCallCapsMonitor->GetProtocolCaps();
CCPCall::TCallType callType;
if ( protocolCaps == RMobileCall::KCapsIsdnMultimedia )
{
callType = CCPCall::ECallTypeVideo;
}
else
{
callType = CCPCall::ECallTypeCSVoice;
}
CSPLOGSTRING2(CSPINT, "CSPVideoCall::SelectCallTypeFromProtocolCaps >\
call type: %d", callType );
return callType;
}
// End of File