// Copyright (c) 2006-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 FILES

#include <etelmm.h>

#include <mmlist.h>

#include "cmmussdtsy.h"

#include <ctsy/serviceapi/cmmsmsutility.h>

#include "MmTsy_timeoutdefs.h"

#include "MmTsy_numberOfSlots.h"

#include "cmmtsyreqhandlestore.h"

#include "CMmCommonStaticUtility.h"

#include "cmmmessagemanagerbase.h"

#include <ctsy/pluginapi/cmmdatapackage.h>

#include <ctsy/serviceapi/gsmerror.h>

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

CMmUssdTsy::CMmUssdTsy()

    {

    }

void CMmUssdTsy::ConstructL(

    CMmPhoneTsy* aMmPhoneTsy )

    {

TFLOGSTRING("TSY: CMmUssdTsy::ConstructL\n" );

    iMmPhone = aMmPhoneTsy;

    // register .

    iMmPhone->MessageManager()->RegisterTsyObject(

		CMmMessageManagerBase::EUssdMessagingTsy, this );

#ifdef REQHANDLE_TIMER   

    // create req handle store

    iTsyReqHandleStore = CMmTsyReqHandleStore::NewL( this, iMmPhone,

        EMultimodeUssdMaxNumOfRequests, iUssdReqHandles);

#else

    // create req handle store

    iTsyReqHandleStore = CMmTsyReqHandleStore::NewL(

        EMultimodeUssdMaxNumOfRequests, iUssdReqHandles);

#endif // REQHANDLE_TIMER

    // Reset all CMmUssdTsy variables

    ResetVariables();

    // Initialize boolean flag

    iUssdNoFdnCheckFlag =  EUssdNoFdnCheckUnknown;

    }

CMmUssdTsy* CMmUssdTsy::NewL( 

    CMmPhoneTsy* aMmPhone )                                 

    {

    CMmUssdTsy* aMmUssdTsy = new( ELeave ) CMmUssdTsy();

    CleanupClosePushL( *aMmUssdTsy );

    aMmUssdTsy->ConstructL( aMmPhone );

    aMmUssdTsy->iMmPhone = aMmPhone;

    CleanupStack::Pop();

    return aMmUssdTsy;

    }

CMmUssdTsy::~CMmUssdTsy()

    {

TFLOGSTRING("TSY: CMmUssdTsy::~CMmUssdTsy" );

    // unregister.

    if ( iMmPhone )

        {

        // deregister tsy object from message manager

        iMmPhone->MessageManager()->DeregisterTsyObject(this);        

        }

    // delete req handle store

    delete iTsyReqHandleStore;

    iTsyReqHandleStore = NULL;

    // Null other pointers

    iReturnResultPtr = NULL;

    iReceiveUssdMessagePtr = NULL;

    iReceiveUssdMessageAttributesPtr = NULL;

    iMmPhone = NULL;

    }

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

// CMmUssdTsy::Init

// Initialisation method that is called from ETel Server.

// (other items were commented in a header).

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

//

void CMmUssdTsy::Init()

    {

    }

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

// CMmUssdTsy::ExtFunc

// ExtFunc is called by the server when it has an "extended",i.e.

// non-core ETel request for the TSY. To process a request handle, request type

// and request data are passed to the TSY.

// (other items were commented in a header).

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

//

