/*

* Copyright (c) 2010 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 FILES

#include "loadgen_messages.h"

#include "loadgen_utils.h"

#include "loadgen.hrh"

#include <loadgen.rsg>

#include <e32math.h>

_LIT(KThreadName, "Messages %d");

_LIT(KMessageSMS, "A test message from LoadGen S60 RnD tool. ");

_LIT( KMessageSMSType, "SMS" );

_LIT( KMessageMMSType, "MMS" );

const TInt KTestMessageLength = 42;

const TInt KDefaultStart = 50;

const TInt KDefaultPeriod = 5000000;

// ===================================== MEMBER FUNCTIONS =====================================

CMessages* CMessages::NewL( TMessageAttributes& aAttributes, TInt aReferenceNumber )

    {

    CMessages* self = new(ELeave) CMessages( aAttributes, aReferenceNumber );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;    

    }

// --------------------------------------------------------------------------------------------

CMessages::~CMessages()

    {

    Close();

    }

// --------------------------------------------------------------------------------------------

CMessages::CMessages( TMessageAttributes& aAttributes, 

                       TInt aReferenceNumber ) 

                            : iAttributes( aAttributes )

    {

    iAttributes.iId = aReferenceNumber;

    }

// --------------------------------------------------------------------------------------------

void CMessages::ConstructL()

    {

    CLoadBase::ConstructL();

    iType = ELoadGenCmdNewLoadMessages;

    TBuf<64> threadName;

    threadName.Format( KThreadName, iAttributes.iId );

    // create a thread

    User::LeaveIfError( iThread.Create( threadName, 

                                        ThreadFunction, 

                                        KDefaultStackSize * 2, 

                                        KMinHeapSize, 

                                        1024 * KMinHeapSize, 

                                        (TAny*) &iAttributes ) );

    // set priority of the thread

    SetPriority();

    }

// --------------------------------------------------------------------------------------------

TInt CMessages::ThreadFunction(TAny* aThreadArg)

    {

    CTrapCleanup* pC = CTrapCleanup::New();

    CActiveScheduler* pS = new CActiveScheduler;

    CActiveScheduler::Install( pS );

    // start generating load, pass pointer to arguments

    GenerateLoad( *( ( TMessageAttributes* ) aThreadArg ) );

    delete pS;

    delete pC;

    return KErrNone;

    }

// --------------------------------------------------------------------------------------------

void CMessages::GenerateLoad( TMessageAttributes& aAttributes )

    {

    CMessageManager* messagesManager = NULL;

    TRAPD( err, messagesManager = CMessageManager::NewL( aAttributes ) );

    if ( err == KErrNone )

        {

        CActiveScheduler::Start();

        }

    delete messagesManager;

    }

// --------------------------------------------------------------------------------------------

void CMessages::Resume()

    {

    CLoadBase::Resume();

    iThread.Resume();

    }

// --------------------------------------------------------------------------------------------

void CMessages::Suspend()

    {

    CLoadBase::Suspend();

    iThread.Suspend();

    }

// --------------------------------------------------------------------------------------------

void CMessages::SetPriority()

    {

    CLoadBase::SetPriority();

    iThread.SetPriority( CLoadGenUtils::SettingItemToThreadPriority( iAttributes.iPriority ) );

    }

// --------------------------------------------------------------------------------------------

void CMessages::Close()

    {

    CLoadBase::Close();

    if ( iThread.ExitReason() == 0 ) // check if the thread is still alive

        {

        // signal the thread that it needs to close

        iThread.RequestComplete( iAttributes.iDeathStatus, KErrCancel );

        // wait the thread to die

        TRequestStatus waiter;

        iThread.Logon( waiter );

        User::WaitForRequest( waiter );

        iThread.Close();

        }

    }

// --------------------------------------------------------------------------------------------

TPtrC CMessages::Description()

    {

    TBuf<256> buf;

    TBuf<16> prioBuf;

    TBuf<3> typeBuf;

    CLoadGenUtils::SettingItemToThreadDescription( iAttributes.iPriority, prioBuf );

    if ( iAttributes.iMessageType == EMessageTypeSMS )

        {

        typeBuf.Copy( KMessageSMSType );

        }

    else

        {

        typeBuf.Copy( KMessageMMSType );

        }

    _LIT(KMessagesEntry, "[%d] Type=%S prio=%S dest=%S idle=%dms random=%d%%");

    buf.Format( KMessagesEntry,  iAttributes.iId, &typeBuf, &prioBuf, &iAttributes.iDestination, 

                iAttributes.iIdle, iAttributes.iRandomVariance );

    return TPtrC( buf );

    }               

// --------------------------------------------------------------------------------------------

CMessageManager* CMessageManager::NewL( TMessageAttributes& aAttributes )

    {

    CMessageManager* self = new(ELeave) CMessageManager( aAttributes );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

// --------------------------------------------------------------------------------------------

CMessageManager::CMessageManager( TMessageAttributes& aAttributes ) :

    CActive( EPriorityStandard ), iAttributes( aAttributes ), iState( EStateIdle )

    {

    iMessageCounter = 0;

    }

// --------------------------------------------------------------------------------------------

CMessageManager::~CMessageManager()

    {

    Cancel();

    delete iMessage;

    if ( iPeriodicTimer )

        {

        iPeriodicTimer->Cancel();

        delete iPeriodicTimer;

        }

    if ( iAttributes.iMessageType == EMessageTypeSMS && iSmsHandler )

        {

        delete iSmsHandler;

        }

    else if ( iMmsHandler )

        {

        delete iMmsHandler;

        }

    }

// --------------------------------------------------------------------------------------------

void CMessageManager::ConstructL()

    {

    CActiveScheduler::Add( this );

    // set the status as pending

    iStatus = KRequestPending;

    SetActive();

    // set the death status pointer point to the request status of this ao

    iAttributes.iDeathStatus = &iStatus;

    if ( iAttributes.iAmount > 0 )

        {

        iState = EStateSend;

        }

    iMessage = HBufC::NewL( iAttributes.iLength );

    CreateMessage();

    // init SMS sender ao

    if ( iAttributes.iMessageType == EMessageTypeSMS )

        {

        iSmsHandler = CSmsHandler::NewL( *this );

        }

    else

        {

        iMmsHandler = CMmsHandler::NewL( *this );

        }

    // start timer    

    iPeriodicTimer = CPeriodic::NewL( CActive::EPriorityStandard );

    iPeriodicTimer->Start( KDefaultStart, KDefaultPeriod, 

                        TCallBack( PeriodicTimerCallBack, this ) );

    }

// --------------------------------------------------------------------------------------------

void CMessageManager::RunL()

    {

    // request status has completed by the main thread meaning that we need to stop now

    CActiveScheduler::Stop();

    }

// --------------------------------------------------------------------------------------------

void CMessageManager::DoCancel()

    {

    }

// --------------------------------------------------------------------------------------------

TInt CMessageManager::PeriodicTimerCallBack(TAny* aAny)

    {

    CMessageManager* self = static_cast<CMessageManager*>( aAny );

    self->iPeriodicTimer->Cancel();

    self->HandleMessageSending();

    return KErrNone;

    }

// --------------------------------------------------------------------------------------------

void CMessageManager::CreateMessage()

    {

    // Message body

    TBuf<KTestMessageLength> mToYou( KMessageSMS );

    TPtr ptr = iMessage->Des();

    // Take as many characters as user requested to create the message

    for ( TInt j = 0; j < iAttributes.iLength; j++ )

          {

           for ( TInt k = 0; k < KTestMessageLength;  k++ )

               {

               ptr.Append( mToYou[k] );

               j++;

               if ( j == iAttributes.iLength )

                   {

                   break;

                   }

               }        

           }

    }

// --------------------------------------------------------------------------------------------

void CMessageManager::HandleMessageSending()

    {

    if ( iState == EStateSend && iAttributes.iDestination.Length() <= KTelephoneNumberMaxLength )

        {

        TBool err( KErrNone );        

        // make a new call

        iState = EStateSending;

        iMessageCounter++;

        if ( iAttributes.iMessageType == EMessageTypeSMS )

            {

            TRAP( err, iSmsHandler->SendL( iAttributes.iDestination, *iMessage ) );

            if ( !err )

                {

                iState = EStateIdle;

                iPeriodicTimer->Start( CLoadGenUtils::MilliSecondsToMicroSeconds( iAttributes.iIdle,

                            iAttributes.iRandomVariance ), KDefaultPeriod, 

                            TCallBack( PeriodicTimerCallBack, this ) );

                }

            }

        else

            {

            TRAP( err, iMmsHandler->SendL( iAttributes.iDestination, *iMessage ) );            

            if ( err )

                {

                HandleStatus( EStateIdle );

                }

            }

        }

    else

        {

        iState = EStateIdle;

        iPeriodicTimer->Start( CLoadGenUtils::MilliSecondsToMicroSeconds( iAttributes.iIdle,

                    iAttributes.iRandomVariance ), KDefaultPeriod, 

                    TCallBack( PeriodicTimerCallBack, this ) );

        }

    }

// --------------------------------------------------------------------------------------------

void CMessageManager::HandleStatus( TInt /*aErr*/ )

    {

    // timer after wait

    if ( iMessageCounter < iAttributes.iAmount )

        {

        iState = EStateSend;

        iPeriodicTimer->Cancel();

        iPeriodicTimer->Start( CLoadGenUtils::MilliSecondsToMicroSeconds( iAttributes.iIdle,

                    iAttributes.iRandomVariance ), KDefaultPeriod, 

                    TCallBack( PeriodicTimerCallBack, this ) );

        }

    }

