/*
* Copyright (c) 2005 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:
*
*/
#include <badesca.h>
#include "mceservercore.h"
#include "mcecssessionimplementation.h"
#include "mcecsserver.h"
#include "mcecssession.h"
#include "mcecomaudiocodec.h"
#include "mcecomvideocodec.h"
#include "mcecssessionreceiver.h"
#include "mcecssubsessionreceiver.h"
#include "mcecssubsession.h"
#include "mcecsserveritc.h"
#include "mcesipmanager.h"
#include "mcemediamanager.h"
#include "mcesrvlogs.h"
#include "mceserial.h"
#include "mcemessagedispatcher.h"
// -----------------------------------------------------------------------------
// CMceCsSession::NewL
// -----------------------------------------------------------------------------
//
CMceCsSession* CMceCsSession::NewL( CMceServerCore& aServerCore )
{
CMceCsSession* self = CMceCsSession::NewLC( aServerCore );
CleanupStack::Pop(self);
return self;
}
// -----------------------------------------------------------------------------
// CMceCsSession::NewLC
// -----------------------------------------------------------------------------
//
CMceCsSession* CMceCsSession::NewLC( CMceServerCore& aServerCore )
{
CMceCsSession* self = new (ELeave) CMceCsSession( aServerCore );
CleanupStack::PushL( self );
self->ConstructL();
return self;
}
// -----------------------------------------------------------------------------
// CMceCsSession::CMceCsSession
// -----------------------------------------------------------------------------
//
CMceCsSession::CMceCsSession (CMceServerCore& aServerCore)
: iServerCore (aServerCore)
{
iServerCore.IncrementSessions();
}
// -----------------------------------------------------------------------------
// CMceCsSession::ConstructL
// -----------------------------------------------------------------------------
//
void CMceCsSession::ConstructL ()
{
MCESRV_DEBUG("CMceCsSession::ConstructL, Entry");
iITC = CMceCsServerITC::NewL();
iImpl = CMceCsSessionImplementation::NewL( iServerCore.Manager(), this );
MCESRV_DEBUG("CMceCsSession::ConstructL, Exit");
}
// -----------------------------------------------------------------------------
// CMceCsSession::CreateSubSessionReceiverL
// -----------------------------------------------------------------------------
//
CMceCsSubSessionReceiver* CMceCsSession::CreateSubSessionReceiverL ()
{
return CMceCsSubSessionReceiver::NewL( ITC() );
}
// -----------------------------------------------------------------------------
// CMceCsSession::Implementation
// -----------------------------------------------------------------------------
//
CMceCsSessionImplementation& CMceCsSession::Implementation()
{
return *iImpl;
}
// -----------------------------------------------------------------------------
// CMceCsSession::~CMceCsSession
// -----------------------------------------------------------------------------
//
CMceCsSession::~CMceCsSession()
{
MCESRV_DEBUG("CMceCsSession::~CMceCsSession, Entry");
iServerCore.DecrementSessions();
iServerCore.Manager().UnRegisterClient( *this );
if ( iImpl )
{
iImpl->RemoveAllSubSessions();
delete iImpl;
iImpl = NULL;
}
iReceivers.ResetAndDestroy();
iReceivers.Close();
delete iITC;
MCESRV_DEBUG("MCE Server session deleted");
MCESRV_DEBUG("CMceCsSession::~CMceCsSession, Exit");
}
// -----------------------------------------------------------------------------
// CMceCsSession::ServerCore
// -----------------------------------------------------------------------------
//
CMceServerCore& CMceCsSession::ServerCore ()
{
return iServerCore;
}
// -----------------------------------------------------------------------------
// CMceCsSession::ServiceL
// From CSession
// -----------------------------------------------------------------------------
//
void CMceCsSession::ServiceL( const RMessage2& aMessage )
{
TInt error = KErrNone;
MCESRV_DEBUG("CMceCsSession::ServiceL, Entry");
#ifdef PLAT_SEC_TEST
iITC->Complete(aMessage, KErrNone);
return;
#endif
TInt function = iITC->Function( aMessage );
TMceIds ids = iITC->ReadMCEIdsL( aMessage );
TRAP( error, DoServiceL( function, aMessage ) );
if ( error != KErrNone )
{
MCESRV_DEBUG_DVALUE("ServiceL: Error occured in session/subsession. ERROR", error );
iITC->WriteL(aMessage, ids);
if ( function == EMceItcClientReadyToReceive ||
function == EMceItcClientCancelReceive )
{
MCESRV_DEBUG("ServiceL: Error occured in ClientReadyToReceiveL -> Stop receive" );
error = KErrCompletion;
}
}
MCESRV_DEBUG("CMceCsSession::ServiceL, Exit");
User::LeaveIfError( error );
}
// -----------------------------------------------------------------------------
// CMceCsSession::DoServiceL
// -----------------------------------------------------------------------------
//
void CMceCsSession::DoServiceL( TInt aFunction, const RMessage2& aMessage )
{
MCESRV_DEBUG("CMceCsSession::ServiceL, Entry");
MCESRV_DEBUG_EVENT("ITC", aFunction);
TMceIds ids = iITC->ReadMCEIdsL( aMessage );
MCESRV_DEBUG_IDS("IDS", ids );
if ( ids.IsAppUIDId() )
{
MCESRV_DEBUG("passing to manager receiver");
switch (aFunction)
{
case EMceItcSetAppUid:
{
SetClientUidL(ids, aMessage);
break;
}
case EMceItcCreateSession:
{
CreateSubSessionL(ids, aMessage);
break;
}
case EMceItcDeleteSession:
{
DeleteSubSessionL(ids, aMessage);
break;
}
case EMceItcClientCancelReceive:
{
CancelClientReceiveL( ids );
break;
}
case EMceItcClientReadyToReceive: // Asynchronous. Do not complete yet.
{
ClientReadyToReceiveL(ids, aMessage);
return;
}
case EMceItcGetSupportedAudioCodecs:
case EMceItcGetSupportedVideoCodecs:
{
SupportedCodecsL(aFunction, aMessage);
break;
}
case EMceItcDisplaysAvailable:
case EMceItcCameraInfo:
case EMceItcCamerasAvailable:
case EMceItcTranscode:
case EMceItcTranscodeWithSession:
case EMceItcCancelTranscode:
case EMceItcFileInfo:
case EMceItcMaxVolume:
case EMceItcMaxGain:
{
MediaServiceL( ids, (TMceItcFunctions)aFunction, aMessage );
break;
}
case EMceItcReceive:
{
ReceiveL (ids, aMessage);
break;
}
case EMceItcSetDefaultHeaders:
{
StoreDefaultHeadersL( aMessage );
break;
}
case EMceItcGetDefaultHeaders:
{
DefaultHeadersL( aMessage );
break;
}
default:
{
#ifndef ALLOW_NOT_SUPPORTED_ITC
User::Leave(KErrNotSupported);
#endif
}
}
iITC->WriteL(aMessage, ids);
iITC->Complete(aMessage, KErrNone);
}
else
{
MCESRV_DEBUG("passing to session receiver");
CallSubSessionL(ids, aFunction, aMessage);
}
MCESRV_DEBUG("CMceCsSession::ServiceL, Exit");
}
// -----------------------------------------------------------------------------
// CMceCsSession::Uid
// -----------------------------------------------------------------------------
//
TUid CMceCsSession::Uid()
{
return iClientUid;
}
// -----------------------------------------------------------------------------
// CMceCsSession::SetClientUidL
// -----------------------------------------------------------------------------
//
void CMceCsSession::SetClientUidL (TMceIds& aIds, const RMessage2& /*aMessage*/)
{
MCESRV_DEBUG("CMceCsSession::SetClientUidL, Entry");
TInt id = (TInt) aIds.iAppUID;
iClientUid = TUid::Uid(id);
ServerCore().Manager().RegisterClientL( *this );
MCESRV_DEBUG("CMceCsSession::SetClientUidL, Exit");
}
// -----------------------------------------------------------------------------
// CMceCsSession::ClientReadyToReceiveL
// -----------------------------------------------------------------------------
//
void CMceCsSession::ClientReadyToReceiveL (TMceIds& aIds, const RMessage2& aMessage)
{
MCESRV_DEBUG("CMceCsSession::ClientReadyToReceiveL, Entry");
ReceiverL( aIds )->ClientReadyToReceiveL (aMessage);
MCESRV_DEBUG("CMceCsSession::ClientReadyToReceiveL, Exit");
}
// -----------------------------------------------------------------------------
// CMceCsSession::CancelClientReceiveL
// -----------------------------------------------------------------------------
//
void CMceCsSession::CancelClientReceiveL ( TMceIds& aIds )
{
MCESRV_DEBUG("CMceCsSession::CancelClientReceiveL, Entry");
ReceiverL( aIds )->CancelClientReceiveL();
MCESRV_DEBUG("CMceCsSession::CancelClientReceiveL, Exit");
}
// -----------------------------------------------------------------------------
// CMceCsSession::SupportedCodecsL
// -----------------------------------------------------------------------------
//
void CMceCsSession::SupportedCodecsL( TInt aFunction, const RMessage2& aMessage )
{
MCESRV_DEBUG("CMceCsSession::SupportedCodecsL, Entry");
HBufC8* codecs = NULL;
if ( aFunction == EMceItcGetSupportedAudioCodecs )
{
codecs = iImpl->SupportedAudioCodecsL();
}
else
{
codecs = iImpl->SupportedVideoCodecsL();
}
CleanupStack::PushL( codecs );
iITC->WriteL( aMessage, *codecs, EMceItcArgContext);
CleanupStack::PopAndDestroy( codecs );
MCESRV_DEBUG("CMceCsSession::SupportedCodecsL, Exit");
}
// -----------------------------------------------------------------------------
// CMceCsSession::MediaServiceL
// -----------------------------------------------------------------------------
//
void CMceCsSession::MediaServiceL( TMceIds& aIds, TMceItcFunctions aFunction,
const RMessage2& aMessage )
{
MCESRV_DEBUG("CMceCsSession::MediaServiceL, Entry");
TMceMessageDispatcher<CMceCsSessionImplementation> dispatcher( *iImpl, *iITC );
dispatcher.DispatchL( aIds, aFunction, aMessage );
MCESRV_DEBUG("CMceCsSubSession::MediaServiceL, Exit");
}
// -----------------------------------------------------------------------------
// CMceCsSession::CallSubSessionL
// -----------------------------------------------------------------------------
//
void CMceCsSession::CallSubSessionL (TMceIds& aIds, TInt aFunction,
const RMessage2& aMessage)
{
CMceCsSubSession* subSession = iImpl->SubSessionL( aIds.iSessionID );
subSession->ServiceL( aIds, (TMceItcFunctions)aFunction, aMessage);
}
// -----------------------------------------------------------------------------
// CMceCsSession::CreateSubSessionL
// -----------------------------------------------------------------------------
//
void CMceCsSession::CreateSubSessionL( TMceIds& aIds, const RMessage2& aMessage )
{
MCESRV_DEBUG("CMceCsSession::CreateSubSessionL, Entry");
HBufC8* encodedMessage = NULL;
encodedMessage = ITC().ReadLC( aMessage, EMceItcArgContext );
CMceMsgTextArray* msgParams = new (ELeave) CMceMsgTextArray();
CleanupStack::PushL( msgParams );
msgParams->DecodeL( *encodedMessage );
CDesC8Array* params = msgParams->iArray;
CleanupStack::PushL( params );
iImpl->CreateSubSessionL( aIds, *params );
CleanupStack::PopAndDestroy( params );
CleanupStack::PopAndDestroy( msgParams );
CleanupStack::PopAndDestroy( encodedMessage );
iITC->WriteL(aMessage, aIds);
MCESRV_DEBUG("CMceCsSession::CreateSubSessionL, Exit");
}
// -----------------------------------------------------------------------------
// CMceCsSession::DeleteSubSessionL
// -----------------------------------------------------------------------------
//
void CMceCsSession::DeleteSubSessionL( TMceIds& /*aIds*/, const RMessage2& aMessage )
{
MCESRV_DEBUG("CMceCsSession::DeleteSubSessionL, Entry");
TUint32 sessionId = iITC->ReadTUint32L(aMessage, EMceItcArgId );
iImpl->RemoveSubSessionL( sessionId );
MCESRV_DEBUG("CMceCsSession::DeleteSubSessionL, Exit");
}
// -----------------------------------------------------------------------------
// CMceCsSession::Receiver
// -----------------------------------------------------------------------------
//
CMceCsSessionReceiver* CMceCsSession::ReceiverL( TMceIds& aIds )
{
TMceManagerType type = aIds.iManagerType;
CMceCsSessionReceiver* receiver = NULL;
TInt index = 0;
while( !receiver && index < iReceivers.Count() )
{
if ( iReceivers[ index ]->Type() == type )
{
receiver = iReceivers[ index ];
}
index++;
}
if (!receiver )
{
receiver = CMceCsSessionReceiver::NewLC( type, *iITC );
iReceivers.AppendL( receiver );
CleanupStack::Pop( receiver );
}
return receiver;
}
// -----------------------------------------------------------------------------
// CMceCsSession::ITC
// -----------------------------------------------------------------------------
//
CMceCsServerITC& CMceCsSession::ITC()
{
return *iITC;
}
// -----------------------------------------------------------------------------
// CMceCsSession::ReceiveL
// -----------------------------------------------------------------------------
//
void CMceCsSession::ReceiveL( TMceIds& aIds, const RMessage2& aMessage )
{
MCESRV_DEBUG("CMceCsSession::ReceiveL, Entry");
ReceiverL( aIds )->ReceiveL( aMessage );
MCESRV_DEBUG("CMceCsSession::ReceiveL, Exit");
}
// -----------------------------------------------------------------------------
// CMceCsSession::StoreDefaultHeadersL
// -----------------------------------------------------------------------------
//
void CMceCsSession::StoreDefaultHeadersL( const RMessage2& aMessage )
{
HBufC8* encodedMsg = ITC().ReadLC( aMessage, EMceItcArgContext );
User::LeaveIfNull( encodedMsg );
TMceComFactory factory;
CMceMsgArray<TMceComFactory>* msgArray =
new (ELeave) CMceMsgArray<TMceComFactory>( factory );
CleanupStack::PushL( msgArray );
msgArray->DecodeL( *encodedMsg );
CDesC8Array* methods = static_cast< CMceMsgTextArray* >
( msgArray->iArray[0] )->iArray;
CleanupStack::PushL( methods );
CDesC8Array* headers = static_cast< CMceMsgTextArray* >
( msgArray->iArray[1] )->iArray;
CleanupStack::PushL( headers );
iImpl->StoreDefaultHeadersL( *methods, headers );
CleanupStack::Pop( headers );
CleanupStack::PopAndDestroy( methods );
CleanupStack::PopAndDestroy( msgArray );
CleanupStack::PopAndDestroy( encodedMsg );
}
// -----------------------------------------------------------------------------
// CMceCsSession::DefaultHeadersL
// -----------------------------------------------------------------------------
//
void CMceCsSession::DefaultHeadersL( const RMessage2& aMessage )
{
MCESRV_DEBUG("CMceCsSession::DefaultHeadersL, Entry");
HBufC8* method = ITC().ReadLC( aMessage, EMceItcArgContext );
HBufC8* headers = iImpl->DefaultHeadersL( *method );
CleanupStack::PopAndDestroy( method );
CleanupStack::PushL( headers );
iITC->WriteL( aMessage, *headers, EMceItcArgContext);
CleanupStack::PopAndDestroy( headers );
MCESRV_DEBUG("CMceCsSession::DefaultHeadersL, Exit");
}
// End of File