--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/mtpdataproviders/mtpimagedp/src/cmtpimagedpdeleteobject.cpp	Tue Feb 02 01:11:40 2010 +0200
@@ -0,0 +1,292 @@
+// Copyright (c) 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
+ @internalTechnology
+ */
+#include <bautils.h>
+#include <mtp/cmtptypearray.h>
+#include <mtp/cmtpobjectmetadata.h>
+#include <mtp/mmtpdataproviderframework.h>
+#include <mtp/mmtpobjectmgr.h>
+#include <mtp/mtpprotocolconstants.h>
+#include <mtp/mmtpstoragemgr.h>
+#include <mtp/tmtptyperequest.h>
+#include "cmtpimagedpdeleteobject.h"
+#include "mtpimagedpconst.h"
+#include "mtpimagedppanic.h"
+#include "cmtpimagedpobjectpropertymgr.h"
+#include "mtpimagedputilits.h"
+#include "cmtpimagedp.h"
+// Class constants.
+__FLOG_STMT(_LIT8(KComponent,"ImageDeleteObject");)
+/**
+ Standard c++ constructor
+ */
+CMTPImageDpDeleteObject::CMTPImageDpDeleteObject(
+        MMTPDataProviderFramework& aFramework, MMTPConnection& aConnection,
+        CMTPImageDataProvider& aDataProvider) :
+    CMTPRequestProcessor(aFramework, aConnection, 0, NULL),
+    iDataProvider(aDataProvider),
+    iResponseCode( EMTPRespCodeOK )
+    {
+    __FLOG_OPEN(KMTPSubsystem, KComponent);
+    __FLOG(_L8(">> CMTPImageDpDeleteObject"));
+    __FLOG(_L8("<< CMTPImageDpDeleteObject"));
+    }
+
+/**
+ Two-phase construction method
+ @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* CMTPImageDpDeleteObject::NewL(
+        MMTPDataProviderFramework& aFramework, MMTPConnection& aConnection,
+        CMTPImageDataProvider& aDataProvider)
+    {
+    CMTPImageDpDeleteObject* self = new (ELeave) CMTPImageDpDeleteObject(
+            aFramework, aConnection, aDataProvider);
+    CleanupStack::PushL(self);
+    self->ConstructL();
+    CleanupStack::Pop(self);
+    return self;
+    }
+
+void CMTPImageDpDeleteObject::ConstructL()
+    {
+    __FLOG(_L8(">> CMTPImageDpDeleteObject::ConstructL"));
+    iObjectMeta = CMTPObjectMetaData::NewL();
+    __FLOG(_L8("<< CMTPImageDpDeleteObject::ConstructL"));
+    }
+/**
+ Destructor
+ */
+CMTPImageDpDeleteObject::~CMTPImageDpDeleteObject()
+    {
+    __FLOG(_L8("~CMTPImageDpDeleteObject - Entry"));
+    Cancel();
+    delete iObjectMeta;
+    iObjectsToDelete.Close();
+    __FLOG(_L8("~CMTPImageDpDeleteObject - Exit"));
+    __FLOG_CLOSE;
+    }
+
+/**
+ Verify the request
+ @return EMTPRespCodeOK if request is verified, otherwise one of the error response codes
+ */
+
+TMTPResponseCode CMTPImageDpDeleteObject::CheckRequestL()
+    {
+    __FLOG(_L8(">> CMTPImageDpDeleteObject::CheckRequestL"));
+    TMTPResponseCode result = EMTPRespCodeOK;
+    TUint32 handle(Request().Uint32(TMTPTypeRequest::ERequestParameter1));
+    if ( handle != KMTPHandleAll )
+        {
+        result = CheckStorageL( handle );
+        }
+    __FLOG(_L8("<< CMTPImageDpDeleteObject::CheckRequestL"));
+    return result;
+    }
+
+/**
+ DeleteObject request handler
+ */
+void CMTPImageDpDeleteObject::ServiceL()
+    {
+    __FLOG(_L8(">> CMTPImageDpDeleteObject::ServiceL"));
+    
+    //begin to find object
+    iObjectsToDelete.Reset();
+    iResponseCode = EMTPRespCodeOK;
+    iObjectsNotDelete = 0;
+    TUint32 objectHandle( Request().Uint32( TMTPTypeRequest::ERequestParameter1 ));
+    TUint32 formatCode( Request().Uint32( TMTPTypeRequest::ERequestParameter2 ));
+    
+    // Check to see whether the request is to delete all images or a specific image
+    if ( objectHandle == KMTPHandleAll )
+        {
+        //add for test
+        __FLOG(_L8("delete all objects"));
+        GetObjectHandlesL( KMTPStorageAll, formatCode, KMTPHandleNone );
+        iObjectsNotDelete = iObjectsToDelete.Count();
+        StartL();
+        }
+    else
+        {
+        //add for test
+        __FLOG(_L8("delete only one object"));
+        iObjectsNotDelete = 1;
+        DeleteObjectL( objectHandle );
+        
+        SendResponseL();
+        }
+    
+    __FLOG(_L8("<< CMTPImageDpDeleteObject::ServiceL"));
+    }
+
+void CMTPImageDpDeleteObject::RunL()
+    {
+    __FLOG(_L8(">> CMTPImageDpDeleteObject::RunL"));
+    
+    TInt numObjectsToDelete = iObjectsToDelete.Count();
+    
+    if ( numObjectsToDelete > 0 )
+        {
+        DeleteObjectL( iObjectsToDelete[0] );
+        iObjectsToDelete.Remove( 0 );
+        }
+    
+    // Start the process again to read the next row...
+    StartL();
+    
+    __FLOG(_L8("<< CMTPImageDpDeleteObject::RunL"));
+    }
+
+void CMTPImageDpDeleteObject::DoCancel()
+    {
+    __FLOG(_L8(">> CMTPImageDpDeleteObject::DoCancel"));
+    
+    TRAP_IGNORE( SendResponseL());
+    
+    __FLOG(_L8("<< CMTPImageDpDeleteObject::DoCancel"));
+    }
+
+/**
+ Check whether the store on which the object resides is read only.
+ @return ETrue if the store is read only, EFalse if read-write
+ */
+TMTPResponseCode CMTPImageDpDeleteObject::CheckStorageL(TUint32 aObjectHandle)
+    {
+    __FLOG(_L8(">> CMTPImageDpDeleteObject::CheckStorageL"));
+    TMTPResponseCode result = MTPImageDpUtilits::VerifyObjectHandleL(
+            iFramework, aObjectHandle, *iObjectMeta);
+    if (EMTPRespCodeOK == result)
+        {
+        TDriveNumber drive= static_cast<TDriveNumber>(iFramework.StorageMgr().DriveNumber(
+                                                      iObjectMeta->Uint(CMTPObjectMetaData::EStorageId)));
+        User::LeaveIfError(drive);
+        TVolumeInfo volumeInfo;
+        User::LeaveIfError(iFramework.Fs().Volume(volumeInfo, drive));
+        if (volumeInfo.iDrive.iMediaAtt == KMediaAttWriteProtected)
+            {
+            result = EMTPRespCodeStoreReadOnly;
+            }
+        }
+    __FLOG(_L8("<< CMTPImageDpDeleteObject::CheckStorageL"));
+    return result;
+    }
+
+void CMTPImageDpDeleteObject::GetObjectHandlesL( TUint32 aStorageId, TUint32 aFormatCode, TUint32 aParentHandle )
+    {
+    __FLOG(_L8(">> CMTPImageDpDeleteObject::GetObjectHandlesL"));
+    
+    RMTPObjectMgrQueryContext context;
+    RArray<TUint> handles;
+    TMTPObjectMgrQueryParams params( aStorageId, aFormatCode, aParentHandle, iFramework.DataProviderId());
+    CleanupClosePushL( context ); // + context
+    CleanupClosePushL( handles ); // + handles
+    
+    do
+        {
+        iFramework.ObjectMgr().GetObjectHandlesL( params, context, handles );
+        for ( TInt i = 0; i < handles.Count(); i++)
+            {
+            iObjectsToDelete.Append( handles[i] );
+            }
+        }
+    while ( !context.QueryComplete() );
+    
+    CleanupStack::PopAndDestroy( &handles ); // - handles
+    CleanupStack::PopAndDestroy( &context ); // - context
+    
+    __FLOG(_L8("<< CMTPImageDpDeleteObject::GetObjectHandlesL"));
+    }
+
+void CMTPImageDpDeleteObject::DeleteObjectL( TUint32 aHandle )
+    {
+    __FLOG(_L8(">> CMTPImageDpDeleteObject::DeleteObjectL"));
+    
+    iFramework.ObjectMgr().ObjectL( aHandle, *iObjectMeta);
+    iDataProvider.PropertyMgr().SetCurrentObjectL(*iObjectMeta, EFalse);
+    TUint16 protectionStatus = EMTPProtectionNoProtection;
+    iDataProvider.PropertyMgr().GetPropertyL(EMTPObjectPropCodeProtectionStatus, protectionStatus);
+    if(EMTPProtectionNoProtection == protectionStatus)
+        {
+        TInt err = iFramework.Fs().Delete(iObjectMeta->DesC(CMTPObjectMetaData::ESuid));
+        __FLOG_1(_L8("delete file error is %d"), err );
+        switch ( err )
+            {
+            case KErrInUse:
+            case KErrAccessDenied:
+                //add for test 
+                __FLOG_1(_L8("err:%d"), err);
+                //add Suid to deleteobjectlist
+                iDataProvider.AppendDeleteObjectsArrayL(iObjectMeta->DesC(CMTPObjectMetaData::ESuid));
+            case KErrNone:
+                //add for test
+                __FLOG(_L8("KErrNone"));
+                iFramework.ObjectMgr().RemoveObjectL( iObjectMeta->Uint(CMTPObjectMetaData::EHandle ));
+                iObjectsNotDelete--;
+                iResponseCode = EMTPRespCodePartialDeletion;
+                break;
+            default:
+                //add for test
+                __FLOG(_L8("default"));
+                User::LeaveIfError( err );
+                break;
+            }
+        }
+    else if ( iResponseCode != EMTPRespCodePartialDeletion )
+        {
+        iResponseCode = EMTPRespCodeObjectWriteProtected;
+        }
+    __FLOG(_L8("<< CMTPImageDpDeleteObject::DeleteObjectL"));
+    }
+
+void CMTPImageDpDeleteObject::StartL()
+    {
+    __FLOG(_L8(">> CMTPImageDpDeleteObject::StartL"));
+    
+    TInt numObjectsToDelete = iObjectsToDelete.Count();
+
+    if ( numObjectsToDelete > 0 )
+        {
+        //Set the active object going to delete the file
+        TRequestStatus* status = &iStatus;
+        User::RequestComplete( status, KErrNone );
+        SetActive();
+        }
+    else
+        {
+        SendResponseL();
+        }
+    __FLOG(_L8("<< CMTPImageDpDeleteObject::StartL"));
+    }
+
+void CMTPImageDpDeleteObject::SendResponseL()
+    {
+    __FLOG(_L8(">> CMTPImageDpDeleteObject::SendResponseL"));
+    
+    if ( iResponseCode == EMTPRespCodePartialDeletion && iObjectsNotDelete == 0 )
+        {
+        iResponseCode = EMTPRespCodeOK;
+        }
+    CMTPRequestProcessor::SendResponseL( iResponseCode );
+    
+    __FLOG(_L8("<< CMTPImageDpDeleteObject::SendResponseL"));
+    }
+