/*

* 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:  Implementation of collection DB Plugin interface

*

*/

// INCLUDE FILES

#include <e32cmn.h>

#include <StringLoader.h>

#include <bautils.h>

#include <data_caging_path_literals.hrh>

#include <mpxcmn.h>

#include <mpxuser.h>

#include <mpxcollectionpluginobserver.h>

#include <mpxmediacontainerdefs.h>

#include <mpxmediamusicdefs.h>

#include <mpxmediaaudiodefs.h>

#include <mpxmediacollectiondetaildefs.h>

#include <mpxcommandgeneraldefs.h>

#include <mpxmessagegeneraldefs.h>

#include <mpxmessagecontainerdefs.h>

#include <mpxcollectioncommanddefs.h>

#include <mpxcollectionmessagedefs.h>

#include <mpxincrementalopendefs.h>

#include <mpxcollectionopenlresultdef.h>

#include <mpxmedia.h>

#include <mpxmediaarray.h>

#include <mpxdrmmediautility.h>

#include <mpxmediadrmdefs.h>

#include <mpxlog.h>

#include <mpxcollectiondbhgres.rsg>

#include <mpxdbhgplugin.mbg>

#include <centralrepository.h>

#ifdef RD_MULTIPLE_DRIVE

#include <driveinfo.h>

#endif //RD_MULTIPLE_DRIVE

#include "mpxresource.h"

#include "mpxdbcommondef.h"

#include "mpxdbcommonutil.h"

#include "mpxdbhandler.h"

#include "mpxdbutil.h"

#include "mpxcollectiondbdef.h"

#include "mpxdbplugin.h"

// CONSTANTS

_LIT(KMPlayerDbPluginMbmFile, "mpxdbhgplugin.mif");

const TInt KFirstFetchCount = 400;

const TUid KCRUIDMusicPlayerFeatures = { 0x101FFCD0 };

const TInt KMusicPlayerFeatures = 1;

const TInt KDisablePodcasting = 0x80;

const TInt KIncrementalDeleteCount = 400;

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

// ============================ MEMBER FUNCTIONS ==============================

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

// Two-phased constructor.

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

//

CMPXDbPlugin* CMPXDbPlugin::NewL(

    TAny* /*aInitParams*/)

    {

    MPX_FUNC("CMPXDbPlugin::NewL");

    CMPXDbPlugin* self = new (ELeave) CMPXDbPlugin();

    CleanupStack::PushL (self);

    self->ConstructL ();

    CleanupStack::Pop (self);

    return self;

    }

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

// Destructor.

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

//

CMPXDbPlugin::~CMPXDbPlugin()

    {

    MPX_FUNC("CMPXDbPlugin::~CMPXDbPlugin");

    iSelections.Reset();

    iSelections.Close();

    iFs.Close();

    delete iDbHandler;

    delete iDrmMediaUtility;

    if (iResource)

        {

        iResource->Release();

        }

    iMusicLibraryMenuIds.Close();

    delete iMusicLibraryMenuTitles;

    delete iMusicLibraryTitles;

    delete iAllSongsForArtistTitle;

    delete iMusicMenuTitle;

    delete iShuffleAllText;

    if (iActiveTask)

        {

        iActiveTask->Cancel();

        delete iActiveTask;

        }

    }

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

// Constructor.

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

//

CMPXDbPlugin::CMPXDbPlugin()

    {

    MPX_FUNC("CMPXDbPlugin::CMPXDbPlugin");

    }

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

// Symbian 2nd phase constructor can leave.

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

//