TInt CMmUssdTsy::ExtFunc( 

    const TTsyReqHandle aTsyReqHandle, 

    const TInt aIpc, 

    const TDataPackage& aPackage )        

    {

    TInt ret = KErrNone;

    TInt trapError = KErrNone;

    // reset last tsy request type

    iReqHandleType = EMultimodeUssdReqHandleUnknown;

    // before processing further the request, check if offline mode status

    // is enabled and if the given request can be perfomed in that case.

    if ( ERfsStateInfoInactive == iMmPhone->GetRfStateInfo() && 

        ( !IsRequestPossibleInOffline( aIpc ) ) )  

        {

TFLOGSTRING2 ("TSY: Offline mode ON, request is not allowed: %d", aIpc );

        ret = CMmCommonStaticUtility::EpocErrorCode( KErrGeneral, 

            KErrGsmOfflineOpNotAllowed );

        // Complete the request with appropiate error

        ReqCompleted ( aTsyReqHandle, ret ); 

        }

    else

        {

        // Original code continues here.

        TRAP( trapError, ret = DoExtFuncL( aTsyReqHandle, aIpc, aPackage ); );

        if ( trapError != KErrNone )

            {

            // Object cannot be created. 

            ReqCompleted( aTsyReqHandle, trapError );

            }

        else if ( ret != KErrNone )

            {

            ReqCompleted( aTsyReqHandle, ret );

            }

        // save request handle

        if ( EMultimodeUssdReqHandleUnknown != iReqHandleType )

            {

#ifdef REQHANDLE_TIMER

            SetTypeOfResponse( iReqHandleType, aTsyReqHandle );

#else

            iTsyReqHandleStore->SetTsyReqHandle( iReqHandleType, 

                aTsyReqHandle );

#endif // REQHANDLE_TIMER

            }

        }

    return KErrNone;

    }

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

// CMmUssdTsy::DoExtFuncL

// ExtFunc is called by the server when it has an "extended",i.e.

// non-core ETel request for the TSY. To process a request handle,request type

// and request data are passed to the TSY.

// (other items were commented in a header).

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

//

TInt CMmUssdTsy::DoExtFuncL( 

    const TTsyReqHandle aTsyReqHandle, 

    const TInt aIpc, 

    const TDataPackage& aPackage )

    {

    TInt ret(KErrNone);

    switch ( aIpc ) 

        {

        // Ussd Messaging requests

        case EMobileUssdMessagingGetCaps:

            ret = GetCaps( aTsyReqHandle, aPackage.Des1n() );

            break;

        case EMobileUssdMessagingReceiveMessage:

            ret = ReceiveMessage( aTsyReqHandle, aPackage.Des1n(), 

                aPackage.Des2n() );

            break;

        case EMobileUssdMessagingSendMessage:

            {

            iUssdNoFdnCheckFlag = EUssdNoFdnCheckNotUsed;

            ret = SendMessageL( 

                aTsyReqHandle, aPackage.Des1n(), aPackage.Des2n() );

            }

            break;

        case EMobileUssdMessagingSendMessageNoFdnCheck:

            {

            iUssdNoFdnCheckFlag = EUssdNoFdnCheckUsed;

            ret = SendMessageL( 

                aTsyReqHandle, aPackage.Des1n(), aPackage.Des2n() );                

            }

            break;

        case EMobileUssdMessagingSendRelease:

            ret = SendReleaseL( aTsyReqHandle, aPackage.Des1n() );

            break;

        case EMobileUssdMessagingNotifyNetworkRelease:

            switch( aPackage.Type() )

                 {

             	// Switch between alternative implementations of NotifyNetworkRelease

                 case TDataPackage::EPackage1n:

                	 ret = NotifyNetworkRelease( aTsyReqHandle, aPackage.Des1n(), NULL );

                	 break;

                 case TDataPackage::EPackage1n2n:

                	 ret = NotifyNetworkRelease( aTsyReqHandle, aPackage.Des1n(), aPackage.Des2n() );

                     break;

                 default:

                     ret = KErrNotSupported;

                     break;

                 }

            break;

        default:

            ret = KErrNotSupported;

            break;

        }

    return ret;

    }

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

// CMmUssdTsy::CancelService

// CancelService is called by the server when it is "cleaning-up"

// any still outstanding asynchronous requests before closing a client's

// sub-session. This will happen if a client closes its R-class handle without

// cancelling outstanding asynchronous requests

// (other items were commented in a header).

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

//

