/*

* 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 podcast collection DB Plugin interface

*

*/

// INCLUDE FILES

#include <e32cmn.h>

#include <PCRes.rsg>

#include <bautils.h>

#include <data_caging_path_literals.hrh>

#include <mpxpodcastdbplugin.mbg>

#include <mpxcmn.h>

#include <mpxcollectionpluginobserver.h>

#include <mpxmediacontainerdefs.h>

#include <mpxmediamusicdefs.h>

#include <mpxmediaaudiodefs.h>

#include <mpxmediacollectiondetaildefs.h>

#include <mpxcommandgeneraldefs.h>

#include <mpxmessagecontainerdefs.h>

#include <mpxcollectioncommanddefs.h>

#include <mpxmedia.h>

#include <mpxmediaarray.h>

#include <mpxdrmmediautility.h>

#include <mpxmediadrmdefs.h>

#include <mpxlog.h>

#ifdef RD_MULTIPLE_DRIVE

#include <driveinfo.h>

#endif //RD_MULTIPLE_DRIVE

#include "mpxdbcommondef.h"

#include "mpxresource.h"

#include "mpxdbcommonstd.h"

#include "mpxdbcommonutil.h"

#include "mpxpodcastcollectiondbstd.h"

#include "mpxpodcastdbhandler.h"

#include "mpxdbutil.h"

#include "mpxpodcastcollectiondbdef.h"

#include "mpxpodcastcollectiondb.hrh"

#include "mpxpodcastdbplugin.h"

// CONSTANTS

_LIT(KMPlayerDbPluginMbmFile, "mpxpodcastdbplugin.mif");

const TInt KIncrementalDeleteCount = 400;

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

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

// Two-phased constructor.

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

//

