/*

* Copyright (c) 2006 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:  MPX delete helper

*

*/

#include <e32base.h>

#include <f32file.h>

#include <mpxmedia.h>

#include <mpxmediageneraldefs.h>

#include <mpxcommandgeneraldefs.h>

#include <mpxcollectioncommanddefs.h>

#include <mpxcollectionpath.h>

#include <mpxcollectionplaylist.h>

#include <mpxplaybackutility.h>

#include <mpxcollectionutility.h>

#include <mpxharvesterutility.h>

#include <mpxplaybackutility.h>

#include <mpxlog.h>

#include <mpxmessagegeneraldefs.h>

#include <mpxcollectionmessage.h>

#include <mpxcollectionmessagedefs.h>

#include <mpxsubscription.h>

#include <mpxharvestercommon.h>

#ifdef RD_MPX_TNM_INTEGRATION

#include <hash.h>

#include <eikenv.h>

#include <f32file.h>

#include <sysutil.h>

#include <thumbnailmanager.h>

#endif //RD_MPX_TNM_INTEGRATION

// cenrep key need to be checked whether USB cable is connected in MTP/Combined Mode

#include <mpxcollectionuihelper.h>

#include "mpxcollectionuihelperobserver.h"

#include "mpxcollectionhelpercommon.h"

#include "mpxdeletehelper.h"

// Constants

const TInt KSQLErrGeneral = -311; // SQL General error. Don't want to include sql header here

const TInt KDeleteUpdateCount = 50;  // Max # of times to update delete status during a group delete. Value (1-100)

#ifdef RD_MPX_TNM_INTEGRATION

_LIT( KImageFileType, "image/jpeg" );

#endif //RD_MPX_TNM_INTEGRATION

// ---------------------------------------------------------------------------

// Constructor

// ---------------------------------------------------------------------------

//

CMPXDeleteHelper::CMPXDeleteHelper(MMPXCollectionUtility& aCollectionUtility,

                                   MMPXHarvesterUtility& aHarvesterUtility,

                                   MMPXCHelperObserver& aObserver)

:   CActive(CActive::EPriorityLow),

    iCollectionUtil(aCollectionUtility),

    iHarvester(aHarvesterUtility),

    iObserver(aObserver),

    iMoreToDo(ETrue),

    iHadInUse(EFalse),

    iState(EMPXIdle),

    iDeletePercent(0),

    iDeleteIncFactor(1),

    iDeleteCount(0),

    iUsbManConnected( EFalse )

    {

    CActiveScheduler::Add(this);

    }

// ---------------------------------------------------------------------------

// 2nd Phase Constructor

// ---------------------------------------------------------------------------

//

void CMPXDeleteHelper::ConstructL()

    {

    iFiles = new(ELeave)CDesCArrayFlat(4);

    iMessageArray = CMPXMessageArray::NewL();

    // Connect to usbman

    ConnectUsbMan();

#ifdef __USE_MESSAGE_SUBSCRIPTION

    // Subscribe to only a few messages from collection utility

    CMPXSubscription* subscription( CMPXSubscription::NewL() );

    CleanupStack::PushL( subscription );

    CMPXSubscriptionItem* subItem1( CMPXSubscriptionItem::NewL() );

    CleanupStack::PushL( subItem1 );

    subItem1->SetTObjectValueL( KMPXMessageGeneralId, KMPXMessageGeneral );

    subItem1->SetTObjectValueL( KMPXMessageGeneralEvent, TMPXCollectionMessage::EBroadcastEvent );

    subItem1->SetTObjectValueL( KMPXMessageGeneralType, EMcMsgFormatStart );

    subscription->AddItemL( *subItem1 );

    CMPXSubscriptionItem* subItem2( CMPXSubscriptionItem::CopyL( *subItem1 ));

    CleanupStack::PushL( subItem2 );

    subItem2->SetTObjectValueL( KMPXMessageGeneralType, EMcMsgDiskRemoved );

    subscription->AddItemL( *subItem2 );

    CMPXSubscriptionItem* subItem3( CMPXSubscriptionItem::CopyL( *subItem1 ));

    CleanupStack::PushL( subItem3 );

    subItem3->SetTObjectValueL( KMPXMessageGeneralType, EMcMsgUSBMassStorageStart );

    subscription->AddItemL( *subItem3 );

    CMPXSubscriptionItem* subItem4( CMPXSubscriptionItem::CopyL( *subItem1 ));

    CleanupStack::PushL( subItem4 );

    subItem4->SetTObjectValueL( KMPXMessageGeneralType, EMcMsgUSBMTPStart );

    subscription->AddItemL( *subItem4 );

    CMPXSubscriptionItem* subItem5( CMPXSubscriptionItem::CopyL( *subItem1 ));

    CleanupStack::PushL( subItem5 );

    iCollectionUtil.Collection().AddSubscriptionL( *subscription );

    CleanupStack::PopAndDestroy( subItem5 );

    CleanupStack::PopAndDestroy( subItem4 );

    CleanupStack::PopAndDestroy( subItem3 );

    CleanupStack::PopAndDestroy( subItem2 );

    CleanupStack::PopAndDestroy( subItem1 );

    CleanupStack::PopAndDestroy( subscription );

#endif

#ifdef RD_MPX_TNM_INTEGRATION

    // Create Thumbnail Manager instance. This object is the observer.

    iTNManager = CThumbnailManager::NewL( *this );

#endif //RD_MPX_TNM_INTEGRATION

    }