TInt CMmUssdTsy::CancelService( 

    const TInt aIpc, 

    const TTsyReqHandle aTsyReqHandle )           

    {

    TInt ret( KErrNone );

    switch ( aIpc )

        {

        case EMobileUssdMessagingReceiveMessage:

            ReceiveMessageCancel( aTsyReqHandle );

            ret = KErrNone;

            break;

        case EMobileUssdMessagingSendMessage:

            SendMessageCancel( aTsyReqHandle );

            ret = KErrNone;

            break;

        case EMobileUssdMessagingSendMessageNoFdnCheck:

            SendMessageNoFdnCheckCancel( aTsyReqHandle );

            ret = KErrNone;

            break;            

        case EMobileUssdMessagingSendRelease:

            SendReleaseCancel();

            ret = KErrNone;

            break;

        case EMobileUssdMessagingNotifyNetworkRelease:

            NotifyNetworkReleaseCancel();

            ret = KErrNone;

            break;

        default:

            ret = KErrNotSupported;

            break;

        } 

    return ret;

    }

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

// CMmUssdTsy::ReqModeL

// When the ETel server receives an "extension" client request,

// it will pass the IPC request number down to the TSY in order to find out

// what type of request it is. The virtual method that gets called is ReqModeL

// (other items were commented in a header).

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

//

CTelObject::TReqMode CMmUssdTsy::ReqModeL(

    const TInt aIpc )    

    {

    CTelObject::TReqMode ret ( 0 );

    switch ( aIpc )

        {

        // Non-Flow Controlled Services

        case EMobileUssdMessagingGetCaps:

            break;

        // Flow Controlled Services

        // Immediate Server Repost

        case EMobileUssdMessagingReceiveMessage:

        case EMobileUssdMessagingNotifyNetworkRelease:

            ret = KReqModeRePostImmediately | 

                KReqModeMultipleCompletionEnabled;

            break;

        // Services handled by TSY

        case EMobileUssdMessagingSendMessage:

        case EMobileUssdMessagingSendMessageNoFdnCheck:

        case EMobileUssdMessagingSendRelease:

            ret = 0;

            break;

        default:

            User::Leave( KErrNotSupported );

            break;

        }

    return ret;

    }

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

// CMmUssdTsy::OpenNewObjectL

// Opens new object and names it. Not supported.

// (other items were commented in a header).

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

//

CTelObject* CMmUssdTsy::OpenNewObjectL( 

    TDes& /*aName*/ )    

    {

    User::Leave( KErrNotSupported );

    //lint -e{527} "unreachable code"

    return NULL;

    }

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

// CMmUssdTsy::OpenNewObjectByNameL

// Open extendible sub-sessions. Not Supported

// (other items were commented in a header).

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

//

CTelObject* CMmUssdTsy::OpenNewObjectByNameL(

    const TDesC& /*aName*/ )       

    {

    User::Leave( KErrNotSupported );

    //lint -e{527} "unreachable code"

    return NULL;

    }

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

// CMmUssdTsy::RegisterNotification

// RegisterNotification is called when the server recognises that

// this notification is being posted for the first time on this sub-session

// object. It enables the TSY to "turn on" any regular notification messages

// that it may receive from DOS.

// (other items were commented in a header).

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

//

TInt CMmUssdTsy::RegisterNotification(

    const TInt aIpc )                             // Notification IPC number

    {

    TFLOGSTRING2( "TSY: CMmUssdTsy::RegisterNotification. IPC: %d", aIpc );

    TInt ret( KErrNone );

    switch ( aIpc )

        {

        case EMobileUssdMessagingNotifyNetworkRelease:

        case EMobileUssdMessagingReceiveMessage:

        	break;

        default:

            // Not supported

            ret = KErrNotSupported;

            break;

        }

    return ret;

    }

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

// CMmUssdTsy::DeregisterNotification

// DeregisterNotification is called when the server recognises 

// that this notification will not be posted again because the last client 

// to have a handle on this sub-session object has just closed the handle.

// It enables the TSY to "turn off" any regular notification messages that it

// may receive from DOS.

// (other items were commented in a header).

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

//

TInt CMmUssdTsy::DeregisterNotification(

    const TInt aIpc )                             // Notification IPC number

    {        

    TFLOGSTRING2( "TSY: CMmUssdTsy::DeregisterNotification. IPC: %d", aIpc );

    TInt ret( KErrNone );

    switch ( aIpc )

        {

        case EMobileUssdMessagingNotifyNetworkRelease:

        case EMobileUssdMessagingReceiveMessage:

            break;

        default:

            // Not supported

            ret = KErrNotSupported;

            break;

        }

    return ret;

    }

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