CMPXPodcastDbPlugin* CMPXPodcastDbPlugin::NewL(

    TAny* /* aInitParams */)

    {

    MPX_FUNC("CMPXPodcastDbPlugin::NewL");

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

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

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

// Destructor.

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

//

CMPXPodcastDbPlugin::~CMPXPodcastDbPlugin()

    {

    MPX_FUNC("CMPXPodcastDbPlugin::~CMPXPodcastDbPlugin");

    iSelections.Reset();

    iSelections.Close();

    iFs.Close();

    delete iDbHandler;

    delete iDrmMediaUtility;

    if (iResource)

        {

        iResource->Release();

        }

    iPodcastLibraryMainMenuItemIds.Close();

    delete iPodcastLibraryMainMenuItemTitles;

    delete iPodcastLibraryTitles;

    iPodcastPublishDateIds.Close();

    delete iPodcastTitlePublishDateCat;

    iPodcastEpisodeViewPublishDateIds.Close();

    delete iPodcastEpisodeViewPublishDateTitle;

    delete iTitleMyPodcast;

    delete iTitleAllEpisodes;

    delete iTitlePubDate;

    delete iTitleTitles;

    delete iTitleAdded;

    delete iTitleUnplayed;

    if (iActiveTask)

        {

        iActiveTask->Cancel();

        delete iActiveTask;

        }

    }

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

// Constructor.

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

//

CMPXPodcastDbPlugin::CMPXPodcastDbPlugin()

    {

    MPX_FUNC("CMPXPodcastDbPlugin::CMPXPodcastDbPlugin");

    }

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

// Symbian 2nd phase constructor can leave.

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

//

void CMPXPodcastDbPlugin::ConstructL ()

    {

    MPX_FUNC("CMPXPodcastDbPlugin::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 = CMPXPodcastDbHandler::NewL(iFs, *iResource);

    iPodcastLibraryMainMenuItemTitles = iResource->ReadMenuArrayL(R_MC_MENU_ITEMS_ARRAY,

        iPodcastLibraryMainMenuItemIds);

    iPodcastTitlePublishDateCat = iResource->ReadMenuArrayL(R_MPX_QTN_NMP_PUBLISH_DATE_ARRAY,

        iPodcastPublishDateIds);

    iPodcastEpisodeViewPublishDateTitle = iResource->ReadMenuArrayL(

        R_MPX_QTN_NMP_EPISODES_TITLE_PUBLISHED_DATE_ARRAY, iPodcastEpisodeViewPublishDateIds);

    iTitleMyPodcast = iResource->ReadHBufCL(R_MPX_QTN_MP_TITLE_MY_PODCAST);

    iTitleAllEpisodes = iResource->ReadHBufCL(R_MPX_QTN_MP_TITLE_ALL_EPISODES);

    iTitlePubDate = iResource->ReadHBufCL(R_MPX_QTN_MUS_TITLE_PUBLISH_DATE);

    iTitleTitles = iResource->ReadHBufCL(R_MPX_QTN_MP_TITLE_PODCASTS);

    iTitleAdded = iResource->ReadHBufCL(R_MPX_QTN_MP_TITLE_RECENTLY_ADDED);

    iTitleUnplayed = iResource->ReadHBufCL(R_MPX_QTN_MP_TITLE_UNPLAYED);

    iPodcastLibraryTitles = iResource->ReadMenuArrayL(R_MC_MENU_TITLES_ARRAY,

        iPodcastLibraryMainMenuItemIds);

    iActiveTask = CMPXDbActiveTask::NewL(*this);

    }

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

// Navigates to the given path

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

//

void CMPXPodcastDbPlugin::OpenL(

    const CMPXCollectionPath& aPath,

    const TArray<TMPXAttribute>& aAttrs,

    CMPXFilter* /*aFilter*/)

    {

    MPX_FUNC("CMPXPodcastDbPlugin::OpenL");

    MPX_DEBUG_PATH (aPath);

    RArray<TMPXAttribute> openAttrs;

    CleanupClosePushL(openAttrs);

    RArray<TInt> supportedIds;

    CleanupClosePushL(supportedIds);

    SetAttributesL(aPath, openAttrs, supportedIds);

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

    CleanupStack::PopAndDestroy(&supportedIds);

    CleanupStack::PushL(entries);

    TInt error(KErrNone);

    TBool isEpisode(EFalse);

    CMPXCollectionPath* newPath(NULL);

    TBool openingForPlayback(EFalse);

    if(aAttrs.Count() == 1 &&

       aAttrs[0].ContentId() == KMPXMediaIdPodcast)

    {

        if(aAttrs[0].AttributeId() & EMPXMediaPodcastSetIsPlayingTrue)

        {

        openingForPlayback = ETrue;

        }

    }

    // Make sure we handle the correct open mode

    //

    TMPXOpenMode openmode = aPath.OpenNextMode();

    switch (openmode)

        {

        case EMPXOpenGroupOrPlaylist:

            {

            MPX_TRAP(error, isEpisode = DoOpenL (

                aPath, openAttrs.Array(), *entries, openingForPlayback));

            break;

            }

        case EMPXOpenPlaylistOnly:

            {

            if( aPath.Count() > 0 )

                {

                // Try to open

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

                CleanupStack::PushL(newPath);

                isEpisode = ETrue;

                }

            else // no items, so open in normal mode

                {

                MPX_TRAP(error, isEpisode = DoOpenL (

                    aPath, openAttrs.Array(), *entries, openingForPlayback));

                }

            break;

            }

        default:

            // do nothing

            break;

        }

    if (isEpisode)

        {

        if (openmode == EMPXOpenGroupOrPlaylist)

            {

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

            }

        else // openmode == EMPXOpenPlaylistOnly

            {

            iObs->HandleOpen(newPath, error);

            }

        }

    else

        {

        MPX_DEBUG_PATH (aPath);

        entries->SetCObjectValueL(KMPXMediaGeneralContainerPath,

            const_cast<CMPXCollectionPath*>(&aPath));

        iObs->HandleOpen(entries, error);

        }

    if (newPath)

        {

        CleanupStack::PopAndDestroy(newPath);

        }

    CleanupStack::PopAndDestroy(entries);

    CleanupStack::PopAndDestroy(&openAttrs);

    }

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

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

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

//

void CMPXPodcastDbPlugin::MediaL(

    const CMPXCollectionPath& aPath,

    const TArray<TMPXAttribute>& aAttrs,

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

    CMPXAttributeSpecs* /*aSpecs*/)

    {

    MPX_FUNC("CMPXPodcastDbPlugin::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

    DoHandleOtherMediaAttributesL(aAttrs, aPath, *entries);

    iObs->HandleMedia(entries, KErrNone);

    CleanupStack::PopAndDestroy(entries);

    }

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

// Cancel outstanding request

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

//

void CMPXPodcastDbPlugin::CancelRequest()

    {

    MPX_FUNC("CMPXPodcastDbPlugin::CancelRequest");

    iActiveTask->Cancel();

    }

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

// Executes the given command on the collection

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

//

void CMPXPodcastDbPlugin::CommandL(

    TMPXCollectionCommand aCmd,

    TInt aArg /* = 0 */)

    {

    MPX_FUNC("CMPXPodcastDbPlugin::CommandL");

    switch (aCmd)

        {

        case EMcCmdRemoveAll:

            {

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

            // Remove EVERYthing from the collection

            iDbHandler->RemoveEntireCollectionL();

            break;

            }

        case EMcCmdClose:

        case EMcCloseCollection:

            {

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

            // Close the specified database

 #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

            break;

            }

        case EMcReOpenCollection:

            {

            MPX_DEBUG1("CMPXPodcastDbPlugin::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

            break;

            }

        case EMcRefreshStarted:

            {

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

            iDbHandler->RefreshStartL();

            iRefreshing = ETrue;

            break;

            }

        case EMcRefreshEnded:

            {

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

            // ask the handler to finalize the transaction

            iDbHandler->RefreshEndL();

            iRefreshing = EFalse;

            break;

            }

         case EMcCmdReCreateDB:

            {

            // Recreate all databases

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

            iDbHandler->ReCreateDatabasesL();

            break;

            }

         case EMcCmdDbCorrupted:

            {

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

            iDbHandler->SetDBCorruptedL(ETrue);

            break;

            }

        case EMcCmdCollectionInit:

        case EMcCmdRefresh:

        case EMcCmdCollectionResyn:

            {

            // deprecated

            break;

            }

        case EMcCmdMtpStart:

            iMtpInUse = ETrue;

            break;

        case EMcCmdMtpEnd:

            iMtpInUse = EFalse;

            break;

        default:

            {

            User::Leave(KErrNotSupported);

            }

        }

    }

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

// Executes the given command on the collection

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

//

void CMPXPodcastDbPlugin::CommandL(

    CMPXCommand& aCmd)

    {

    MPX_FUNC("CMPXPodcastDbPlugin::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("CMPXPodcastDbPlugin::CommandL - KMPXCommandIdCollectionRetrieveUriForDeletion");

                DoRetrieveUriForDeletionL(aCmd);

                break;

                }

            case KMPXCommandIdCollectionRemove:

                {

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

                if (iFirstDeleteStep )

                    {

                    iFirstDeleteStep = EFalse;

                    }

                DoRemovePathL(aCmd);

                break;

                }

            case KMPXCommandIdCollectionRemoveMedia:

                {

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

                DoRemoveMediaL(aCmd);

                break;

                }

            case KMPXCommandIdCollectionCleanupDeletedMedias:

                {

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

                CleanupDeletedRecordsL(aCmd);

                break;

                }

            case KMPXCommandIdCollectionAdd:

                {

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

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

                User::LeaveIfNull( media );

                TInt id = DoAddL(*media);

                aCmd.SetTObjectValueL<TMPXItemId>(KMPXCommandColAddRtnId, id);

                break;

                }

            case KMPXCommandIdCollectionSet:

                {

                MPX_DEBUG1("CMPXPodcastDbPlugin::CommandL - KMPXCommandIdCollectionSet");

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

                User::LeaveIfNull( media );

                DoSetL(*media);

                break;

                }

            case KMPXCommandIdCollectionCompleteDelete:

                {

                MPX_DEBUG1("CMPXPodcastDbPlugin::CommandL - KMPXCommandIdCollectionCompleteDelete");

                DoHandleDeleteCompleteL(aCmd);

                break;

                }

            case KMPXCommandIdUpdateRefreshTime:

                {

                MPX_DEBUG1("CMPXPodcastDbPlugin::CommandL - KMPXCommandIdUpdateRefreshTime");

                TTime curTime;

                curTime.HomeTime();

                iDbHandler->SetLastRefreshedTimeL(curTime);

                break;

                }

            case KMPXCommandCollectionGetCount:

                {

                MPX_DEBUG1("CMPXPodcastDbPlugin::CommandL - KMPXCommandCollectionGetCount");

                DoGetCollectionCountL(aCmd);