void CMPXDbPlugin::ConstructL()

    {

    MPX_FUNC("CMPXDbPlugin::ConstructL");

    iFirstDeleteStep = ETrue;

    User::LeaveIfError(iFs.Connect());

    iDrmMediaUtility = CMPXDrmMediaUtility::NewL();

    TParse parse;

    parse.Set( KMPXCollectionDbResourceFile, &KDC_APP_RESOURCE_DIR, NULL );

    TFileName resFile(parse.FullName());

    User::LeaveIfError(MPXUser::CompleteWithDllPath(resFile));

    BaflUtils::NearestLanguageFile(iFs, resFile);

    iResource = CMPXResource::NewL(resFile);

    iDbHandler = CMPXDbHandler::NewL(iFs, *iResource);

    iMusicLibraryMenuTitles = iResource->ReadMenuArrayL(R_MC_MENU_ITEMS_ARRAY, iMusicLibraryMenuIds);

    iMusicLibraryTitles = iResource->ReadMenuArrayL(R_MC_TITLE_ITEMS_ARRAY, iMusicLibraryMenuIds );

    iAllSongsForArtistTitle = iResource->ReadHBufCL(R_MC_ALL_SONGS_FOR_ARTIST);

#ifdef __ENABLE_MUSIC_TEXT_ALIGNMENT

    iMusicMenuTitle = iResource->ReadHBufCL(R_MPX_QTN_MP_TITLE_MY_MUSIC_MENU_NSERIES);

#else

    iMusicMenuTitle = iResource->ReadHBufCL(R_MPX_QTN_MUS_TITLE_MUSIC_MENU);

#endif // __ENABLE_MUSIC_TEXT_ALIGNMENT

    iShuffleAllText = iResource->ReadHBufCL(R_MC_SHUFFLE_ALL);

    iActiveTask = CMPXDbActiveTask::NewL(*this);

    CRepository* cenrep(NULL);

    TRAPD( err, cenrep = CRepository::NewL( KCRUIDMusicPlayerFeatures ) );

    if( err == KErrNone )

        {

        TInt val(0);

        cenrep->Get( KMusicPlayerFeatures, val );

        iDisablePodcasting = val&KDisablePodcasting ? ETrue:EFalse;

        delete cenrep;

        }

    else

        {

        iDisablePodcasting = EFalse;

        }

    iAllSongsValid = ETrue;

    }

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

// Navigates to the given path

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

//

void CMPXDbPlugin::OpenL(

    const CMPXCollectionPath& aPath,

    const TArray<TMPXAttribute>& /*aAttrs*/,

    CMPXFilter* aFilter)

    {

    MPX_FUNC("CMPXDbPlugin::OpenL");

    MPX_DEBUG_PATH(aPath);

    //Create a path object to be returned.

    CMPXCollectionPath* path = CMPXCollectionPath::NewL(aPath);

    CleanupStack::PushL(path);

    RArray<TMPXAttribute> openAttrs;

    CleanupClosePushL(openAttrs);

    RArray<TInt> supportedIds;

    CleanupClosePushL(supportedIds);

    // Replace the attributes requested by the client with the ones below.

    // This will eventually have to be fixed

    SetAttributesL(aPath, openAttrs, supportedIds);

    CMPXMedia* entries = CMPXMedia::NewL(supportedIds.Array());

    CleanupStack::PopAndDestroy(&supportedIds);

    CleanupStack::PushL(entries);

    //Add returned path into media

    entries->SetTObjectValueL<TInt>(KMPXMediaGeneralValue, (TInt)path);

    TInt error(KErrNone);

    TBool isASong(EFalse);

    CMPXCollectionPath* newPath(NULL);

    // Make sure we handle open the correct open mode

    //

    TMPXOpenMode openmode = aPath.OpenNextMode();

    switch (openmode)

        {

        case EMPXOpenGroupOrPlaylist:

            {

            // Open By Path

            MPX_TRAP(error, isASong = DoOpenL(aPath, openAttrs.Array(), *entries, aFilter));

            break;

            }

        case EMPXOpenPlaylistOnly:

            {

            if (aPath.Count() > 0)

                {

                // Try to open

                MPX_TRAP(error, newPath = DoOpenPlaylistL(aPath, openAttrs.Array()));

                CleanupStack::PushL(newPath);

                isASong = ETrue;

                }

            else // no items

                {

                MPX_TRAP(error, isASong = DoOpenL(aPath, openAttrs.Array(), *entries, aFilter));

                }

            break;

            }

        default:

            // do nothing

            break;

        }

    // generate the callback

    if (isASong )

        {

        if (openmode == EMPXOpenGroupOrPlaylist)

            {

            iObs->HandleOpen(const_cast<CMPXCollectionPath*>(&aPath), error);

            }

        else  // openmode == EMPXOpenPlaylistOnly

            {

            iObs->HandleOpen(newPath, error);

            }

        }

    else

        {

        entries->SetCObjectValueL(KMPXMediaGeneralContainerPath,

            const_cast<CMPXCollectionPath*>(&aPath));

        entries->Delete(KMPXMediaGeneralValue);

        iObs->HandleOpen(entries, path, error);

        }

    if (newPath)

        {

        CleanupStack::PopAndDestroy(newPath);

        }

    CleanupStack::PopAndDestroy(entries);

    CleanupStack::PopAndDestroy(&openAttrs);

    CleanupStack::PopAndDestroy(path);

    }

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

// Get the extended properties of the current file (async)

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

//

