FCL/sf/mw/remoteconn: comparison mtpfws/mtpfw/dataproviders/dputility/src/cmtpsendobjectinfo.cpp

equal deleted inserted replaced

-:a5deb6b96675
+:63cf70d3ecd8
 #include "mtpdppanic.h"
 #include "cmtpfsexclusionmgr.h"
 #include "cmtpdataprovidercontroller.h"
 #include "cmtpdataprovider.h"
 #include "cmtpstoragemgr.h"
+#include "mtpdebug.h"
+#include "OstTraceDefinitions.h"
-// Class constants.
+#ifdef OST_TRACE_COMPILER_IN_USE
-__FLOG_STMT(_LIT8(KComponent,"SendObjectInfo");)
+#include "cmtpsendobjectinfoTraces.h"
+#endif
 /**
 Verification data for the SendObjectInfo request
 */
 const TMTPRequestElementInfo KMTPSendObjectInfoPolicy[] =
 /**
 Destructor
 */
 EXPORT_C CMTPSendObjectInfo::~CMTPSendObjectInfo()
 {
-__FLOG(_L8("~CMTPSendObjectInfo - Entry"));
+OstTraceFunctionEntry0( CMTPSENDOBJECTINFO_CMTPSENDOBJECTINFO_DES_ENTRY );
-__FLOG_2(_L8("iProgress:%d NoRollback:%d"),iProgress,iNoRollback);
+OstTraceExt2( TRACE_NORMAL, CMTPSENDOBJECTINFO_CMTPSENDOBJECTINFO,
+"iProgress:%d NoRollback:%d", iProgress,iNoRollback );
 if ((iProgress == EObjectInfoSucceed ||
 iProgress == EObjectInfoFail ||
 iProgress == EObjectInfoInProgress) && !iNoRollback)
 {
 // Not finished SendObjectInfo/PropList SendObject pair detected.
 delete iParentSuid;
 delete iReceivedObject;
 delete iObjectInfo;
 delete iObjectPropList;
 iSingletons.Close();
-__FLOG(_L8("~CMTPSendObjectInfo - Exit"));
+OstTraceFunctionExit0( CMTPSENDOBJECTINFO_CMTPSENDOBJECTINFO_DES_EXIT );
-__FLOG_CLOSE;
 }
 /**
 Standard c++ constructor
 @param aFramework    The data provider framework
 @param aConnection    The connection from which the request comes
 */
 CMTPSendObjectInfo::CMTPSendObjectInfo(MMTPDataProviderFramework& aFramework, MMTPConnection& aConnection) :
-CMTPRequestProcessor(aFramework, aConnection, 0, NULL)
+CMTPRequestProcessor(aFramework, aConnection, 0, NULL),
+iHiddenStatus( EMTPVisible )
 {
 }
 /**
 Verify the request
 @return EMTPRespCodeOK if request is verified, otherwise one of the error response codes
 */
 TMTPResponseCode CMTPSendObjectInfo::CheckRequestL()
 {
-__FLOG(_L8("CheckRequestL - Entry"));
+OstTraceFunctionEntry0( CMTPSENDOBJECTINFO_CHECKREQUESTL_ENTRY );
 TMTPResponseCode result = CheckSendingStateL();
 if (result != EMTPRespCodeOK)
 {
+OstTraceFunctionExit0( CMTPSENDOBJECTINFO_CHECKREQUESTL_EXIT );
 return result;
 }
 if (iProgress == EObjectNone)    //this is the SendObjectInfo phase
 {
 {
 result = EMTPRespCodeNoValidObjectInfo;
 }
 }
-__FLOG_VA((_L8("Result = 0x%04X"), result));
+OstTrace1( TRACE_NORMAL, CMTPSENDOBJECTINFO_CHECKREQUESTL, "Result = 0x%04X", result );
-__FLOG(_L8("CheckRequestL - Exit"));
+OstTraceFunctionExit0( DUP1_CMTPSENDOBJECTINFO_CHECKREQUESTL_EXIT );
 return result;
 }
 TBool CMTPSendObjectInfo::HasDataphase() const
 {
 NOTE: SendObjectInfo has to be comes before SendObject requests.  To maintain the state information
 between the two requests, the two requests are combined together in one request processor.
 */
 void CMTPSendObjectInfo::ServiceL()
 {
-__FLOG(_L8("ServiceL - Entry"));
+OstTraceFunctionEntry0( CMTPSENDOBJECTINFO_SERVICEL_ENTRY );
 if (iProgress == EObjectNone)
 {
 iIsFolder = EFalse;
 if (iOperationCode == EMTPOpCodeSendObjectInfo)
 {
 }
 else
 {
 ServiceSendObjectL();
 }
-__FLOG(_L8("ServiceL - Exit"));
+OstTraceFunctionExit0( CMTPSENDOBJECTINFO_SERVICEL_EXIT );
 }
 /**
 Second-phase construction
 */
 void CMTPSendObjectInfo::ConstructL()
 {
-__FLOG_OPEN(KMTPSubsystem, KComponent);
+OstTraceFunctionEntry0( CMTPSENDOBJECTINFO_CONSTRUCTL_ENTRY );
-__FLOG(_L8("ConstructL - Entry"));
 iExpectedSendObjectRequest.SetUint16(TMTPTypeRequest::ERequestOperationCode, EMTPOpCodeSendObject);
 iReceivedObject = CMTPObjectMetaData::NewL();
 iReceivedObject->SetUint(CMTPObjectMetaData::EDataProviderId, iFramework.DataProviderId());
 iDpSingletons.OpenL(iFramework);
 iNoRollback = EFalse;
 iSingletons.OpenL();
 _LIT(KM4A, ".m4a");
 _LIT(KODF, ".odf");
 iExceptionList.AppendL(KM4A());
 iExceptionList.AppendL(KODF());
-__FLOG(_L8("ConstructL - Exit"));
+OstTraceFunctionExit0( CMTPSENDOBJECTINFO_CONSTRUCTL_EXIT );
 }
 /**
 Override to match both the SendObjectInfo and SendObject requests
 @param aRequest    The request to match
 @param aConnection The connection from which the request comes
 @return ETrue if the processor can handle the request, otherwise EFalse
 */
 TBool CMTPSendObjectInfo::Match(const TMTPTypeRequest& aRequest, MMTPConnection& aConnection) const
 {
-__FLOG(_L8("Match - Entry"));
+OstTraceFunctionEntry0( CMTPSENDOBJECTINFO_MATCH_ENTRY );
 TBool result = EFalse;
 TUint16 operationCode = aRequest.Uint16(TMTPTypeRequest::ERequestOperationCode);
 if ((operationCode == EMTPOpCodeSendObjectInfo ||
 operationCode == EMTPOpCodeSendObject ||
 operationCode == EMTPOpCodeSendObjectPropList) &&
 &iConnection == &aConnection)
 {
 result = ETrue;
 }
-__FLOG(_L8("Match - Exit"));
+OstTraceFunctionExit0( CMTPSENDOBJECTINFO_MATCH_EXIT );
 return result;
 }
 /**
 Override to handle the response phase of SendObjectInfo and SendObject requests
 @return EFalse
 */
 TBool CMTPSendObjectInfo::DoHandleResponsePhaseL()
 {
-__FLOG(_L8("DoHandleResponsePhaseL - Entry"));
+OstTraceFunctionEntry0( CMTPSENDOBJECTINFO_DOHANDLERESPONSEPHASEL_ENTRY );
 //to check if the sending/receiving data is successful
 TBool successful = !iCancelled;
 if (iProgress == EObjectInfoInProgress)
 {
 if (iOperationCode == EMTPOpCodeSendObjectInfo)
 {
 successful = DoHandleSendObjectCompleteL();
 iProgress = (successful ? ESendObjectSucceed : ESendObjectFail);
 }
-__FLOG(_L8("DoHandleResponsePhaseL - Exit"));
+OstTraceFunctionExit0( CMTPSENDOBJECTINFO_DOHANDLERESPONSEPHASEL_EXIT );
 return EFalse;
 }
 /**
 Override to handle the completing phase of SendObjectInfo and SendObject requests
 @return ETrue if succesfully received the file, otherwise EFalse
 */
 TBool CMTPSendObjectInfo::DoHandleCompletingPhaseL()
 {
-__FLOG(_L8("DoHandleCompletingPhaseL - Entry"));
+OstTraceFunctionEntry0( CMTPSENDOBJECTINFO_DOHANDLECOMPLETINGPHASEL_ENTRY );
 TBool result = ETrue;
 CMTPRequestProcessor::DoHandleCompletingPhaseL();
 if (iProgress == EObjectInfoSucceed)
 {
 if (iOperationCode == EMTPOpCodeSendObjectInfo || iOperationCode == EMTPOpCodeSendObjectPropList)
 iPreviousTransactionID++;
 }
 iProgress = EObjectInfoSucceed;
 result = EFalse;
 }
-__FLOG_2(_L8("DoHandleCompletingPhaseL - Exit result:%d progress:%d"),result,iProgress);
+OstTraceExt2( TRACE_NORMAL, CMTPSENDOBJECTINFO_DOHANDLECOMPLETINGPHASEL,
+"Exit result:%d progress:%d",result,iProgress );
+OstTraceFunctionExit0( CMTPSENDOBJECTINFO_DOHANDLECOMPLETINGPHASEL_EXIT );
 return result;
 }
 /**
 @return EMTPRespCodeOK if SendObject request comes after a valid SendObjectInfo request, otherwise
 EMTPRespCodeNoValidObjectInfo
 */
 TMTPResponseCode CMTPSendObjectInfo::CheckSendingStateL()
 {
-__FLOG(_L8("CheckSendingState - Entry"));
+OstTraceFunctionEntry0( CMTPSENDOBJECTINFO_CHECKSENDINGSTATEL_ENTRY );
 TMTPResponseCode result = EMTPRespCodeOK;
 iOperationCode = Request().Uint16(TMTPTypeRequest::ERequestOperationCode);
 if (iOperationCode == EMTPOpCodeSendObject)
 	{
 iProgress = EObjectNone;
 }
 }
 else
 {
+OstTrace1( TRACE_ERROR, CMTPSENDOBJECTINFO_CHECKSENDINGSTATEL,
+"The progress state is not right.  Current state is %d", iProgress );
 User::Leave( KErrGeneral );
 }
-__FLOG(_L8("CheckSendingState - Exit"));
+OstTraceFunctionExit0( CMTPSENDOBJECTINFO_CHECKSENDINGSTATEL_EXIT );
 return result;
 }
 /**
 SendObjectInfo request handler
 */
 void CMTPSendObjectInfo::ServiceSendObjectInfoL()
 {
-__FLOG(_L8("ServiceSendObjectInfoL - Entry"));
+OstTraceFunctionEntry0( CMTPSENDOBJECTINFO_SERVICESENDOBJECTINFOL_ENTRY );
 delete iObjectInfo;
 iObjectInfo = NULL;
 iObjectInfo = CMTPTypeObjectInfo::NewL();
 iCancelled = EFalse;
 ReceiveDataL(*iObjectInfo);
 iProgress = EObjectInfoInProgress;
-__FLOG(_L8("ServiceSendObjectInfoL - Exit"));
+OstTraceFunctionExit0( CMTPSENDOBJECTINFO_SERVICESENDOBJECTINFOL_EXIT );
 }
 /**
 SendObjectPropList request handler
 */
 void CMTPSendObjectInfo::ServiceSendObjectPropListL()
 {
-__FLOG(_L8("ServiceSendObjectPropListL - Entry"));
+OstTraceFunctionEntry0( CMTPSENDOBJECTINFO_SERVICESENDOBJECTPROPLISTL_ENTRY );
 delete iObjectPropList;
 iObjectPropList = NULL;
 iObjectPropList = CMTPTypeObjectPropList::NewL();
 iCancelled = EFalse;
 iReceivedObject->SetUint(CMTPObjectMetaData::EFormatCode, iRequest->Uint32(TMTPTypeRequest::ERequestParameter3));
 ReceiveDataL(*iObjectPropList);
 iProgress = EObjectInfoInProgress;
-__FLOG(_L8("ServiceSendObjectPropListL - Exit"));
+OstTraceFunctionExit0( CMTPSENDOBJECTINFO_SERVICESENDOBJECTPROPLISTL_EXIT );
 }
 /**
 SendObject request handler
 */
 void CMTPSendObjectInfo::ServiceSendObjectL()
 {
-__FLOG(_L8("ServiceSendObjectL - Entry"));
+OstTraceFunctionEntry0( CMTPSENDOBJECTINFO_SERVICESENDOBJECTL_ENTRY );
 if (iIsFolder)
 {
 // A generic folder doesn't have anything interesting during its data phase
 ReceiveDataL(iNullObject);
 }
 {
 ReceiveDataL(*iFileReceived);
 }
 iProgress = ESendObjectInProgress;
-__FLOG(_L8("ServiceSendObjectL - Exit"));
+OstTraceFunctionExit0( CMTPSENDOBJECTINFO_SERVICESENDOBJECTL_EXIT );
 }
 /**
 Get a default parent object, if the request does not specify a parent object.
 */
 void CMTPSendObjectInfo::GetDefaultParentObjectL()
 {
-__FLOG(_L8("GetDefaultParentObjectL - Entry"));
+OstTraceFunctionEntry0( CMTPSENDOBJECTINFO_GETDEFAULTPARENTOBJECTL_ENTRY );
 if (iStorageId == KMTPStorageDefault)
 {
 iStorageId = iFramework.StorageMgr().DefaultStorageId();
 }
 TInt drive(iFramework.StorageMgr().DriveNumber(iStorageId));
-User::LeaveIfError(drive);
+LEAVEIFERROR(drive,
+OstTrace1( TRACE_ERROR, CMTPSENDOBJECTINFO_GETDEFAULTPARENTOBJECTL, "can't get driver number for storage %d", iStorageId));
 // Obtain the root of the drive.  Logical storages can sometimes have a filesystem root
 // other than <drive>:\ .  For example an MP3 DP might have a root of c:\media\music\
 // The DevDP needs to be aware of this when handling associations (folders) so they are
 // created in the correct location on the filesystem.
 delete iParentSuid;
 iParentSuid = NULL;
 iParentSuid=(iFramework.StorageMgr().StorageL(iStorageId).DesC(CMTPStorageMetaData::EStorageSuid)).AllocL();
 iReceivedObject->SetUint(CMTPObjectMetaData::EParentHandle, KMTPHandleNoParent);
-__FLOG(_L8("GetDefaultParentObjectL - Exit"));
+OstTraceFunctionExit0( CMTPSENDOBJECTINFO_GETDEFAULTPARENTOBJECTL_EXIT );
 }
 /**
 Get parent object and storage id
 @return EMTPRespCodeOK if successful, otherwise, EMTPRespCodeInvalidParentObject
 */
 TMTPResponseCode CMTPSendObjectInfo::GetParentObjectAndStorageIdL()
 {
-__FLOG(_L8("GetParentObjectAndStorageIdL - Entry"));
+OstTraceFunctionEntry0( CMTPSENDOBJECTINFO_GETPARENTOBJECTANDSTORAGEIDL_ENTRY );
 __ASSERT_DEBUG(iRequestChecker, Panic(EMTPDpRequestCheckNull));
 iStorageId = Request().Uint32(TMTPTypeRequest::ERequestParameter1);
 iParentHandle = Request().Uint32(TMTPTypeRequest::ERequestParameter2);
 //does not take ownership
 iParentSuid = NULL;
 iParentSuid = parentObjectInfo->DesC(CMTPObjectMetaData::ESuid).AllocL();
 iReceivedObject->SetUint(CMTPObjectMetaData::EParentHandle, iParentHandle);
 }
-__FLOG_VA((_L8("iParentSuid = %S"), iParentSuid));
+OstTraceExt1( TRACE_NORMAL, CMTPSENDOBJECTINFO_GETPARENTOBJECTANDSTORAGEIDL, "iParentSuid = %S", *iParentSuid );
-__FLOG(_L8("GetParentObjectAndStorageIdL - Exit"));
+OstTraceFunctionExit0( CMTPSENDOBJECTINFO_GETPARENTOBJECTANDSTORAGEIDL_EXIT );
 return EMTPRespCodeOK;
 }
 /**
 Handling the completing phase of SendObjectInfo request
 @return ETrue if the specified object can be saved on the specified location, otherwise, EFalse
 */
 TBool CMTPSendObjectInfo::DoHandleSendObjectInfoCompleteL()
 {
-__FLOG(_L8("DoHandleSendObjectInfoCompleteL - Entry"));
+OstTraceFunctionEntry0( CMTPSENDOBJECTINFO_DOHANDLESENDOBJECTINFOCOMPLETEL_ENTRY );
 TBool result(ETrue);
 TUint16 format(iObjectInfo->Uint16L(CMTPTypeObjectInfo::EObjectFormat));
 result = iDpSingletons.ExclusionMgrL().IsFormatValid(TMTPFormatCode(format));
 if (result)
 {
-__FLOG_VA((_L8("ASSOCIATION TYPE IS: %X"), iObjectInfo->Uint16L(CMTPTypeObjectInfo::EAssociationType)));
+		OstTrace1( TRACE_NORMAL, CMTPSENDOBJECTINFO_DOHANDLESENDOBJECTINFOCOMPLETEL,
-		if(format == EMTPFormatCodeAssociation)
+		        "ASSOCIATION TYPE IS: %X", iObjectInfo->Uint16L(CMTPTypeObjectInfo::EAssociationType));
+if(format == EMTPFormatCodeAssociation)
 			{
 			if((iObjectInfo->Uint16L(CMTPTypeObjectInfo::EAssociationType) == EMTPAssociationTypeGenericFolder) ||
 		      (iObjectInfo->Uint16L(CMTPTypeObjectInfo::EAssociationType) == EMTPAssociationTypeUndefined))
 				iIsFolder = ETrue;
 			else{
 TRAPD(err, CreateFsObjectL());
 if (err != KErrNone)
 {
-__FLOG_1(_L8("Fail to create fs object %d"),err);
+OstTrace1( TRACE_ERROR, DUP1_CMTPSENDOBJECTINFO_DOHANDLESENDOBJECTINFOCOMPLETEL, "Fail to create fs object %d", err );
 SendResponseL(ErrorToMTPError(err));
 result = EFalse;
 }
 else
 {
 ReserveObjectL();
 }
 }
-__FLOG(_L8("DoHandleSendObjectInfoCompleteL - Exit"));
+OstTraceFunctionExit0( CMTPSENDOBJECTINFO_DOHANDLESENDOBJECTINFOCOMPLETEL_EXIT );
 return result;
 }
 /**
 Handling the completing phase of SendObjectPropList request
 @return ETrue if the specified object can be saved on the specified location, otherwise, EFalse
 */
 TBool CMTPSendObjectInfo::DoHandleSendObjectPropListCompleteL()
 {
-__FLOG(_L8("DoHandleSendObjectPropListCompleteL - Entry"));
+OstTraceFunctionEntry0( CMTPSENDOBJECTINFO_DOHANDLESENDOBJECTPROPLISTCOMPLETEL_ENTRY );
 TBool result(ETrue);
 TMTPResponseCode responseCode(GetParentObjectAndStorageIdL());
 if (responseCode != EMTPRespCodeOK)
 {
 TRAPD(err, CreateFsObjectL());
 if (err != KErrNone)
 {
-__FLOG_1(_L8("Fail to create fs object %d"),err);
+OstTrace1( TRACE_ERROR, CMTPSENDOBJECTINFO_DOHANDLESENDOBJECTPROPLISTCOMPLETEL, "Fail to create fs object %d", err );
 SendResponseL(ErrorToMTPError(err));
 result = EFalse;
 }
 else
 {
 ReserveObjectL();
 }
 }
-__FLOG(_L8("DoHandleSendObjectPropListCompleteL - Exit"));
+OstTraceFunctionExit0( CMTPSENDOBJECTINFO_DOHANDLESENDOBJECTPROPLISTCOMPLETEL_EXIT );
 return result;
 }
 /**
 Handling the completing phase of SendObject request
 @return ETrue if the object has been successfully saved on the device, otherwise, EFalse
 */
 TBool CMTPSendObjectInfo::DoHandleSendObjectCompleteL()
 {
-__FLOG(_L8("DoHandleSendObjectCompleteL - Entry"));
+OstTraceFunctionEntry0( CMTPSENDOBJECTINFO_DOHANDLESENDOBJECTCOMPLETEL_ENTRY );
 TBool result(ETrue);
 if (!iIsFolder)
 {
 delete iFileReceived;
 iFileReceived = NULL;
 TEntry fileEntry;
-User::LeaveIfError(iFramework.Fs().Entry(iFullPath, fileEntry));
+LEAVEIFERROR(iFramework.Fs().Entry(iFullPath, fileEntry),
+OstTraceExt1( TRACE_ERROR, CMTPSENDOBJECTINFO_DOHANDLESENDOBJECTCOMPLETEL, "Gets the entry details for %S failed!", iFullPath));
 if (fileEntry.FileSize() != iObjectSize)
 {
+			delete iFileReceived;
+	iFileReceived = NULL;
 iFramework.RouteRequestUnregisterL(iExpectedSendObjectRequest, iConnection);
 iFramework.Fs().Delete(iFullPath);
 iFramework.ObjectMgr().UnreserveObjectHandleL(*iReceivedObject);
 TMTPResponseCode responseCode = EMTPRespCodeObjectTooLarge;
 TInt ret = connection.GetDataReceiveResult();
 frameworkSingletons.Close();
 // SendObject is cancelled or connection is dropped.
 if(result && (iCancelled || (ret == KErrAbort)))
 {
-__FLOG(_L8("It is a cancel for sendObject."));
+OstTrace0( TRACE_NORMAL, DUP1_CMTPSENDOBJECTINFO_DOHANDLESENDOBJECTCOMPLETEL, "It is a cancel for sendObject." );
 iFramework.RouteRequestUnregisterL(iExpectedSendObjectRequest, iConnection);
 Rollback();
 SendResponseL(EMTPRespCodeTransactionCancelled);
 }
 else if (result && !iCancelled)
 //with folder creation.
 if(!iIsFolder)
 {
 SetPropertiesL();
+delete iFileReceived;
+iFileReceived = NULL;
 iFramework.ObjectMgr().CommitReservedObjectHandleL(*iReceivedObject);
 iFullPath.LowerCase();
-__FLOG_VA((_L8("File Name %S"), &iFullPath));
+OstTraceExt1( TRACE_NORMAL, DUP2_CMTPSENDOBJECTINFO_DOHANDLESENDOBJECTCOMPLETEL, "File Name %S", iFullPath);
 TParsePtrC file( iFullPath );
 if ( file.ExtPresent() && file.Ext().Length()<=KExtensionLength && iExceptionList.Find(file.Ext()) != KErrNotFound)
 {
 TUint32 DpId = iFramework.DataProviderId();
 HBufC* mime = iDpSingletons.MTPUtility().ContainerMimeType(iFullPath);
 }
 }
 SendResponseL(EMTPRespCodeOK);
 	    }
-__FLOG(_L8("DoHandleSendObjectCompleteL - Exit"));
+OstTraceFunctionExit0( CMTPSENDOBJECTINFO_DOHANDLESENDOBJECTCOMPLETEL_EXIT );
 return result;
 }
 /**
 on return, contains the full path name of the object to be saved
 @return ETrue if the name is valid, EFalse otherwise
 */
 TBool CMTPSendObjectInfo::GetFullPathNameL(const TDesC& aFileName)
 {
-__FLOG(_L8("GetFullPathNameL - Entry"));
+OstTraceFunctionEntry0( CMTPSENDOBJECTINFO_GETFULLPATHNAMEL_ENTRY );
 TBool result(EFalse);
 if (aFileName.Length() > 0)
 {
 iFullPath = *iParentSuid;
 if (iFullPath.Length() + aFileName.Length() < iFullPath.MaxLength())
 result = iFramework.Fs().IsValidName(iFullPath);
 }
 }
 }
-#ifdef __FLOG_ACTIVE
+#ifdef OST_TRACE_COMPILER_IN_USE
 TFileName tempName;
 tempName.Copy(iFullPath);
 tempName.Collapse();
-__FLOG_VA((_L8("iFullPath = %S, Result = %d"), &tempName, result));
+OstTraceExt2( TRACE_NORMAL, CMTPSENDOBJECTINFO_GETFULLPATHNAMEL, "iFullPath = %S, Result = %d", tempName, result);
-__FLOG(_L8("GetFullPathNameL - Exit"));
 #endif
+OstTraceFunctionExit0( CMTPSENDOBJECTINFO_GETFULLPATHNAMEL_EXIT );
 return result;
 }
 /**
 Check if the object is too large
 @return ETrue if yes, otherwise EFalse
 */
 TBool CMTPSendObjectInfo::IsTooLarge(TUint64 aObjectSize) const
 {
-__FLOG(_L8("IsTooLarge - Entry"));
+OstTraceFunctionEntry0( CMTPSENDOBJECTINFO_ISTOOLARGE_ENTRY );
 TBool ret(aObjectSize > KMaxTInt64);
 if(!ret)
 {
 TBuf<255> fsname;
 if (storageId == KMTPStorageDefault)
 {
 storageId = iFramework.StorageMgr().DefaultStorageId();
 }
 TInt drive( iFramework.StorageMgr().DriveNumber(storageId) );
-User::LeaveIfError(drive);
+LEAVEIFERROR(drive,
+OstTrace1( TRACE_ERROR, CMTPSENDOBJECTINFO_ISTOOLARGE, "can't get driver number for storage %d", storageId));
 iFramework.Fs().FileSystemSubType(drive, fsname);
 const TUint64 KMaxFatFileSize = 0xFFFFFFFF; //Maximal file size supported by all FAT filesystems (4GB-1)
 _LIT(KFsFAT16, "FAT16");
 _LIT(KFsFAT32, "FAT32");
 if((fsname.CompareF(KFsFAT16) == 0 || fsname.CompareF(KFsFAT32) == 0) && aObjectSize > KMaxFatFileSize)
 {
 ret = ETrue;
 }
 }
-__FLOG_VA((_L8("Result = %d"), ret));
+OstTrace1( TRACE_NORMAL, DUP1_CMTPSENDOBJECTINFO_ISTOOLARGE, "Result = %d", ret );
-__FLOG(_L8("IsTooLarge - Exit"));
+OstTraceFunctionExit0( CMTPSENDOBJECTINFO_ISTOOLARGE_EXIT );
 return ret;
 }
 /**
 Check if the file already exists on the storage.
 @return ETrue if file is exists, otherwise EFalse
 */
 TBool CMTPSendObjectInfo::Exists(const TDesC& aName) const
 {
-__FLOG(_L8("Exists - Entry"));
+OstTraceFunctionEntry0( CMTPSENDOBJECTINFO_EXISTS_ENTRY );
 // This detects both files and folders
 TBool ret(EFalse);
 ret = BaflUtils::FileExists(iFramework.Fs(), aName);
-__FLOG_VA((_L8("Result = %d"), ret));
+OstTrace1( TRACE_NORMAL, CMTPSENDOBJECTINFO_EXISTS, "Result = %d", ret );
-__FLOG(_L8("Exists - Exit"));
+OstTraceFunctionExit0( CMTPSENDOBJECTINFO_EXISTS_EXIT );
 return ret;
 }
 /**
 Check if the property list is valid and extract properties (file name)
 @param aInvalidParameterIndex if invalid, contains the index of the property.  Undefined, if it is valid.
 @return if error, one of the error response code; otherwise EMTPRespCodeOK
 */
 TMTPResponseCode CMTPSendObjectInfo::VerifyObjectPropListL(TInt& aInvalidParameterIndex)
 {
-__FLOG(_L8("VerifyObjectPropListL - Entry"));
+OstTraceFunctionEntry0( CMTPSENDOBJECTINFO_VERIFYOBJECTPROPLISTL_ENTRY );
 TMTPResponseCode responseCode(EMTPRespCodeOK);
 const TUint KCount(iObjectPropList->NumberOfElements());
 	iObjectPropList->ResetCursor();
 for (TUint i(0); (i < KCount); i++)
 {
 if (responseCode != EMTPRespCodeOK)
 {
 break;
 }
 }
-__FLOG_VA((_L8("Result = 0x%04X"), responseCode));
+OstTrace1( TRACE_NORMAL, CMTPSENDOBJECTINFO_VERIFYOBJECTPROPLISTL, "Result = 0x%04X", responseCode);
-__FLOG(_L8("VerifyObjectPropListL - Exit"));
+OstTraceFunctionExit0( CMTPSENDOBJECTINFO_VERIFYOBJECTPROPLISTL_EXIT );
 return responseCode;
 }
 /**
 Extracts the file information from the object property list element
 @param aPropertyCode MTP property code for the element
 @return MTP response code
 */
 TMTPResponseCode CMTPSendObjectInfo::ExtractPropertyL(const CMTPTypeObjectPropListElement& aElement)
 {
-__FLOG(_L8("ExtractPropertyL - Entry"));
+OstTraceFunctionEntry0( CMTPSENDOBJECTINFO_EXTRACTPROPERTYL_ENTRY );
 TMTPResponseCode responseCode(EMTPRespCodeOK);
 switch (aElement.Uint16L(CMTPTypeObjectPropListElement::EPropertyCode))
 {
 case EMTPObjectPropCodeAssociationDesc:
 // Actually, any association is treated as a folder, and iIsFolder should already be set
 iDateMod = aElement.StringL(CMTPTypeObjectPropListElement::EValue).AllocL();
 break;
 case EMTPObjectPropCodeName:
 	iName = aElement.StringL(CMTPTypeObjectPropListElement::EValue);
 	break;
+case EMTPObjectPropCodeHidden:
+iHiddenStatus = aElement.Uint16L(CMTPTypeObjectPropListElement::EValue);
+break;
 default:
 break;
 }
-__FLOG_VA((_L8("Result = 0x%04X"), responseCode));
+OstTrace1( TRACE_NORMAL, CMTPSENDOBJECTINFO_EXTRACTPROPERTYL, "Result = 0x%04X", responseCode);
-__FLOG(_L8("ExtractPropertyL - Exit"));
+OstTraceFunctionExit0( CMTPSENDOBJECTINFO_EXTRACTPROPERTYL_EXIT );
 return responseCode;
 }
 /**
 Validates the data type for a given property code.
 @param aPropertyCode MTP property code for the element
 @return EMTPRespCodeOK if the combination is valid, or another MTP response code if not
 */
 TMTPResponseCode CMTPSendObjectInfo::CheckPropCodeL(const CMTPTypeObjectPropListElement& aElement) const
 {
-__FLOG(_L8("CheckPropCode - Entry"));
+OstTraceFunctionEntry0( CMTPSENDOBJECTINFO_CHECKPROPCODEL_ENTRY );
 TMTPResponseCode responseCode(EMTPRespCodeOK);
 switch(aElement.Uint16L(CMTPTypeObjectPropListElement::EPropertyCode))
 {
 case EMTPObjectPropCodeStorageID:
 if (aElement.Uint16L(CMTPTypeObjectPropListElement::EDatatype) != EMTPTypeUINT32)
 responseCode = EMTPRespCodeInvalidObjectPropFormat;
 }
 break;
 case EMTPObjectPropCodeAssociationType:
+case EMTPObjectPropCodeHidden:
 if (aElement.Uint16L(CMTPTypeObjectPropListElement::EDatatype) != EMTPTypeUINT16)
 {
 responseCode = EMTPRespCodeInvalidObjectPropFormat;
 }
 	break;
 default:
 responseCode = EMTPRespCodeInvalidObjectPropCode;
 break;
 }
-__FLOG_VA((_L8("Result = 0x%04X"), responseCode));
+OstTrace1( TRACE_NORMAL, CMTPSENDOBJECTINFO_CHECKPROPCODEL, "Result = 0x%04X", responseCode);
-__FLOG(_L8("CheckPropCode - Exit"));
+OstTraceFunctionExit0( CMTPSENDOBJECTINFO_CHECKPROPCODEL_EXIT );
 return responseCode;
 }
 /**
 Validates the data type for a given property code.
 				{
 				ret = EMTPRespCodeInvalidObjectHandle;
 				}
 			}
 	}
 return ret;
 }
 /**
 Reserves space for and assigns an object handle to the received object, then
 sends a success response.
 */
 void CMTPSendObjectInfo::ReserveObjectL()
 {
-__FLOG(_L8("ReserveObjectL - Entry"));
+OstTraceFunctionEntry0( CMTPSENDOBJECTINFO_RESERVEOBJECTL_ENTRY );
 iReceivedObject->SetUint(CMTPObjectMetaData::EStorageId, iStorageId);
 iReceivedObject->SetDesCL(CMTPObjectMetaData::ESuid, iFullPath);
 if(iIsFolder)
 {
 TUint32 parameters[3];
 parameters[0] = iStorageId;
 parameters[1] = iParentHandle;
 parameters[2] = iReceivedObject->Uint(CMTPObjectMetaData::EHandle);
 SendResponseL(EMTPRespCodeOK, (sizeof(parameters) / sizeof(parameters[0])), parameters);
-__FLOG(_L8("ReserveObjectL - Exit"));
+OstTraceFunctionExit0( CMTPSENDOBJECTINFO_RESERVEOBJECTL_EXIT );
 }
 void CMTPSendObjectInfo::CreateFsObjectL()
 {
 if (iIsFolder)
 {
 if (!Exists(iFullPath))
 {
-User::LeaveIfError(iFramework.Fs().MkDirAll(iFullPath));
+LEAVEIFERROR(iFramework.Fs().MkDirAll(iFullPath),
+OstTraceExt1( TRACE_ERROR, CMTPSENDOBJECTINFO_CREATEFSOBJECTL, "Makes directories failed for %S", iFullPath));
 }
 }
 else
 {
 delete iFileReceived;
 void CMTPSendObjectInfo::Rollback()
 {
 if(iIsFolder)
 {
-__FLOG(_L8("Rollback the dir created."));
+OstTrace0( TRACE_NORMAL, CMTPSENDOBJECTINFO_ROLLBACK, "Rollback the dir created." );
 iFramework.Fs().RmDir(iFullPath);
 // If it is folder, delete it from MTP database, i.e ObjectStore.
 TRAP_IGNORE(iFramework.ObjectMgr().RemoveObjectL(iFullPath));
 }
 else
 {
-__FLOG(_L8("Rollback the file created."));
+OstTrace0( TRACE_NORMAL, DUP1_CMTPSENDOBJECTINFO_ROLLBACK, "Rollback the file created." );
 delete iFileReceived;
 iFileReceived = NULL;
 // Delete this object from file system.
 iFramework.Fs().Delete(iFullPath);
 TRAP_IGNORE(iFramework.ObjectMgr().UnreserveObjectHandleL(*iReceivedObject));
 break;
 default:
 break;
 }
 return resp;
 }
 /**
 Sets the read only status on the current file to match the sent object.
 */
 void CMTPSendObjectInfo::SetPropertiesL()
 {
-__FLOG(_L8("SetPropertiesL - Entry"));
+OstTraceFunctionEntry0( CMTPSENDOBJECTINFO_SETPROPERTIESL_ENTRY );
 TEntry entry;
-User::LeaveIfError(iFramework.Fs().Entry(iFullPath, entry));
+LEAVEIFERROR(iFramework.Fs().Entry(iFullPath, entry),
+OstTraceExt1( TRACE_ERROR, CMTPSENDOBJECTINFO_SETPROPERTIESL, "can't get entry details from %S", iFullPath));
 TUint16 assoc(EMTPAssociationTypeUndefined);
 	if (entry.IsDir())
 		{
 		assoc = EMTPAssociationTypeGenericFolder;
 }
 else
 {
 entry.iAtt |= KEntryAttReadOnly;
 }
-User::LeaveIfError(iFramework.Fs().SetAtt(iFullPath, entry.iAtt, ~entry.iAtt));
+if ( iFileReceived )
-}
+{
+User::LeaveIfError(iFileReceived->File().SetAtt(entry.iAtt, ~entry.iAtt));
+}
+else
+{
+LEAVEIFERROR(iFramework.Fs().SetAtt(iFullPath, entry.iAtt, ~entry.iAtt),
+OstTraceExt2( TRACE_ERROR, DUP1_CMTPSENDOBJECTINFO_SETPROPERTIESL, "set attribute %d for %S failed!", (TInt32)entry.iAtt, iFullPath));
+}
+}
+if ( EMTPHidden == iHiddenStatus )
+{
+		entry.iAtt &= ~KEntryAttHidden;
+entry.iAtt |= KEntryAttHidden;
+if ( iFileReceived )
+{
+User::LeaveIfError(iFileReceived->File().SetAtt(entry.iAtt, ~entry.iAtt));
+}
+else
+{
+User::LeaveIfError(iFramework.Fs().SetAtt(iFullPath, entry.iAtt, ~entry.iAtt));
+}
+}
 if(iDateMod != NULL && iDateMod->Length())
 {
 TTime modifiedTime;
 iDpSingletons.MTPUtility().MTPTimeStr2TTime(*iDateMod, modifiedTime);
-User::LeaveIfError(iFramework.Fs().SetModified(iFullPath, modifiedTime));
+if ( iFileReceived )
+{
+User::LeaveIfError(iFileReceived->File().SetModified( modifiedTime ));
+}
+else
+{
+User::LeaveIfError(iFramework.Fs().SetModified(iFullPath, modifiedTime));
+}
 }
 iReceivedObject->SetDesCL(CMTPObjectMetaData::EName, iName);
-__FLOG(_L8("SetPropertiesL - Exit"));
+OstTraceFunctionExit0( CMTPSENDOBJECTINFO_SETPROPERTIESL_EXIT );
 }

changeset 47	63cf70d3ecd8
parent 38	48c22c726cf9