// 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 <mmlist.h>

#include <etelmm.h>

#include "cmmbroadcasttsy.h"

#include "cmmphonetsy.h"

#include "CMmPrivateUtility.h"    // Read all list class 

#include <ctsy/serviceapi/cmmsmsutility.h>

#include "MmTsy_numberOfSlots.h"

#include "cmmtsyreqhandlestore.h"

#include <ctsy/pluginapi/cmmdatapackage.h>

#include "cmmnettsy.h"

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

CMmBroadcastTsy::CMmBroadcastTsy():

    iReqHandleType(EMultimodeBroadcastReqHandleUnknown)

    {

    // Set number of WCDMA CBS Pages to 0

	iWcdmaPageNumber = 0;

	// Defaut value for iWcdmaCbsPageLeft.it means that there are

	// no page left to send to upper layer

	iWcdmaCbsPageLeft = EFalse;

	// First page is always at index 0

	iWcdmaCbsMsgPageIndex = 0;

    }

void CMmBroadcastTsy::ConstructL()

    {

#ifdef REQHANDLE_TIMER   

    // create req handle store

    iTsyReqHandleStore = CMmTsyReqHandleStore::NewL( this, iMmPhone, 

        EMultimodeBroadcastMaxNumOfRequests, iBroadcastReqHandles );

#else

    // create req handle store

    iTsyReqHandleStore = CMmTsyReqHandleStore::NewL( 

        EMultimodeBroadcastMaxNumOfRequests, iBroadcastReqHandles );

#endif // REQHANDLE_TIMER

    // Reset all CMmBroadcastTsy variables

    ResetVariables();

	// Maximun of subBlocks is 15 so let's put the granularity to 10

	iCbsMsg = new( ELeave ) CArrayPtrFlat< TWcdmaCbsMsg >( 10 );

    // register broadcast tsy in the message manager

    iMmPhone->MessageManager()->RegisterTsyObject( 

        CMmMessageManagerBase::EBroadcastMessagingTsy, this );

    }

CMmBroadcastTsy* CMmBroadcastTsy::NewL( 

    CMmPhoneTsy* aMmPhone )    

    {

    CMmBroadcastTsy* aMmBroadcastTsy = new ( ELeave ) CMmBroadcastTsy();

    CleanupClosePushL( *aMmBroadcastTsy );

    aMmBroadcastTsy->iMmPhone = aMmPhone;

    aMmBroadcastTsy->ConstructL();

    CleanupStack::Pop();

    return aMmBroadcastTsy;

    }

CMmBroadcastTsy::~CMmBroadcastTsy()

    {     

    if ( iMmPhone )

        {

        // deregister tsy object from message manager

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

        }

    delete iTsyReqHandleStore;

    iTsyReqHandleStore = NULL;

    // Delete iCbsMsg

    delete iCbsMsg;

    iCbsMsg = NULL;

	// Set pointers to NULL

	iMmPhone = NULL;

	iMessageManager = NULL;

	iReceiveCbMessagePtr = NULL;

	iReceiveCbMessageAttributesPtr = NULL;

	iNotifyFilterSettingChangePtr = NULL;

    }

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

// CMmBroadcastTsy::Init

// Initialisation method

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

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

//

void CMmBroadcastTsy::Init()

    {

    }

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

// CMmBroadcastTsy::ExtFunc

// Handling of extended requests

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

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

//