// ---------------------------------------------------------------------------

// Two-Phased Constructor

// ---------------------------------------------------------------------------

//

CMPXDeleteHelper* CMPXDeleteHelper::NewL(MMPXCollectionUtility& aCollectionUtility,

                                         MMPXHarvesterUtility& aHarvesterUtility,

                                         MMPXCHelperObserver& aObserver)

    {

    CMPXDeleteHelper* self =

        new(ELeave)CMPXDeleteHelper( aCollectionUtility,

                                     aHarvesterUtility,

                                     aObserver );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

// ---------------------------------------------------------------------------

// Destructor

// ---------------------------------------------------------------------------

//

CMPXDeleteHelper::~CMPXDeleteHelper()

    {

    if( iPbUtil )

        {

        iPbUtil->Close();

        }

    delete iDeletePath;

    delete iFiles;

    delete iMessageArray;

#ifdef RD_MPX_TNM_INTEGRATION

    delete iTNManager;

#endif //RD_MPX_TNM_INTEGRATION

    if ( iUsbManConnected )

        {

        iUsbMan.Close();

        }

    }

// ---------------------------------------------------------------------------

// Start the delete operation

// ---------------------------------------------------------------------------

//

void CMPXDeleteHelper::DeleteL( CMPXCollectionPath& aPath )

    {

    MPX_DEBUG1("CMPXDeleteHelper::DeleteL()");

    MPX_DEBUG_PATH(aPath);

    TInt deletePercentFactor = 100 / KDeleteUpdateCount;

    if( iPbUtil )

        {

        iPbUtil->Close();

        iPbUtil = NULL;

        }

    iPbUtil = MMPXPlaybackUtility::UtilityL();

    iDeletePath = CMPXCollectionPath::NewL( aPath );

    iState = EMPXInitDelete;

    iDeleteCount = 0;

    iMessageArray->Reset();

    RArray<TMPXItemId> selections;

    CleanupClosePushL(selections);

    iDeletePath->SelectionL(selections);

    iItemsCount = selections.Count();

    CleanupStack::PopAndDestroy(&selections);

    iRetrievedItemsCount = 0;

    // Calculate percent increment factor used during a delete.

    if ( (iItemsCount > 0) && (iItemsCount < KDeleteUpdateCount) )

        {

        TReal factor = (KDeleteUpdateCount/iItemsCount) * deletePercentFactor;

        iDeleteIncFactor = factor;

        }

    else

        {

        iDeleteIncFactor = deletePercentFactor;

        }

    TRequestStatus* status = &iStatus;

    *status = KRequestPending;

    User::RequestComplete(status, KErrNone);

    SetActive();

    }

// ---------------------------------------------------------------------------

// From MMPXCollectionObserver

// to-do: this should be changed to HandleCollectionMessage

// ---------------------------------------------------------------------------

//

void CMPXDeleteHelper::HandleCollectionMessage(CMPXMessage* aMessage, TInt /*aErr*/)

    {

    if( aMessage &&

        aMessage->IsSupported(KMPXMessageGeneralEvent) &&

        aMessage->IsSupported(KMPXMessageGeneralType) )

        {

        TInt event( aMessage->ValueTObjectL<TInt>( KMPXMessageGeneralEvent ) );

        TInt op( aMessage->ValueTObjectL<TInt>( KMPXMessageGeneralType ) );

        MPX_DEBUG3( "CMPXDeleteHelper::HandleCollectionMessageL event = %d, type = %d",

                    event, op );

        if( event == TMPXCollectionMessage::EBroadcastEvent )

            {

            if( op == EMcMsgFormatStart ||

                op == EMcMsgDiskRemoved ||

                op == EMcMsgUSBMassStorageStart ||

                op == EMcMsgUSBMTPStart )

                {

                iCancelled = ETrue;

                Cancel();

                }

            }

        }

    }

// ---------------------------------------------------------------------------

// Start the delete operation

// ---------------------------------------------------------------------------

//

void CMPXDeleteHelper::DoTaskStep()

    {

    MPX_DEBUG1("CMPXDeleteHelper::DoTaskStep()");

    TRequestStatus* status = &iStatus;

    *status = KRequestPending;

    TRAPD( error, DoTaskStepL() );

    User::RequestComplete( status, error );

    }

// ---------------------------------------------------------------------------

// Start the delete operation

// to-do: delete file first before removing it from the collection

// ---------------------------------------------------------------------------

//

void CMPXDeleteHelper::DoTaskStepL()

    {

    MPX_DEBUG1("CMPXDeleteHelper::DoTaskStepL()");

    switch(iState)

        {

        case EMPXInitDelete:

            {

            StartDeleteL();  

            iState = EMPXPreparation;

            break;

            }

        case EMPXPreparation:

            {

            RetrieveFileListL();

            iState = EMPXDelete;

            break;

            }

        case EMPXDelete:

            {

            DeleteL();

            break;

            }

        default:

            break;

        }

    }

// ----------------------------------------------------------------------------

// Handles request completion event

// ----------------------------------------------------------------------------

//

void CMPXDeleteHelper::RunL()

    {

    MPX_DEBUG3("CMPXDeleteHelper::RunL. [iMoreToDo %d] [iStatus %d]", iMoreToDo, iStatus.Int());

        {

        }

    if (iMoreToDo && iStatus.Int() == KErrNone)

        {

        DoTaskStep();

        SetActive();

        }

    else

        {

        CompleteDelete(iStatus.Int());

        }

    }

// ---------------------------------------------------------------------------

// Cancel the delete operation

// ---------------------------------------------------------------------------

//

void CMPXDeleteHelper::DoCancel()

    {

    MPX_DEBUG3("CMPXDeleteHelper::DoCancel iStatus %d, iState %d", iStatus.Int(), iState);

    CompleteDelete(iStatus.Int());

    }

// ---------------------------------------------------------------------------

// End state for a delete operation

// ---------------------------------------------------------------------------

//

void CMPXDeleteHelper::CompleteDelete( TInt aErr )

    {

    MPX_DEBUG2("CMPXDeleteHelper::CompleteDelete %d", aErr);

    TRAP_IGNORE( DoCompleteDeleteL( aErr ) );

    }

// ---------------------------------------------------------------------------

// End state for a delete operation

// ---------------------------------------------------------------------------

//

void CMPXDeleteHelper::DoCompleteDeleteL( TInt aErr )

    {

    MPX_DEBUG3("CMPXDeleteHelper::CompleteDeleteL error %d cancelled %d", aErr, iCancelled);

    if( iState != EMPXIdle )

        {

        // Finally callback to observer and complete task queue event

        // to-do: change HandleOperationCompletedL to HandleOperationComplete

        TInt error = iHadInUse ? KErrInUse : aErr;

        // Error cases that need to be ignored when mmc card is removed

        if( error == KErrBadName ||

            error == KErrNotReady ||

            error == KErrAbort ||

            error == KSQLErrGeneral ||

            (iCancelled && error == KErrNotFound) )

            {

            error = KErrNone;

            }

        // Reset all states

        Reset();

        // Close Harvester database transaction

        TRAP_IGNORE(iHarvester.CloseTransactionL() );

        // Send a complete delete command to finish off the delete operation

        //

        CMPXCommand* cmd = CMPXCommand::NewL();

        CleanupStack::PushL( cmd );

        cmd->SetTObjectValueL(KMPXCommandGeneralId,KMPXCommandIdCollectionCompleteDelete);

        cmd->SetTObjectValueL(KMPXCommandGeneralDoSync, ETrue);

        cmd->SetTObjectValueL(KMPXCommandCollectionDeleteCompactDb, ETrue);

        cmd->SetCObjectValueL(KMPXCommandCollectionDeleteMsgArray, iMessageArray);

        iCollectionUtil.Collection().CommandL(*cmd);

        CleanupStack::PopAndDestroy( cmd );

        TRAP_IGNORE(iObserver.HandleOperationCompleteL( EDeleteOp, error, NULL ) );

        // Message array ownership passed to engine

        delete iMessageArray;

        iMessageArray = NULL;

        iMessageArray = CMPXMessageArray::NewL();

        if( iPbUtil )

            {

            iPbUtil->Close();

            iPbUtil = NULL;

            }

        iCancelled = EFalse;

        }

    }

// ---------------------------------------------------------------------------

// Resets members to get ready for the next client request

//

// ---------------------------------------------------------------------------

//

void CMPXDeleteHelper::Reset()

    {

    MPX_DEBUG1("CMPXDeleteHelper::Reset");

    iMoreToDo = ETrue;

    iHadInUse = EFalse;

    iDeleteCount = 0;

    iDeletePercent = 0;

    iDeleteIncFactor = 1;

    iState = EMPXIdle;

    delete iDeletePath;

    iDeletePath = NULL;

    iFiles->Reset();

    }

// ---------------------------------------------------------------------------

// Perfom cleanup of all unused data before delete

//

// ---------------------------------------------------------------------------

//

void CMPXDeleteHelper::StartDeleteL()

    {

    //

    // set up the command to send to the collection

    //

    CMPXCommand* command = CMPXCommand::NewL();

    CleanupStack::PushL(command);

    command->SetTObjectValueL<TMPXCommandId>(

        TMPXAttribute(KMPXCommandContentIdGeneral, EMPXCommandGeneralId), KMPXCommandIdCollectionPrepareDelete);

    command->SetTObjectValueL<TBool>(

        TMPXAttribute(KMPXCommandContentIdGeneral, EMPXCommandGeneralDoSync), ETrue);

    command->SetCObjectValueL(

        TMPXAttribute(KMPXCommandIdCollectionPrepareDelete, EMPXCommandCollectionRetrievePath), 

        iDeletePath);

    // send sync prepare delete URI command    

    iCollectionUtil.Collection().CommandL(*command);

    CleanupStack::PopAndDestroy(command);

}

//

// Retrieve files associated with the path

//

// ---------------------------------------------------------------------------

//

void CMPXDeleteHelper::RetrieveFileListL()

    {

    //

    // set up the command to send to the collection

    //

    CMPXCommand* command = CMPXCommand::NewL();

    CleanupStack::PushL(command);

    command->SetTObjectValueL<TMPXCommandId>(

        TMPXAttribute(KMPXCommandContentIdGeneral, EMPXCommandGeneralId), KMPXCommandIdCollectionRetrieveUriForDeletion);

    command->SetTObjectValueL<TBool>(

        TMPXAttribute(KMPXCommandContentIdGeneral, EMPXCommandGeneralDoSync), ETrue);

    command->SetCObjectValueL(

        TMPXAttribute(KMPXCommandIdCollectionRetrieveUriForDeletion, EMPXCommandCollectionRetrievePath),

        iDeletePath);

    // send sync retrieve URI command

    iCollectionUtil.Collection().CommandL(*command);

    //

    // return command should contain error and URI array

    //

    if (!command->IsSupported(TMPXAttribute(KMPXCommandIdCollectionRetrieveUriForDeletion, EMPXCommandCollectionRetrieveUriError)) ||

        !command->IsSupported(TMPXAttribute(KMPXCommandIdCollectionRetrieveUriForDeletion, EMPXCommandCollectionRetrieveMediaUriArray)))

        {

        User::Leave(KErrAbort);

        }

    //

    // abandon operation if an error occured removing a media from the collection

    //

    TInt error =

         command->ValueTObjectL<TInt>(

            TMPXAttribute(KMPXCommandIdCollectionRetrieveUriForDeletion, EMPXCommandCollectionRetrieveUriError));

    User::LeaveIfError(error);

    //

    // retrieve the list of files to be deleted

    //

    CDesCArray* files =

        command->ValueNoNewLCObjectL<CDesCArray>(

            TMPXAttribute(KMPXCommandIdCollectionRetrieveUriForDeletion, EMPXCommandCollectionRetrieveMediaUriArray));

    CleanupStack::PushL(files);

    ::CopyArrayL(*files, *iFiles);

    iRetrievedItemsCount +=files->MdcaCount();

    CleanupStack::PopAndDestroy(files);

    //

    // retrieve the updated path. If the original path ends at a particular artist,

    // album, genre, or composer, the path will have been expended to include the

    // songs under that category

    //

    delete iDeletePath;

    iDeletePath = NULL;

    iDeletePath =

        command->ValueCObjectL<CMPXCollectionPath>(

            TMPXAttribute(KMPXCommandIdCollectionRetrieveUriForDeletion, EMPXCommandCollectionRetrievePath));

    CleanupStack::PopAndDestroy(command);

    }

// ---------------------------------------------------------------------------

// Deletes the file from the file system then deletes it from the collection

// ---------------------------------------------------------------------------