mtpfws/mtpfw/dataproviders/devdp/src/cmtpsetdevicepropvalue.cpp
changeset 47 63cf70d3ecd8
parent 18 1b39655331a3
equal deleted inserted replaced
44:a5deb6b96675 47:63cf70d3ecd8
    22 #include <mtp/mmtpframeworkconfig.h>
    22 #include <mtp/mmtpframeworkconfig.h>
    23 #include "cmtpdevicedatastore.h"
    23 #include "cmtpdevicedatastore.h"
    24 #include "cmtpsetdevicepropvalue.h"
    24 #include "cmtpsetdevicepropvalue.h"
    25 #include "mtpdevicedpconst.h"
    25 #include "mtpdevicedpconst.h"
    26 #include "mtpdevdppanic.h"
    26 #include "mtpdevdppanic.h"
       
    27 #include "OstTraceDefinitions.h"
       
    28 #ifdef OST_TRACE_COMPILER_IN_USE
       
    29 #include "cmtpsetdevicepropvalueTraces.h"
       
    30 #endif
       
    31 
    27 
    32 
    28 // Class constants.
    33 // Class constants.
    29 __FLOG_STMT(_LIT8(KComponent,"SetDevicePropValue");)
       
    30 
    34 
    31 /**
    35 /**
    32 Two-phase constructor.
    36 Two-phase constructor.
    33 @param aPlugin  The data provider plugin
    37 @param aPlugin  The data provider plugin
    34 @param aFramework The data provider framework
    38 @param aFramework The data provider framework
    47 /**
    51 /**
    48 Destructor
    52 Destructor
    49 */    
    53 */    
    50 CMTPSetDevicePropValue::~CMTPSetDevicePropValue()
    54 CMTPSetDevicePropValue::~CMTPSetDevicePropValue()
    51     {    
    55     {    
    52     __FLOG(_L8("~CMTPSetDevicePropValue - Entry"));
    56     OstTraceFunctionEntry0( CMTPSETDEVICEPROPVALUE_CMTPSETDEVICEPROPVALUE_DES_ENTRY );
    53     delete iString;
    57     delete iString;
    54     delete iMtparray;
    58     delete iMtparray;
    55     delete iData;
    59     delete iData;
    56     __FLOG(_L8("~CMTPSetDevicePropValue - Exit"));
    60     OstTraceFunctionExit0( CMTPSETDEVICEPROPVALUE_CMTPSETDEVICEPROPVALUE_DES_EXIT );
    57     __FLOG_CLOSE;
       
    58     }
    61     }
    59 
    62 
    60 /**
    63 /**
    61 Standard c++ constructor
    64 Standard c++ constructor
    62 */    
    65 */    
    69 /**
    72 /**
    70 Second-phase construction
    73 Second-phase construction
    71 */    
    74 */    
    72 void CMTPSetDevicePropValue::ConstructL()
    75 void CMTPSetDevicePropValue::ConstructL()
    73     {
    76     {
    74     __FLOG_OPEN(KMTPSubsystem, KComponent);
    77     OstTraceFunctionEntry0( CMTPSETDEVICEPROPVALUE_CONSTRUCTL_ENTRY );
    75     __FLOG(_L8("ConstructL - Entry")); 
       
    76     CMTPGetDevicePropDesc::ConstructL();
    78     CMTPGetDevicePropDesc::ConstructL();
    77     iString = CMTPTypeString::NewL();
    79     iString = CMTPTypeString::NewL();
    78     iMtparray = CMTPTypeArray::NewL(EMTPTypeAUINT8);
    80     iMtparray = CMTPTypeArray::NewL(EMTPTypeAUINT8);
    79     iData = new(ELeave) TMTPTypeGuid();
    81     iData = new(ELeave) TMTPTypeGuid();
    80     __FLOG(_L8("ConstructL - Exit")); 
    82     OstTraceFunctionExit0( CMTPSETDEVICEPROPVALUE_CONSTRUCTL_EXIT );
    81     }
    83     }
    82 
    84 
    83 /**
    85 /**
    84 Service Battery level property
    86 Service Battery level property
    85 */    
    87 */    
    86 void CMTPSetDevicePropValue::ServiceBatteryLevelL()
    88 void CMTPSetDevicePropValue::ServiceBatteryLevelL()
    87     {
    89     {
    88     __FLOG(_L8("ServiceBatteryLevelL - Entry"));
    90     OstTraceFunctionEntry0( CMTPSETDEVICEPROPVALUE_SERVICEBATTERYLEVELL_ENTRY );
    89     SendResponseL(EMTPRespCodeAccessDenied); 
    91     SendResponseL(EMTPRespCodeAccessDenied); 
    90     __FLOG(_L8("ServiceBatteryLevelL - Exit"));   
    92     OstTraceFunctionExit0( CMTPSETDEVICEPROPVALUE_SERVICEBATTERYLEVELL_EXIT );
    91     }
    93     }
    92 
    94 
    93 /**
    95 /**
    94 Service the device friendly name property.
    96 Service the device friendly name property.
    95 */   
    97 */   
    96 void CMTPSetDevicePropValue::ServiceDeviceFriendlyNameL()
    98 void CMTPSetDevicePropValue::ServiceDeviceFriendlyNameL()
    97     {
    99     {
    98     __FLOG(_L8("ServiceDeviceFriendlyNameL - Entry"));
   100     OstTraceFunctionEntry0( CMTPSETDEVICEPROPVALUE_SERVICEDEVICEFRIENDLYNAMEL_ENTRY );
    99     iString->SetL(KNullDesC);
   101     iString->SetL(KNullDesC);
   100     ReceiveDataL(*iString); 
   102     ReceiveDataL(*iString); 
   101     __FLOG(_L8("ServiceDeviceFriendlyNameL - Exit"));    
   103     OstTraceFunctionExit0( CMTPSETDEVICEPROPVALUE_SERVICEDEVICEFRIENDLYNAMEL_EXIT );
   102     }
   104     }
   103         
   105         
   104 /**
   106 /**
   105 Service the synchronisation partner property.
   107 Service the synchronisation partner property.
   106 */ 
   108 */ 
   107 void CMTPSetDevicePropValue::ServiceSynchronisationPartnerL()
   109 void CMTPSetDevicePropValue::ServiceSynchronisationPartnerL()
   108     {    
   110     {    
   109     __FLOG(_L8("ServiceSynchronisationPartnerL - Entry")); 
   111     OstTraceFunctionEntry0( CMTPSETDEVICEPROPVALUE_SERVICESYNCHRONISATIONPARTNERL_ENTRY );
   110     iString->SetL(KNullDesC);
   112     iString->SetL(KNullDesC);
   111     ReceiveDataL(*iString);
   113     ReceiveDataL(*iString);
   112     __FLOG(_L8("ServiceSynchronisationPartnerL - Exit"));
   114     OstTraceFunctionExit0( CMTPSETDEVICEPROPVALUE_SERVICESYNCHRONISATIONPARTNERL_EXIT );
   113     }
   115     }
   114     
   116     
   115 /**
   117 /**
   116 SetDevicePropValue request validator.
   118 SetDevicePropValue request validator.
   117 @return EMTPRespCodeOK if request is verified, otherwise one of the error response codes
   119 @return EMTPRespCodeOK if request is verified, otherwise one of the error response codes
   118 */
   120 */
   119 TMTPResponseCode CMTPSetDevicePropValue::CheckRequestL()
   121 TMTPResponseCode CMTPSetDevicePropValue::CheckRequestL()
   120 	{
   122 	{
   121 	__FLOG(_L8("CheckRequestL - Entry")); 
   123 	OstTraceFunctionEntry0( CMTPSETDEVICEPROPVALUE_CHECKREQUESTL_ENTRY );
   122 	TMTPResponseCode responseCode = CMTPGetDevicePropDesc::CheckRequestL();
   124 	TMTPResponseCode responseCode = CMTPGetDevicePropDesc::CheckRequestL();
   123 	
   125 	
   124 	TUint32 propCode = Request().Uint32(TMTPTypeRequest::ERequestParameter1);
   126 	TUint32 propCode = Request().Uint32(TMTPTypeRequest::ERequestParameter1);
   125 	if( propCode == EMTPDevicePropCodeBatteryLevel)
   127 	if( propCode == EMTPDevicePropCodeBatteryLevel)
   126 		{
   128 		{
   127 		responseCode = EMTPRespCodeAccessDenied;
   129 		responseCode = EMTPRespCodeAccessDenied;
   128 		}
   130 		}
   129 	__FLOG(_L8("CheckRequestL - Exit")); 
   131 	OstTraceFunctionExit0( CMTPSETDEVICEPROPVALUE_CHECKREQUESTL_EXIT );
   130 	return responseCode;
   132 	return responseCode;
   131 	}
   133 	}
   132 
   134 
   133 /**
   135 /**
   134 Process the transaction response phase.
   136 Process the transaction response phase.
   135 */    
   137 */    
   136 TBool CMTPSetDevicePropValue::DoHandleResponsePhaseL()
   138 TBool CMTPSetDevicePropValue::DoHandleResponsePhaseL()
   137     {
   139     {
   138     __FLOG(_L8("DoHandleResponsePhaseL - Entry"));
   140     OstTraceFunctionEntry0( CMTPSETDEVICEPROPVALUE_DOHANDLERESPONSEPHASEL_ENTRY );
   139     MExtnDevicePropDp* extnDevplugin = iDpSingletons.DeviceDataStore().ExtnDevicePropDp();
   141     MExtnDevicePropDp* extnDevplugin = iDpSingletons.DeviceDataStore().ExtnDevicePropDp();
   140     TUint32 propCode(Request().Uint32(TMTPTypeRequest::ERequestParameter1));
   142     TUint32 propCode(Request().Uint32(TMTPTypeRequest::ERequestParameter1));
   141     switch(propCode)
   143     switch(propCode)
   142         {
   144         {
   143     case EMTPDevicePropCodeSynchronizationPartner:
   145     case EMTPDevicePropCodeSynchronizationPartner:
   183 		{
   185 		{
   184 		SendResponseL(EMTPRespCodeDevicePropNotSupported); 
   186 		SendResponseL(EMTPRespCodeDevicePropNotSupported); 
   185 		}
   187 		}
   186         break;             
   188         break;             
   187         }
   189         }
   188     __FLOG(_L8("DoHandleResponsePhaseL - Exit"));
   190     OstTraceFunctionExit0( CMTPSETDEVICEPROPVALUE_DOHANDLERESPONSEPHASEL_EXIT );
   189     return EFalse;    
   191     return EFalse;    
   190     }
   192     }
   191     
   193     
   192 TBool CMTPSetDevicePropValue::HasDataphase() const
   194 TBool CMTPSetDevicePropValue::HasDataphase() const
   193 	{
   195 	{
   197 /**
   199 /**
   198 Processes the device friendly name property transaction response phase.
   200 Processes the device friendly name property transaction response phase.
   199 */
   201 */
   200 void CMTPSetDevicePropValue::CompleteServiceDeviceFriendlyNameL()
   202 void CMTPSetDevicePropValue::CompleteServiceDeviceFriendlyNameL()
   201     {
   203     {
   202     __FLOG(_L8("CompleteServiceDeviceFriendlyNameL - Entry"));
   204     OstTraceFunctionEntry0( CMTPSETDEVICEPROPVALUE_COMPLETESERVICEDEVICEFRIENDLYNAMEL_ENTRY );
   203     iDpSingletons.DeviceDataStore().SetDeviceFriendlyNameL(iString->StringChars());
   205     iDpSingletons.DeviceDataStore().SetDeviceFriendlyNameL(iString->StringChars());
   204     SendResponseL(EMTPRespCodeOK);  
   206     SendResponseL(EMTPRespCodeOK);  
   205     __FLOG(_L8("CompleteServiceDeviceFriendlyNameL - Exit"));  
   207     OstTraceFunctionExit0( CMTPSETDEVICEPROPVALUE_COMPLETESERVICEDEVICEFRIENDLYNAMEL_EXIT );
   206     }
   208     }
   207 
   209 
   208 /**
   210 /**
   209 Processes the synchronisation partner property transaction response phase.
   211 Processes the synchronisation partner property transaction response phase.
   210 */
   212 */
   211 void CMTPSetDevicePropValue::CompleteServiceSynchronisationPartnerL()
   213 void CMTPSetDevicePropValue::CompleteServiceSynchronisationPartnerL()
   212     {
   214     {
   213     __FLOG(_L8("CompleteServiceSynchronisationPartnerL - Entry"));
   215     OstTraceFunctionEntry0( CMTPSETDEVICEPROPVALUE_COMPLETESERVICESYNCHRONISATIONPARTNERL_ENTRY );
   214     iDpSingletons.DeviceDataStore().SetSynchronisationPartnerL(iString->StringChars());
   216     iDpSingletons.DeviceDataStore().SetSynchronisationPartnerL(iString->StringChars());
   215     SendResponseL(EMTPRespCodeOK);
   217     SendResponseL(EMTPRespCodeOK);
   216     __FLOG(_L8("CompleteServiceSynchronisationPartnerL - Exit"));
   218     OstTraceFunctionExit0( CMTPSETDEVICEPROPVALUE_COMPLETESERVICESYNCHRONISATIONPARTNERL_EXIT );
   217     }
   219     }
   218 
   220 
   219 void CMTPSetDevicePropValue::HandleExtnServiceL(TInt aPropCode, MExtnDevicePropDp* aExtnDevplugin)
   221 void CMTPSetDevicePropValue::HandleExtnServiceL(TInt aPropCode, MExtnDevicePropDp* aExtnDevplugin)
   220 	{
   222 	{
       
   223 	OstTraceFunctionEntry0( CMTPSETDEVICEPROPVALUE_HANDLEEXTNSERVICEL_ENTRY );
   221 	MMTPType* ammtptype = NULL;
   224 	MMTPType* ammtptype = NULL;
   222 	aExtnDevplugin->GetDevicePropertyContainerL((TMTPDevicePropertyCode)aPropCode, &ammtptype);	
   225 	aExtnDevplugin->GetDevicePropertyContainerL((TMTPDevicePropertyCode)aPropCode, &ammtptype);	
   223 	if(ammtptype != NULL)
   226 	if(ammtptype != NULL)
   224 	{
   227 	{
   225 	ReceiveDataL(*ammtptype);
   228 	ReceiveDataL(*ammtptype);
   226 	}
   229 	}
   227 	else
   230 	else
   228 	{
   231 	{
   229 	SendResponseL(EMTPRespCodeDevicePropNotSupported);	
   232 	SendResponseL(EMTPRespCodeDevicePropNotSupported);	
   230 	}
   233 	}
       
   234 	OstTraceFunctionExit0( CMTPSETDEVICEPROPVALUE_HANDLEEXTNSERVICEL_EXIT );
   231 	}
   235 	}
   232  
   236  
   233 /**
   237 /**
   234 Processes the session initiator version info and set the same to session device data store.
   238 Processes the session initiator version info and set the same to session device data store.
   235 */
   239 */
   236 void CMTPSetDevicePropValue::CompleteServiceSessionInitiatorVersionInfoL()
   240 void CMTPSetDevicePropValue::CompleteServiceSessionInitiatorVersionInfoL()
   237 	{
   241 	{
   238 	__FLOG(_L8("CompleteServiceSynchronisationPartnerL - Entry"));
   242 	OstTraceFunctionEntry0( CMTPSETDEVICEPROPVALUE_COMPLETESERVICESESSIONINITIATORVERSIONINFOL_ENTRY );
   239 	RProcess process;
   243 	RProcess process;
   240 	RProperty::Set(process.SecureId(), EMTPConnStateKey, iString->StringChars());
   244 	RProperty::Set(process.SecureId(), EMTPConnStateKey, iString->StringChars());
   241 	iDpSingletons.DeviceDataStore().SetSessionInitiatorVersionInfoL(iString->StringChars());
   245 	iDpSingletons.DeviceDataStore().SetSessionInitiatorVersionInfoL(iString->StringChars());
   242 	SendResponseL(EMTPRespCodeOK);
   246 	SendResponseL(EMTPRespCodeOK);
   243 	__FLOG(_L8("CompleteServiceSynchronisationPartnerL - Exit"));
   247 	OstTraceFunctionExit0( CMTPSETDEVICEPROPVALUE_COMPLETESERVICESESSIONINITIATORVERSIONINFOL_EXIT );
   244 	}
   248 	}
   245 
   249 
   246 /**
   250 /**
   247 Service session initiator property.
   251 Service session initiator property.
   248 */ 
   252 */ 
   249 void CMTPSetDevicePropValue::ServiceSessionInitiatorVersionInfoL()
   253 void CMTPSetDevicePropValue::ServiceSessionInitiatorVersionInfoL()
   250 	{	 
   254 	{	 
   251 	__FLOG(_L8("SetSessionInitiatorVersionInfoL - Entry")); 
   255 	OstTraceFunctionEntry0( CMTPSETDEVICEPROPVALUE_SERVICESESSIONINITIATORVERSIONINFOL_ENTRY );
   252 	iString->SetL(KNullDesC);
   256 	iString->SetL(KNullDesC);
   253 	ReceiveDataL(*iString);
   257 	ReceiveDataL(*iString);
   254 	__FLOG(_L8("SetSessionInitiatorVersionInfoL - Exit"));
   258 	OstTraceFunctionExit0( CMTPSETDEVICEPROPVALUE_SERVICESESSIONINITIATORVERSIONINFOL_EXIT );
   255 	}
   259 	}
   256 
   260 
   257 
   261 
   258 /**
   262 /**
   259 This should be removed no set for percived device type.
   263 This should be removed no set for percived device type.
   260 */
   264 */
   261 void CMTPSetDevicePropValue::CompletePerceivedDeviceTypeL()
   265 void CMTPSetDevicePropValue::CompletePerceivedDeviceTypeL()
   262     {
   266     {
   263     __FLOG(_L8("CompletePerceivedDeviceType - Entry"));
   267     OstTraceFunctionEntry0( CMTPSETDEVICEPROPVALUE_COMPLETEPERCEIVEDDEVICETYPEL_ENTRY );
   264     SendResponseL(EMTPRespCodeAccessDenied);
   268     SendResponseL(EMTPRespCodeAccessDenied);
   265     __FLOG(_L8("CompletePerceivedDeviceType - Exit"));
   269     OstTraceFunctionExit0( CMTPSETDEVICEPROPVALUE_COMPLETEPERCEIVEDDEVICETYPEL_EXIT );
   266     }
   270     }
   267 
   271 
   268 /**
   272 /**
   269 *Service the PerceivedDeviceType property.
   273 *Service the PerceivedDeviceType property.
   270 *it is not set type it should be removed 
   274 *it is not set type it should be removed 
   271 **/
   275 **/
   272 void CMTPSetDevicePropValue::ServicePerceivedDeviceTypeL()
   276 void CMTPSetDevicePropValue::ServicePerceivedDeviceTypeL()
   273     {	 
   277     {	 
   274     __FLOG(_L8("ServicePerceivedDeviceType - Entry")); 	
   278     OstTraceFunctionEntry0( CMTPSETDEVICEPROPVALUE_SERVICEPERCEIVEDDEVICETYPEL_ENTRY );
   275     ReceiveDataL(iUint32);
   279     ReceiveDataL(iUint32);
   276     __FLOG(_L8("ServicePerceivedDeviceType - Exit"));
   280     OstTraceFunctionExit0( CMTPSETDEVICEPROPVALUE_SERVICEPERCEIVEDDEVICETYPEL_EXIT );
   277     }
   281     }
   278 
   282 
   279 /**
   283 /**
   280 Processes the Date Time property transaction response phase.
   284 Processes the Date Time property transaction response phase.
   281 */
   285 */
   282 void CMTPSetDevicePropValue::CompleteServiceDateTimeL()
   286 void CMTPSetDevicePropValue::CompleteServiceDateTimeL()
   283 	{
   287 	{
   284 	__FLOG(_L8("CompleteDateTime - Entry"));
   288 	OstTraceFunctionEntry0( CMTPSETDEVICEPROPVALUE_COMPLETESERVICEDATETIMEL_ENTRY );
   285 												
   289 												
   286 	//validate the incoming date time string first and then set it.
   290 	//validate the incoming date time string first and then set it.
   287 	if(KErrNone == iDpSingletons.DeviceDataStore().SetDateTimeL(iString->StringChars()) )
   291 	if(KErrNone == iDpSingletons.DeviceDataStore().SetDateTimeL(iString->StringChars()) )
   288 		{
   292 		{
   289 		SendResponseL(EMTPRespCodeOK);
   293 		SendResponseL(EMTPRespCodeOK);
   291 	else
   295 	else
   292 		{
   296 		{
   293 		SendResponseL(EMTPRespCodeInvalidDataset);
   297 		SendResponseL(EMTPRespCodeInvalidDataset);
   294 		}
   298 		}
   295 	
   299 	
   296 	__FLOG(_L8("CompleteDateTime - Exit"));
   300 	OstTraceFunctionExit0( CMTPSETDEVICEPROPVALUE_COMPLETESERVICEDATETIMEL_EXIT );
   297 	}
   301 	}
   298 
   302 
   299 /**
   303 /**
   300 Service the Date Time property. 
   304 Service the Date Time property. 
   301 */ 
   305 */ 
   302 void CMTPSetDevicePropValue::ServiceDateTimeL()
   306 void CMTPSetDevicePropValue::ServiceDateTimeL()
   303     {	 
   307     {	 
   304     __FLOG(_L8("ServiceDateTime - Entry")); 
   308     OstTraceFunctionEntry0( CMTPSETDEVICEPROPVALUE_SERVICEDATETIMEL_ENTRY );
   305     iString->SetL(KNullDesC);
   309     iString->SetL(KNullDesC);
   306     ReceiveDataL(*iString);
   310     ReceiveDataL(*iString);
   307     __FLOG(_L8("ServiceDateTime - Exit"));
   311     OstTraceFunctionExit0( CMTPSETDEVICEPROPVALUE_SERVICEDATETIMEL_EXIT );
   308     }
   312     }
   309 
   313 
   310 /*
   314 /*
   311 *Complete Service the Device Icon property and CompleteDeviceIcon.
   315 *Complete Service the Device Icon property and CompleteDeviceIcon.
   312 As of now implemented as device property of type get.
   316 As of now implemented as device property of type get.
   313 */
   317 */
   314 void CMTPSetDevicePropValue::CompleteDeviceIconL()
   318 void CMTPSetDevicePropValue::CompleteDeviceIconL()
   315     {   	
   319     {   	
   316     __FLOG(_L8("CompleteDeviceIcon - Entry"));
   320     OstTraceFunctionEntry0( CMTPSETDEVICEPROPVALUE_COMPLETEDEVICEICONL_ENTRY );
   317     //it is Get only device property
   321     //it is Get only device property
   318     SendResponseL(EMTPRespCodeAccessDenied);
   322     SendResponseL(EMTPRespCodeAccessDenied);
   319     __FLOG(_L8("CompleteDeviceIcon - Exit"));
   323     OstTraceFunctionExit0( CMTPSETDEVICEPROPVALUE_COMPLETEDEVICEICONL_EXIT );
   320     }
   324     }
   321 
   325 
   322 /*
   326 /*
   323 *Service the Device Icon property and CompleteDeviceIcon.
   327 *Service the Device Icon property and CompleteDeviceIcon.
   324 As of now implemented as device property of type get.
   328 As of now implemented as device property of type get.
   325 */   
   329 */   
   326 void CMTPSetDevicePropValue::ServiceDeviceIconL()
   330 void CMTPSetDevicePropValue::ServiceDeviceIconL()
   327     {    
   331     {    
   328     __FLOG(_L8("ServiceDeviceIcon - Entry")); 	
   332     OstTraceFunctionEntry0( CMTPSETDEVICEPROPVALUE_SERVICEDEVICEICONL_ENTRY );
   329     //no need to recive this data beacuse it is Get property
   333     //no need to recive this data beacuse it is Get property
   330     ReceiveDataL(*iMtparray);
   334     ReceiveDataL(*iMtparray);
   331     __FLOG(_L8("ServiceDeviceIcon - Exit"));
   335     OstTraceFunctionExit0( CMTPSETDEVICEPROPVALUE_SERVICEDEVICEICONL_EXIT );
   332     }
   336     }
   333        
   337        
   334 
   338 
   335 /*
   339 /*
   336 *Processes the PerceivedDeviceType property transaction response phase.
   340 *Processes the PerceivedDeviceType property transaction response phase.
   337 */
   341 */
   338 void CMTPSetDevicePropValue::CompleteServiceSupportedFormatsOrderedL()
   342 void CMTPSetDevicePropValue::CompleteServiceSupportedFormatsOrderedL()
   339     {
   343     {
   340     __FLOG(_L8("CompleteServiceSupportedFormatsOrdered - Entry"));
   344     OstTraceFunctionEntry0( CMTPSETDEVICEPROPVALUE_COMPLETESERVICESUPPORTEDFORMATSORDEREDL_ENTRY );
   341     //it is Get only device property
   345     //it is Get only device property
   342     SendResponseL(EMTPRespCodeAccessDenied);
   346     SendResponseL(EMTPRespCodeAccessDenied);
   343     __FLOG(_L8("CompleteServiceSupportedFormatsOrdered - Exit"));
   347     OstTraceFunctionExit0( CMTPSETDEVICEPROPVALUE_COMPLETESERVICESUPPORTEDFORMATSORDEREDL_EXIT );
   344     }
   348     }
   345 
   349 
   346 /*
   350 /*
   347 *ServiceSupportedFormatsOrdered property. it is get only type.
   351 *ServiceSupportedFormatsOrdered property. it is get only type.
   348 */
   352 */
   349 void CMTPSetDevicePropValue::ServiceSupportedFormatsOrderedL()
   353 void CMTPSetDevicePropValue::ServiceSupportedFormatsOrderedL()
   350     {	 
   354     {	 
   351     __FLOG(_L8("ServiceSupportedFormatsOrdered - Entry")); 	
   355     OstTraceFunctionEntry0( CMTPSETDEVICEPROPVALUE_SERVICESUPPORTEDFORMATSORDEREDL_ENTRY );
   352     //no need to recive this data beacuse it is Get property
   356     //no need to recive this data beacuse it is Get property
   353     ReceiveDataL(iUint8);
   357     ReceiveDataL(iUint8);
   354     __FLOG(_L8("ServicePerceivedDeviceType - Exit"));
   358     OstTraceFunctionExit0( CMTPSETDEVICEPROPVALUE_SERVICESUPPORTEDFORMATSORDEREDL_EXIT );
   355     }
   359     }
   356 
   360 
   357 /*
   361 /*
   358 *Processes the FunctionalID property transaction response phase.
   362 *Processes the FunctionalID property transaction response phase.
   359 */
   363 */
   360 void CMTPSetDevicePropValue::CompleteServiceFunctionalIDL()
   364 void CMTPSetDevicePropValue::CompleteServiceFunctionalIDL()
   361     {
   365     {
   362     __FLOG(_L8("CompleteServiceFunctionalIDL - Entry"));
   366     OstTraceFunctionEntry0( CMTPSETDEVICEPROPVALUE_COMPLETESERVICEFUNCTIONALIDL_ENTRY );
   363 
   367 
   364     TPtrC8 ptr(NULL,0);
   368     TPtrC8 ptr(NULL,0);
   365     if ( KMTPChunkSequenceCompletion == iData->FirstReadChunk(ptr) )
   369     if ( KMTPChunkSequenceCompletion == iData->FirstReadChunk(ptr) )
   366    		{
   370    		{
   367    		SaveGUID( MMTPFrameworkConfig::EDeviceCurrentFuncationalID, *iData );
   371    		SaveGUID( MMTPFrameworkConfig::EDeviceCurrentFuncationalID, *iData );
   368    		SendResponseL(EMTPRespCodeOK);
   372    		SendResponseL(EMTPRespCodeOK);
   369     	}
   373     	}
   370     
   374     
   371     __FLOG(_L8("CompleteServiceFunctionalIDL - Exit"));
   375     OstTraceFunctionExit0( CMTPSETDEVICEPROPVALUE_COMPLETESERVICEFUNCTIONALIDL_EXIT );
   372     }
   376     }
   373 
   377 
   374 /*
   378 /*
   375 *FunctionalID property. 
   379 *FunctionalID property. 
   376 */
   380 */
   377 void CMTPSetDevicePropValue::ServiceFunctionalIDL()
   381 void CMTPSetDevicePropValue::ServiceFunctionalIDL()
   378     {	 
   382     {	 
   379     __FLOG(_L8("ServiceFunctionalIDL - Entry")); 	
   383     OstTraceFunctionEntry0( CMTPSETDEVICEPROPVALUE_SERVICEFUNCTIONALIDL_ENTRY );
   380     ReceiveDataL(*iData);
   384     ReceiveDataL(*iData);
   381     __FLOG(_L8("ServiceFunctionalIDL - Exit"));
   385     OstTraceFunctionExit0( CMTPSETDEVICEPROPVALUE_SERVICEFUNCTIONALIDL_EXIT );
   382     }
   386     }
   383 
   387 
   384 /*
   388 /*
   385 *Processes the ModelID property transaction response phase.
   389 *Processes the ModelID property transaction response phase.
   386 */
   390 */
   387 void CMTPSetDevicePropValue::CompleteServiceModelIDL()
   391 void CMTPSetDevicePropValue::CompleteServiceModelIDL()
   388     {
   392     {
   389     __FLOG(_L8("CompleteServiceModelIDL - Entry"));
   393     OstTraceFunctionEntry0( CMTPSETDEVICEPROPVALUE_COMPLETESERVICEMODELIDL_ENTRY );
   390     SendResponseL(EMTPRespCodeAccessDenied);
   394     SendResponseL(EMTPRespCodeAccessDenied);
   391     __FLOG(_L8("CompleteServiceModelIDL - Exit"));
   395     OstTraceFunctionExit0( CMTPSETDEVICEPROPVALUE_COMPLETESERVICEMODELIDL_EXIT );
   392     }
   396     }
   393 
   397 
   394 /*
   398 /*
   395 *ModelID property. 
   399 *ModelID property. 
   396 */
   400 */
   397 void CMTPSetDevicePropValue::ServiceModelIDL()
   401 void CMTPSetDevicePropValue::ServiceModelIDL()
   398     {	 
   402     {	 
   399     __FLOG(_L8("ServiceModelIDL - Entry")); 	
   403     OstTraceFunctionEntry0( CMTPSETDEVICEPROPVALUE_SERVICEMODELIDL_ENTRY );	
   400     ReceiveDataL(*iData);
   404     ReceiveDataL(*iData);
   401     __FLOG(_L8("ServiceModelIDL - Exit"));
   405     OstTraceFunctionExit0( CMTPSETDEVICEPROPVALUE_SERVICEMODELIDL_EXIT );
   402     }
   406     }
   403 
   407 
   404 /*
   408 /*
   405 *Processes the UseDeviceStage property transaction response phase.
   409 *Processes the UseDeviceStage property transaction response phase.
   406 */
   410 */
   407 void CMTPSetDevicePropValue::CompleteServiceUseDeviceStageL()
   411 void CMTPSetDevicePropValue::CompleteServiceUseDeviceStageL()
   408     {
   412     {
   409     __FLOG(_L8("CompleteServiceUseDeviceStageL - Entry"));
   413     OstTraceFunctionEntry0( CMTPSETDEVICEPROPVALUE_COMPLETESERVICEUSEDEVICESTAGEL_ENTRY );
   410     SendResponseL(EMTPRespCodeAccessDenied);
   414     SendResponseL(EMTPRespCodeAccessDenied);
   411     __FLOG(_L8("CompleteServiceUseDeviceStageL - Exit"));
   415     OstTraceFunctionExit0( CMTPSETDEVICEPROPVALUE_COMPLETESERVICEUSEDEVICESTAGEL_EXIT );
   412     }
   416     }
   413 
   417 
   414 /*
   418 /*
   415 *UseDeviceStage property. 
   419 *UseDeviceStage property. 
   416 */
   420 */
   417 void CMTPSetDevicePropValue::ServiceUseDeviceStageL()
   421 void CMTPSetDevicePropValue::ServiceUseDeviceStageL()
   418     {	 
   422     {	 
   419     __FLOG(_L8("ServiceUseDeviceStageL - Entry")); 	
   423     OstTraceFunctionEntry0( CMTPSETDEVICEPROPVALUE_SERVICEUSEDEVICESTAGEL_ENTRY );
   420     ReceiveDataL(iUint8);
   424     ReceiveDataL(iUint8);
   421     __FLOG(_L8("ServiceUseDeviceStageL - Exit"));
   425     OstTraceFunctionExit0( CMTPSETDEVICEPROPVALUE_SERVICEUSEDEVICESTAGEL_EXIT );
   422     }
   426     }