// --------------------------------------------------------------------------------------------

// --------------------------------------------------------------------------------------------

// INCLUDE FILES

#include <eikenv.h>

#include <coemain.h>

#include <e32std.h>

#include <msvids.h>

#include <msvstd.h>

#include <smsclnt.h>

#include <smut.h>

#include <mtclreg.h>

#include <txtrich.h>

#include <smscmds.h>

#include <mtmuibas.h>

#include <mtmdef.h>

#include <StringLoader.h>

#include "smutset.h"

#include "smuthdr.h"

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------

// CSmsHandler::CSmsHandler()

// C++ default constructor can NOT contain any code, that might leave.

// -----------------------------------------------------------------------------

//

CSmsHandler::CSmsHandler( CMessageManager& aManager )

    : CActive( CActive::EPriorityStandard ), iManager( aManager )

    {

    CActiveScheduler::Add( this );

    }

// -----------------------------------------------------------------------------

// CSmsHandler::ConstructL()

// Symbian 2nd phase constructor can leave.

// -----------------------------------------------------------------------------

//

void CSmsHandler::ConstructL()

    {

    // Session to message server is opened asynchronously.

    iSession = CMsvSession::OpenAsyncL( *this );

    }

// -----------------------------------------------------------------------------

// CSmsHandler::NewL()