void CMPXDbPlugin::MediaL(

    const CMPXCollectionPath& aPath,

    const TArray<TMPXAttribute>& aAttrs,

    const TArray<TCapability>& /*aCaps*/,

    CMPXAttributeSpecs* /*aSpecs*/)

    {

    MPX_FUNC("CMPXDbPlugin::MediaL");

    MPX_DEBUG_PATH(aPath);

    RArray<TInt> supportedIds;

    CleanupClosePushL(supportedIds);

    if (aPath.Selection().Count())

        {

        // it's a container if there are multiple selection, else it's not a container

        supportedIds.AppendL(KMPXMediaIdContainer);

        }

    MPXDbCommonUtil::FillInSupportedUIDsL(aAttrs, supportedIds);

    CMPXMedia* entries = CMPXMedia::NewL(supportedIds.Array());

    CleanupStack::PopAndDestroy(&supportedIds);

    CleanupStack::PushL(entries);

    DoMediaL(aPath, aAttrs, *entries);

    // Also fetch collection details and set the path if required

    DoHandleOtherMediaAttributesL(aAttrs, aPath, *entries);

    iObs->HandleMedia(entries, KErrNone);

    CleanupStack::PopAndDestroy(entries);

    }

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

// Cancel outstanding request

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

//

void CMPXDbPlugin::CancelRequest()

    {

    MPX_FUNC("CMPXDbPlugin::CancelRequest");

    iActiveTask->Cancel();

    }

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

// Executes the given command on the collection

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

//

void CMPXDbPlugin::CommandL(

    TMPXCollectionCommand aCmd,

    TInt aArg /* = 0 */)

    {

    MPX_FUNC("CMPXDbPlugin::CommandL");

    MPX_DEBUG2("CMPXDbPlugin::CommandL %d", aCmd);

    iAllSongsValid = ETrue;

    switch (aCmd)

        {

        case EMcCmdRemoveAll:

            {

            MPX_DEBUG1("CMPXDbPlugin::CommandL - EMcCmdRemoveAll");

            // Remove EVERYthing from the collection

            iDbHandler->RemoveEntireCollectionL();

            break;

            }

        case EMcCmdClose:

        case EMcCloseCollection:

            {

            MPX_DEBUG1("CMPXDbPlugin::CommandL - EMcCloseCollection");

            // Close the specified database

            TRAP_IGNORE(iDbHandler->PreCloseCollectionL());

 #ifdef RD_MULTIPLE_DRIVE

            MPX_DEBUG1("Multiple drives closing databases");

            if ( aArg <0)

                {

                DriveInfo::TDriveArray driveArray;

                User::LeaveIfError ( DriveInfo::GetUserVisibleDrives( iFs, driveArray));

                TInt count( driveArray.Count ());

                for (TInt i=0; i<count; ++i)

                    {

                    MPX_DEBUG2("At drive %i", driveArray[i]);

                    if (( driveArray[i] != EDriveC) && (!iDbHandler->IsRemoteDrive(static_cast<TDriveNumber>(driveArray[i]))))

                        {

                        MPX_DEBUG2("Closing database %i", driveArray[i]);

                        TRAP_IGNORE( iDbHandler->CloseDatabaseL( driveArray[i] ) );

                        }

                    }

                }

            else

                {

                iDbHandler->CloseDatabaseL(aArg);

                }

 #else

            iDbHandler->CloseDatabaseL(aArg);

 #endif // RD_MULTIPLE_DRIVE

            iDbHandler->CollectionClosed();

            break;

            }

        case EMcReOpenCollection:

            {

            MPX_DEBUG1("CMPXDbPlugin::CommandL - EMcReOpenCollection");

            // Open the specified database

#ifdef RD_MULTIPLE_DRIVE

            MPX_DEBUG1("Multiple drives opening databases");

            DriveInfo::TDriveArray driveArray;

            User::LeaveIfError( DriveInfo::GetUserVisibleDrives( iFs, driveArray ) );

            TInt count( driveArray.Count() );

            for( TInt i=0; i<count; ++i )

                {

                MPX_DEBUG2("At drive %i", driveArray[i]);

                if( (driveArray[i] != EDriveC)  && (!iDbHandler->IsRemoteDrive(static_cast<TDriveNumber>(driveArray[i]))))

                    {

                    TUint driveStatus(0);

                    User::LeaveIfError( DriveInfo::GetDriveStatus(

                        iFs, driveArray[i], driveStatus ) );

                    if( driveStatus & DriveInfo::EDrivePresent )

                        {

                        MPX_DEBUG2("Opening database %i", driveArray[i]);

                        TRAP_IGNORE( iDbHandler->OpenDatabaseL( driveArray[i] ) );

                        }

                    }

                }

#else

            iDbHandler->OpenDatabaseL(aArg);

#endif // RD_MULTIPLE_DRIVE

            TRAP_IGNORE(iDbHandler->CollectionOpenedL());

            break;

            }

        case EMcRefreshStarted:

            {

            MPX_DEBUG1("CMPXDbPlugin::CommandL - EMcRefreshStarted");

            iDbHandler->CheckDiskSpaceOnDrivesL();

            // ask the handler to start a transaction

            iDbHandler->RefreshStartL();

            iRefreshing=ETrue;

            break;

            }

        case EMcRefreshEnded:

            {

            MPX_DEBUG1("CMPXDbPlugin::CommandL - EMcRefreshEnded");

            iDbHandler->CheckDiskSpaceOnDrivesL();

            // ask the handler to finalize the transaction

            iDbHandler->RefreshEndL();

            iRefreshing=EFalse;

            break;

            }

         case EMcCmdReCreateDB:

            {

            MPX_DEBUG1("CMPXDbPlugin::CommandL - EMcCmdReCreateDB");

            // Recreate all databases

            iDbHandler->ReCreateDatabasesL();

            break;

            }

         case EMcCmdDbCorrupted:

            {

            MPX_DEBUG1("CMPXDbPlugin::CommandL - EMcCmdDbCorrupted");

            iDbHandler->SetDBCorruptedL(ETrue);

            break;

            }

        case EMcCmdRefresh:

        case EMcCmdCollectionInit:

        case EMcCmdCollectionResyn:

            {

            // deprecated

            break;

            }

        case EMcCmdMtpStart:

            iDbHandler->CheckDiskSpaceOnDrivesL();

            iMtpInUse = ETrue;

            iDbHandler->MtpStartL();

            break;

        case EMcCmdMtpEnd:

            iDbHandler->CheckDiskSpaceOnDrivesL();

            iMtpInUse = EFalse;

            iDbHandler->MtpEndL();

            break;

         default:

            {

            User::Leave(KErrNotSupported);

            }

        }

    }

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

