// Copyright (c) 2007-2009 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 "ussdtestclient.h"

#include <ctsy/mmtsy_names.h>

#include <e32debug.h>

#include <e32math.h> 

CCTsyUssdMessagingTestClient::CCTsyUssdMessagingTestClient()

    {

    }  

/**

@SYMTestCaseID 

@SYMComponent  telephony_ctsy

@SYMTestCaseDesc Test support in CTSY for RMobileUssdMessaging::ReceiveMessage

@SYMTestPriority High

@SYMTestActions Invokes RMobileUssdMessaging::ReceiveMessage

@SYMTestExpectedResults Pass

@SYMTestType CT

*/

TInt CCTsyUssdMessagingTestClient::ReceiveMessageL(TBool aAcceptDialogue, TBool aReceiveTimeout, TReal aAfterTimePeriod)

    {

    // Create a cleanup stack object

    CTrapCleanup* cleanup=CTrapCleanup::New();

    if (cleanup==NULL)

        return KErrNoMemory;    

    RTelServer server;

    RMobilePhone phone;

    TInt ret = server.Connect();

    if (ret != KErrNone)

        {

        server.Close();

        return ret; 

        }

    ret = phone.Open(server,KMmTsyPhoneName);

    if (ret != KErrNone)

        {

        server.Close();

        phone.Close();

        return ret; 

        }

    TRequestStatus requestStatus;   

    RMobileUssdMessaging::TGsmUssdMessageData name;

    RMobileUssdMessaging::TMobileUssdAttributesV1 attributes;

    TPckg<RMobileUssdMessaging::TMobileUssdAttributesV1> msgAttributes(attributes);

    RMobileUssdMessaging ussdMessaging;

    ret = ussdMessaging.Open(phone);

    if (ret != KErrNone)

        {

        server.Close();

        phone.Close();

        return ret; 

        }

    //RDebug::Printf("%x >> ReceiveMessage", User::Identity());

    ussdMessaging.ReceiveMessage(requestStatus, name, msgAttributes);

    //RDebug::Printf("%x << ReceiveMessage", User::Identity());

    if (aReceiveTimeout)

        {

        // This section of code and the aReceiveTimeout parameter apply

        // to the TestReceiveMessageWithTestClient0016L test 

        // (BA-CTSY-USSDM-URM-0020).

        // This test verifies that the second client does not recieve

        // a message. As part of the test spec we must call close on

        // the RMobileUssdMessaging object.

        // Rather than adding a whole ActiveScheduler framework to this

        // executable we've put in a wait and check loop. We can't use 

        // User::WaitForRequest as this would block. We don't want to

        // block as we are checking that an event which 

        // *does not occur* rather than checking for an event which

        // does occur.

        for (TInt i=0; i<50; ++i)

            {

            User::After(100000); // 0.1s

            if (requestStatus.Int() != KRequestPending)

                {

                break;

                }

            }

        if (requestStatus.Int() == KRequestPending)

            {

            ussdMessaging.Close();

            phone.Close();

            server.Close();

            delete cleanup;

            return KRequestPending;

            }

        }

    //RDebug::Printf("%x >> WaitForRequest", User::Identity());

    User::WaitForRequest(requestStatus);     

    //RDebug::Printf("%x << WaitForRequest", User::Identity());

    //RDebug::Printf("%x requestStatus = %d", User::Identity(), requestStatus.Int());

    if (aAfterTimePeriod)

        {

        //RDebug::Printf("%x Waiting for %f seconds", User::Identity(), aAfterTimePeriod);

        // Wait, mimic a bad client taking too long...

        User::After(aAfterTimePeriod * 1000000);

        }

    if (aAcceptDialogue)

        {

        //RDebug::Printf("%x >> AcceptIncomingDialogue", User::Identity());

        // Client wants the dialogue

        ret = ussdMessaging.AcceptIncomingDialogue(); 

        //RDebug::Printf("%x << AcceptIncomingDialogue", User::Identity());

        }

    else

        {

        // Client not interested

        //RDebug::Printf("%x >> RejectIncomingDialogue", User::Identity());

        ret = ussdMessaging.RejectIncomingDialogue();   

        //RDebug::Printf("%x << RejectIncomingDialogue", User::Identity());

        }

    User::After(2 * 1000000);

    ussdMessaging.Close();

    phone.Close();

    server.Close();

    delete cleanup;

    return ret;

	}

