mmsharing/livecommsui/lcui/tsrc/mustester/Stubs/mceclientstub/src/mussessionsimulator.cpp
/*
* 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 <e32base.h>
#include <e32property.h>
#include <MceTransactionDataContainer.h>
#include <MceSession.h>
#include <MceInSession.h>
#include <MceOutSession.h>
#include "mceinsessionobserver.h"
#include "mcesessionobserver.h"
#include "mussessionsimulator.h"
#include "muslogger.h"
#include <musmanagercommon.h>
#include "mussessionproperties.h"
TInt KDuration = 60*1;
// ============================ MEMBER FUNCTIONS ===============================
// -----------------------------------------------------------------------------
// CMceManager::NewL
// -----------------------------------------------------------------------------
//
CMusTestSessionSimulator* CMusTestSessionSimulator::NewL( CMceManager& aManager)
{
CMusTestSessionSimulator* self =
new (ELeave) CMusTestSessionSimulator( aManager );
CleanupStack::PushL( self );
self->ConstructL( );
CleanupStack::Pop( self );
return self;
}
// -----------------------------------------------------------------------------
// CMceManager::~CMceManager
// -----------------------------------------------------------------------------
//
CMusTestSessionSimulator::CMusTestSessionSimulator( CMceManager& aManager )
:iManager(aManager)
{
}
// -----------------------------------------------------------------------------
// CMceManager::~CMceManager
// -----------------------------------------------------------------------------
//
void CMusTestSessionSimulator::ConstructL( )
{
iTimer = CMusTestTimer::NewL(CActive::EPriorityStandard, *this);
SimulateReceiveSession();
StartL();
}
// -----------------------------------------------------------------------------
// Callback implementation when the timer activity happens in the CMusTestTimer class
// -----------------------------------------------------------------------------
//
void CMusTestSessionSimulator::StartL()
{
TTimeIntervalMicroSeconds32 someInterVal(KDuration); //you can call After/At/Inactivity depending on what you want to do
iTimer->After(someInterVal);
}
// -----------------------------------------------------------------------------
// Callback implementation when the timer activity happens in the CMusTestTimer class
// -----------------------------------------------------------------------------
//
TBool CMusTestSessionSimulator::IsRunning()
{
return iTimer->IsActive();
}
// -----------------------------------------------------------------------------
// Callback implementation when the timer activity happens in the CMusTestTimer class
// -----------------------------------------------------------------------------
//
void CMusTestSessionSimulator::Stop( )
{
iTimer->Cancel();
}
// -----------------------------------------------------------------------------
// Callback implementation when the timer activity happens in the CMusTestTimer class
// -----------------------------------------------------------------------------
//
void CMusTestSessionSimulator::TimerExpired(TAny* aTimer,TInt aError)
{
if(aError == KErrNone)
{
// Timer successfully completed, handle it
CMusTestTimer* timer = (CMusTestTimer*)aTimer;
MUS_LOG("CMusTestSessionSimulator TimerExipired Change the state")
StateChangeL();
if( (iManager.iSessions[0]->iState == CMceSession::EEstablished )||
( iManager.iSessions[0]->iState == CMceSession::EIncoming )
)
{
timer->Cancel();
}
else
{
TTimeIntervalSeconds seconds(KDuration);
timer->Inactivity(seconds); //Notify inactivity after 10 seconds
}
}
}
// -----------------------------------------------------------------------------
// Simulates Receive Session
// -----------------------------------------------------------------------------
//
void CMusTestSessionSimulator::SimulateReceiveSession()
{
MUS_LOG("CMusTestSessionSimulator::SimulateReceiveSession ->")
TInt usecase;
TInt err = RProperty::Get( NMusSessionApi::KCategoryUid, NMusSessionApi::KUseCase, usecase);
if( err == KErrNone )
{
if( usecase == MultimediaSharing::EMusReceive || usecase == MultimediaSharing::EMusReceiveTwoWayVideo )
{
MUS_LOG("CMusTestSessionSimulator::SimulateReceiveSession receive session ")
CMceInSession* inSession = CMceInSession::NewL();
inSession->iState = CMceSession::EIncoming;
iManager.iSessions.AppendL( inSession );
ibIncoming = ETrue;
}
else
{
ibIncoming = EFalse;
}
}
else
{
MUS_LOG1("CMusTestSessionSimulator::SimulateReceiveSession err = %d ",err)
}
MUS_LOG("CMusTestSessionSimulator::SimulateReceiveSession <-")
}
// -----------------------------------------------------------------------------
// CMceManager::~CMceManager
// -----------------------------------------------------------------------------
//
void CMusTestSessionSimulator::StateChangeL()
{
MUS_LOG("CMusTestSessionSimulator::StateChangeL ->")
TMceTransactionDataContainer* container = new TMceTransactionDataContainer();
HBufC8* resonPharase = _L8("OK").AllocL(); ;
TInt statusCode = 200;
switch( iManager.iSessions[0]->iState )
{
case CMceSession::EIdle : // offering
statusCode = 180;
delete resonPharase;
resonPharase = _L8("Ringing").AllocL();
iManager.iSessions[0]->iState = CMceSession::EOffering;
MUS_LOG("CMusTestSessionSimulator Session state : Offering 180")
break;
case CMceSession::EOffering : // estabilished
case CMceSession::EAnswering : // estabilished
delete resonPharase;
resonPharase = _L8("OK").AllocL();
iManager.iSessions[0]->iState = CMceSession::EEstablished;
MUS_LOG("CMusTestSessionSimulator Session state : Answering")
break;
case CMceSession::EEstablished : // estabilished
delete resonPharase;
resonPharase = _L8("OK").AllocL();
MUS_LOG("CMusTestSessionSimulator Session state : Estabilished")
break;
case CMceSession::ETerminating : // estabilished
delete resonPharase;
resonPharase = _L8("OK").AllocL();
iManager.iSessions[0]->iState = CMceSession::ETerminated;
MUS_LOG("CMusTestSessionSimulator Session state : Terminated")
break;
case CMceSession::EIncoming : // estabilished
// handled down
break;
case CMceSession::EProceeding : // estabilished
iManager.iSessions[0]->iState = CMceSession::EAnswering;
MUS_LOG("CMusTestSessionSimulator Session state : Proceeding");
break;
case CMceSession::EReserving : // estabilished
iManager.iSessions[0]->iState = CMceSession::EProceeding;
MUS_LOG("CMusTestSessionSimulator Session state : Reserving")
default:
break;
}
if( iManager.iSessions[0]->iState == CMceSession::EIncoming )
{
MUS_LOG("CMusTestSessionSimulator Session state : Incoming")
if( iManager.iSessionObserver && container )
{
CMceInSession* session = ( CMceInSession* ) iManager.iSessions[0];
if( session )
{
MUS_LOG("CMusTestSessionSimulator Calling InComingSession")
iManager.iInSessionObserver->IncomingSession( session , container );
iManager.iSessions[0]->iState = CMceSession::EReserving;
}
}
else
{
MUS_LOG("CMusTestSessionSimulator insessionobserver empty ")
}
}
else
{
MUS_LOG("CMusTestSessionSimulator Session state : Inform Session state")
container->SetStatusCode(statusCode);
container->SetReasonPhrase( resonPharase );
if( iManager.iSessionObserver && container )
{
MUS_LOG("CMusTestSessionSimulator Calling SessionStateChanged")
if( iManager.iSessions.Count() > 0 )
{
CMceSession* session = iManager.iSessions[0];
if( session )
{
iManager.iSessionObserver->SessionStateChanged( *session ,container);
}
else
{
MUS_LOG("CMusTestSessionSimulator session empty ")
}
}
else
{
MUS_LOG("CMusTestSessionSimulator No Session found ")
}
}
else
{
MUS_LOG("CMusTestSessionSimulator Invalid pointer")
}
}
delete container;
MUS_LOG("CMusTestSessionSimulator::StateChangeL <-")
}
// -----------------------------------------------------------------------------
// CMceManager::~CMceManager
// -----------------------------------------------------------------------------
//
EXPORT_C CMusTestSessionSimulator::~CMusTestSessionSimulator()
{
Stop();
delete iTimer;
}
//--------------------------------------------------------------------------------
// Timer implementation
//--------------------------------------------------------------------------------
//
CMusTestTimer::CMusTestTimer(const TInt aPriority,MTimerNotify& aNotify)
:CActive(aPriority),iNotify(aNotify)
{
}
CMusTestTimer::~CMusTestTimer()
{
Cancel();
iTimer.Close();
}
CMusTestTimer* CMusTestTimer::NewL(const TInt aPriority,MTimerNotify& aNotify)
{
CMusTestTimer* me = new (ELeave) CMusTestTimer(aPriority,aNotify);
CleanupStack::PushL(me);
me->ConstructL();
CleanupStack::Pop();
return me;
}
void CMusTestTimer::ConstructL(void)
{
CActiveScheduler::Add(this);
iTimer.CreateLocal();
}
void CMusTestTimer::After(TTimeIntervalMicroSeconds32 aInterval)
{
Cancel();
iTimer.After(iStatus,aInterval);
SetActive();
}
void CMusTestTimer::At(const TTime& aTime)
{
Cancel();
iTimer.At(iStatus,aTime);
SetActive();
}
void CMusTestTimer::Inactivity(TTimeIntervalSeconds aSeconds)
{
Cancel();
iTimer.Inactivity(iStatus,aSeconds);
SetActive();
}
void CMusTestTimer::DoCancel()
{
iTimer.Cancel();
}
void CMusTestTimer::RunL()
{
iNotify.TimerExpired(this,iStatus.Int());
}