1 /*

     2 * Copyright (c) 2006 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description:  Implementation of collection DB Plugin interface

    15 *

    16 */

    17 

    18 

    19 // INCLUDE FILES

    20 #include <e32cmn.h>

    21 #include <StringLoader.h>

    22 #include <bautils.h>

    23 #include <data_caging_path_literals.hrh>

    24 

    25 #include <mpxcmn.h>

    26 #include <mpxuser.h>

    27 #include <mpxcollectionpluginobserver.h>

    28 #include <mpxmediacontainerdefs.h>

    29 #include <mpxmediamusicdefs.h>

    30 #include <mpxmediaaudiodefs.h>

    31 #include <mpxmediacollectiondetaildefs.h>

    32 #include <mpxcommandgeneraldefs.h>

    33 #include <mpxmessagegeneraldefs.h>

    34 #include <mpxmessagecontainerdefs.h>

    35 #include <mpxcollectioncommanddefs.h>

    36 #include <mpxcollectionmessagedefs.h>

    37 #include <mpxincrementalopendefs.h>

    38 #include <mpxcollectionopenlresultdef.h>

    39 #include <mpxmedia.h>

    40 #include <mpxmediaarray.h>

    41 #include <mpxdrmmediautility.h>

    42 #include <mpxmediadrmdefs.h>

    43 #include <mpxlog.h>

    44 #include <mpxcollectiondbres.rsg>

    45 //#include <mpxdbplugin.mbg>	// commented out when migrate to HB

    46 #include <centralrepository.h>

    47 

    48 #ifdef RD_MULTIPLE_DRIVE

    49 #include <driveinfo.h>

    50 #endif //RD_MULTIPLE_DRIVE

    51 

    52 #include "mpxresource.h"

    53 #include "mpxdbcommondef.h"

    54 #include "mpxdbcommonutil.h"

    55 

    56 #include "mpxdbhandler.h"

    57 #include "mpxdbutil.h"

    58 #include "mpxcollectiondbdef.h"

    59 #include "mpxdbplugin.h"

    60 

    61 // CONSTANTS

    62 const TInt KFirstFetchCount = 400;

    63 

    64 const TUid KCRUIDMusicPlayerFeatures = { 0x101FFCD0 };

    65 const TInt KMusicPlayerFeatures = 1;

    66 const TInt KDisablePodcasting = 0x80;

    67 

    68 const TInt KIncrementalDeleteCount = 400;

    69 

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

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

    72 

    73 // ----------------------------------------------------------------------------

    74 // Two-phased constructor.

    75 // ----------------------------------------------------------------------------

    76 //

    77 CMPXDbPlugin* CMPXDbPlugin::NewL(

    78     TAny* /*aInitParams*/)

    79     {

    80     MPX_FUNC("CMPXDbPlugin::NewL");

    81 

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

    83     CleanupStack::PushL (self);

    84     self->ConstructL ();

    85     CleanupStack::Pop (self);

    86     return self;

    87     }

    88 

    89 // ----------------------------------------------------------------------------

    90 // Destructor.

    91 // ----------------------------------------------------------------------------

    92 //

    93 CMPXDbPlugin::~CMPXDbPlugin()

    94     {

    95     MPX_FUNC("CMPXDbPlugin::~CMPXDbPlugin");

    96 

    97     iSelections.Reset();

    98     iSelections.Close();

    99     iFs.Close();

   100     delete iDbHandler;

   101     delete iDrmMediaUtility;

   102     if (iResource)

   103         {

   104         iResource->Release();

   105         }

   106     iMusicLibraryMenuIds.Close();

   107     delete iMusicLibraryMenuTitles;

   108     delete iMusicLibraryTitles;

   109     delete iAllSongsForArtistTitle;

   110     delete iMusicMenuTitle;

   111 

   112     if (iActiveTask)

   113         {

   114         iActiveTask->Cancel();

   115         delete iActiveTask;

   116         }

   117     }

   118 

   119 // ----------------------------------------------------------------------------

   120 // Constructor.

   121 // ----------------------------------------------------------------------------

   122 //

   123 CMPXDbPlugin::CMPXDbPlugin()

   124     {

   125     MPX_FUNC("CMPXDbPlugin::CMPXDbPlugin");

   126     }

   127 

   128 // ----------------------------------------------------------------------------

   129 // Symbian 2nd phase constructor can leave.

   130 // ----------------------------------------------------------------------------

   131 //

   132 void CMPXDbPlugin::ConstructL()

   133     {

   134     MPX_FUNC("CMPXDbPlugin::ConstructL");

   135     iFirstDeleteStep = ETrue;

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

   137     iDrmMediaUtility = CMPXDrmMediaUtility::NewL();

   138 

   139     TParse parse;

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

   141     TFileName resFile(parse.FullName());

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

   143     BaflUtils::NearestLanguageFile(iFs, resFile);

   144     iResource = CMPXResource::NewL(resFile);

   145 

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

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

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

   149     iAllSongsForArtistTitle = iResource->ReadHBufCL(R_MC_ALL_SONGS_FOR_ARTIST);

   150 

   151 #ifdef __ENABLE_MUSIC_TEXT_ALIGNMENT

   152     iMusicMenuTitle = iResource->ReadHBufCL(R_MPX_QTN_MP_TITLE_MY_MUSIC_MENU_NSERIES);

   153 #else

   154     iMusicMenuTitle = iResource->ReadHBufCL(R_MPX_QTN_MUS_TITLE_MUSIC_MENU);

   155 #endif // __ENABLE_MUSIC_TEXT_ALIGNMENT

   156 

   157     iActiveTask = CMPXDbActiveTask::NewL(*this);

   158 

   159     CRepository* cenrep(NULL);

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

   161     if( err == KErrNone )

   162         {

   163         TInt val(0);

   164         cenrep->Get( KMusicPlayerFeatures, val );

   165         iDisablePodcasting = val&KDisablePodcasting ? ETrue:EFalse;

   166         delete cenrep;

   167         }

   168     else

   169         {

   170         iDisablePodcasting = EFalse;

   171         }

   172     iAllSongsValid = ETrue;

   173     }

   174 

   175 // ----------------------------------------------------------------------------

   176 // Navigates to the given path

   177 // ----------------------------------------------------------------------------

   178 //

   179 void CMPXDbPlugin::OpenL(

   180     const CMPXCollectionPath& aPath,

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

   182     CMPXFilter* aFilter)

   183     {

   184     MPX_FUNC("CMPXDbPlugin::OpenL");

   185     MPX_DEBUG_PATH(aPath);

   186     //Create a path object to be returned.

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

   188     CleanupStack::PushL(path);

   189     RArray<TMPXAttribute> openAttrs;

   190     CleanupClosePushL(openAttrs);

   191 

   192     RArray<TInt> supportedIds;

   193     CleanupClosePushL(supportedIds);

   194 

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

   196     // This will eventually have to be fixed

   197     SetAttributesL(aPath, openAttrs, supportedIds);

   198 

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

   200     CleanupStack::PopAndDestroy(&supportedIds);

   201     CleanupStack::PushL(entries);

   202     //Add returned path into media

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

   204 

   205     TInt error(KErrNone);

   206     TBool isASong(EFalse);

   207     CMPXCollectionPath* newPath(NULL);

   208 

   209     // Make sure we handle open the correct open mode

   210     //

   211     TMPXOpenMode openmode = aPath.OpenNextMode();

   212     switch (openmode)

   213         {

   214         case EMPXOpenGroupOrPlaylist:

   215             {

   216             // Open By Path

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

   218             break;

   219             }

   220 

   221         case EMPXOpenPlaylistOnly:

   222             {

   223             if (aPath.Count() > 0)

   224                 {

   225                 // Try to open

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

   227                 CleanupStack::PushL(newPath);

   228                 isASong = ETrue;

   229                 }

   230             else // no items

   231                 {

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

   233                 }

   234 

   235             break;

   236             }

   237 

   238         default:

   239             // do nothing

   240             break;

   241         }

   242 

   243     // generate the callback

   244     if (isASong )

   245         {

   246         if (openmode == EMPXOpenGroupOrPlaylist)

   247             {

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

   249             }

   250         else  // openmode == EMPXOpenPlaylistOnly

   251             {

   252             iObs->HandleOpen(newPath, error);

   253             }

   254         }

   255     else

   256         {

   257         entries->SetCObjectValueL(KMPXMediaGeneralContainerPath,

   258             const_cast<CMPXCollectionPath*>(&aPath));

   259         entries->Delete(KMPXMediaGeneralValue);

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

   261         }

   262 

   263     if (newPath)

   264         {

   265         CleanupStack::PopAndDestroy(newPath);

   266         }

   267 

   268     CleanupStack::PopAndDestroy(entries);

   269     CleanupStack::PopAndDestroy(&openAttrs);

   270     CleanupStack::PopAndDestroy(path);

   271     }

   272 

   273 // ----------------------------------------------------------------------------

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

   275 // ----------------------------------------------------------------------------

   276 //

   277 void CMPXDbPlugin::MediaL(

   278     const CMPXCollectionPath& aPath,

   279     const TArray<TMPXAttribute>& aAttrs,

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

   281     CMPXAttributeSpecs* /*aSpecs*/)

   282     {

   283     MPX_FUNC("CMPXDbPlugin::MediaL");

   284     MPX_DEBUG_PATH(aPath);

   285 

   286     RArray<TInt> supportedIds;

   287     CleanupClosePushL(supportedIds);

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

   289         {

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

   291         supportedIds.AppendL(KMPXMediaIdContainer);

   292         }

   293     MPXDbCommonUtil::FillInSupportedUIDsL(aAttrs, supportedIds);

   294 

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

   296     CleanupStack::PopAndDestroy(&supportedIds);

   297     CleanupStack::PushL(entries);

   298 

   299     DoMediaL(aPath, aAttrs, *entries);

   300 

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

   302     DoHandleOtherMediaAttributesL(aAttrs, aPath, *entries);

   303 

   304     iObs->HandleMedia(entries, KErrNone);

   305     CleanupStack::PopAndDestroy(entries);

   306     }

   307 

   308 // ----------------------------------------------------------------------------

   309 // Cancel outstanding request

   310 // ----------------------------------------------------------------------------

   311 //

   312 void CMPXDbPlugin::CancelRequest()

   313     {

   314     MPX_FUNC("CMPXDbPlugin::CancelRequest");

   315     iActiveTask->Cancel();

   316     }

   317 

   318 // ----------------------------------------------------------------------------

   319 // Executes the given command on the collection

   320 // ----------------------------------------------------------------------------

   321 //

   322 void CMPXDbPlugin::CommandL(

   323     TMPXCollectionCommand aCmd,

   324     TInt aArg /* = 0 */)

   325     {

   326     MPX_FUNC("CMPXDbPlugin::CommandL");

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

   328     iAllSongsValid = ETrue;

   329     switch (aCmd)

   330         {

   331         case EMcCmdRemoveAll:

   332             {

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

   334             // Remove EVERYthing from the collection

   335             iDbHandler->RemoveEntireCollectionL();

   336             break;

   337             }

   338         case EMcCmdClose:

   339         case EMcCloseCollection:

   340             {

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

   342             // Close the specified database

   343             TRAP_IGNORE(iDbHandler->PreCloseCollectionL());

   344  #ifdef RD_MULTIPLE_DRIVE

   345             MPX_DEBUG1("Multiple drives closing databases");

   346             if ( aArg <0)

   347                 {

   348                 DriveInfo::TDriveArray driveArray;

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

   350                 TInt count( driveArray.Count ());

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

   352                     {

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

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

   355                         {

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

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

   358                         }

   359                     }

   360                 }

   361             else

   362                 {

   363                 iDbHandler->CloseDatabaseL(aArg);

   364                 }

   365  #else

   366             iDbHandler->CloseDatabaseL(aArg);

   367  #endif // RD_MULTIPLE_DRIVE

   368             iDbHandler->CollectionClosed();

   369             break;

   370             }

   371         case EMcReOpenCollection:

   372             {

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

   374             // Open the specified database

   375 #ifdef RD_MULTIPLE_DRIVE

   376             MPX_DEBUG1("Multiple drives opening databases");

   377             DriveInfo::TDriveArray driveArray;

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

   379             TInt count( driveArray.Count() );

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

   381                 {

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

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

   384                     {

   385                     TUint driveStatus(0);

   386                     User::LeaveIfError( DriveInfo::GetDriveStatus(

   387                         iFs, driveArray[i], driveStatus ) );

   388                     if( driveStatus & DriveInfo::EDrivePresent )

   389                         {

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

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

   392                         }

   393                     }

   394                 }

   395 #else

   396             iDbHandler->OpenDatabaseL(aArg);

   397 #endif // RD_MULTIPLE_DRIVE

   398             TRAP_IGNORE(iDbHandler->CollectionOpenedL());

   399             break;

   400             }

   401         case EMcRefreshStarted:

   402             {

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

   404             iDbHandler->CheckDiskSpaceOnDrivesL();

   405             // ask the handler to start a transaction

   406             iDbHandler->RefreshStartL();

   407             iRefreshing=ETrue;

   408             break;

   409             }

   410         case EMcRefreshEnded:

   411             {

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

   413             iDbHandler->CheckDiskSpaceOnDrivesL();

   414             // ask the handler to finalize the transaction

   415             iDbHandler->RefreshEndL();

   416             iRefreshing=EFalse;

   417             break;

   418             }

   419          case EMcCmdReCreateDB:

   420             {

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

   422             // Recreate all databases

   423             iDbHandler->ReCreateDatabasesL();

   424             break;

   425             }

   426          case EMcCmdDbCorrupted:

   427             {

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

   429             iDbHandler->SetDBCorruptedL(ETrue);

   430             break;

   431             }

   432         case EMcCmdRefresh:

   433         case EMcCmdCollectionInit:

   434         case EMcCmdCollectionResyn:

   435             {

   436             // deprecated

   437             break;

   438             }

   439         case EMcCmdMtpStart:

   440             iDbHandler->CheckDiskSpaceOnDrivesL();

   441             iMtpInUse = ETrue;

   442             iDbHandler->MtpStartL();            

   443             break;

   444         case EMcCmdMtpEnd:

   445             iDbHandler->CheckDiskSpaceOnDrivesL();

   446             iMtpInUse = EFalse;

   447             iDbHandler->MtpEndL();            

   448             break;

   449          default:

   450             {

   451             User::Leave(KErrNotSupported);

   452             }

   453         }

   454     }

   455 

   456 // ----------------------------------------------------------------------------

   457 // Executes the given command on the collection

   458 // ----------------------------------------------------------------------------

   459 //

   460 void CMPXDbPlugin::CommandL(

   461     CMPXCommand& aCmd)

   462     {

   463     MPX_FUNC("CMPXDbPlugin::CommandL");

   464 

   465     if (!aCmd.IsSupported(KMPXCommandGeneralId))

   466         {

   467         User::Leave(KErrArgument);

   468         }

   469 

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

   471 

   472     TBool syncOp(EFalse);

   473     if (aCmd.IsSupported(KMPXCommandGeneralDoSync))

   474         {

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

   476         }

   477 

   478     // Handle this operation synchronously or asynchronously

   479     //

   480     if (!syncOp)

   481         {

   482         iActiveTask->StartL(commandId, aCmd);

   483         }

   484     else  // Sync operation

   485         {

   486         switch (commandId)

   487             {

   488             case KMPXCommandIdCollectionRetrieveUriForDeletion:

   489                 {

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

   491                 DoRetrieveUriForDeletionL(aCmd);

   492                 break;

   493                 }

   494             case KMPXCommandIdCollectionRemove:

   495                 {

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

   497                 if ( !iDbHandler->InTransaction() )

   498                     {

   499                     iDbHandler->BeginTransactionL();

   500                     }

   501 

   502                 if (iFirstDeleteStep )

   503                     {

   504                     iFirstDeleteStep = EFalse;

   505                     }

   506                 DoRemovePathL(aCmd);

   507                 break;

   508                 }

   509             case KMPXCommandIdCollectionRemoveMedia:

   510                 {

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

   512                 DoRemoveMediaL(aCmd);

   513                 break;

   514                 }

   515             case KMPXCommandIdCollectionCleanupDeletedMedias:

   516                 {

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

   518                 CleanupDeletedRecordsL(aCmd);

   519                 break;

   520                 }

   521             case KMPXCommandIdCollectionAdd:

   522                 {

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

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

   525                 User::LeaveIfNull( media );

   526                 TUint32 id(DoAddL(*media));

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

   528                 break;

   529                 }

   530             case KMPXCommandIdCollectionSet:

   531                 {

   532                 MPX_DEBUG1("CMPXDbPlugin::CommandL - KMPXCommandIdCollectionSet");

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

   534                 User::LeaveIfNull( media );

   535                 DoSetL(*media);

   536                 break;

   537                 }

   538             case KMPXCommandIdCollectionCompleteDelete:

   539                 {

   540                 MPX_DEBUG1("CMPXDbPlugin::CommandL - KMPXCommandIdCollectionCompleteDelete");

   541                 DoHandleDeleteCompleteL(aCmd);

   542                 break;

   543                 }

   544             case KMPXCommandIdReorderPlaylist:

   545                 {

   546                 MPX_DEBUG1("CMPXDbPlugin::CommandL - KMPXCommandIdReorderPlaylist");

   547                 DoReorderPlaylistL(aCmd);

   548                 break;

   549                 }

   550             case KMPXCommandIdUpdateRefreshTime:

   551                 {

   552                 MPX_DEBUG1("CMPXDbPlugin::CommandL - KMPXCommandIdUpdateRefreshTime");

   553                 TTime curTime;

   554                 curTime.HomeTime();

   555                 iDbHandler->SetLastRefreshedTimeL(curTime);

   556                 break;

   557                 }

   558             case KMPXCommandCollectionGetCount:

   559                 {

   560                 MPX_DEBUG1("CMPXDbPlugin::CommandL - KMPXCommandCollectionGetCount");

   561                 DoGetCollectionCountL(aCmd);

   562                 break;

   563                 }

   564             case KMPXCommandCollectionGetURIs:

   565                 {

   566                 MPX_DEBUG1("CMPXDbPlugin::CommandL - KMPXCommandCollectionGetURIs");

   567                 DoGetCollectionUriL(aCmd);

   568                 break;

   569                 }

   570             default:

   571                 {

   572                 User::Leave(KErrNotSupported);

   573                 }

   574             }

   575         }

   576     }

   577 

   578 // ----------------------------------------------------------------------------

   579 // Adds an item (song or playlist) to the collection

   580 // ----------------------------------------------------------------------------

   581 //

   582 void CMPXDbPlugin::AddL(

   583     const CMPXMedia& aMedia)

   584     {

   585     MPX_FUNC("CMPXDbPlugin::AddL");

   586     DoAddL(aMedia);

   587     }

   588 

   589 // ----------------------------------------------------------------------------

   590 // Remove an item from the collection database using the given path

   591 // ----------------------------------------------------------------------------

   592 //

   593 void CMPXDbPlugin::RemoveL(

   594     const CMPXCollectionPath& aPath)

   595     {

   596     MPX_FUNC("CMPXDbPlugin::RemoveL(by path)");

   597     MPX_DEBUG_PATH(aPath);

   598 

   599     CMPXMessageArray* msgAry = CMPXMessageArray::NewL();

   600     CleanupStack::PushL(msgAry);

   601 

   602     // Return file path for deleted item(s)

   603     CDesCArray* fp = DoRemoveL(aPath, *msgAry);

   604 

   605     iObs->HandleRemove(*fp, KErrNone);

   606     delete fp;

   607 

   608     // Send Change Messages

   609     iActiveTask->SetVisibleChange(CMPXDbActiveTask::EAllVisible);

   610     DoHandleChangeL(msgAry);

   611     CleanupStack::PopAndDestroy(msgAry);

   612     }

   613 

   614 // ----------------------------------------------------------------------------

   615 // Remove an item from the collection database using the given media properties

   616 // ----------------------------------------------------------------------------

   617 //

   618 void CMPXDbPlugin::RemoveL(

   619     const CMPXMedia& aMedia)

   620     {

   621     MPX_FUNC("CMPXDbPlugin::RemoveL(by media)");

   622     DoRemoveL(aMedia, EFalse);

   623     }

   624 

   625 // ----------------------------------------------------------------------------

   626 // Sets/updates the media for an item in the collection

   627 // DEPRECATED for week 18

   628 // ----------------------------------------------------------------------------

   629 //

   630 void CMPXDbPlugin::SetL(

   631     const CMPXMedia& aMedia)

   632     {

   633     MPX_FUNC("CMPXDbPlugin::SetL");

   634     DoSetL(aMedia);

   635     }

   636 

   637 // ----------------------------------------------------------------------------

   638 // Find the items matching the media specifications

   639 // ----------------------------------------------------------------------------

   640 //

   641 void CMPXDbPlugin::FindAllL(

   642     const CMPXMedia& aCriteria,

   643     const TArray<TMPXAttribute>& aAttrs)

   644     {

   645     MPX_FUNC("CMPXDbPlugin::FindAllL");

   646 

   647     CMPXMedia* entries = FindAllSyncL(aCriteria, aAttrs);

   648 

   649     // notify client. if FindAllL leaves, framework will notify client of the error

   650     iObs->HandleFindAll(entries, KErrNone);

   651     delete entries;

   652     }

   653 

   654 // ----------------------------------------------------------------------------

   655 // Find the items matching the media specifications

   656 // ----------------------------------------------------------------------------

   657 //

   658 CMPXMedia* CMPXDbPlugin::FindAllSyncL(

   659     const CMPXMedia& aCriteria,

   660     const TArray<TMPXAttribute>& aAttrs)

   661     {

   662     MPX_FUNC("CMPXDbPlugin::FindAllSyncL");

   663 

   664     CMPXMedia* entries = iDbHandler->FindAllLC(aCriteria, aAttrs);

   665 

   666     if (entries)

   667         {

   668         CMPXMediaArray* ary = entries->Value<CMPXMediaArray>(KMPXMediaArrayContents);

   669         User::LeaveIfNull( ary );

   670         DoSetDrmForArrayL( *ary, aAttrs );

   671         }

   672 

   673     CleanupStack::Pop(entries);

   674     return entries;

   675     }

   676 

   677 // ----------------------------------------------------------------------------

   678 // Get the list of supported capabilities

   679 // ----------------------------------------------------------------------------

   680 //

   681 TCollectionCapability CMPXDbPlugin::GetCapabilities()

   682     {

   683     // This one supports simple search

   684     return EMcSearch;

   685     }

   686 

   687 // ----------------------------------------------------------------------------

   688 // Get the list of supported capabilities

   689 // ----------------------------------------------------------------------------

   690 //

   691 TBool CMPXDbPlugin::HandleStepL()

   692     {

   693     MPX_FUNC("CMPXDbPlugin::HandleStepL");

   694 

   695     TBool done(ETrue);

   696 

   697     switch (iActiveTask->GetTask())

   698         {

   699         case KMPXCommandIdCollectionSet:

   700             {

   701             done = DoSetAsyncL();

   702             break;

   703             }

   704         case KMPXCommandIdCollectionAdd:

   705             {

   706             done = DoAddAsyncL();

   707             break;

   708             }

   709         case KMPXCommandIdCollectionRemove:

   710             {

   711             DoRemovePathL(iActiveTask->GetCommand());

   712             done = ETrue;

   713             break;

   714             }

   715         case KMPXCommandIdCollectionRemoveMedia:

   716             {

   717             DoRemoveMediaL(iActiveTask->GetCommand());

   718             done = ETrue;

   719             break;

   720             }

   721         case KMPXCommandIdCollectionRetrieveUriForDeletion:

   722             {

   723             DoRetrieveUriForDeletionL(iActiveTask->GetCommand());

   724             done = ETrue;

   725             break;

   726             }

   727         case KMPXCommandIdCollectionCleanupDeletedMedias:

   728             {

   729             CleanupDeletedRecordsL(iActiveTask->GetCommand());

   730             done = ETrue;

   731             break;

   732             }

   733         case KMPXCommandIdCollectionCompleteDelete:

   734             {

   735             DoHandleDeleteCompleteL( iActiveTask->GetCommand() );

   736             break;

   737             }

   738         case KMPXCommandIdUpdateRefreshTime:

   739             {

   740             MPX_DEBUG1("CMPXDbPlugin::CommandL - KMPXCommandIdUpdateRefreshTime");

   741             TTime curTime;

   742             curTime.HomeTime();

   743             iDbHandler->SetLastRefreshedTimeL(curTime);

   744             break;

   745             }

   746         case KMPXCommandIdIncrementalOpenL:

   747             {

   748             DoIncrementalOpenL( iActiveTask->GetCommand() );

   749             done = ETrue;

   750             break;

   751             }

   752         default:

   753             {

   754             // Should never happen!

   755             ASSERT(0);

   756             break;

   757             }

   758         }

   759     return done;

   760     }

   761 

   762 // ----------------------------------------------------------------------------

   763 // Handler for async operations completed

   764 // ----------------------------------------------------------------------------

   765 //

   766 void CMPXDbPlugin::HandleOperationCompleted(

   767     TInt aErr)

   768     {

   769     MPX_FUNC("CMPXDbPlugin::HandleOperationCompleted");

   770     TRAP_IGNORE(DoHandleOperationCompletedL(aErr));

   771     }

   772 

   773 // ----------------------------------------------------------------------------

   774 // Process the OpenL command

   775 // ----------------------------------------------------------------------------

   776 //

   777 TBool CMPXDbPlugin::DoOpenL(

   778     const CMPXCollectionPath& aPath,

   779     const TArray<TMPXAttribute>& aAttrs,

   780     CMPXMedia& aEntries,

   781     CMPXFilter* aFilter )

   782     {

   783     MPX_FUNC("CMPXDbPlugin::DoOpenL");

   784 

   785     TInt err( KErrNone );

   786     CMPXMediaArray* array = CMPXMediaArray::NewL();

   787     CleanupStack::PushL(array);

   788 

   789     TInt count(0);

   790     TInt levels(aPath.Levels());

   791     TBool isASong(EFalse);

   792 

   793     aEntries.SetTObjectValueL<TMPXItemId>(KMPXMediaGeneralId, aPath.Id(levels - 1));

   794 

   795     if (1 == levels)

   796         {

   797         // return the "main menu"

   798         count = iMusicLibraryMenuTitles->Count();

   799         RArray<TMPXItemId> ids;

   800         CleanupClosePushL(ids);

   801 

   802         // due to ui changes, the order of main menu is changed

   803         // since multiple clients hardcode indexes to each entry,

   804         // the enum cannot be changed, instead we will have to

   805         // manually change the display order to minimize the impact to

   806         // external clients

   807 

   808         // change from:

   809         // all songs, playlist, artist, album, (podcast), genre, composer

   810         // to:

   811         // artist, album, playlist, all songs, (podcast), genre, composer

   812         for (TInt i = EBrowseArtist; i <= EBrowseAlbum; ++i)

   813             {

   814             MPXDbCommonUtil::AppendMediaL(*array, iMusicLibraryMenuTitles->MdcaPoint(i), EMPXGroup,

   815                 CategoryForBrowseType(static_cast<TMCBrowseType>(i)), iMusicLibraryMenuIds[i]);

   816             ids.AppendL(TMPXItemId(iMusicLibraryMenuIds[i]));

   817             }

   818         MPXDbCommonUtil::AppendMediaL(*array, iMusicLibraryMenuTitles->MdcaPoint(1), EMPXGroup,

   819             CategoryForBrowseType(static_cast<TMCBrowseType>(1)), iMusicLibraryMenuIds[1]);

   820         ids.AppendL(TMPXItemId(iMusicLibraryMenuIds[1]));

   821         MPXDbCommonUtil::AppendMediaL(*array, iMusicLibraryMenuTitles->MdcaPoint(0), EMPXGroup,

   822             CategoryForBrowseType(static_cast<TMCBrowseType>(0)), iMusicLibraryMenuIds[0]);

   823         ids.AppendL(TMPXItemId(iMusicLibraryMenuIds[0]));

   824 

   825 #ifdef __ENABLE_PODCAST_IN_MUSIC_MENU

   826         if( !iDisablePodcasting )

   827             {

   828             MPXDbCommonUtil::AppendMediaL(*array, iMusicLibraryMenuTitles->MdcaPoint(EBrowsePodcasts), EMPXGroup,

   829                 CategoryForBrowseType(static_cast<TMCBrowseType>(EBrowsePodcasts)), iMusicLibraryMenuIds[EBrowsePodcasts]);

   830             ids.AppendL(TMPXItemId(iMusicLibraryMenuIds[EBrowsePodcasts]));

   831             }

   832 #endif // __ENABLE_PODCAST_IN_MUSIC_MENU

   833 

   834         // Genre and composer

   835         for (TInt i = ( EBrowseGenre ); i < count; ++i)

   836             {

   837             MPXDbCommonUtil::AppendMediaL(*array, iMusicLibraryMenuTitles->MdcaPoint(i), EMPXGroup,

   838                 CategoryForBrowseType(static_cast<TMCBrowseType>(i)), iMusicLibraryMenuIds[i]);

   839             ids.AppendL(TMPXItemId(iMusicLibraryMenuIds[i]));

   840             }

   841 

   842         TInt pPath = aEntries.ValueTObjectL<TInt>(KMPXMediaGeneralValue);

   843         MPX_ASSERT(pPath);

   844         ((CMPXCollectionPath*)pPath)->AppendL(ids.Array());

   845         CleanupStack::PopAndDestroy(&ids);

   846         SetMediaGeneralAttributesL(aEntries, EMPXGroup, EMPXCollection, *iMusicMenuTitle);

   847         aEntries.SetTObjectValueL<TMPXGeneralNonPermissibleActions>(

   848             KMPXMediaGeneralNonPermissibleActions, EMPXWrite);

   849         }

   850     else if (levels >= 2)

   851         {

   852         // Create a media which hold the pointer to the returned path

   853         if (aEntries.IsSupported(KMPXMediaGeneralValue))

   854             {

   855             CMPXMedia* pMedia = CMPXMedia::NewL();

   856             CleanupStack::PushL(pMedia);

   857             pMedia->SetTObjectValueL<TInt>(KMPXMediaGeneralValue,

   858                                           aEntries.ValueTObjectL<TInt>(KMPXMediaGeneralValue));

   859             array->AppendL(*pMedia);

   860             CleanupStack::PopAndDestroy(pMedia);

   861             MPX_ASSERT(array->Count()==1);

   862             }

   863 

   864         // check the browse type

   865         switch (aPath.Id(1).iId2)

   866             {

   867             case EBrowseAll:

   868                 {

   869                 TBool doIncremental(ETrue);

   870                 if( aFilter && aFilter->IsSupported( KMPXCollectionOpenLSupportsIncremental ) )

   871                     {

   872                     doIncremental =

   873                          aFilter->ValueTObjectL<TBool>(KMPXCollectionOpenLSupportsIncremental);

   874                     }

   875 

   876                 if( doIncremental )

   877                     {

   878                     TRAP( err, isASong = DoOpenIncrementalL( aPath, aAttrs, aEntries, array ) );

   879                     }

   880                 else

   881                     {

   882                     TRAP( err, isASong = DoOpenBrowseAllL(aPath, aAttrs, aEntries, array) );

   883                     }

   884                 break;

   885                 }

   886 

   887             case EBrowseArtist:

   888                 {

   889                 if( iAllSongsValid )

   890                     {

   891                     isASong = DoOpenBrowseArtistL( aPath, aAttrs, aEntries, array );

   892                     }

   893                 break;

   894                 }

   895 

   896             case EBrowseAlbum:

   897                 {

   898                 if( iAllSongsValid )

   899                     {

   900                     isASong = DoOpenBrowseAlbumL( aPath, aAttrs, aEntries, array );

   901                     }

   902                 break;

   903                 }

   904 

   905             case EBrowsePlaylist:

   906                 {

   907                 if( iAllSongsValid )

   908                     {

   909                     isASong = DoOpenBrowsePlaylistL(aPath, aAttrs, aEntries, array);

   910                     }

   911 

   912                 break;

   913                 }

   914 

   915             case EBrowseGenre:

   916                 {

   917                 if( iAllSongsValid )

   918                     {

   919                     isASong = DoOpenBrowseGenreL( aPath, aAttrs, aEntries, array );

   920                     }

   921                 break;

   922                 }

   923 

   924             case EBrowseComposer:

   925                 {

   926                 if( iAllSongsValid )

   927                     {

   928                     isASong = DoOpenBrowseComposerL( aPath, aAttrs, aEntries, array );

   929                     }

   930                 break;

   931                 }

   932 

   933             default:

   934                 {

   935                 User::Leave(KErrArgument);

   936                 }

   937             }

   938         //Remove the first media

   939         if ( array->Count() &&

   940             (*array)[0]->IsSupported(KMPXMediaGeneralValue))

   941             {

   942             array->Remove(0);

   943             }

   944         }

   945     else

   946         {

   947         User::Leave(KErrNotSupported);

   948         }

   949     aEntries.SetCObjectValueL(KMPXMediaArrayContents, array);

   950     aEntries.SetTObjectValueL<TInt>(KMPXMediaArrayCount, array->Count());

   951 

   952     CleanupStack::PopAndDestroy(array);

   953 

   954     if( err == KSQLErrGeneral )

   955         {

   956         iAllSongsValid = EFalse;

   957         User::Leave( KErrDiskFull );

   958         }

   959     else if( err != KErrNone )

   960         {

   961         User::Leave( err );

   962         }

   963     return isASong;

   964     }

   965 

   966 

   967 // ----------------------------------------------------------------------------

   968 // CMPXDbPlugin::DoOpenIncrementalL

   969 // ----------------------------------------------------------------------------

   970 //

   971 TBool CMPXDbPlugin::DoOpenIncrementalL( const CMPXCollectionPath& aPath,  const TArray<TMPXAttribute>& aAttrs,

   972                                        CMPXMedia& aEntries, CMPXMediaArray* aArray)

   973     {

   974     TBool isASong(EFalse);

   975 

   976     TInt levels(aPath.Levels());

   977 

   978     if( levels == 2 )

   979         {

   980         // Remove the pPath dummy from the array

   981         TInt pPath = aEntries.ValueTObjectL<TInt>(KMPXMediaGeneralValue);

   982         aArray->Remove(0);

   983         CMPXCollectionPath* p = (CMPXCollectionPath*) pPath;

   984 

   985         RArray<TMPXItemId> ids;

   986         CleanupClosePushL( ids );

   987 

   988         iDbHandler->GetAllSongsLimitedL( aAttrs, *aArray, KFirstFetchCount );

   989 

   990         TInt c( aArray->Count() );

   991         for( TInt i=0; i<c; ++i )

   992             {

   993             TMPXItemId id = aArray->AtL(i)->ValueTObjectL<TMPXItemId>( KMPXMediaGeneralId );

   994             ids.Append( id );

   995             }

   996 

   997         // Rest are all blank items

   998         CMPXMedia* entry = CMPXMedia::NewL();

   999         CleanupStack::PushL(entry);

  1000         entry->SetTObjectValueL<TMPXGeneralType>(KMPXMediaGeneralType, EMPXItem);

  1001         entry->SetTObjectValueL<TMPXGeneralCategory>(KMPXMediaGeneralCategory, EMPXSong);

  1002         entry->SetTObjectValueL<TMPXItemId>(KMPXMediaGeneralId, KMPXInvalidItemId );

  1003 

  1004         TInt count = iDbHandler->NumberOfItemsL(EMPXSong);

  1005         count-=c;

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

  1007             {

  1008             aArray->AppendL( *entry );

  1009             ids.Append( KMPXInvalidItemId );

  1010             }

  1011         CleanupStack::PopAndDestroy( entry );

  1012 

  1013         // Set the "Supportes incremental Command" flag

  1014         //

  1015         aEntries.SetTObjectValueL( KMPXCollectionOpenLSupportsIncremental, ETrue );

  1016 

  1017         TMPXOpenDataBlock block;

  1018         block.iOffset=KErrNotFound;

  1019         block.iSize=count;

  1020         aEntries.SetTObjectValueL<TMPXOpenDataBlock>( KMPXCollectionOpenLResultRange, block );

  1021 

  1022         SetMediaGeneralAttributesL(aEntries, EMPXGroup, EMPXSong,

  1023                 iMusicLibraryTitles->MdcaPoint(EBrowseAll));

  1024 

  1025         p->AppendL(ids.Array());

  1026         CleanupStack::PopAndDestroy( &ids );

  1027         }

  1028     else if( levels == 3 )

  1029         {

  1030         iDbHandler->GetSongL(aPath.Id(levels - 1).iId2, aAttrs, *aArray);

  1031         isASong = ETrue;

  1032         }

  1033 

  1034 

  1035     return isASong;

  1036     }

  1037 

  1038 // ----------------------------------------------------------------------------

  1039 // Handles OpenL called for EBrowseAll

  1040 // ----------------------------------------------------------------------------

  1041 //

  1042 TBool CMPXDbPlugin::DoOpenBrowseAllL(

  1043     const CMPXCollectionPath& aPath,

  1044     const TArray<TMPXAttribute>& aAttrs,

  1045     CMPXMedia& aEntries,

  1046     CMPXMediaArray* aArray)

  1047     {

  1048     MPX_FUNC("CMPXDbPlugin::DoOpenBrowseAllL");

  1049 

  1050     TInt levels(aPath.Levels());

  1051     switch (levels)

  1052        {

  1053        // All songs

  1054        case 2:

  1055             {

  1056             MPX_PERF_START(CMPXDbPlugin_DoOpenBrowseAllL_All);

  1057 

  1058             iDbHandler->GetAllSongsL(aArray, aAttrs);

  1059             SetMediaGeneralAttributesL(aEntries, EMPXGroup, EMPXSong,

  1060                 iMusicLibraryTitles->MdcaPoint(EBrowseAll));

  1061 

  1062             MPX_PERF_END(CMPXDbPlugin_DoOpenBrowseAllL_All);

  1063             break;

  1064             }

  1065 

  1066          // A Song in all songs

  1067          case 3:

  1068             {

  1069             MPX_PERF_START(CMPXDbPlugin_DoOpenBrowseAllL_Song);

  1070 

  1071             iDbHandler->GetSongL(aPath.Id(levels - 1).iId2, aAttrs, *aArray);

  1072 

  1073             MPX_PERF_END(CMPXDbPlugin_DoOpenBrowseAllL_Song);

  1074             break;

  1075             }

  1076 

  1077          default:

  1078             {

  1079             MPX_DEBUG2("CMPXDbPlugin_DoOpenBrowseAllL: Invalid levels[%d]", levels);

  1080             User::Leave(KErrNotSupported);

  1081             }

  1082         } // end switch(levels)

  1083 

  1084     return (levels == 3);

  1085     }

  1086 

  1087 // ----------------------------------------------------------------------------

  1088 // Handles OpenL called for EBrowseArtist

  1089 // ----------------------------------------------------------------------------

  1090 //

  1091 TBool CMPXDbPlugin::DoOpenBrowseArtistL(

  1092     const CMPXCollectionPath& aPath,

  1093     const TArray<TMPXAttribute>& aAttrs,

  1094     CMPXMedia& aEntries,

  1095     CMPXMediaArray* aArray)

  1096     {

  1097     MPX_FUNC("CMPXDbPlugin::DoOpenBrowseArtistL");

  1098 

  1099     TBool isASong(EFalse);

  1100     TInt levels(aPath.Levels());

  1101     TInt idIndex(levels - 1);

  1102 

  1103     RArray<TMPXItemId> selections;

  1104     CleanupClosePushL(selections);

  1105     aPath.SelectionL(selections);

  1106 

  1107     switch (levels)

  1108         {

  1109         // All artists

  1110         case 2:

  1111             {

  1112             MPX_PERF_START(CMPXDbPlugin_DoOpenBrowseArtistL_All);

  1113 

  1114             iDbHandler->GetAllArtistsL(aAttrs, aArray);

  1115             SetMediaGeneralAttributesL(aEntries, EMPXGroup, EMPXArtist,

  1116                 iMusicLibraryTitles->MdcaPoint(EBrowseArtist));

  1117 

  1118             MPX_PERF_END(CMPXDbPlugin_DoOpenBrowseArtistL_All);

  1119             break;

  1120             }

  1121 

  1122         // All albums of an artist

  1123         case 3:

  1124             {

  1125             MPX_PERF_START(CMPXDbPlugin_DoOpenBrowseArtistL_AllAlbums);

  1126             // get the albums

  1127             TInt id(aPath.Id(idIndex).iId2);

  1128             MPX_ASSERT(aArray->Count());

  1129             MPX_ASSERT((*aArray)[0]->IsSupported(KMPXMediaGeneralValue));

  1130             TInt pPath = (*aArray)[0]->ValueTObjectL<TInt>(KMPXMediaGeneralValue);

  1131             MPX_ASSERT(pPath);

  1132             iDbHandler->GetAlbumsMatchingArtistL(id, aAttrs, *aArray);

  1133             SetMediaGeneralAttributesL(aEntries, EMPXItem, EMPXArtist, id);