--- /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 <mccpcscall.h> //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<MCCPConferenceCallObserver*>( &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<CVccPerformer*>( 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<CVccPerformer*>( 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<CVccPerformer*>( &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<MCCPConferenceCallObserver*>( &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<MCCPCall>& aCallArray )
+ {
+ RUBY_DEBUG_BLOCK( "CVccConferenceCall::GetCallArray" );
+ RPointerArray<MCCPCall> pluginCalls;
+ iConferenceCall->GetCallArray( pluginCalls );
+ for( TInt i = 0; i < pluginCalls.Count(); i++ )
+ {
+ aCallArray.Append( MatchPluginToVccCall( pluginCalls[i] ) );
+ }
+
+ pluginCalls.Close();
+ return KErrNone;
+ }
+