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

equal deleted inserted replaced

-:cbb1bfb7ebfb
+:edd273b3192a
 #include "tmmmtpdppanic.h"
 #include "mmmtpdplogger.h"
 #include "cpropertysettingutility.h"
 #include "cmmmtpdpmetadataaccesswrapper.h"
+const TInt KMtpRollbackFuncCnt = 3;
 // Verification data for the SendObjectInfo request
 const TMTPRequestElementInfo KMTPSendObjectInfoPolicy[] =
 {
 {
 TMTPTypeRequest::ERequestParameter1,
 // Destructor
 // -----------------------------------------------------------------------------
 //
 EXPORT_C CSendObject::~CSendObject()
 {
-if ( !iNoRollback )
+Rollback();
-{
+iRollbackList.Close();
-// Not finished SendObjectInfo \ SendObject pair detected.
-Rollback();
-PRINT( _L( "MM MTP <> CSendObject::~CSendObject, Rollback" ) );
-}
 delete iFileReceived;
 delete iParentSuid;
 delete iObjectInfo;
 delete iObjectPropList;
 MMTPConnection& aConnection,
 MMmMtpDpConfig& aDpConfig ) :
 CRequestProcessor( aFramework, aConnection, 0, NULL ),
 iFs( iFramework.Fs() ),
 iObjectMgr( iFramework.ObjectMgr() ),
-iDpConfig( aDpConfig )
+iDpConfig( aDpConfig ),
+iRollbackList( KMtpRollbackFuncCnt )
 {
 PRINT( _L( "Operation: SendObjectInfo/SendObject/SendObjectPropList(0x100C/0x100D/0x9808)" ) );
 }
 // -----------------------------------------------------------------------------
 iReceivedObjectInfo->SetUint( CMTPObjectMetaData::EDataProviderId,
 iFramework.DataProviderId() );
 PRINT1( _L( "MM MTP <> CSendObject::ConstructL DataProviderId = 0x%x" ), iFramework.DataProviderId());
-iNoRollback = EFalse;
-SetPSStatus();
 PRINT( _L( "MM MTP <= CSendObject::ConstructL" ) );
 }
 // -----------------------------------------------------------------------------
 // CSendObject::Match
 if ( IsTooLarge( iObjectSize ) )
 {
 responseCode = EMTPRespCodeObjectTooLarge;
 }
-if ( ( responseCode != EMTPRespCodeOK ) && !CanStoreFileL( iStorageId, iObjectSize ) )
-{
-responseCode = EMTPRespCodeStoreFull;
-}
 }
 }
 PRINT1( _L( "MM MTP <= CSendObject::CheckRequestL, responseCode = 0x%x" ), responseCode );
 return responseCode;
 // -----------------------------------------------------------------------------
 //
 EXPORT_C void CSendObject::ServiceL()
 {
 PRINT( _L( "MM MTP => CSendObject::ServiceL" ) );
+MmMtpDpUtility::SetPSStatus(EMtpPSStatusActive);
 if ( iProgress == EObjectNone )
 {
 if ( iOperationCode == EMTPOpCodeSendObjectInfo )
 {
 // -----------------------------------------------------------------------------
 //
 void CSendObject::ServiceObjectL()
 {
 PRINT( _L( "MM MTP => CSendObject::ServiceObjectL" ) );
-delete iFileReceived;
-iFileReceived = NULL;
-PRINT2( _L( "MM MTP <> CSendObject::ServiceObjectL, iFullPath is %S, iObjectSize: %Lu" ), &iFullPath, iObjectSize );
-TRAPD( err, iFileReceived = CMTPTypeFile::NewL( iFs,
-iFullPath,
-EFileWrite ) );
-PRINT1( _L("MM MTP <> CSendObject::ServiceObjectL, Leave Code is: %d"), err );
-User::LeaveIfError( err );
-iFileReceived->SetSizeL( iObjectSize );
 ReceiveDataL( *iFileReceived );
 iProgress = ESendObjectInProgress;
 PRINT( _L( "MM MTP <= CSendObject::ServiceObjectL" ) );
 }
 PRINT1( _L("MM MTP <> CSendObject::DoHandleResponsePhaseInfoL, iObjectSize = %Lu"), iObjectSize );
 if ( IsTooLarge( iObjectSize ) )
 {
 SendResponseL( EMTPRespCodeObjectTooLarge );
-result = EFalse;
+Rollback();
-}
-if ( result && !CanStoreFileL( iStorageId, iObjectSize ) )
-{
-SendResponseL( EMTPRespCodeStoreFull );
 result = EFalse;
 }
 if ( result )
 {
 PRINT1( _L( "MM MTP <> CSendObject::DoHandleResponsePhaseInfoL iProtectionStatus = %d" ), iProtectionStatus );
 if ( iProtectionStatus != EMTPProtectionNoProtection
 && iProtectionStatus != EMTPProtectionReadOnly )
 {
 SendResponseL( EMTPRespCodeParameterNotSupported );
+Rollback();
 result = EFalse;
 }
 }
 if ( result )
 result = GetFullPathNameL( iObjectInfo->StringCharsL( CMTPTypeObjectInfo::EFilename ) );
 if ( !result )
 {
 // File and/or parent pathname invalid.
 SendResponseL( EMTPRespCodeInvalidDataset );
+Rollback();
 }
 }
 if ( result )
 {
 if ( ExistsL( iFullPath ) )
 {
-// Object with the same name already exists.
-iNoRollback = ETrue;
 SendResponseL( EMTPRespCodeAccessDenied );
+Rollback();
 result = EFalse;
 }
 }
 if ( result )
-ReserveObjectL();
+{
+if ( KErrNone != ReserveObjectL() )
+{
+result = EFalse;
+}
+}
 PRINT1( _L( "MM MTP <= CSendObject::DoHandleResponsePhaseInfoL result = %d" ), result );
 return result;
 }
 TMTPResponseCode responseCode = EMTPRespCodeOK;
 TInt invalidParameterIndex = KErrNotFound;
 responseCode = VerifyObjectPropListL( invalidParameterIndex );
+TInt err = KErrNone;
 if ( responseCode != EMTPRespCodeOK )
 {
 TUint32 parameters[4];
 parameters[0] = 0;
 parameters[1] = 0;
 parameters[2] = 0;
 parameters[3] = invalidParameterIndex;
 SendResponseL( responseCode, 4, parameters );
+Rollback();
 }
 else if ( ExistsL( iFullPath ) )
 {
-// Object with the same name already exists.
-iNoRollback = ETrue;
 SendResponseL( EMTPRespCodeAccessDenied );
+Rollback();
 }
 else
-ReserveObjectL();
+err = ReserveObjectL();
 PRINT( _L( "MM MTP <= CSendObject::DoHandleResponsePhasePropListL" ) );
-return ( responseCode == EMTPRespCodeOK );
+return ( responseCode == EMTPRespCodeOK && err == KErrNone);
 }
 // -----------------------------------------------------------------------------
 // CSendObject::DoHandleResponsePhaseObjectL
 // SendObject
 {
 PRINT( _L( "MM MTP => CSendObject::DoHandleResponsePhaseObjectL" ) );
 TBool result = ETrue;
+TEntry fileEntry;
+User::LeaveIfError( iFs.Entry( iFullPath, fileEntry ) );
+if ( fileEntry.FileSize() != iObjectSize )
+{
+iFs.Delete( iFullPath );
+iObjectMgr.UnreserveObjectHandleL( *iReceivedObjectInfo );
+TMTPResponseCode responseCode = EMTPRespCodeObjectTooLarge;
+if ( fileEntry.FileSize() < iObjectSize )
+{
+responseCode = EMTPRespCodeIncompleteTransfer;
+}
+SendResponseL( responseCode );
+Rollback();
+result = EFalse;
+}
 // SendObject is cancelled or connection is dropped.
-if ( iCancelled )
+if ( result && iCancelled )
 {
-// In SendObject response phase, unregister is not necessary.
-// But there's no harm, still keep it here.
 iFramework.RouteRequestUnregisterL( iExpectedSendObjectRequest,
 iConnection );
+SendResponseL( EMTPRespCodeTransactionCancelled );
 Rollback();
-SendResponseL( EMTPRespCodeTransactionCancelled );
+}
-}
+else if ( result && !iCancelled )
-else
+{
-{
+if ( iObjectSize > 0 ) // media file
-TEntry fileEntry;
+{
-User::LeaveIfError( iFs.Entry( iFullPath, fileEntry ) );
+TRAPD( err, AddMediaToStoreL() );
+PRINT1( _L( "MM MTP <= CSendObject::DoHandleResponsePhaseObjectL err = %d" ), err );
-if ( fileEntry.FileSize() != iObjectSize )
-{
+if ( ( iPreviousOperation == EMTPOpCodeSendObjectPropList )
-Rollback();
+&& ( err == KErrNone ) )
-TMTPResponseCode responseCode = EMTPRespCodeObjectTooLarge;
+{
-if ( fileEntry.FileSize() < iObjectSize )
+// Only leave when getting proplist element from data received by fw.
-{
+// It should not happen after ReceiveDataL in which construction of proplist already succeed.
-responseCode = EMTPRespCodeIncompleteTransfer;
+SetObjectPropListL();
 }
-SendResponseL( responseCode );
-result = EFalse;
+// Commits into MTP data object enumeration store the object handle and
-}
+// storage space previously reserved for the specified object.
-else
+iFramework.ObjectMgr().CommitReservedObjectHandleL( *iReceivedObjectInfo );
-{
+iRollbackList.Append( &CSendObject::RemoveObjectFromDbL );
-if ( iObjectSize > 0 ) // media file
+}
-{
-TRAPD( err, AddMediaToStoreL() );
+// Commit object to MTP data store
-PRINT1( _L( "MM MTP <> CSendObject::DoHandleResponsePhaseObjectL err = %d" ), err );
+iFramework.RouteRequestUnregisterL( iExpectedSendObjectRequest,
+iConnection );
-if ( ( iPreviousOperation == EMTPOpCodeSendObjectPropList )
-&& ( err == KErrNone ) )
+SendResponseL( EMTPRespCodeOK );
-{
-// Only leave when getting proplist element from data received by fw.
-// It should not happen after ReceiveDataL in which construction of proplist already succeed.
-SetObjectPropListL();
-}
-// Commits into MTP data object enumeration store the object handle and
-// storage space previously reserved for the specified object.
-iFramework.ObjectMgr().CommitReservedObjectHandleL( *iReceivedObjectInfo );
-}
-// In SendObject response phase, unregister is not necessary.
-// But there's no harm, still keep it here.
-iFramework.RouteRequestUnregisterL( iExpectedSendObjectRequest,
-iConnection );
-SendResponseL( EMTPRespCodeOK );
-}
 }
 PRINT1( _L( "MM MTP <= CSendObject::DoHandleResponsePhaseObjectL result = %d" ), result );
 return result;
 {
 //Sending Object failed, but still do not delete request, can try again with current info
 iProgress = EObjectInfoSucceed;
 result = EFalse;
 }
+if ( result )
+iRollbackList.Reset();
 PRINT2( _L( "MM MTP <= CSendObject::DoHandleCompletingPhaseL iProgress= %d, result = %d" ),
 iProgress,
 result );
 TBool ret = ( aObjectSize > KMaxSupportedFileSize );
 PRINT2( _L( "MM MTP <> CSendObject::IsTooLarge aObjectSize = 0x%Lx, ret = %d" ), aObjectSize, ret );
 return ret;
 }
-// -----------------------------------------------------------------------------
-// CSendObject::CanStoreFileL
-// Check if we can store the file on the storage
-// @return ETrue if yes, otherwise EFalse
-// -----------------------------------------------------------------------------
-//
-TBool CSendObject::CanStoreFileL( TUint32 aStorageId,
-TInt64 aObjectSize ) const
-{
-PRINT( _L( "MM MTP => CSendObject::CanStoreFileL" ) );
-TBool result = ETrue;
-TVolumeInfo volumeInfo;
-TInt driveNo = iFramework.StorageMgr().DriveNumber( aStorageId );
-User::LeaveIfError( iFs.Volume( volumeInfo, driveNo ) );
-if ( volumeInfo.iFree < aObjectSize )
-{
-result = EFalse;
-}
-PRINT1( _L( "MM MTP <= CSendObject::CanStoreFileL , result = %d" ), result );
-return result;
-}
 // -----------------------------------------------------------------------------
 // CSendObject::GetFullPathNameL
 // Get the full path name of the object to be saved
 // @param aFileName, on entry, contains the file name of the object,
 // -----------------------------------------------------------------------------
 // CSendObject::ReserveObjectL
 // -----------------------------------------------------------------------------
 //
-void CSendObject::ReserveObjectL()
+TInt CSendObject::ReserveObjectL()
 {
 PRINT( _L( "MM MTP => CSendObject::ReserveObjectL" ) );
 TInt err = KErrNone;
 iReceivedObjectInfo->SetUint( CMTPObjectMetaData::EStorageId, iStorageId );
 // Reserves space for and assigns an object handle to the object described
 // by the specified object information record.
 TRAP( err, iObjectMgr.ReserveObjectHandleL( *iReceivedObjectInfo,
 iObjectSize ) );
+iRollbackList.Append( &CSendObject::UnreserveObjectL );
 PRINT2( _L( "MM MTP => CSendObject::ReserveObjectL iObjectsize = %Lu, Operation: 0x%x" ), iObjectSize, iOperationCode );
 if ( err != KErrNone )
-PRINT1( _L( "MM MTP <> CSendObject::ReserveObjectL err = %d" ), err );
+{
-if ( iObjectSize == 0 )
+PRINT1( _L( "MM MTP <> ReserveObjectHandleL err = %d" ), err );
+}
+if ( err == KErrNone )
+{
+delete iFileReceived;
+iFileReceived = NULL;
+PRINT2( _L( "MM MTP <> CSendObject::ServiceObjectL, iFullPath is %S, iObjectSize: %Lu" ), &iFullPath, iObjectSize );
+iRollbackList.Append( &CSendObject::RemoveObjectFromFs );
+TRAP( err, iFileReceived = CMTPTypeFile::NewL( iFs, iFullPath, EFileWrite ) );
+PRINT1( _L("MM MTP <> CMTPTypeFile::NewL Leave Code is: %d"), err );
+}
+if ( err == KErrNone )
+{
+TRAP( err, iFileReceived->SetSizeL( iObjectSize ) );
+PRINT1( _L( "MM MTP <> SetSizeL leave code:%d" ), err );
+if ( err == KErrDiskFull )
+{
+SendResponseL( EMTPRespCodeStoreFull );
+Rollback();
+return err;
+}
+}
+if ( err == KErrNone && iObjectSize == 0 )
 {
 // Already trapped inside SaveEmptyFileL.
 SaveEmptyFileL();
-if( iOperationCode == EMTPOpCodeSendObjectPropList )
+if ( iOperationCode == EMTPOpCodeSendObjectPropList )
 {
 // Only leave when getting proplist element from data received by fw.
 // It should not happen after ReceiveDataL in which construction of proplist already succeed.
 SetObjectPropListL();
 }
 iObjectMgr.CommitReservedObjectHandleL( *iReceivedObjectInfo );
-}
+iRollbackList.Reset();
+}
-iExpectedSendObjectRequest.SetUint32( TMTPTypeRequest::ERequestSessionID,
-iSessionId );
+if ( err == KErrNone )
-iFramework.RouteRequestRegisterL( iExpectedSendObjectRequest, iConnection );
+{
+iExpectedSendObjectRequest.SetUint32( TMTPTypeRequest::ERequestSessionID, iSessionId );
-TUint32 parameters[3];
+iFramework.RouteRequestRegisterL( iExpectedSendObjectRequest, iConnection );
-parameters[0] = iStorageId;
-parameters[1] = iParentHandle;
+TUint32 parameters[3];
-parameters[2] = iReceivedObjectInfo->Uint( CMTPObjectMetaData::EHandle );
+parameters[0] = iStorageId;
-SendResponseL( EMTPRespCodeOK, 3, parameters );
+parameters[1] = iParentHandle;
+parameters[2] = iReceivedObjectInfo->Uint( CMTPObjectMetaData::EHandle );
+SendResponseL( EMTPRespCodeOK, 3, parameters );
+}
+else
+{
+SendResponseL( EMTPRespCodeGeneralError );
+Rollback();
+}
 PRINT( _L( "MM MTP <= CSendObject::ReserveObjectL" ) );
+return err;
 }
 // -----------------------------------------------------------------------------
 // CSendObject::SetProtectionStatus
 // -----------------------------------------------------------------------------
 PRINT1( _L("MM MTP <> CSendObject::SetProtectionStatus err = %d" ), err );
 }
 }
 // Close the file after SetProtectionStatus to make sure other process won't open
 // the file successfully right at the time calling RFile::SetAtt.
