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

#include "cmockpcktservicemesshandler.h"

#include "mmockmesshandlerbase.h"

#include <ctsy/pluginapi/mmmessagemanagercallback.h>

#include <ctsy/pluginapi/cmmdatapackage.h>

#include <ctsy/tflogger.h>

#include <pcktcs.h>

#include "cmockltsyengine.h"

#include "tmockltsydata.h"

/**

Factory function

*/

CMockPcktServiceMessHandler* CMockPcktServiceMessHandler::NewL(CMmMessageRouter* aMessageRouter)

    {

    CMockPcktServiceMessHandler* self = new(ELeave)CMockPcktServiceMessHandler(aMessageRouter);

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

/**

Constructor

*/

CMockPcktServiceMessHandler::CMockPcktServiceMessHandler(CMmMessageRouter* aMessageManager)

	: iMessageRouter(aMessageManager)

    {

    }

/**

2nd phase contructor

*/

void CMockPcktServiceMessHandler::ConstructL()

    {      

    }

/**

Destructor

*/

CMockPcktServiceMessHandler::~CMockPcktServiceMessHandler()

    {

    iPcktMbmsMonitoredServiceLists.ResetAndDestroy();

    }

/**

Execute a request

*/

TInt CMockPcktServiceMessHandler::ExtFuncL(TInt aIpc, const CMmDataPackage* aDataPackage)     

    {

     switch (aIpc)

    	{    	    	

    	case EPacketGetAttachMode:

    		{

    		RPacketService::TPreferredBearer prefBearer;

			aDataPackage->UnPackData(prefBearer);

			TMockLtsyData1<RPacketService::TPreferredBearer> data(prefBearer);

			return iMessageRouter->MockLtsyEngine()->ExecuteCommandL(aIpc, data );    		

    		}    		

    	case EPacketSetPrefBearer:

    		{

     		TBool initState;

   			aDataPackage->UnPackData(initState);

			TMockLtsyData1<TBool> data(initState);

			return iMessageRouter->MockLtsyEngine()->ExecuteCommandL(aIpc,data);

    		}

    	case EPacketEnumerateMbmsActiveServiceList:

    		{

     		TMockLtsyData0 data;

 			return iMessageRouter->MockLtsyEngine()->ExecuteCommandL(aIpc,data);

    		}    	

    	case EPacketSetDefaultContextParams:

    		{

    		TPacketDataConfigBase base;    		

    		aDataPackage->UnPackData(base);

    		switch ( base.ExtensionId() )

    			{

    			case TPacketDataConfigBase::KConfigGPRS:

    				{

    				RPacketContext::TContextConfigGPRS configGPRS;    	

   					aDataPackage->UnPackData(configGPRS);

					TMockLtsyData1<RPacketContext::TContextConfigGPRS> data(configGPRS);

					return iMessageRouter->MockLtsyEngine()->ExecuteCommandL(aIpc,data);

    				}

    			case TPacketDataConfigBase::KConfigRel99Rel4:

    				{

    				RPacketContext::TContextConfigR99_R4 configRel99;    	

   					aDataPackage->UnPackData(configRel99);

					TMockLtsyData1<RPacketContext::TContextConfigR99_R4> data(configRel99);

					return iMessageRouter->MockLtsyEngine()->ExecuteCommandL(aIpc,data);    				

    				}  			

    			case TPacketDataConfigBase::KConfigCDMA:

    				{

    				RPacketContext::TContextConfigCDMA configCDMA;    	

   					aDataPackage->UnPackData(configCDMA);

					TMockLtsyData1<RPacketContext::TContextConfigCDMA> data(configCDMA);

					return iMessageRouter->MockLtsyEngine()->ExecuteCommandL(aIpc,data);    				

    				}   

    			case TPacketDataConfigBase::KConfigRel5:

    				{

    				RPacketContext::TContextConfig_R5 configRel5;    	

   					aDataPackage->UnPackData(configRel5);

					TMockLtsyData1<RPacketContext::TContextConfig_R5> data(configRel5);

					return iMessageRouter->MockLtsyEngine()->ExecuteCommandL(aIpc,data);    				

    				}

    			default:

    				{

		    		TMockLtsyData0 data;

 					return iMessageRouter->MockLtsyEngine()->ExecuteCommandL(aIpc,data);

    				}

    			}     		

    		}

    	case EPacketSetAttachMode:

    		{

     		RPacketService::TAttachMode attachMode;

   			aDataPackage->UnPackData(attachMode);

			TMockLtsyData1<RPacketService::TAttachMode> data(attachMode);

			return iMessageRouter->MockLtsyEngine()->ExecuteCommandL(aIpc,data);

    		}

    	case EPacketUpdateMbmsMonitorServiceList:

    		{

         	TMmMbmsMonitorServiceListParams params;

         	aDataPackage->UnPackData(params);

			TMockLtsyData1<TMmMbmsMonitorServiceListParams> data(params);

			return iMessageRouter->MockLtsyEngine()->ExecuteCommandL(aIpc, data);

    		}

    	case EPacketGetMbmsNetworkServiceStatus:

    		{

         	TBool aAttemptAttach;

    		aDataPackage->UnPackData(aAttemptAttach);

    		TMockLtsyData1<TBool> data(aAttemptAttach);

			return iMessageRouter->MockLtsyEngine()->ExecuteCommandL(aIpc,data);

    		}

        case EPacketGetStaticCaps:

        {

        	return 0;

        }

        case EPacketEnumerateMbmsMonitorServiceList:

        {

        	TMockLtsyData0 data;

 			return iMessageRouter->MockLtsyEngine()->ExecuteCommandL(aIpc,data);

        }

    	default:

    		{

		    TMockLtsyData0 data;

 			return iMessageRouter->MockLtsyEngine()->ExecuteCommandL(aIpc,data);

    		}

    	}

    }

/**

Complete a request

*/

void CMockPcktServiceMessHandler::CompleteL(TInt aIpc, const TDesC8& aData, TInt aResult)

	{

	CMmDataPackage dataPackage;

	switch (aIpc)

		{

        case EPacketEnumerateMbmsActiveServiceList:

            {

			TMockLtsyData1Buf<TInt> ret;

			ret.DeserialiseL(aData);

			dataPackage.PackData(ret.Data1Ptr());            

            }

            break;

		case EPacketNotifyStatusChange:

			{			

		//	TBool resumed;

		//	RPacketService::TStatus status;

			TMockLtsyData2Buf<RPacketService::TStatus , TBool> ret;

			ret.DeserialiseL(aData);

			dataPackage.PackData(ret.Data1Ptr(), ret.Data2Ptr());

			}

			break;

		case EPacketGetAttachMode:

			{			

			//RPacketService::TAttachMode mode;

			TMockLtsyData1Buf<RPacketService::TAttachMode> ret;

			ret.DeserialiseL(aData);

			dataPackage.PackData(ret.Data1Ptr());

			}

			break;

		case EPacketNotifyChangeOfNtwkRegStatus:

			{			

			TMockLtsyData1Buf<RPacketService::TRegistrationStatus> reg;

			reg.DeserialiseL(aData);

			dataPackage.PackData(reg.Data1Ptr());

			}

			break;			

		case EPacketGetNtwkRegStatus:

			{			

			TMockLtsyData1Buf<RPacketService::TRegistrationStatus> reg;

			reg.DeserialiseL(aData);

			dataPackage.PackData(reg.Data1Ptr());

			}

			break;			

		case EPacketNotifyContextAdded:

			{

			TMockLtsyData2Buf<TInfoName, TInt > ret;

			ret.DeserialiseL(aData);

			dataPackage.PackData(ret.Data1Ptr(), ret.Data2Ptr());			

			}

			break;		

		case EPacketNotifyMSClassChange:

			{

			TMockLtsyData1Buf< RPacketService::TMSClass> ret;

			ret.DeserialiseL(aData);

			dataPackage.PackData(ret.Data1Ptr());			

			}

			break;

		case EPacketNotifyDynamicCapsChange:

			{

			TMockLtsyData2Buf< TBool, TBool> ret;

			ret.DeserialiseL(aData);

			dataPackage.PackData(ret.Data1Ptr(), ret.Data2Ptr());		

			}

			break;				

		case EPacketNotifyContextActivationRequested:

			{ 

            TMockLtsyData1Buf<RPacketContext::TContextConfigGPRS> gprsBuf;

            gprsBuf.DeserialiseL(aData);   

            RPacketContext::TContextConfigGPRS* configGPRS = gprsBuf.Data1Ptr();     

            TInt extensionId = configGPRS->ExtensionId();      

            switch ( extensionId )

                {

                case TPacketDataConfigBase::KConfigGPRS:

                    {

                    dataPackage.PackData(configGPRS);

                    break;                 

                    }

                case TPacketDataConfigBase::KConfigCDMA:

                    {

                    TMockLtsyData1Buf<RPacketContext::TContextConfigCDMA> cdmaBuf;

                    cdmaBuf.DeserialiseL(aData);                                   

                    dataPackage.PackData(cdmaBuf.Data1Ptr()); 

                    break;                                                 

                    }

                case TPacketDataConfigBase::KConfigRel99Rel4:

                    {                    

                    TMockLtsyData1Buf<RPacketContext::TContextConfigR99_R4> r99Buf;

                    r99Buf.DeserialiseL(aData);                                    

                    dataPackage.PackData(r99Buf.Data1Ptr());

                    break; 

                    }                    

                case TPacketDataConfigBase::KConfigRel5:

                    {                     

                    TMockLtsyData1Buf<RPacketContext::TContextConfig_R5> r5Buf;

                    r5Buf.DeserialiseL(aData);                                     

                    dataPackage.PackData(r5Buf.Data1Ptr());

                    break;           

                    }                          

                case TPacketDataConfigBase::KConfigMBMS:   

                    {                         

                    TMockLtsyData1Buf<RPacketMbmsContext::TContextConfigMbmsV1> mbmsBuf;

                    mbmsBuf.DeserialiseL(aData);                                   

                    dataPackage.PackData(mbmsBuf.Data1Ptr());

                    break;        

                    }         

                default:

                    //Do nothing

                    break;

                }

			}

			break;

		case EPacketNotifyAttachModeChange:

			{			

			TMockLtsyData1Buf<RPacketService::TPreferredBearer> ret;

			ret.DeserialiseL(aData);

			dataPackage.PackData(ret.Data1Ptr());

			}

			break;

		case EPacketNotifyTransferCapsIPC: 

			{			

			TMockLtsyData1Buf<TDynamicTransferCapsFlags> ret;

			ret.DeserialiseL(aData);

			dataPackage.PackData(ret.Data1Ptr());

			}

			break;

		case EMmTsyNotifyEGprsInfoChangeIPC:

			{			

			TMockLtsyData1Buf<TBool> ret;

			ret.DeserialiseL(aData);

			dataPackage.PackData(ret.Data1Ptr());

			}

			break;

		case EPacketNotifyReleaseModeChange:

			{				

			TMockLtsyData1Buf<RMobilePhone::TMobilePhoneNetworkMode> ret;

			ret.DeserialiseL(aData);

			dataPackage.PackData(ret.Data1Ptr());

			}

			break;

		case EPacketGetMbmsNetworkServiceStatus:

			{			

			TMockLtsyData1Buf<TMbmsNetworkServiceStatus> reg;

			reg.DeserialiseL(aData);

			dataPackage.PackData(reg.Data1Ptr());

			}

			break;

		case EPacketNotifyMbmsNetworkServiceStatusChange:

			{			

			TMockLtsyData1Buf<TMbmsNetworkServiceStatus> reg;

			reg.DeserialiseL(aData);

			dataPackage.PackData(reg.Data1Ptr());

			}

			break;

		case EPacketGetStaticCaps:

			{			

			TMockLtsyData1Buf<TBool> reg;

			reg.DeserialiseL(aData);

			dataPackage.PackData(reg.Data1Ptr());

			}

			break;					

		case EPacketEnumerateMbmsMonitorServiceList:

			{

			TMockLtsyData1Buf<TInt> reg;

			reg.DeserialiseL(aData);

			dataPackage.PackData(reg.Data1Ptr());

			}

			break;

		case EPacketUpdateMbmsMonitorServiceList:

		case EPacketNotifyMbmsServiceAvailabilityChange:

			{

			TMockLtsyData1Buf< CPcktMbmsMonitoredServiceList *> completeData;

			completeData.DeserialiseL(aData);

			if (completeData.Data1())

				{

				completeData.PushL();

				iPcktMbmsMonitoredServiceLists.AppendL(completeData.Data1());

				CleanupStack::Pop(&completeData);

				}

			dataPackage.PackData(completeData.Data1());

			}

			break;							

		default:

			// complete event without data

			break;

		}

	iMessageRouter->MessageManagerCallback()->Complete(aIpc, &dataPackage, aResult);

	}