// CMmUssdTsy::NumberOfSlotsL

// NumberOfSlotsL is called by the server when it is registering 

// a new NOTIFICATION. It enables the TSY to tell the server how many buffer 

// slots to allocate for "repost immediately" notifications that may trigger

// before clients collect them.

// (other items were commented in a header).

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

//

TInt CMmUssdTsy::NumberOfSlotsL(

    const TInt aIpc )

    {

    TInt numberOfSlots = 1;

    switch ( aIpc )

        {

        case EMobileUssdMessagingReceiveMessage:

            numberOfSlots = KMmUssdMessagingReceiveMessageSlots;  

            break;

        case EMobileUssdMessagingNotifyNetworkRelease:

            numberOfSlots = KMmUssdMessagingNotifyNetworkReleaseSlots;  

            break;

        default:

            User::Leave( KErrNotSupported );

            break;

        }

    return numberOfSlots;

    }

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

// CMmUssdTsy::GetCaps

// This method returns a class that reflects the Ussd messaging 

// capabilities of the phone. This feature can be completed without sending 

// message, because TSY knows phones Ussd capabilities

// (other items were commented in a header).

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

//

TInt CMmUssdTsy::GetCaps( 

    const TTsyReqHandle aTsyReqHandle, 

    TDes8* aCaps )

    {

    TInt ret = KErrNone;

    if( aCaps->MaxLength() >= sizeof(RMobileUssdMessaging::TMobileUssdCapsV1Pckg) )

    	{

        RMobileUssdMessaging::TMobileUssdCapsV1Pckg* ussdCapsPckg =

            reinterpret_cast<RMobileUssdMessaging::TMobileUssdCapsV1Pckg*> 

            ( aCaps );

    	RMobileUssdMessaging::TMobileUssdCapsV1& ussdCaps = ( *ussdCapsPckg )();

    	// TSY knows what capabilities it has.

		// Capabilities depend on the TSY implementation.

		ussdCaps.iUssdTypes = KUssdTypeCaps;

		ussdCaps.iUssdFormat = RMobileUssdMessaging::KCapsPackedString;

    	}

    else

    	{

    	ret = KErrArgument;

    	}

    ReqCompleted( aTsyReqHandle, ret );

    return KErrNone;

    }

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

// CMmUssdTsy::ReceiveMessage

// This method activates receiving of Ussd messages.

// (other items were commented in a header).

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

//

TInt CMmUssdTsy::ReceiveMessage(

    const TTsyReqHandle aTsyReqHandle, 

    TDes8* aData, 

    TDes8* aAttributes )              

    {

    if(sizeof(RMobileUssdMessaging::TMobileUssdAttributesV1) > aAttributes->MaxLength())

    	{

    	return KErrArgument;

    	}

    TPckg<RMobileUssdMessaging::TMobileUssdAttributesV1>* ussdAttributesPckg =

         reinterpret_cast<TPckg<RMobileUssdMessaging::TMobileUssdAttributesV1>*>

         ( aAttributes );

    RMobileUssdMessaging::TMobileUssdAttributesV1& ussdAttributes = 

    ( *ussdAttributesPckg )();

    // Save request handle

    iTsyReqHandleStore->SetTsyReqHandle( 

        EMultimodeUssdReceiveMessage, aTsyReqHandle );

    iReceiveUssdMessagePtr = aData;

    iReceiveUssdMessageAttributesPtr = &ussdAttributes;

    return KErrNone;

    }

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

// CMmUssdTsy::ReceiveMessageCancel

// This method cancels reception of USSD messages

// (other items were commented in a header).

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

//

void CMmUssdTsy::ReceiveMessageCancel(

    const TTsyReqHandle aTsyReqHandle )

    {

    iTsyReqHandleStore->ResetTsyReqHandle( EMultimodeUssdReceiveMessage );

    ReqCompleted( aTsyReqHandle, KErrCancel );

    }

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

// CMmUssdTsy::CompleteReceiveMessage

// This method completes reception of USSD messages request

// (other items were commented in a header).

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

//