-delete iFileReceived;
+if ( iObjectSize > 0 )
-iFileReceived = NULL;
+{
+delete iFileReceived;
+iFileReceived = NULL;
+}
+else
+iFileReceived->File().Close();
 }
 PRINT( _L( "MM MTP <= CSendObject::SetProtectionStatus" ) );
 }
 //
 void CSendObject::SaveEmptyFileL()
 {
 PRINT( _L( "MM MTP => CSendObject::SaveEmptyFileL" ) );
-RFile file;
-User::LeaveIfError( file.Create( iFs, iFullPath, EFileWrite ) );
-CleanupClosePushL( file );  // + file
 if ( EMTPFormatCodeAbstractAudioVideoPlaylist == iObjectFormat )
 {
-TInt err = KErrNone;
+TInt err = iFileReceived->File().SetAtt( KEntryAttSystem | KEntryAttHidden,
-err = file.SetAtt( KEntryAttSystem | KEntryAttHidden,
 KEntryAttReadOnly | KEntryAttNormal );
 if ( err != KErrNone )
 PRINT1( _L( "MM MTP <> CSendObject::SaveEmptyFileL err = %d" ), err );
 iDpConfig.GetWrapperL().AddDummyFileL( iFullPath );
 }
-CleanupStack::PopAndDestroy( &file );   // - file
 // add playlist to MPX DB
 TRAPD( err, AddMediaToStoreL() );
 if ( err != KErrNone )
-{
+iRollbackList.Append( &CSendObject::RemoveObjectFromDbL );
-// Ignore err even add into MPX get failed.
+else
-}
+iRollbackList.Reset();
-PRINT1( _L( "MM MTP <= CSendObject::SaveEmptyFileLerr = %d" ), err );
+PRINT1( _L( "MM MTP <= CSendObject::SaveEmptyFileL err = %d" ), err );
 }
 // -----------------------------------------------------------------------------
 // CSendObject::AddMediaToStoreL()
 //
 // SetProtectionStatus here make sure no matter the previous operation is SendObjectInfo
 // or SendObjectPropList
 // Might need to set dateadded and datemodify for further extension.
 SetProtectionStatus();
-iDpConfig.GetWrapperL().SetStorageRootL( iFullPath );
 PRINT1( _L( "MM MTP <> CSendObject::AddMediaToStoreL iFullPath = %S" ), &iFullPath );
 iDpConfig.GetWrapperL().AddObjectL( *iReceivedObjectInfo );
 iDpConfig.GetWrapperL().SetImageObjPropL( *iReceivedObjectInfo, iWidth, iHeight );
 // delete the file, which transfer incompletely
 // -----------------------------------------------------------------------------
 //
 void CSendObject::Rollback()
 {
-// Delete this object from file system.
+PRINT( _L("MM MTP => CSendObject::Rollback") );
-if ( iProgress == ESendObjectInProgress )
-// || iProgress == EObjectInfoSucceed   // this line is to be commented out until SetSize is done in SendObjectInfo/SendObjectPropList
+TInt count = iRollbackList.Count();
-//||iProgress == EObjectInfoFail )
+PRINT1( _L("MM MTP => CSendObject::Rollback, iRollbackList.Count() = %d"), iRollbackList.Count() );
-{
-PRINT1( _L( "MM MTP <> CSendObject::Rollback ROLLBACK_FILE %S" ), &iFullPath );
+for ( TInt i = 0; i < count; i++ )
-// Close the interrupted transfer file by delete iFileReceived object
+{
-delete iFileReceived;
+TMmMtpRollbackAction tmp = iRollbackList[i];
-iFileReceived = NULL;
+( this->*((TMmMtpRollbackAction)(iRollbackList[i])))();
+}
-iFramework.Fs().Delete( iFullPath );
+iRollbackList.Reset();
-TRAP_IGNORE( iFramework.ObjectMgr().UnreserveObjectHandleL( *iReceivedObjectInfo ) );
-iProgress = EObjectNone;
+PRINT( _L("MM MTP <= CSendObject::Rollback") );
 }
+void CSendObject::UnreserveObjectL()
+{
+PRINT( _L("MM MTP => CSendObject::UnreserveObjectL") );
+iFramework.ObjectMgr().UnreserveObjectHandleL( *iReceivedObjectInfo );
+PRINT( _L("MM MTP <= CSendObject::UnreserveObjectL") );
+}
+void CSendObject::RemoveObjectFromDbL()
+{
+PRINT( _L("MM MTP => CSendObject::RemoveObjectFromDbL") );
+iFramework.ObjectMgr().RemoveObjectL( iReceivedObjectInfo->DesC( CMTPObjectMetaData::ESuid ) );
+iDpConfig.GetWrapperL().DeleteObjectL( *iReceivedObjectInfo );
+PRINT( _L("MM MTP <= CSendObject::RemoveObjectFromDbL") );
+}
+void CSendObject::RemoveObjectFromFs()
+{
+PRINT( _L("MM MTP => CSendObject::RemoveObjectFromFs") );
+delete iFileReceived;
+iFileReceived = NULL;
+TInt err = iFramework.Fs().Delete( iFullPath );
+if ( err != KErrNone )
+{
+PRINT1( _L("MM MTP <> CSendObject::RemoveObjectFromFs err = %d"), err );
+}
+PRINT( _L("MM MTP <= CSendObject::RemoveObjectFromFs") );
 }
 // end of file

changeset 32	edd273b3192a
parent 27	cbb1bfb7ebfb
child 35	2ee890d2f7e7