// Two-phased constructor.

// -----------------------------------------------------------------------------

//

CSmsHandler* CSmsHandler::NewL( CMessageManager& aManager  )

    {

    CSmsHandler* self = NewLC( aManager );

    CleanupStack::Pop( self );

    return self;

    }

// -----------------------------------------------------------------------------

// CSmsHandler::NewLC()

// Two-phased constructor.

// -----------------------------------------------------------------------------

//

CSmsHandler* CSmsHandler::NewLC(  CMessageManager& aManager )

    {

    CSmsHandler* self = new ( ELeave ) CSmsHandler( aManager );

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

// ----------------------------------------------------------

// CSmsHandler::~CSmsHandler()

// Destructor.

// ----------------------------------------------------------

//

CSmsHandler::~CSmsHandler()

    {

    Cancel();           // cancel any outstanding request

    delete iOperation;

    delete iMtmUiRegistry;

    delete iSmsMtm;

    delete iMtmRegistry;

    delete iSession;    // session must be deleted last

    }

// -----------------------------------------------------------------------------

// CSmsHandler::DoCancel()

// Cancels a request.

// -----------------------------------------------------------------------------

//

void CSmsHandler::DoCancel()

    {

    if ( iOperation )

        {

        iOperation->Cancel();

        }

    }

// -----------------------------------------------------------------------------

// CSmsHandler::RunL()

// Handles request completion events.

// -----------------------------------------------------------------------------

//

void CSmsHandler::RunL()

    {

    User::LeaveIfError( iStatus != KErrNone );

    // Determine the current operations progress.

    // ProgressL returns an 8 bit descriptor.

    TBufC8<KMsvProgressBufferLength> progress( iOperation->ProgressL() );

    _LIT8( KCompare, "KErrNone" );

    User::LeaveIfError( !progress.Compare( KCompare ) );

    // The pointer to the current CMsvOperation object is no longer needed.

    delete iOperation;

    iOperation = NULL;

    // Determine which request has finished.

    switch ( iState )

        {

        case EWaitingForMoving:

            // Once a message is moved to Outbox it is scheduled for sending.

            ScheduleL();

            break;

        case EWaitingForScheduling:

            {

            TMsvEntry entry( iSmsMtm->Entry().Entry() );

            TInt state( entry.SendingState() );

            if ( state == KMsvSendStateWaiting || state == KMsvSendStateScheduled)

                {

                // notify the observer that status has changed

                iManager.HandleStatus( iStatus.Int() );

                }

            break;

            }

        default:

            break;

        }

    }

// -----------------------------------------------------------------------------

// CSmsHandler::HandleSessionEventL()

// Handles notifications of events from the Message Server.

// -----------------------------------------------------------------------------

//

void CSmsHandler::HandleSessionEventL( TMsvSessionEvent aEvent,

                                      TAny* /*aArg1*/, TAny* /*aArg2*/, TAny* /*aArg3*/)

    {

    switch ( aEvent )

        {

        // Session to server established

        case EMsvServerReady:

            {

            TMsvId serviceId( KUidMsgTypeSMS.iUid ); // SMS service id

            // Determine if the event was succesful.

            // ServiceProgress inserts TBuf8 value in progress.

            TBuf8<KBfrLength> progress;

            iSession->ServiceProgress( serviceId, progress );

            _LIT8( KCompare, "KErrNone" );