diff -r 000000000000 -r a4daefaec16c callcontinuity/vcc/src/cvccconferencecall.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/callcontinuity/vcc/src/cvccconferencecall.cpp Mon Jan 18 20:12:36 2010 +0200 @@ -0,0 +1,418 @@ +/* +* Copyright (c) 2008 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: Base class of VCC conference call object +* +*/ + +#include //CCP API + +#include "cvccconferencecall.h" +#include "cvccperformer.h" +#include "cconvergedcallprovider.h" +#include "rubydebug.h" + +// ======== MEMBER FUNCTIONS ======== + +// --------------------------------------------------------------------------- +// C'tor +// --------------------------------------------------------------------------- +// +CVccConferenceCall::CVccConferenceCall( const TUint32 aServiceId, + const MCCPConferenceCallObserver& aObserver, + RVccCallArray& aCallArray ) +: iServiceId( aServiceId ), + iObserver( const_cast( &aObserver ) ), + iCallArray( aCallArray ) + { + RUBY_DEBUG_BLOCK("CVccConferenceCall::CVccConferenceCall"); + } + +// --------------------------------------------------------------------------- +// C'tor +// --------------------------------------------------------------------------- +// +CVccConferenceCall::CVccConferenceCall( MCCPConferenceCall& aConferenceCall, + RVccCallArray& aCallArray ) +: iServiceId( aConferenceCall.ServiceId() ), + iCallArray( aCallArray ) + { + RUBY_DEBUG_BLOCK("CVccConferenceCall::CVccConferenceCall"); + RUBY_DEBUG0("CVccConferenceCall::CVccConferenceCall2"); + iConferenceCall = &aConferenceCall; + // Get reference to CS plugin + CConvergedCallProvider& csProv = iCallArray[0]->CsProvider(); + iCsProvider = &csProv; + } +// --------------------------------------------------------------------------- +// 2nd phase C'tor +// --------------------------------------------------------------------------- +// +void CVccConferenceCall::ConstructL() + { + RUBY_DEBUG_BLOCKL( "CVccConferenceCall::ConstructL" ); + + __ASSERT_ALWAYS( iCallArray.Count() > 0, User::Leave( KErrArgument ) ); + + // Get reference to CS plugin + CConvergedCallProvider& csProv = iCallArray[0]->CsProvider(); + iCsProvider = &csProv; + + // Order CS plugin to create new conference + iConferenceCall = iCsProvider->NewConferenceL( iServiceId, *this ); + } + +// --------------------------------------------------------------------------- +// Two phased C'tor +// --------------------------------------------------------------------------- +// +CVccConferenceCall* CVccConferenceCall::NewL( const TUint32 aServiceId, + const MCCPConferenceCallObserver& aObserver, + RVccCallArray& aCallArray ) + { + CVccConferenceCall* self = new( ELeave ) CVccConferenceCall( aServiceId, + aObserver, + aCallArray ); + CleanupStack::PushL( self ); + self->ConstructL(); + CleanupStack::Pop( self ); + return self; + } + +// --------------------------------------------------------------------------- +// Two phased C'tor +// --------------------------------------------------------------------------- +// +CVccConferenceCall* CVccConferenceCall::NewL( MCCPConferenceCall& aConferenceCall, + RVccCallArray& aCallArray ) + { + RUBY_DEBUG0("CVccConferenceCall::NewL2"); + + CVccConferenceCall* self = new( ELeave ) CVccConferenceCall( + aConferenceCall, + aCallArray ); + + return self; + } + +// --------------------------------------------------------------------------- +// D'tor +// --------------------------------------------------------------------------- +// +CVccConferenceCall::~CVccConferenceCall() + { + RUBY_DEBUG0( "CVccConferenceCall::~CVccConferenceCall() - ENTER" ); + + RUBY_DEBUG0( "CVccConferenceCall::~CVccConferenceCall() - EXIT" ); + } + +// --------------------------------------------------------------------------- +// Signals CS plugin that conference is released +// --------------------------------------------------------------------------- +// +void CVccConferenceCall::ReleaseConference() + { + RUBY_DEBUG_BLOCK( "CVccConferenceCall::ReleaseConference" ); + iCsProvider->ReleaseConferenceCall( *iConferenceCall ); + } + +// --------------------------------------------------------------------------- +// @see MCCPConferenceCall::ServiceId +// --------------------------------------------------------------------------- +// +TUint32 CVccConferenceCall::ServiceId() const + { + RUBY_DEBUG_BLOCK("CVccConferenceCall::ServiceId"); + + return iServiceId; + } + +// --------------------------------------------------------------------------- +// @see MCCPConferenceCall::HangUp +// --------------------------------------------------------------------------- +// +TInt CVccConferenceCall::HangUp() + { + RUBY_DEBUG_BLOCK( "CVccConferenceCall::HangUp" ); + + TInt retValue( iConferenceCall->HangUp() ); + + RUBY_DEBUG1( "Error: %d", retValue ); + + return retValue; + } + +// --------------------------------------------------------------------------- +// @see MCCPConferenceCall::Hold +// --------------------------------------------------------------------------- +// +TInt CVccConferenceCall::Hold() + { + RUBY_DEBUG_BLOCK( "CVccConferenceCall::Hold" ); + + TInt retValue( iConferenceCall->Hold() ); + + RUBY_DEBUG1( "Error: %d", retValue ); + + return retValue; + } + + +// --------------------------------------------------------------------------- +// @see MCCPConferenceCall::Resume +// --------------------------------------------------------------------------- +// +TInt CVccConferenceCall::Resume() + { + RUBY_DEBUG_BLOCK( "CVccConferenceCall::Resume" ); + + TInt retValue( iConferenceCall->Resume() ); + + RUBY_DEBUG1( "Error: %d", retValue ); + + return retValue; + } + + +// --------------------------------------------------------------------------- +// @see MCCPConferenceCall::Swap +// --------------------------------------------------------------------------- +// +TInt CVccConferenceCall::Swap() + { + RUBY_DEBUG_BLOCK( "CVccConferenceCall::Swap" ); + + TInt retValue( iConferenceCall->Swap() ); + + RUBY_DEBUG1( "Error: %d", retValue ); + + return retValue; + } + + +// --------------------------------------------------------------------------- +// @see MCCPConferenceCall::AddCallL +// --------------------------------------------------------------------------- +// +void CVccConferenceCall::AddCallL( MCCPCall* aCall ) + { + RUBY_DEBUG_BLOCK( "CVccConferenceCall::AddCallL" ); + + // NULL pointer + __ASSERT_ALWAYS( aCall, User::Leave( KErrArgument ) ); + RUBY_DEBUG0( "- Not a NULL pointer" ); + + CVccPerformer* call = static_cast( aCall ); + + // Tell CS plugin to add the call in conference and add it to the + // local conference array + iConferenceCall->AddCallL( call->PrimaryCall() ); + + } + + +// --------------------------------------------------------------------------- +// @see MCCPConferenceCall::RemoveCallL +// --------------------------------------------------------------------------- +// +void CVccConferenceCall::RemoveCallL( MCCPCall* aCall ) + { + RUBY_DEBUG_BLOCK( "CVccConferenceCall::RemoveCallL" ); + + // NULL pointer + __ASSERT_ALWAYS( aCall, User::Leave( KErrArgument ) ); + RUBY_DEBUG0( "- Not a NULL pointer" ); + + CVccPerformer* call = static_cast( aCall ); + + // Tell CS plugin to remeove call from conference + iConferenceCall->RemoveCallL( call->PrimaryCall() ); + + } + +// --------------------------------------------------------------------------- +// @see MCCPConferenceCall::CallCount +// --------------------------------------------------------------------------- +// +TInt CVccConferenceCall::CallCount() const + { + RUBY_DEBUG_BLOCK( "CVccConferenceCall::CallCount" ); + + return iConferenceCall->CallCount(); + } + + +// --------------------------------------------------------------------------- +// @see MCCPConferenceCall::GoOneToOneL +// --------------------------------------------------------------------------- +// +void CVccConferenceCall::GoOneToOneL( MCCPCall& aCall ) + { + RUBY_DEBUG_BLOCK( "CVccConferenceCall::GoOneToOneL" ); + + // Find call from conference array + CVccPerformer* call = dynamic_cast( &aCall ); + + // Check that the call was found in conference array + __ASSERT_ALWAYS( call, User::Leave( KErrNotFound ) ); + + // Tell CS plugin to go one-on-one + iConferenceCall->GoOneToOneL( *call->PrimaryCall() ); + } + + +// --------------------------------------------------------------------------- +// @see MCCPConferenceCall::CurrentCallsToConferenceL +// --------------------------------------------------------------------------- +// +void CVccConferenceCall::CurrentCallsToConferenceL() + { + RUBY_DEBUG_BLOCK( "CVccConferenceCall::CurrentCallsToConferenceL" ); + iConferenceCall->CurrentCallsToConferenceL(); + } + +// --------------------------------------------------------------------------- +// @see MCCPConferenceCall::AddObserverL +// --------------------------------------------------------------------------- +// +void CVccConferenceCall::AddObserverL( + const MCCPConferenceCallObserver& aObserver ) + { + RUBY_DEBUG_BLOCK( "CVccConferenceCall::AddObserverL" ); + + iObserver = const_cast( &aObserver ); + } + + +// --------------------------------------------------------------------------- +// @see MCCPConferenceCall::RemoveObserver +// --------------------------------------------------------------------------- +// +TInt CVccConferenceCall::RemoveObserver( + const MCCPConferenceCallObserver& aObserver ) + { + RUBY_DEBUG_BLOCK( "CVccConferenceCall::RemoveObserver" ); + + TInt retValue( KErrNone ); + + if ( iObserver == &aObserver ) + { + iObserver = NULL; + } + else + { + retValue = KErrNotFound; + } + + return retValue; + } + +// --------------------------------------------------------------------------- +// @see MCCPConferenceCallObserver::ErrorOccurred +// --------------------------------------------------------------------------- +// +void CVccConferenceCall::ErrorOccurred( TCCPConferenceCallError aError ) + { + RUBY_DEBUG_BLOCK( "CVccConferenceCall::ErrorOccurred" ); + RUBY_DEBUG1( "- Error code [%d]", aError ); + + // Tell CCE level that error occurred + iObserver->ErrorOccurred( aError ); + } + + +// --------------------------------------------------------------------------- +// @see MCCPConferenceCallObserver::ConferenceCallCapsChanged +// --------------------------------------------------------------------------- +// +void CVccConferenceCall::ConferenceCallCapsChanged( + const TCCPConferenceCallCaps aCaps ) + { + RUBY_DEBUG_BLOCK( "CVccConferenceCall::ConferenceCallStateChanged()" ); + RUBY_DEBUG1( "- Caps = %d", aCaps ); + + iObserver->ConferenceCallCapsChanged( aCaps ); + } + + +// --------------------------------------------------------------------------- +// @see MCCPConferenceCallObserver::ConferenceCallStateChanged +// --------------------------------------------------------------------------- +// +void CVccConferenceCall::ConferenceCallStateChanged( + const TCCPConferenceCallState aState ) + { + RUBY_DEBUG_BLOCK( "CVccConferenceCall::ConferenceCallStateChanged" ); + RUBY_DEBUG1( "- State = %d", aState ); + iObserver->ConferenceCallStateChanged( aState ); + } + +// --------------------------------------------------------------------------- +// @see MCCPConferenceCallObserver::ConferenceCallEventOccurred +// --------------------------------------------------------------------------- +// +void CVccConferenceCall::ConferenceCallEventOccurred( + const TCCPConferenceCallEvent aEvent, MCCPCall* aReferredCall ) + { + RUBY_DEBUG_BLOCK( "CVccConferenceCall::ConferenceCallEventOccurred" ); + iObserver->ConferenceCallEventOccurred( aEvent, + MatchPluginToVccCall( aReferredCall ) ); + } + + +// --------------------------------------------------------------------------- +// Search a specific call from call array +// --------------------------------------------------------------------------- +// +CVccPerformer* CVccConferenceCall::MatchPluginToVccCall( MCCPCall* aPluginCall ) + { + RUBY_DEBUG_BLOCK( "CVccConferenceCall::FindInCallArray()" ); + + CVccPerformer* call = NULL; + + if ( aPluginCall ) + { + for ( TInt i = 0; i < iCallArray.Count(); i++ ) + { + // Comparison is made to CVccPerformer and MCCPCall objects + // for simplicity sake + if ( iCallArray[i]->PrimaryCall() == aPluginCall ) + { + RUBY_DEBUG0( "- Call found" ); + call = iCallArray[i]; + break; + } + } + } + + return call; + } + +// --------------------------------------------------------------------------- +// Collect all conference participants into array +// --------------------------------------------------------------------------- +// +TInt CVccConferenceCall::GetCallArray( RPointerArray& aCallArray ) + { + RUBY_DEBUG_BLOCK( "CVccConferenceCall::GetCallArray" ); + RPointerArray pluginCalls; + iConferenceCall->GetCallArray( pluginCalls ); + for( TInt i = 0; i < pluginCalls.Count(); i++ ) + { + aCallArray.Append( MatchPluginToVccCall( pluginCalls[i] ) ); + } + + pluginCalls.Close(); + return KErrNone; + } +