TInt CCTsyUssdMessagingTestClient::SendMessageL()

    {

    // Create a cleanup stack object

    CTrapCleanup* cleanup=CTrapCleanup::New();

    if (cleanup==NULL)

        return KErrNoMemory;    

    RTelServer server;

    RMobilePhone phone;

    TInt ret = server.Connect();

    if (ret != KErrNone)

        {

        server.Close();

        return ret; 

        }

    ret = phone.Open(server,KMmTsyPhoneName);

    if (ret != KErrNone)

        {

        server.Close();

        phone.Close();

        return ret; 

        }

    TRequestStatus requestStatus;

    TUint32 flags = 100;

    RMobileUssdMessaging::TMobileUssdDataFormat format = RMobileUssdMessaging::EFormatUnspecified;

    RMobileUssdMessaging::TMobileUssdMessageType type  = RMobileUssdMessaging::EUssdMORequest;

    TUint8 dcs = 200;

    RMobileUssdMessaging::TMobileUssdAttributesV1 attributes;

    TPckg<RMobileUssdMessaging::TMobileUssdAttributesV1> msgAttributes(attributes);

    attributes.iFlags  = flags;

    attributes.iFormat = format;

    attributes.iType   = type;

    attributes.iDcs   = dcs;

    TName name = _L("Name1");

    TPckg<TName> msgData(name);

    RMobileUssdMessaging ussdMessaging;

    ret = ussdMessaging.Open(phone);

    if (ret != KErrNone)

        {

        server.Close();

        phone.Close();

        return ret; 

        }

    //RDebug::Printf(">> SendMessage");

    ussdMessaging.SendMessage(requestStatus, msgData, msgAttributes);

    //RDebug::Printf("<< SendMessage");

    //RDebug::Printf(">> WaitForRequest");

    User::WaitForRequest(requestStatus);     

    //RDebug::Printf("<< WaitForRequest");

    ret = requestStatus.Int();

    //RDebug::Printf("requestStatus = %d", ret);

    User::After(2 * 1000000);

    ussdMessaging.Close();

    phone.Close();

    server.Close();

    delete cleanup;

    return KErrNone;

    }

TInt CCTsyUssdMessagingTestClient::RandomLoopL()

    {

    // Create a cleanup stack object

    CTrapCleanup* cleanup=CTrapCleanup::New();

    if (cleanup==NULL)

        return KErrNoMemory;    

    RTelServer server;

    RMobilePhone phone;

    TInt ret = server.Connect();

    if (ret != KErrNone)

        {

        server.Close();

        return ret; 

        }

    ret = phone.Open(server,KMmTsyPhoneName);

    if (ret != KErrNone)

        {

        server.Close();

        phone.Close();

        return ret; 

        }

    TRequestStatus requestStatus;   

    RMobileUssdMessaging::TGsmUssdMessageData name;

    RMobileUssdMessaging::TMobileUssdAttributesV1 attributes;

    TPckg<RMobileUssdMessaging::TMobileUssdAttributesV1> msgAttributes(attributes);

    RMobileUssdMessaging ussdMessaging;

    FOREVER

        {

        ret = ussdMessaging.Open(phone);

        if (ret != KErrNone)

            {

            server.Close();

            phone.Close();

            return ret; 

            }

        //RDebug::Printf("%x >> ReceiveMessage", User::Identity());

        ussdMessaging.ReceiveMessage(requestStatus, name, msgAttributes);

        //RDebug::Printf("%x << ReceiveMessage", User::Identity());

        if (ProbabilityPercent(50))

            {

            for (TInt i=0; i<10; ++i)

                {

                User::After(100000); // 0.1s

                if (requestStatus.Int() != KRequestPending)

                    {

                    break;

                    }

                }

            }

        else

            {

            User::WaitForRequest(requestStatus);  

            }

        if (requestStatus.Int() == KErrNone)

            {

            if (ProbabilityPercent(50))

                {

                TInt timeout = RandomNumber(1000000);

                User::After(timeout);

                }

            if (ProbabilityPercent(50))

                {

                ret = ussdMessaging.AcceptIncomingDialogue();

                }

            else

                {

                ret = ussdMessaging.RejectIncomingDialogue();

                }

            }

        else

            {

            ussdMessaging.CancelAsyncRequest(EMobileUssdMessagingReceiveMessage);

            }

        ussdMessaging.Close();

        }

    phone.Close();

    server.Close();

    delete cleanup;

    return ret;

    }