TInt CMmBroadcastTsy::ExtFunc( 

    const TTsyReqHandle aTsyReqHandle, 

    const TInt aIpc, 

    const TDataPackage& aPackage )        

    {

    TInt ret( KErrNone );

    TAny* dataPtr = aPackage.Ptr1();

    TAny* dataPtr2 = aPackage.Ptr2();

    switch ( aIpc )

        {

         // Cell broadcast requests that doesn't need trapping

        case EMobileBroadcastMessagingGetCaps:

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

            break;

        case EMobileBroadcastMessagingGetFilterSetting:

            ret = GetFilterSetting( aTsyReqHandle, reinterpret_cast<

                RMobileBroadcastMessaging::TMobilePhoneBroadcastFilter*>

                ( dataPtr ) );

            break;

        case EMobileBroadcastMessagingGetIdListPhase1:

            TRAP_IGNORE( ret = GetBroadcastIdListPhase1L( aTsyReqHandle,

                reinterpret_cast< CRetrieveMobilePhoneBroadcastIdList::

                TGetBroadcastIdRequest* > ( dataPtr ),

                reinterpret_cast< TInt* > ( dataPtr2 ) ); );

            break;

        case EMobileBroadcastMessagingGetIdListPhase2:

            ret = GetBroadcastIdListPhase2( aTsyReqHandle,

                reinterpret_cast< RMobilePhone::TClientId* > ( dataPtr ),

                aPackage.Des2n() );

            break;

        // Cell broadcast requests that may need trapping

        default:

            // Ensure the ReqHandleType is unset.

            // This will detect cases where this method indirectly calls itself

            // (e.g. servicing a client call that causes a self-reposting notification to complete and thus repost).

            // Such cases are not supported because iReqHandleType is in the context of this class instance,

            // not this request, and we don't want the values set by the inner request and the outer request

            // interfering with each other.

            __ASSERT_DEBUG(iReqHandleType==EMultimodeBroadcastReqHandleUnknown, User::Invariant());

            TInt leaveCode( KErrNone );

            TRAP( leaveCode, ret = DoExtFuncL( aTsyReqHandle, aIpc, 

                aPackage ); );

            if ( KErrNone != leaveCode )

                {

                ReqCompleted( aTsyReqHandle, leaveCode );

                }

            // save request handle

            if ( EMultimodeBroadcastReqHandleUnknown != iReqHandleType )

                {

#ifdef REQHANDLE_TIMER

                SetTypeOfResponse( iReqHandleType, aTsyReqHandle );

#else

                //Never comes here ? See SetTypeOfResponse.

                iTsyReqHandleStore->SetTsyReqHandle( iReqHandleType, 

                    aTsyReqHandle );

#endif // REQHANDLE_TIMER

                // We've finished with this value now. Clear it so it doesn't leak

                //  up to any other instances of this method down the call stack

                iReqHandleType = EMultimodeBroadcastReqHandleUnknown;

                }

            break;

        }

    return ret;

    }

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

// CMmBroadcastTsy::DoExtFuncL

// Handling of broadcast related requests that needs trapping

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

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

//

