FCL/sf/mw/mmappfw: comparison mmappcomponents/mmmtpdataprovider/mmmtpdprequestprocessor/src/ccopyobject.cpp

equal deleted inserted replaced

-:d240f0a77280
+:780c925249c1
 *
 */
 #include <bautils.h>
-#include <mtp/mmtpdataproviderframework.h>
 #include <mtp/mmtpobjectmgr.h>
 #include <mtp/mmtpreferencemgr.h>
 #include <mtp/mmtpstoragemgr.h>
-#include <mtp/cmtpobjectmetadata.h>
 #include <mtp/cmtptypestring.h>
 #include <mtp/cmtptypearray.h>
 #include <mtp/cmtptypeobjectproplist.h>
 #include "ccopyobject.h"
 //
 EXPORT_C CCopyObject::~CCopyObject()
 {
 Cancel();
+delete iTargetObject;
 delete iDest;
 if ( iPropertyElement )
 delete iPropertyElement;
 delete iPropertyList;
 MMmMtpDpConfig& aDpConfig ) :
 CRequestProcessor( aFramework,
 aConnection,
 sizeof( KMTPCopyObjectPolicy ) / sizeof( TMTPRequestElementInfo ),
 KMTPCopyObjectPolicy ),
-iDpConfig( aDpConfig )
+iDpConfig( aDpConfig ),
+iSourceObject( NULL ),
+iTargetObject( NULL )
 {
 PRINT( _L( "Operation: CopyObject(0x101A)" ) );
 }
 // -----------------------------------------------------------------------------
 RBuf newObjectName;
 newObjectName.CreateL( KMaxFileName );
 newObjectName.CleanupClosePushL(); // + newObjectName
 newObjectName = *iDest;
-const TDesC& suid( iObjectInfo->DesC( CMTPObjectMetaData::ESuid ) );
+const TDesC& suid( iSourceObject->DesC( CMTPObjectMetaData::ESuid ) );
 TParsePtrC fileNameParser( suid );
 if ( ( newObjectName.Length() + fileNameParser.NameAndExt().Length() )
 <= newObjectName.MaxLength() )
 {
 newObjectName.Append( fileNameParser.NameAndExt() );
 objectHandle,
 iStorageId,
 iNewParentHandle );
 // not taking owernship
-iObjectInfo = iRequestChecker->GetObjectInfo( objectHandle );
+iSourceObject = iRequestChecker->GetObjectInfo( objectHandle );
-__ASSERT_DEBUG( iObjectInfo, Panic( EMmMTPDpObjectNull ) );
+__ASSERT_DEBUG( iSourceObject, Panic( EMmMTPDpObjectNull ) );
 if ( iNewParentHandle == KMTPHandleNone )
 {
 SetDefaultParentObjectL();
 }
 PRINT( _L( "MM MTP <= CCopyObject::GetParametersL" ) );
 }
 // -----------------------------------------------------------------------------
 // CCopyObject::SetDefaultParentObjectL
-// Get a default parent object, ff the request does not specify a parent object,
+// Set a default destination, if the request does not specify a parent object,
 // -----------------------------------------------------------------------------
 //
 void CCopyObject::SetDefaultParentObjectL()
 {
 PRINT( _L( "MM MTP => CCopyObject::SetDefaultParentObjectL" ) );
 #else
 result = EMTPRespCodeInvalidParentObject;
 #endif
 }
 // This is used to keep the same behavior in mass storage and device file manager.
