diff -r 000000000000 -r d0791faffa3f mtpfws/mtpfw/dataproviders/devdp/src/cmtpgetdevicepropdesc.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/mtpfws/mtpfw/dataproviders/devdp/src/cmtpgetdevicepropdesc.cpp	Tue Feb 02 01:11:40 2010 +0200
@@ -0,0 +1,491 @@
+// 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:
+//
+
+/**
+ @file
+ @internalComponent
+*/
+
+#include <mtp/cmtptypedevicepropdesc.h>
+#include <mtp/mmtpdataproviderframework.h>
+#include <mtp/mtpdatatypeconstants.h>
+#include <mtp/mtpprotocolconstants.h>
+#include <mtp/tmtptyperequest.h>
+#include <mtp/mmtpframeworkconfig.h>
+#include <centralrepository.h>
+
+#include "cmtpdevicedatastore.h"
+#include "cmtpgetdevicepropdesc.h"
+#include "mtpdevicedpconst.h"
+#include "mtpdevdppanic.h"
+#include "cmtpdevicedpconfigmgr.h"
+
+// Class constants.
+__FLOG_STMT(_LIT8(KComponent,"GetDevicePropDesc");)
+
+/**
+Two-phase constructor.
+@param aPlugin The data provider plugin
+@param aFramework The data provider framework
+@param aConnection The connection from which the request comes
+@return a pointer to the created request processor object
+*/  
+MMTPRequestProcessor* CMTPGetDevicePropDesc::NewL(MMTPDataProviderFramework& aFramework, MMTPConnection& aConnection)
+    {
+    CMTPGetDevicePropDesc* self = new (ELeave) CMTPGetDevicePropDesc(aFramework, aConnection);
+    CleanupStack::PushL(self);
+    self->ConstructL();
+    CleanupStack::Pop(self);
+    return self;
+    }
+
+/**
+Destructor.
+*/    
+CMTPGetDevicePropDesc::~CMTPGetDevicePropDesc()
+    {    
+    __FLOG(_L8("~CMTPGetDevicePropDesc - Entry"));
+    delete iData;
+    delete iPropDesc;
+    delete iRepository;
+    iDpSingletons.Close();
+    __FLOG(_L8("~CMTPGetDevicePropDesc - Exit"));
+    __FLOG_CLOSE;
+    }
+
+/**
+Constructor.
+*/    
+CMTPGetDevicePropDesc::CMTPGetDevicePropDesc(MMTPDataProviderFramework& aFramework, MMTPConnection& aConnection) :
+    CMTPRequestProcessor(aFramework, aConnection, 0, NULL)
+    {    
+    }
+    
+/**
+GetDevicePropDesc request validator.
+@return EMTPRespCodeOK if request is verified, otherwise one of the error response codes
+*/
+TMTPResponseCode CMTPGetDevicePropDesc::CheckRequestL()
+    {
+    __FLOG(_L8("CheckRequestL - Entry"));
+    TMTPResponseCode respCode(EMTPRespCodeDevicePropNotSupported);
+    iPropCode = Request().Uint32(TMTPTypeRequest::ERequestParameter1);
+    const TInt count = sizeof(KMTPDeviceDpSupportedProperties) / sizeof(KMTPDeviceDpSupportedProperties[0]);
+    for (TUint i(0); ((respCode != EMTPRespCodeOK) && (i < count)); i++)
+        {
+        if (iPropCode == KMTPDeviceDpSupportedProperties[i])
+            {
+            respCode = EMTPRespCodeOK;
+            }
+        }
+    if((respCode != EMTPRespCodeOK) && iDpSingletons.DeviceDataStore().ExtnDevicePropDp())//2113 
+        {
+        respCode = EMTPRespCodeOK;
+        }
+    __FLOG(_L8("CheckRequestL - Exit"));
+    return respCode;
+    }
+
+/**
+GetDevicePropDesc request handler.
+*/    
+void CMTPGetDevicePropDesc::ServiceL()
+    {
+    __FLOG(_L8("ServiceL - Entry"));    
+    iPropCode = Request().Uint32(TMTPTypeRequest::ERequestParameter1);
+    //before performing any operation will check the properties are supported or 
+    //not if not then return EMTPRespCodeDevicePropNotSupported
+    const CMTPTypeArray *mtpArray = &(iDpSingletons.DeviceDataStore().GetSupportedDeviceProperties());
+    RArray <TUint> supportedArray;	    
+    mtpArray->Array(supportedArray);
+    __FLOG_VA((_L8("No of elements in supported property array = %d "), supportedArray.Count()));	
+    if(KErrNotFound == supportedArray.Find(iPropCode))
+        {
+        SendResponseL(EMTPRespCodeDevicePropNotSupported);       
+        __FLOG(_L8("CMTPGetDevicePropDesc::EMTPRespCodeDevicePropNotSupported "));	  
+        }
+    else
+        {
+        switch (iPropCode)
+            {
+            case EMTPDevicePropCodeBatteryLevel:
+            if (iDpSingletons.DeviceDataStore().RequestPending())
+                {
+                // BatteryLevel already pending - return busy code
+                SendResponseL(EMTPRespCodeDeviceBusy);
+                }
+            else
+                {
+                iDpSingletons.DeviceDataStore().BatteryLevelL(iStatus, iBatteryLevelValue);
+                SetActive();	
+                }
+            break;
+            
+            case EMTPDevicePropCodeSynchronizationPartner:
+                ServiceSynchronisationPartnerL();
+            break;
+            
+            case EMTPDevicePropCodeDeviceFriendlyName:
+                ServiceDeviceFriendlyNameL();
+            break;
+            
+            case EMTPDevicePropCodeSessionInitiatorVersionInfo:
+                ServiceSessionInitiatorVersionInfoL();
+            break;
+            
+            case EMTPDevicePropCodePerceivedDeviceType:
+                ServicePerceivedDeviceTypeL();
+            break;
+            
+            case EMTPDevicePropCodeDateTime:
+                ServiceDateTimeL();
+            break;
+            
+            case EMTPDevicePropCodeDeviceIcon:
+                ServiceDeviceIconL();
+            break;
+
+            case EMTPDevicePropCodeSupportedFormatsOrdered:
+            ServiceSupportedFormatsOrderedL();
+            break;
+            
+            case EMTPDevicePropCodeFunctionalID:
+            	ServiceFunctionalIDL();
+            break;
+            case EMTPDevicePropCodeModelID:
+            	ServiceModelIDL();
+            break;
+            case EMTPDevicePropCodeUseDeviceStage:
+            	ServiceUseDeviceStageL();
+            break;
+ 
+            default:
+            if(iDpSingletons.DeviceDataStore().ExtnDevicePropDp())
+                {
+                HandleExtnServiceL(iPropCode, iDpSingletons.DeviceDataStore().ExtnDevicePropDp());
+                }
+            else 
+                SendResponseL(EMTPRespCodeDevicePropNotSupported); 
+            break;
+            }
+        }
+    supportedArray.Close();
+    __FLOG(_L8("ServiceL - Exit"));
+    }
+    
+    
+void  CMTPGetDevicePropDesc::HandleExtnServiceL(TInt aPropCode, MExtnDevicePropDp* aExtnDevplugin )
+	{
+	//call	 plugin ->desc
+	MMTPType* mtptype;
+	if(KErrNone == aExtnDevplugin->GetDevPropertyDescL((TMTPDevicePropertyCode)aPropCode, &mtptype))
+	{
+	SendDataL(*mtptype);	
+	}
+	else
+	{
+	SendResponseL(EMTPRespCodeDevicePropNotSupported); 	
+	}
+
+	
+	}
+void CMTPGetDevicePropDesc::DoCancel()
+    {
+    __FLOG(_L8("DoCancel - Entry"));
+    if (iPropCode == EMTPDevicePropCodeBatteryLevel)
+        {
+        iDpSingletons.DeviceDataStore().Cancel();
+        }
+    __FLOG(_L8("DoCancel - Exit"));
+    }
+    
+void CMTPGetDevicePropDesc::RunL()
+    {
+    __FLOG(_L8("RunL - Entry"));
+    if (iPropCode == EMTPDevicePropCodeBatteryLevel)
+        {
+        ServiceBatteryLevelL();
+        }
+    else
+        {
+        __DEBUG_ONLY(Panic(EMTPDevDpUnknownDeviceProperty));
+        }
+    __FLOG(_L8("RunL - Exit"));
+    }
+
+/**
+Second-phase constructor.
+*/        
+void CMTPGetDevicePropDesc::ConstructL()
+    {
+    __FLOG_OPEN(KMTPSubsystem, KComponent);
+    __FLOG(_L8("CMTPGetDevicePropDesc: ConstructL - Entry")); 
+    iDpSingletons.OpenL(iFramework);
+	const TUint32 KUidMTPRepositoryValue(0x10282FCC);
+    const TUid KUidMTPRepository = {KUidMTPRepositoryValue};
+    iRepository = CRepository::NewL(KUidMTPRepository);
+    __FLOG(_L8("CMTPGetDevicePropDesc: ConstructL - Exit")); 
+    }
+
+/**
+Services the battery level property.
+*/        
+void CMTPGetDevicePropDesc::ServiceBatteryLevelL()
+    {
+    __FLOG(_L8("ServiceBatteryLevelL - Entry")); 
+    CMTPTypeDevicePropDescRangeForm* form = CMTPTypeDevicePropDescRangeForm::NewLC(EMTPTypeUINT8);
+    form->SetUint8L(CMTPTypeDevicePropDescRangeForm::EMinimumValue, 0);
+    form->SetUint8L(CMTPTypeDevicePropDescRangeForm::EMaximumValue, 100);
+    form->SetUint8L(CMTPTypeDevicePropDescRangeForm::EStepSize, 10);
+    
+    delete iPropDesc;
+    iPropDesc = NULL;
+    iPropDesc = CMTPTypeDevicePropDesc::NewL(EMTPDevicePropCodeBatteryLevel, *form);
+    iPropDesc->SetUint8L(CMTPTypeDevicePropDesc::EFactoryDefaultValue, 0);    
+    iPropDesc->SetUint8L(CMTPTypeDevicePropDesc::ECurrentValue, iBatteryLevelValue);
+    CleanupStack::PopAndDestroy(form);
+
+    SendDataL(*iPropDesc);
+    __FLOG(_L8("ServiceBatteryLevelL - Exit")); 
+    }
+
+/**
+Services the device friendly name property.
+*/    
+void CMTPGetDevicePropDesc::ServiceDeviceFriendlyNameL()
+    {
+    __FLOG(_L8("ServiceDeviceFriendlyNameL - Entry"));
+    delete iPropDesc;
+    iPropDesc = NULL;
+    iPropDesc = CMTPTypeDevicePropDesc::NewL(EMTPDevicePropCodeDeviceFriendlyName);
+    
+    CMTPDeviceDataStore& device(iDpSingletons.DeviceDataStore());
+    iPropDesc->SetStringL(CMTPTypeDevicePropDesc::EFactoryDefaultValue, device.DeviceFriendlyNameDefault());
+    iPropDesc->SetStringL(CMTPTypeDevicePropDesc::ECurrentValue, device.DeviceFriendlyName());
+    
+    SendDataL(*iPropDesc);    
+    __FLOG(_L8("ServiceDeviceFriendlyNameL - Exit")); 
+    }
+        
+/**
+Services the synchronisation partner property.
+*/    
+void CMTPGetDevicePropDesc::ServiceSynchronisationPartnerL()
+    {
+    __FLOG(_L8("ServiceSynchronisationPartnerL - Entry")); 
+    delete iPropDesc;
+    iPropDesc = NULL;
+    iPropDesc = CMTPTypeDevicePropDesc::NewL(EMTPDevicePropCodeSynchronizationPartner);
+    
+    CMTPDeviceDataStore& device(iDpSingletons.DeviceDataStore());
+    iPropDesc->SetStringL(CMTPTypeDevicePropDesc::EFactoryDefaultValue, device.SynchronisationPartnerDefault());
+    iPropDesc->SetStringL(CMTPTypeDevicePropDesc::ECurrentValue, device.SynchronisationPartner());
+    
+    SendDataL(*iPropDesc); 
+    __FLOG(_L8("ServiceSynchronisationPartnerL - Exit")); 
+    }
+
+/**
+*Services the synchronisation partner property. 
+*/    
+void CMTPGetDevicePropDesc::ServiceSessionInitiatorVersionInfoL()
+    {
+    __FLOG(_L8("ServiceSessionInitiatorVersionInfoL - Entry")); 
+    delete iPropDesc;
+    iPropDesc = NULL;
+    // this property is of type set or get 
+    iPropDesc = CMTPTypeDevicePropDesc::NewL(EMTPDevicePropCodeSessionInitiatorVersionInfo, 0x01/*set/get*/, 0x00, NULL);   
+    CMTPDeviceDataStore& device(iDpSingletons.DeviceDataStore());   
+    iPropDesc->SetStringL(CMTPTypeDevicePropDesc::EFactoryDefaultValue, device.SessionInitiatorVersionInfoDefault());
+    iPropDesc->SetStringL(CMTPTypeDevicePropDesc::ECurrentValue, device.SessionInitiatorVersionInfo());
+    SendDataL(*iPropDesc); 
+    __FLOG(_L8("ServiceSessionInitiatorVersionInfoL - Exit")); 
+    }
+
+/**
+*Services the Service Perceived Device Type. 
+*/    
+void CMTPGetDevicePropDesc::ServicePerceivedDeviceTypeL()
+    {
+    __FLOG(_L8("ServicePerceivedDeviceType - Entry")); 
+    delete iPropDesc;
+    iPropDesc = NULL;
+    iPropDesc = CMTPTypeDevicePropDesc::NewL(EMTPDevicePropCodePerceivedDeviceType, 0x00/*get only*/, 0x00, NULL);
+    CMTPDeviceDataStore& device(iDpSingletons.DeviceDataStore());    
+    iPropDesc->SetUint32L(CMTPTypeDevicePropDesc::EFactoryDefaultValue, device.PerceivedDeviceTypeDefault());
+    iPropDesc->SetUint32L(CMTPTypeDevicePropDesc::ECurrentValue, device.PerceivedDeviceType());
+    SendDataL(*iPropDesc); 
+    __FLOG(_L8("ServicePerceivedDeviceType - Exit")); 
+    }
+
+/**
+Services the Date Time property. 
+*/    
+void CMTPGetDevicePropDesc::ServiceDateTimeL()
+    {
+    __FLOG(_L8("ServicePerceivedDeviceType - Entry")); 
+    delete iPropDesc;
+    iPropDesc = NULL;
+    iPropDesc = CMTPTypeDevicePropDesc::NewL(EMTPDevicePropCodeDateTime, 0x01/*get/set*/, 0x00, NULL);
+    CMTPDeviceDataStore& device(iDpSingletons.DeviceDataStore());    
+    iPropDesc->SetStringL(CMTPTypeDevicePropDesc::EFactoryDefaultValue, device.DateTimeL());
+    iPropDesc->SetStringL(CMTPTypeDevicePropDesc::ECurrentValue, device.DateTimeL());
+    SendDataL(*iPropDesc); 
+    __FLOG(_L8("ServicePerceivedDeviceType - Exit")); 
+    }
+
+/**
+Services the Date Time property. 
+*/	  
+void CMTPGetDevicePropDesc::ServiceDeviceIconL()
+    {
+    __FLOG(_L8("ServiceDeviceIcon - Entry")); 
+    delete iPropDesc;
+    iPropDesc = NULL;
+    iPropDesc = CMTPTypeDevicePropDesc::NewL(EMTPDevicePropCodeDeviceIcon, 0x00, 0x00, NULL);
+    CMTPDeviceDataStore& device(iDpSingletons.DeviceDataStore());	 
+    //need to think of which one to be used for default.
+    iPropDesc->SetL(CMTPTypeDevicePropDesc::EFactoryDefaultValue, device.DeviceIcon());
+    iPropDesc->SetL(CMTPTypeDevicePropDesc::ECurrentValue, device.DeviceIcon());
+    SendDataL(*iPropDesc); 
+    __FLOG(_L8("ServiceDeviceIcon- Exit"));   
+    }
+
+/*
+*Service Supported format ordered.
+*/
+void CMTPGetDevicePropDesc::ServiceSupportedFormatsOrderedL()
+    {
+    __FLOG(_L8("ServiceSupportedFormatsOrdered - Entry")); 
+    delete iPropDesc;
+    iPropDesc = NULL;
+    iPropDesc = CMTPTypeDevicePropDesc::NewL(EMTPDevicePropCodeSupportedFormatsOrdered, 0x00, 0x00, NULL);    
+    iPropDesc->SetUint8L(CMTPTypeDevicePropDesc::EFactoryDefaultValue, (TUint8)FORMAT_UNORDERED);
+    iPropDesc->SetUint8L(CMTPTypeDevicePropDesc::ECurrentValue, GetFormatOrdered());
+    SendDataL(*iPropDesc); 
+    __FLOG(_L8("ServiceSupportedFormatsOrdered - Exit")); 
+    }
+
+/*
+*Service Supported FuntionalID.
+*/
+void CMTPGetDevicePropDesc::ServiceFunctionalIDL()
+    {
+    __FLOG(_L8("ServiceFuntionalIDL - Entry")); 
+    delete iPropDesc;
+    iPropDesc = NULL;
+    iPropDesc = CMTPTypeDevicePropDesc::NewL(EMTPDevicePropCodeFunctionalID, 1, 0, NULL); 
+    
+    delete iData;
+	iData = GetGUIDL( MMTPFrameworkConfig::EDeviceDefaultFuncationalID ); 
+	iPropDesc->SetL(CMTPTypeDevicePropDesc::EFactoryDefaultValue, *iData);
+	delete iData;
+	iData = GetGUIDL(MMTPFrameworkConfig::EDeviceCurrentFuncationalID); 
+	iPropDesc->SetL(CMTPTypeDevicePropDesc::ECurrentValue, *iData);
+	
+    SendDataL(*iPropDesc); 
+    __FLOG(_L8("ServiceFuntionalIDL - Exit")); 
+    }
+
+/*
+*Service Supported ModelID.
+*/
+void CMTPGetDevicePropDesc::ServiceModelIDL()
+    {
+    __FLOG(_L8("ServiceModelIDL - Entry")); 
+    delete iPropDesc;
+    iPropDesc = NULL;
+    iPropDesc = CMTPTypeDevicePropDesc::NewL(EMTPDevicePropCodeModelID, 0, 0, NULL);   
+    
+    delete iData;
+    iData = GetGUIDL(MMTPFrameworkConfig::EDeviceDefaultModelID);  
+    iPropDesc->SetL(CMTPTypeDevicePropDesc::EFactoryDefaultValue, *iData);
+    
+    delete iData;
+    iData = GetGUIDL(MMTPFrameworkConfig::EDeviceCurrentModelID); 
+	iPropDesc->SetL(CMTPTypeDevicePropDesc::ECurrentValue, *iData);
+	
+    SendDataL(*iPropDesc); 
+    __FLOG(_L8("ServiceModelIDL - Exit")); 
+    }
+
+/*
+*Service Supported UseDeviceStage.
+*/
+void CMTPGetDevicePropDesc::ServiceUseDeviceStageL()
+    {
+    __FLOG(_L8("ServiceUseDeviceStageL - Entry")); 
+    delete iPropDesc;
+    iPropDesc = NULL;
+    iPropDesc = CMTPTypeDevicePropDesc::NewL(EMTPDevicePropCodeUseDeviceStage, 0, 0, NULL); 
+    
+    TMTPTypeUint8 *data = new (ELeave)TMTPTypeUint8(1);
+    iPropDesc->SetL(CMTPTypeDevicePropDesc::EFactoryDefaultValue, *data);
+    iPropDesc->SetL(CMTPTypeDevicePropDesc::ECurrentValue, *data);
+    
+    delete data;
+
+    SendDataL(*iPropDesc); 
+    __FLOG(_L8("ServiceUseDeviceStageL - Exit")); 
+    }
+
+/*
+*This method to set the supported format order.
+*this value will be set by getdevice info based on the formats present in the
+*mtpdevicedp_config.rss file.
+*/
+TUint8 CMTPGetDevicePropDesc::GetFormatOrdered()
+    {
+    TUint8 formatOrdered;
+    RArray<TUint> orderedFormats(8);
+    CleanupClosePushL(orderedFormats);  
+    TRAPD(error,iDpSingletons.ConfigMgr().GetRssConfigInfoArrayL(orderedFormats, EDevDpFormats));
+	if(error!=KErrNone)
+		{
+		__FLOG_VA((_L8("GetRssConfigArray returned with %d"), error));
+		}
+    if(orderedFormats.Count() > 0)
+        {
+        formatOrdered = (TUint8)FORMAT_ORDERED;
+        }
+    else
+        {
+        formatOrdered = (TUint8)FORMAT_UNORDERED; 
+        }
+    CleanupStack::PopAndDestroy(&orderedFormats);   
+    return formatOrdered;
+    }
+
+TMTPTypeGuid* CMTPGetDevicePropDesc::GetGUIDL(const TUint aKey)
+    {
+    
+    TBuf8<KMTPTypeUINT128Size> ptr;
+    
+    iRepository->Get(aKey,ptr);
+    
+    TMTPTypeGuid* ret = new (ELeave) TMTPTypeGuid( ptr );
+    
+    return ret;
+    }
+
+void CMTPGetDevicePropDesc::SaveGUID( const TUint aKey,  TMTPTypeGuid& aValue )
+    {
+    TPtrC8 ptr;
+    if ( KMTPChunkSequenceCompletion == aValue.FirstReadChunk(ptr) )
+    	{
+    	iRepository->Set(aKey,ptr);
+    	}
+    }
+