TInt CMmBroadcastTsy::DoExtFuncL( 

    const TTsyReqHandle aTsyReqHandle, 

    const TInt aIpc, 

    const TDataPackage& aPackage )

    {

    TInt ret( KErrNone );

    TAny* dataPtr = aPackage.Ptr1();

    switch ( aIpc )

        {

        // Cell broadcast requests that may need trapping

        case EMobileBroadcastMessagingReceiveMessage:

            ret = ReceiveMessageL( 

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

            break;

        case EMobileBroadcastMessagingSetFilterSetting:

            ret = SetFilterSettingL( aTsyReqHandle, 

                reinterpret_cast<

                RMobileBroadcastMessaging::TMobilePhoneBroadcastFilter* >

                ( dataPtr ) );

            break;

        case EMobileBroadcastMessagingNotifyFilterSettingChange:

            ret = NotifyFilterSettingChange( reinterpret_cast< 

                RMobileBroadcastMessaging::TMobilePhoneBroadcastFilter* >

                ( dataPtr ) );

            break;

        case EMobileBroadcastMessagingStoreIdList:

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

            break;

        default:

            ret = KErrNotSupported;

            break;

        }

    return ret;

    }

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

// CMmBroadcastTsy::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 on

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

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

//

TInt CMmBroadcastTsy::CancelService( 

    const TInt aIpc, 

    const TTsyReqHandle aTsyReqHandle )

    {

    TInt ret( KErrNone );

    switch ( aIpc )

        {

        case EMobileBroadcastMessagingNotifyFilterSettingChange:

            ret = NotifyFilterSettingChangeCancel ( aTsyReqHandle );

            break;

        case EMobileBroadcastMessagingSetFilterSetting:

        case EMobileBroadcastMessagingStoreIdList:

        case EMobileBroadcastMessagingGetIdListPhase1:

        case EMobileBroadcastMessagingGetIdListPhase2:

            ret = KErrNone;

            break;

        // This cancel request may need message construction, 

        // so trapping is needed

        case EMobileBroadcastMessagingReceiveMessage:

            // call cancel handling

            TRAPD( leaveCode, ( ret = ReceiveMessageCancelL( aTsyReqHandle ) ) );

            if ( KErrNone != leaveCode )

                {

                ReqCompleted( aTsyReqHandle, leaveCode );

                }

            break;

        default:

            ret = KErrGeneral; 

            break;

        } 

    return ret;

    }

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

// CMmBroadcastTsy::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

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

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

//

CTelObject::TReqMode CMmBroadcastTsy::ReqModeL( 

    const TInt aIpc )

    {

    CTelObject::TReqMode ret = 0;

    switch ( aIpc )

        {

        // Non-Flow Controlled Services

        case EMobileBroadcastMessagingGetCaps:

        case EMobileBroadcastMessagingGetFilterSetting:

        case EMobileBroadcastMessagingGetIdListPhase1:

        case EMobileBroadcastMessagingGetIdListPhase2:

        case EMobileBroadcastMessagingStoreIdList:

            break;

        // Flow Controlled Services

        case EMobileBroadcastMessagingSetFilterSetting:

            ret = KReqModeFlowControlObeyed;

            break;

        // Multiple Completion Services with Immediate Server Repost

        // (Usually Notifications)

        case EMobileBroadcastMessagingReceiveMessage:

        case EMobileBroadcastMessagingNotifyFilterSettingChange:

            ret = KReqModeMultipleCompletionEnabled |

                     KReqModeRePostImmediately;

            break;

        default:

            User::Leave ( KErrNotSupported );

            break;         

        }

    return ret;

    }

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

// CMmBroadcastTsy::NumberOfSlotsL

// When the ETel server discovers that a request is "repost 

// immediately" it will ask the TSY how big a buffer it wants. 

// NumberOfSlotsL Returns number of slots to be used for given 

// requests

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

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

//

TInt CMmBroadcastTsy::NumberOfSlotsL( 

    const TInt aIpc )

    {

    TInt numberOfSlots = 1;

    switch ( aIpc )

        {

        // Number of slots for the receive message

        case EMobileBroadcastMessagingReceiveMessage:   

            numberOfSlots = KMmBroadcastMessagingReceiveMessageSlots;

            break;

        // Number of the slots for the notify changes

        case EMobileBroadcastMessagingNotifyFilterSettingChange:

            numberOfSlots = 

                KMmBroadcastMessagingNotifyFilterSettingChangeSlots;

            break;

        default:

            // Unknown or invalid Broadcast IPC

            User::Leave ( KErrNotSupported );

            break;

        }

    return numberOfSlots;

    }

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

// CMmBroadcastTsy::OpenNewObjectByNameL

// Creates new object and returns a pointer to it

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

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

//

CTelObject* CMmBroadcastTsy::OpenNewObjectByNameL( 

    const TDesC& /*aName*/ )

    {

    User::Leave( KErrNotSupported );

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

    return NULL;

    }

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

// CMmBroadcastTsy::OpenNewObjectL

// Creates new object and returns a pointer to it

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

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

//

CTelObject* CMmBroadcastTsy::OpenNewObjectL( 

    TDes& /*aName*/ )

    {

    User::Leave( KErrNotSupported );

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

    return NULL;

    }

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

// CMmBroadcastTsy::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 CMmBroadcastTsy::RegisterNotification( 

    const TInt aIpc )         

    {

    switch ( aIpc )

        {

        case EMobileBroadcastMessagingReceiveMessage:

        case EMobileBroadcastMessagingNotifyFilterSettingChange:

            return KErrNone;

        default:

            // Unknown or invalid Broadcast IPC

            return KErrNotSupported;

        }

    }

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