TBool CCTsyUssdMessagingTestClient::ProbabilityPercent(TInt aPercentTrue)

    {

    TInt random = RandomNumber(100);

    return aPercentTrue < random;

    }

// Not properly random but good enough...

TInt CCTsyUssdMessagingTestClient::RandomNumber(TInt aMax)

    {

    TUint32 rand = Math::Random() % aMax;

    return rand;

    }

_LIT(KReceiveOption,"-R");

_LIT(KReceiveTimeoutOption,"-RTimeout");

_LIT(KSendOption,"-S");

_LIT(KAcceptOption,"-A");

_LIT(KTimerOption,"-T");

_LIT(KRandomOption,"-Random");

TInt ParseCommandLine(TReal& aAfterTimePeriod)

    {

    TBuf<256> c;

    User::CommandLine(c);

    TLex l(c);

    // Get options

    TInt option = 0;

    aAfterTimePeriod = 0;

    TPtrC nextToken;

    for (;;)

        {

        nextToken.Set(l.NextToken());

        if (nextToken == KReceiveOption)

            {               

            option |= EOptionReceive;

            }

        else if (nextToken == KReceiveTimeoutOption)

            { 

            option |= EOptionReceiveTimeout;

            }

        else if (nextToken == KSendOption)

            {               

            option |= EOptionSend;

            }

        else if (nextToken == KAcceptOption)

            {               

            option |= EOptionAccept;

            }

        else if (nextToken == KTimerOption)

            {               

            nextToken.Set(l.NextToken());

            if (nextToken != KNullDesC)

                {

                TLex sl(nextToken);

                if (sl.Val(aAfterTimePeriod)!=KErrNone)

                    aAfterTimePeriod = 0.0;

                }

            }

        else if (nextToken == KRandomOption)

            {               

            option |= EOptionRandom;

            }

        else

            {

            break;

            }

        }

    return option;

    }

TInt E32Main()

/** 

   Executable entrypoint calls test functions within heap check.

 */

    {

    //__UHEAP_MARK;

    CTrapCleanup* cleanup=CTrapCleanup::New();

    TReal afterTimePeriod;

    TInt option = ParseCommandLine(afterTimePeriod);

    TInt err = KErrNone;

    TInt ret = KErrNone;

    CCTsyUssdMessagingTestClient ussdClient;

    if (option & EOptionReceive)

        {

        TRAPD(err, ret = ussdClient.ReceiveMessageL((option & EOptionAccept), (option & EOptionReceiveTimeout), afterTimePeriod));

        }

    if (option & EOptionSend)

        {

        TRAPD(err, ret = ussdClient.SendMessageL());

        }

    if (option & EOptionRandom)

        {

        TRAPD(err, ret = ussdClient.RandomLoopL());

        }

    delete cleanup;

    //__UHEAP_MARKEND;

    return err ? err : ret;

    }