// Executes the given command on the collection

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

//

void CMPXDbPlugin::CommandL(

    CMPXCommand& aCmd)

    {

    MPX_FUNC("CMPXDbPlugin::CommandL");

    if (!aCmd.IsSupported(KMPXCommandGeneralId))

        {

        User::Leave(KErrArgument);

        }

    TMPXCommandId commandId = aCmd.ValueTObjectL<TMPXCommandId>(KMPXCommandGeneralId);

    TBool syncOp(EFalse);

    if (aCmd.IsSupported(KMPXCommandGeneralDoSync))

        {

        syncOp = aCmd.ValueTObjectL<TBool>(KMPXCommandGeneralDoSync);

        }

    // Handle this operation synchronously or asynchronously

    //

    if (!syncOp)

        {

        iActiveTask->StartL(commandId, aCmd);

        }

    else  // Sync operation

        {

        switch (commandId)

            {

            case KMPXCommandIdCollectionRetrieveUriForDeletion:

                {

                MPX_DEBUG1("CMPXDbPlugin::CommandL - KMPXCommandIdCollectionRetrieveUriForDeletion");

                DoRetrieveUriForDeletionL(aCmd);

                break;

                }

            case KMPXCommandIdCollectionRemove:

                {

                MPX_DEBUG1("CMPXDbPlugin::CommandL - KMPXCommandIdCollectionRemove");

                if ( !iDbHandler->InTransaction() )

                    {

                    iDbHandler->BeginTransactionL();

                    }

                if (iFirstDeleteStep )

                    {

                    iFirstDeleteStep = EFalse;

                    }

                DoRemovePathL(aCmd);

                break;

                }

            case KMPXCommandIdCollectionRemoveMedia:

                {

                MPX_DEBUG1("CMPXDbPlugin::CommandL - KMPXCommandIdCollectionRemoveMedia");

                DoRemoveMediaL(aCmd);

                break;

                }

            case KMPXCommandIdCollectionCleanupDeletedMedias:

                {

                MPX_DEBUG1("CMPXDbPlugin::CommandL - KMPXCommandIdCollectionCleanupDeletedMedias");

                CleanupDeletedRecordsL(aCmd);

                break;

                }

            case KMPXCommandIdCollectionAdd:

                {

                MPX_DEBUG1("CMPXDbPlugin::CommandL - KMPXCommandIdCollectioAdd");

                CMPXMedia* media = aCmd.Value<CMPXMedia>(KMPXCommandColAddMedia);