1 // Copyright (c) 2007-2009 Nokia Corporation and/or its subsidiary(-ies).

     2 // All rights reserved.

     3 // This component and the accompanying materials are made available

     4 // under the terms of "Eclipse Public License v1.0"

     5 // which accompanies this distribution, and is available

     6 // at the URL "http://www.eclipse.org/legal/epl-v10.html".

     7 //

     8 // Initial Contributors:

     9 // Nokia Corporation - initial contribution.

    10 //

    11 // Contributors:

    12 //

    13 // Description:

    14 //

    15 

    16 #include <etelpckt.h>

    17 #include "cmockpcktcontextmesshandler.h"

    18 #include <ctsy/tflogger.h>

    19 #include <pcktcs.h>

    20 #include <ctsy/pluginapi/mmmessagemanagercallback.h>

    21 #include "cmockltsyengine.h"

    22 #include "tmockltsydata.h"

    23 

    24 #include "CMmCommonStaticUtility.h"

    25 #include <ctsy/serviceapi/mmtsy_ipcdefs.h>

    26 

    27 /**

    28 Factory function

    29 */

    30 CMockPcktContextMessHandler* CMockPcktContextMessHandler::NewL(CMmMessageRouter* aMessageRouter)

    31     {

    32     CMockPcktContextMessHandler* self = new (ELeave)CMockPcktContextMessHandler(aMessageRouter);

    33     CleanupStack::PushL(self);

    34     self->ConstructL();

    35     CleanupStack::Pop();

    36     return self;    

    37     }

    38 

    39 /**

    40 Constructor

    41 */

    42 CMockPcktContextMessHandler::CMockPcktContextMessHandler(CMmMessageRouter* aMessageRouter)

    43 	:iMessageRouter(aMessageRouter)

    44     {

    45     }

    46 

    47 /**

    48 2nd phase contructor

    49 */

    50 void CMockPcktContextMessHandler::ConstructL()

    51     {

    52     }

    53 

    54 /**

    55 Destructor

    56 */

    57 CMockPcktContextMessHandler::~CMockPcktContextMessHandler()

    58     {

    59     iMbmsSessionLists.ResetAndDestroy();

    60     }

    61 

    62 /**

    63 Cleanup CArrayPtrFlat<RPacketContext::CTFTMediaAuthorizationV3>*

    64 */

    65 void CMockPcktContextMessHandler::CleanupArrayPtrFlat(TAny* aSelf)

    66 	{

    67 	if(aSelf)

    68 		{

    69 		CArrayPtrFlat<RPacketContext::CTFTMediaAuthorizationV3>* array (NULL);

    70 		array = static_cast<CArrayPtrFlat<RPacketContext::CTFTMediaAuthorizationV3>*>(aSelf);

    71 		array->ResetAndDestroy();

    72 		delete array;

    73 		}	

    74 	}

    75 

    76 /**

    77 Execute a request

    78 */

    79 TInt CMockPcktContextMessHandler::ExtFuncL(TInt aIpc,const CMmDataPackage* aMmDataPackage)

    80 	{

    81 	switch (aIpc)

    82     	{

    83 	   	case EPacketAddMediaAuthorization:

    84 	   		{

    85 	   		TInfoName* infoName = NULL;

    86 	   		RPacketContext::CTFTMediaAuthorizationV3* mediaAuthorization = NULL;

    87 	   		//TPacketContextConfigGPRS contextConfig;

    88 	   		TInt configurationType;

    89 	   		

    90 	   		CMmPacketDataPackage* dataPacket = (CMmPacketDataPackage*) aMmDataPackage;

    91 	   		dataPacket->UnPackData(&infoName, &mediaAuthorization);

    92 	   		RPacketContext::TContextConfigGPRS contextConfig;

    93 	   		dataPacket->GetConfig(&contextConfig, configurationType);	   		

    94 	   		/*contextConfig.iPdpType              = pointerContextConfig.iPdpType;

    95 	   		contextConfig.iAccessPointName      = pointerContextConfig.iAccessPointName;

    96 	   		contextConfig.iPdpAddress           = pointerContextConfig.iPdpAddress;

    97 	   		contextConfig.iPdpCompression       = pointerContextConfig.iPdpCompression;

    98 	   		contextConfig.iAnonymousAccessReqd  = pointerContextConfig.iAnonymousAccessReqd;

    99 	   		contextConfig.iUseEdge              = pointerContextConfig.iUseEdge;

   100 	   		contextConfig.iProtocolConfigOption = pointerContextConfig.iProtocolConfigOption;

   101 	   		contextConfig.iNWIContext           = pointerContextConfig.iNWIContext;*/

   102 	   		

   103 			TMockLtsyContextData2< TInfoName, RPacketContext::CTFTMediaAuthorizationV3* > 

   104 				data(contextConfig, configurationType, *infoName, mediaAuthorization);

   105 				

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

   107 	   		}

   108 	   		

   109     	case EPacketContextGetDataVolumeTransferred:

   110     	

   111     	case EPacketContextDelete:

   112     	case EPacketContextActivate:

   113     		{

   114      		TInfoName name;

   115    			aMmDataPackage->UnPackData(name);

   116 			TMockLtsyData1< TInfoName > data(name);

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

   118     		}

   119     	case EPacketContextDeactivate:

   120 	    	{

   121      		TInfoName name1;

   122       		aMmDataPackage->UnPackData(name1);  		

   123 

   124       		// @TODO: We should probably change this

   125       		if( 0 <= name1.Match(_L("*MBMS*") ) )

   126 	      		{

   127 	      		TInfoName name;

   128 	      		RPacketMbmsContext::CMbmsSession* servicesArray;

   129 	      		aMmDataPackage->UnPackData(name, servicesArray);  		

   130 	      		TMockLtsyData2< TInfoName,  RPacketMbmsContext::CMbmsSession*> data(name, servicesArray);

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

   132 	      		}

   133       		else

   134       			{

   135 	      		TInfoName name;

   136 	      		aMmDataPackage->UnPackData(name);  		

   137 	      		TMockLtsyData1< TInfoName> data(name);

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

   139       			}

   140 			}

   141 	    		    	

   142 	    	

   143     	case EPacketContextInitialiseContext:

   144     		{

   145      		TInfoName name1;

   146       		TInfoName name2;

   147 	   	aMmDataPackage->UnPackData(name1, name2);

   148 		TMockLtsyData2< TInfoName, TInfoName > data(name1, name2);

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

   150     		}

   151     		

   152     	case ECtsyPacketMbmsInitialiseContextReq:

   153     		{

   154      		TInfoName name1;

   155    		aMmDataPackage->UnPackData(name1);

   156 

   157     		TMockLtsyData1< TInfoName> data(name1);

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

   159     		}

   160     		    		

   161     	case EPacketContextModifyActiveContext:

   162     		{

   163      		CArrayFixFlat<RPacketContext::CTFTMediaAuthorizationV3>* mediaAuthorizationArray;

   164      		TContextConfiguration expectConfig;

   165    			aMmDataPackage->UnPackData(expectConfig, mediaAuthorizationArray);

   166 

   167      		CArrayPtrFlat<RPacketContext::CTFTMediaAuthorizationV3>* mediaAuthorizationArrayPtr(NULL);

   168 

   169    			if(mediaAuthorizationArray)

   170    				{

   171    				mediaAuthorizationArrayPtr = new(ELeave) CArrayPtrFlat<RPacketContext::CTFTMediaAuthorizationV3>(3);

   172    				CleanupStack::PushL(TCleanupItem(CleanupArrayPtrFlat, mediaAuthorizationArrayPtr));

   173    				for(TInt i=0;i<mediaAuthorizationArray->Count();i++)

   174    					{

   175    					RPacketContext::CTFTMediaAuthorizationV3* newEntry = RPacketContext::CTFTMediaAuthorizationV3::NewL();

   176    					CleanupStack::PushL(newEntry);

   177    					RPacketContext::CTFTMediaAuthorizationV3* entry = &mediaAuthorizationArray->At(i);

   178    					newEntry->iAuthorizationToken = entry->iAuthorizationToken;

   179    					for(TInt j=0;j<entry->iFlowIds.Count();j++)

   180    						{

   181    						RPacketContext::CTFTMediaAuthorizationV3::TFlowIdentifier fid;

   182    						fid.iIPFlowNumber = entry->iFlowIds[j].iIPFlowNumber;

   183    						fid.iMediaComponentNumber = entry->iFlowIds[j].iMediaComponentNumber;

   184    						newEntry->iFlowIds.Append(fid);

   185    						}

   186    					mediaAuthorizationArrayPtr->AppendL(newEntry);

   187    					CleanupStack::Pop(); //newentry

   188    					}

   189    				}  			

   190 

   191 			TMockLtsyData2< TContextConfiguration, CArrayPtrFlat<RPacketContext::CTFTMediaAuthorizationV3>* >

   192 															 data(expectConfig, mediaAuthorizationArrayPtr);

   193 			TInt ret = iMessageRouter->MockLtsyEngine()->ExecuteCommandL(aIpc,data);

   194 			if(mediaAuthorizationArrayPtr)

   195 				CleanupStack::PopAndDestroy(); //mediaAuthorizationArrayPtr

   196 			return ret;

   197     		}

   198     	

   199     	case EPacketContextSetConfig:

   200     		{

   201      		TPacketDataConfigBase base;

   202      		TInfoName name;

   203    			aMmDataPackage->UnPackData(base, name);

   204    			

   205    			if ( TPacketDataConfigBase::KConfigGPRS == base.ExtensionId() )

   206    				{

   207    				RPacketContext::TContextConfigGPRS config;

   208    				aMmDataPackage->UnPackData(config, name);   				

   209                     

   210    				TMockLtsyData2< RPacketContext::TContextConfigGPRS, TInfoName > data(config, name);

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

   212    				}   

   213    								

   214    			if ( TPacketDataConfigBase::KConfigRel99Rel4 == base.ExtensionId() )					  

   215    				{

   216    				 RPacketContext::TContextConfigR99_R4 config;

   217    				 aMmDataPackage->UnPackData(config, name);   				 

   218                     

   219                  TMockLtsyData2< RPacketContext::TContextConfigR99_R4, TInfoName > data(config, name);

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

   221 	   			}

   222 	   			

   223 	   		if (TPacketDataConfigBase::KConfigRel5 == base.ExtensionId() )

   224 	   			{

   225 	   			RPacketContext::TContextConfig_R5 config;

   226 	   			aMmDataPackage->UnPackData(config, name);   			

   227 	   			

   228 	   			TMockLtsyData2< RPacketContext::TContextConfig_R5, TInfoName > data(config, name);

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

   230 	   			}   	

   231 	   		

   232    			if ( TPacketDataConfigBase::KConfigMBMS == base.ExtensionId() )

   233    				{

   234    				RPacketMbmsContext::TContextConfigMbmsV1 config;

   235    				aMmDataPackage->UnPackData(config, name);   				

   236                     

   237    				TMockLtsyData2< RPacketMbmsContext::TContextConfigMbmsV1, TInfoName > data(config, name);

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

   239    				}  	   		

   240 	   		

   241 	   		// if unknown type	

   242 	   		TMockLtsyData0 data;

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

   244  								

   245     		}

   246 	    case EPacketContextUpdateMbmsSessionList:

   247             {

   248 			TInfoName name;

   249 			TMmMbmsActiveServiceListParams params;

   250 	    	aMmDataPackage->UnPackData(name, params);

   251 			

   252 			TMockLtsyData2< TInfoName, TMmMbmsActiveServiceListParams > data(name, params);

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

   254             }    	        		

   255     	case EPacketContextAddPacketFilter:

   256     		{

   257      		CArrayFixFlat<RPacketContext::TPacketFilterV2>* filterArray = NULL;

   258      		TInfoName* name = NULL;

   259      		TInt configurationType;

   260 			//TPacketContextConfigGPRS* configGPRS(NULL);

   261 			RPacketContext::TContextConfigGPRS configGPRS;

   262    			

   263    			aMmDataPackage->UnPackData(&name, &filterArray);

   264 			(static_cast<const CMmPacketDataPackage*>(aMmDataPackage))->GetConfig( &configGPRS, configurationType );

   265 						

   266 			//if ( configGPRS )

   267 			//	{

   268 			TMockLtsyContextData2< TInfoName, CArrayFixFlat< RPacketContext::TPacketFilterV2 >* > 

   269 					data(configGPRS, configurationType, *name, filterArray);

   270 	    			

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

   272 			//	}

   273 				

   274 			//return KErrCorrupt;

   275     		}

   276     		

   277     	case EPacketContextRemovePacketFilter:

   278     	default:

   279     		{

   280 		    TMockLtsyData0 data;

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

   282     		}

   283     	}

   284     }

   285 

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

   287 	{

   288 	CMmDataPackage dataPackage;

   289 	switch (aIpc)

   290 		{

   291 		case EPacketContextUpdateMbmsSessionList:

   292 		    {		        		        

   293 			TMockLtsyData1Buf< TInfoName > ret;

   294 			ret.DeserialiseL(aData);

   295 			dataPackage.PackData(ret.Data1Ptr());

   296 			}

   297 			break;		

   298 		case EPacketContextInitialiseContext:	

   299 			{

   300 			TMockLtsyData1Buf<TInfoName> ret1;

   301 			ret1.DeserialiseL(aData);

   302 			dataPackage.PackData(ret1.Data1Ptr());

   303 			}

   304 			break;

   305 		

   306 		case ECtsyPacketMbmsInitialiseContextComp:	

   307 			{

   308 			TMockLtsyData2Buf<TInfoName, RPacketContext::TDataChannelV2> ret1;

   309 			ret1.DeserialiseL(aData);

   310 			dataPackage.PackData(ret1.Data1Ptr(), ret1.Data2Ptr());

   311 			}

   312 			break;

   313 			

   314 		case EPacketContextDeactivate:	

   315 			{			

   316 			if( KErrMbmsImpreciseServiceEntries == aResult )

   317 				{

   318 				TMockLtsyData2Buf< TInfoName, RPacketMbmsContext::CMbmsSession *> ret;

   319 				ret.DeserialiseL(aData);

   320 				CleanupStack::PushL(ret.Data2());

   321 				iMbmsSessionLists.AppendL(ret.Data2());

   322 				CleanupStack::Pop();

   323 				dataPackage.PackData(ret.Data1Ptr(), ret.Data2() );

   324 				}

   325 			else

   326 				{

   327 				TMockLtsyData1Buf< TInfoName > ret;

   328 				ret.DeserialiseL(aData);

   329 				dataPackage.PackData(ret.Data1Ptr());

   330 				}	

   331 			}

   332 			break;

   333 		case EPacketContextSetConfig:

   334 		case EPacketContextDelete:

   335 			{			

   336 			TMockLtsyData1Buf< TInfoName > ret;

   337 			ret.DeserialiseL(aData);

   338 			dataPackage.PackData(ret.Data1Ptr());

   339 			}

   340 			break;

   341 		

   342 		case EPacketContextNotifyStatusChange:

   343 			{

   344 			TMockLtsyData2Buf< TInfoName, TContextMisc > ret;

   345 			ret.DeserialiseL(aData);

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

   347 			

   348 			}

   349 			break;	

   350 		

   351 		case EPacketContextNotifyConfigChanged:

   352 			{	

   353 			TMockLtsyData2Buf< TInfoName, RPacketContext::TContextConfigGPRS> ret;

   354    			ret.DeserialiseL(aData);

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

   356 			}

   357 			break;

   358 			

   359 		case ECtsyPacketMbmsContextNotifyConfigChanged:

   360 			{	

   361 			TMockLtsyData2Buf< TInfoName, RPacketMbmsContext::TContextConfigMbmsV1> ret;

   362    			ret.DeserialiseL(aData);

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

   364 			}

   365 			break;

   366 

   367 		case EPacketContextActivate:

   368 			{

   369 			TMockLtsyData2Buf< TInfoName, RPacketContext::TContextConfigGPRS> ret;

   370 			ret.DeserialiseL(aData);

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

   372 			}

   373 			break;

   374 		case EPacketGetMbmsSessionListPhase1:

   375 		case EPacketContextNotifyConnectionSpeedChange:

   376 			{

   377 			TMockLtsyData2Buf< TInfoName, TInt> ret;

   378 			ret.DeserialiseL(aData);

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

   380 			}

   381 			break;

   382 		

   383 		case EPacketContextModifyActiveContext:

   384 			{			

   385 			TMockLtsyData2Buf< TInfoName, TBuf8 <1> > ret;

   386 			ret.DeserialiseL(aData);

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

   388 			}

   389 			break;	

   390 		

   391 		case EPacketContextGetDataVolumeTransferred:

   392 		case EPacketContextNotifyDataTransferred:

   393 			{

   394 			TMockLtsyData2Buf< TInfoName, RPacketContext::TDataVolume> ret;

   395 			ret.DeserialiseL(aData);

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

   397 			}

   398 			break;

   399 		case EPacketContextNotifyConnectionInfoChange:

   400 			{

   401 			TMockLtsyData2Buf<TInfoName, RPacketContext::TConnectionInfoV1> ret;

   402 			ret.DeserialiseL(aData);

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

   404 			}

   405 			break;						

   406 		case EPacketContextAddPacketFilter:

   407 		case EPacketContextRemovePacketFilter:

   408 		default:

   409 			// complete event without data

   410 			break;		

   411 		}

   412 

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

   414 	}

   415