-else if ( iObjectInfo->Uint( CMTPObjectMetaData::EFormatCode )
+else if ( iSourceObject->Uint( CMTPObjectMetaData::EFormatCode )
 == EMTPFormatCodeAbstractAudioVideoPlaylist )
 {
 PRINT( _L( "MM MTP <> CCopyObject::CanCopyObjectL playlist file can't copy" ) );
 result = EMTPRespCodeAccessDenied;
 }
 // A helper function of CopyFileL
 // -----------------------------------------------------------------------------
 //
 TUint32 CCopyObject::CopyFileL( const TDesC& aNewFileName )
 {
-const TDesC& suid( iObjectInfo->DesC( CMTPObjectMetaData::ESuid ) );
+PRINT( _L( "MM MTP => CCopyObject::CopyFileL" ) );
-PRINT2( _L( "MM MTP => CCopyObject::CopyFileL old name = %S, aNewFileName = %S" ),
-&suid,
+GetPreviousPropertiesL();
-&aNewFileName );
-GetPreviousPropertiesL( *iObjectInfo );
 // TODO: Need rollback mechanism for consistant with image dp in fw.
 // Not sure if it should be trap if something wrong with MPX db.
-TUint32 handle = AddObjectToStoreL( suid, aNewFileName );
+TPtrC oldFileName( iSourceObject->DesC( CMTPObjectMetaData::ESuid ) );
+TUint32 handle = AddObjectToStoreL( oldFileName, aNewFileName );
 // Only leave when getting proplist element from data received by fw.
 // It should not happen after ReceiveDataL in which construction of proplist already succeed.
-SetPreviousPropertiesL( *iObjectInfo );
+SetPreviousPropertiesL();
 CFileMan* fileMan = CFileMan::NewL( iFramework.Fs() );
-User::LeaveIfError( fileMan->Copy( suid, aNewFileName ) );
+User::LeaveIfError( fileMan->Copy( oldFileName, aNewFileName ) );
 delete fileMan;
 fileMan = NULL;
-User::LeaveIfError( iFramework.Fs().SetModified( aNewFileName,
+PRINT( _L( "MM MTP <= CCopyObject::CopyFileL" ) );
-iPreviousModifiedTime ) );
-PRINT1( _L( "MM MTP <= CCopyObject::CopyFileL handle = 0x%x" ), handle );
 return handle;
 }
 // -----------------------------------------------------------------------------
 // CCopyObject::GetPreviousPropertiesL
 // Save the object properties before doing the copy
 // -----------------------------------------------------------------------------
 //
-void CCopyObject::GetPreviousPropertiesL( const CMTPObjectMetaData& aObject )
+void CCopyObject::GetPreviousPropertiesL()
 {
 PRINT( _L( "MM MTP => CCopyObject::GetPreviousPropertiesL" ) );
-const TDesC& suid( aObject.DesC( CMTPObjectMetaData::ESuid ) );
+TUint formatCode = iSourceObject->Uint( CMTPObjectMetaData::EFormatCode );
-User::LeaveIfError( iFramework.Fs().Modified( suid, iPreviousModifiedTime ) );
-TUint formatCode = aObject.Uint( CMTPObjectMetaData::EFormatCode );
 const RArray<TUint>* properties = iDpConfig.GetSupportedPropertiesL( formatCode );
 TInt count = properties->Count();
 TInt err = KErrNone;
 TUint16 propCode;
-TUint32 handle = aObject.Uint( CMTPObjectMetaData::EHandle );
+TUint32 handle = iSourceObject->Uint( CMTPObjectMetaData::EHandle );
 if ( iPropertyElement != NULL )
 {
 delete iPropertyElement;
 iPropertyElement = NULL;
 break;
 case EMTPObjectPropCodeNonConsumable:
 iPropertyElement = &( iPropertyList->ReservePropElemL( handle, propCode ) );
 iPropertyElement->SetUint8L( CMTPTypeObjectPropListElement::EValue,
-aObject.Uint( CMTPObjectMetaData::ENonConsumable ) );
+iSourceObject->Uint( CMTPObjectMetaData::ENonConsumable ) );
 break;
 case EMTPObjectPropCodeName:
 case EMTPObjectPropCodeDateAdded:
-if ( ( propCode == EMTPObjectPropCodeName )
+case EMTPObjectPropCodeAlbumArtist:
-|| ( !MmMtpDpUtility::IsVideoL( aObject.DesC( CMTPObjectMetaData::ESuid ), iFramework )
+{
-&& ( propCode == EMTPObjectPropCodeDateAdded ) ) )
+CMTPTypeString* textData = CMTPTypeString::NewLC(); // + textData
+TRAP( err, iDpConfig.GetWrapperL().GetObjectMetadataValueL( propCode,
+*textData,
+*iSourceObject ) );
+PRINT1( _L( "MM MTP <> CCopyObject::GetPreviousPropertiesL err = %d" ), err );
+if ( err == KErrNone )
 {
-CMTPTypeString* textData = CMTPTypeString::NewLC(); // + textData
+iPropertyElement = &( iPropertyList->ReservePropElemL( handle, propCode ) );
+iPropertyElement->SetStringL( CMTPTypeObjectPropListElement::EValue,
-TRAP( err, iDpConfig.GetWrapperL().GetObjectMetadataValueL( propCode,
+textData->StringChars() );
-*textData,
-aObject ) );
-PRINT1( _L( "MM MTP <> CCopyObject::GetPreviousPropertiesL err = %d" ), err );
-if ( err == KErrNone )
-{
-iPropertyElement = &( iPropertyList->ReservePropElemL( handle, propCode ) );
-iPropertyElement->SetStringL( CMTPTypeObjectPropListElement::EValue,
-textData->StringChars() );
-}
-else
-{
-iPropertyElement = NULL;
-}
-CleanupStack::PopAndDestroy( textData ); // - textData
 }
+else
+{
+iPropertyElement = NULL;
+}
+CleanupStack::PopAndDestroy( textData ); // - textData
+}
 break;
 default:
 {
-ServiceGetSpecificObjectPropertyL( propCode, handle, aObject );
+ServiceGetSpecificObjectPropertyL( propCode, handle, *iSourceObject );
 }
 break;
 }
 if ( iPropertyElement != NULL )
 // -----------------------------------------------------------------------------
 // CCopyObject::SetPreviousPropertiesL
 // Set the object properties after doing the copy
 // -----------------------------------------------------------------------------
 //
-void CCopyObject::SetPreviousPropertiesL( const CMTPObjectMetaData& aObject )
+void CCopyObject::SetPreviousPropertiesL()
 {
 PRINT( _L( "MM MTP => CCopyObject::SetPreviousPropertiesL" ) );
 TMTPResponseCode respcode = EMTPRespCodeOK;
 case EMTPObjectPropCodeDateModified:
 case EMTPObjectPropCodeDateAdded:
 break;
 case EMTPObjectPropCodeNonConsumable:
-iObjectInfo->SetUint( CMTPObjectMetaData::ENonConsumable,
+iTargetObject->SetUint( CMTPObjectMetaData::ENonConsumable,
 element.Uint8L( CMTPTypeObjectPropListElement::EValue ) );
 // TODO: need to reconsider,
 // should wait all property setting finished then insert object, or not?
 // need to investigate if it will affect performance result
-iFramework.ObjectMgr().ModifyObjectL( *iObjectInfo );
+iFramework.ObjectMgr().ModifyObjectL( *iTargetObject );
 break;
 case EMTPObjectPropCodeName:
+case EMTPObjectPropCodeAlbumArtist:
 {
 CMTPTypeString *stringData = CMTPTypeString::NewLC( element.StringL( CMTPTypeObjectPropListElement::EValue ) ); // + stringData
 respcode = iDpConfig.PropSettingUtility()->SetMetaDataToWrapper( iDpConfig,
 propertyCode,
 *stringData,
-aObject );
+*iTargetObject );
 CleanupStack::PopAndDestroy( stringData ); // - stringData
 }
 break;
 default:
 {
 respcode = iDpConfig.PropSettingUtility()->SetSpecificObjectPropertyL( iDpConfig,
 propertyCode,
-aObject,
+*iTargetObject,
 element );
 }
 break;
 }
 } // end of for loop
 {
 PRINT2( _L( "MM MTP => CCopyObject::AddObjectToStoreL aOldObjectName = %S, aNewObjectName = %S" ),
 &aOldObjectName,
 &aNewObjectName );
-CMTPObjectMetaData* objectInfo = CMTPObjectMetaData::NewLC(); // + objectInfo
+iTargetObject = CMTPObjectMetaData::NewL();
 // 1. Add new object into objectMgr db
-objectInfo->SetUint( CMTPObjectMetaData::EDataProviderId, iObjectInfo->Uint( CMTPObjectMetaData::EDataProviderId ) );
+iTargetObject->SetUint( CMTPObjectMetaData::EDataProviderId, iSourceObject->Uint( CMTPObjectMetaData::EDataProviderId ) );
-TUint formatCode = iObjectInfo->Uint( CMTPObjectMetaData::EFormatCode );
+TUint formatCode = iSourceObject->Uint( CMTPObjectMetaData::EFormatCode );
-objectInfo->SetUint( CMTPObjectMetaData::EFormatCode, formatCode );
+iTargetObject->SetUint( CMTPObjectMetaData::EFormatCode, formatCode );
-TUint subFormatCode = iObjectInfo->Uint( CMTPObjectMetaData::EFormatSubCode );
+TUint subFormatCode = iSourceObject->Uint( CMTPObjectMetaData::EFormatSubCode );
-objectInfo->SetUint( CMTPObjectMetaData::EFormatSubCode, subFormatCode );
+iTargetObject->SetUint( CMTPObjectMetaData::EFormatSubCode, subFormatCode );
-objectInfo->SetUint( CMTPObjectMetaData::EParentHandle, iNewParentHandle );
+iTargetObject->SetUint( CMTPObjectMetaData::EParentHandle, iNewParentHandle );
-objectInfo->SetUint( CMTPObjectMetaData::EStorageId, iStorageId );
+iTargetObject->SetUint( CMTPObjectMetaData::EStorageId, iStorageId );
-objectInfo->SetDesCL( CMTPObjectMetaData::ESuid, aNewObjectName );
+iTargetObject->SetDesCL( CMTPObjectMetaData::ESuid, aNewObjectName );
-iFramework.ObjectMgr().InsertObjectL( *objectInfo );
+iFramework.ObjectMgr().InsertObjectL( *iTargetObject );
 // 2. Add new object into MPX db
-iDpConfig.GetWrapperL().AddObjectL( aNewObjectName, formatCode, subFormatCode );
+iDpConfig.GetWrapperL().AddObjectL( *iTargetObject );
 // 3. Set references into references db
 if ( formatCode == EMTPFormatCodeM3UPlaylist )
 {
 MMTPReferenceMgr& referenceMgr = iFramework.ReferenceMgr();
 CDesCArray* references = referenceMgr.ReferencesLC( aOldObjectName ); // + references
 referenceMgr.SetReferencesL( aNewObjectName, *references );
 CleanupStack::PopAndDestroy( references ); // - references
 }
-TUint32 handle = objectInfo->Uint( CMTPObjectMetaData::EHandle );
+TUint32 handle = iTargetObject->Uint( CMTPObjectMetaData::EHandle );
-CleanupStack::PopAndDestroy( objectInfo ); // - objectInfo
 PRINT1( _L( "MM MTP <= CCopyObject::AddObjectToStoreL handle = 0x%x" ), handle );
 return handle;
 }

branch	RCL_3
changeset 17	780c925249c1
parent 14	05b0d2323768
child 30	6f9f6e99a23e