// CMmBroadcastTsy::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 CMmBroadcastTsy::DeregisterNotification( 

    const TInt aIpc )

    {

    switch ( aIpc )

        {

        case EMobileBroadcastMessagingReceiveMessage:

        case EMobileBroadcastMessagingNotifyFilterSettingChange:

            return KErrNone;

        default:

            // Unknown or invalid Broadcast IPC

            return KErrNotSupported;

        }

    }

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

// CMmBroadcastTsy::GetCaps

// This method returns a class that reflects the broadcast 

// messaging capabilities of the phone.

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

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

//

TInt CMmBroadcastTsy::GetCaps( 

    const TTsyReqHandle aTsyReqHandle, 

    TDes8* aCaps )

    {

    TInt ret( KErrArgument );     

    if ( aCaps )

        {        

        TInt paramLength = aCaps->MaxLength();

        TInt expectedLength = sizeof( RMobileBroadcastMessaging::TMobileBroadcastCapsV1Pckg );

        if (paramLength == expectedLength)

            {    

            RMobileBroadcastMessaging::TMobileBroadcastCapsV1Pckg* cbsCapsPckg = 

                reinterpret_cast< RMobileBroadcastMessaging::TMobileBroadcastCapsV1Pckg* > 

                ( aCaps );

            RMobileBroadcastMessaging::TMobileBroadcastCapsV1& cbsCaps = 

                ( *cbsCapsPckg )();

            cbsCaps.iModeCaps = RMobileBroadcastMessaging::KCapsGsmTpduFormat; 

#ifdef __WINS__

            // force GSM+WCDMA capabilities for emulator testing

            cbsCaps.iModeCaps = RMobileBroadcastMessaging::KCapsWcdmaTpduFormat 

                | RMobileBroadcastMessaging::KCapsGsmTpduFormat;

#endif // __WINS__       

            // TSY supports only "accept all" and "reject all" filtering.

            cbsCaps.iFilterCaps = RMobileBroadcastMessaging::KCapsSimpleFilter;

            ret = KErrNone;

            ReqCompleted( aTsyReqHandle, ret );

            }

        }        

    return ret;

    }

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

// CMmBroadcastTsy::ReceiveMessageL

// Activates routing of CB messages, and then waits for incoming CB messages

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

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

//

TInt CMmBroadcastTsy::ReceiveMessageL( 

    const TTsyReqHandle aTsyReqHandle, 

    TDes8* aMsgData, 

    TDes8* aMsgAttributes )

    {

    TInt ret = KErrArgument;

    if (aMsgData && aMsgAttributes)

        {

		RMobileBroadcastMessaging::TBroadcastPageData tempData;

		if (aMsgData->MaxLength() == tempData.MaxLength())

			{

			RMobileBroadcastMessaging::TMobileBroadcastAttributesV1 tempV1;

			RMobileBroadcastMessaging::TMobileBroadcastAttributesV1Pckg tempV1Pckg(tempV1);

			RMobileBroadcastMessaging::TMobileBroadcastAttributesV2 tempV2;

			RMobileBroadcastMessaging::TMobileBroadcastAttributesV2Pckg tempV2Pckg(tempV2);

			if ( (aMsgAttributes->MaxLength() == tempV1Pckg.MaxLength()) || (aMsgAttributes->MaxLength() == tempV2Pckg.MaxLength()) )

				{

				ret = KErrNone;

				}

		    if (ret == KErrNone)

		    	{

			    iReceiveCbMessagePtr = aMsgData;

			    iReceiveCbMessageAttributesPtr = aMsgAttributes;

    		    if ( iWcdmaCbsPageLeft )

    		        {