mpxplugins/serviceplugins/collectionplugins/inc/mpxdbcommonutil.h
changeset 0 ff3acec5bc43
child 14 943ff5625028
equal deleted inserted replaced
-1:000000000000 0:ff3acec5bc43
       
     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:  The class MPXDbCommonUtil which contains utilities functions
       
    15 *
       
    16 */
       
    17 
       
    18 
       
    19 #ifndef MPXDBCOMMONUTIL_H
       
    20 #define MPXDBCOMMONUTIL_H
       
    21 
       
    22 // INCLUDES
       
    23 #include <apmstd.h>
       
    24 #include <f32file.h>
       
    25 #include <badesca.h>
       
    26 #include <mpxmediageneraldefs.h>
       
    27 #include <mpxmessagegeneraldefs.h>
       
    28 #include <mpxcollectionmessagedefs.h>
       
    29 #include <mpxmessage2.h>
       
    30 #include <mpxcollectionpath.h>
       
    31 
       
    32 #include "mpxdbcommonstd.h"
       
    33 
       
    34 
       
    35 // FORWARD DECLARATIONS
       
    36 class CMPXRowSet;
       
    37 class CMPXDatabase;
       
    38 class CMPXMedia;
       
    39 class CMPXMediaArray;
       
    40 class RSqlStatement;
       
    41 
       
    42 // CLASS DECLARATION
       
    43 
       
    44 /**
       
    45 * This static class contains utilities functions used by MPX Collection DB Plugins
       
    46 */
       
    47 class MPXDbCommonUtil
       
    48     {
       
    49 
       
    50     public:
       
    51 
       
    52         /**
       
    53         * Set HBufC data member.
       
    54         * Free the memory and set the aBuf to the new location.
       
    55         * @param aBuf, the buf to be set
       
    56         * @param aSource, source descriptor
       
    57         * @param aMaxLen, max length allowed in aBuf, -1 is unlimited.
       
    58         * @return KErrOverflow if the length of source is greater than MaxLen
       
    59         */
       
    60         IMPORT_C static TInt SetHBuf(HBufC*& aBuf,
       
    61                             const TDesC* aSource,
       
    62                             TInt aMaxLen = -1);
       
    63 
       
    64         /**
       
    65         * Replace the single quote in the SQL string
       
    66         * @param aSrc source descriptor
       
    67         * @param aTrg target descriptor
       
    68         */
       
    69         IMPORT_C static void FindAndReplaceSingleQuote(const TDesC& aSrc, TDes& aTrg);
       
    70 
       
    71         /**
       
    72         * Delete from file system (includes read-only files)
       
    73         * @param aFs File server session handle
       
    74         * @param aFile File path to be deleted
       
    75         * @return KErrNone if file deleted successfully
       
    76         *         System-wide error code otherwise
       
    77         */
       
    78         IMPORT_C static TInt DeleteFile(RFs& aFs, const TDesC& aFile);
       
    79 
       
    80         /**
       
    81         * Get the drive Id with a given volume unique Id
       
    82         * @param aFs File server session handle
       
    83         * @param aVolumeId volume ID to match
       
    84         * @return drive Id. If volume Id not found, return KErrNotFound
       
    85         */
       
    86         IMPORT_C static TInt GetDriveIdMatchVolIdL(RFs& aFs, TUint aVolumeId);
       
    87 
       
    88         /**
       
    89         * Get the volume Id with a given drive Id
       
    90         * @param aFs File server session handle
       
    91         * @param aDriveId: a drive ID to match
       
    92         * @return volume Id. If no correspending media is found for given
       
    93         *         aDriveId, 0 will return
       
    94         */
       
    95         IMPORT_C static TUint GetVolIdMatchDriveIdL(RFs& aFs, TInt aDriveId);
       
    96 
       
    97         /**
       
    98         * Generate a 32bits Unique Id with MD5
       
    99         * If the input is a filename, only the path part will be hashed
       
   100         * The drive part of the path will be replaced by the corresponding
       
   101         * volume Id in order to maintain uniquenss as one media may mount as
       
   102         * different drive letter in different devices
       
   103         * @param aFs File server session handle
       
   104         * @param aTableId Use category as table Id
       
   105         * @param aName Category name or file name as input to encoder
       
   106         * @param aCaseSensitve ETrue if case sensitivity should be taken
       
   107         *                      into account when generating unique ID
       
   108         * @return unique Id
       
   109         * NOTE If aName given is a path and the drive/media doesn't
       
   110         * exist (e.g. MMC not inserted), full path will be hashed
       
   111         */
       
   112         IMPORT_C static TUint32 GenerateUniqueIdL(RFs& aFs, TMPXGeneralCategory aTableId,
       
   113             const TDesC& aName, TBool aCaseSensitive);
       
   114 
       
   115         /**
       
   116         * Create a media object with title, type, category and ID and append it to the media array
       
   117         * @param aArray media array
       
   118         * @param aTitle title
       
   119         * @param aType attribute type
       
   120         * @param aCat attribute category
       
   121         * @param aId unique ID
       
   122         * @param aNonPermissibleActions bitmask specifying the non-permissible actions for the entry
       
   123         * @param aDbflag Dbflag value for the new media entry
       
   124         */
       
   125         IMPORT_C static void AppendMediaL(CMPXMediaArray& aArray, const TDesC& aTitle, TMPXGeneralType aType,
       
   126             TMPXGeneralCategory aCat, TMPXItemId aId = 0, TInt aNonPermissibleActions = 0,
       
   127             TUint aDbflag = 0);
       
   128 
       
   129         /**
       
   130         * Create a media object with title, type, category and ID and prepend it to the media array
       
   131         * @param aArray media array
       
   132         * @param aTitle title
       
   133         * @param aType attribute type
       
   134         * @param aCat attribute category
       
   135         * @param aId unique ID
       
   136         * @param aNonPermissibleActions bitmask specifying the non-permissible actions for the entry
       
   137         * @param aDbflag Dbflag value for the new media entry
       
   138         * @param aPos postion of the new item, 0 is the first item
       
   139         */
       
   140         IMPORT_C static void PrependMediaL(CMPXMediaArray& aArray, const TDesC& aTitle, TMPXGeneralType aType,
       
   141             TMPXGeneralCategory aCat, TMPXItemId aId = 0, TInt aNonPermissibleActions = 0,
       
   142             TUint aDbflag = 0,
       
   143             TInt aPos = 0);
       
   144 
       
   145         /**
       
   146         * Fill in the supported UID array based on what is requested in the attribute array
       
   147         * @param aAttrs requested attributes
       
   148         * @param aSupportedIds supported UID array
       
   149         */
       
   150         IMPORT_C static void FillInSupportedUIDsL(const TArray<TMPXAttribute>& aAttrs, RArray<TInt>& aSupportedIds);
       
   151 
       
   152         /**
       
   153         * Fill in the message with item changed information
       
   154         * @param aMessage a message to be filled with the supplied information
       
   155         * @param aId item id
       
   156         * @param aChangeType change type
       
   157         * @param aCategory category of the item changed
       
   158         * @param aUid plugin UID
       
   159         * @param aDeprecatedId deprecated id of the item after it's been moved/renamed
       
   160         */
       
   161         IMPORT_C static void FillItemChangedMessageL(CMPXMessage& aMessage, TMPXItemId aId,
       
   162             TMPXChangeEventType aChangeType, TMPXGeneralCategory aCategory, TUint aUid,
       
   163             TMPXItemId aDeprecatedId = 0);
       
   164 
       
   165         /**
       
   166         * Constructs an item changed message and adds it to the array
       
   167         * @param aMessageArray array to add the message to
       
   168         * @param aId item ID
       
   169         * @param aChangeType change type
       
   170         * @param aCategory category of the item changed
       
   171         * @param aUid plugin UID
       
   172         * @param aDeprecatedId deprecated id of the item after it's been moved/renamed
       
   173         */
       
   174         IMPORT_C static void AddItemChangedMessageL(CMPXMessageArray& aMessageArray, TMPXItemId aId,
       
   175             TMPXChangeEventType aChangeType, TMPXGeneralCategory aCategory, TUint aUid,
       
   176             TMPXItemId aDeprecatedId = 0);
       
   177 
       
   178         /**
       
   179         * Find the matching item changed message from the array
       
   180         * @param aMessageArray array containing item changed messages
       
   181         * @param aMessage the message to search for in the array.
       
   182         * @return KErrNotFound if the message cannot be found in the array; otherwise,
       
   183         *         the index of the 1st matching message in the array.
       
   184         */
       
   185         IMPORT_C static TInt FindItemChangedMessageL(const CMPXMessageArray& aMessageArray,
       
   186             const CMPXMessage& aMessage);
       
   187 
       
   188         /**
       
   189         * Get the DRM protection type of the file
       
   190         * @param aFile the file to retrieve the DRM type
       
   191         * @return DRM protection type of the file
       
   192         */
       
   193         IMPORT_C static TMCDrmType GetDRMTypeL(const TDesC& aFile);
       
   194 
       
   195         /**
       
   196         * Processes the string for single quotes
       
   197         * @param aString source string
       
   198         * @return processed string
       
   199         */
       
   200         IMPORT_C static HBufC* ProcessSingleQuotesLC(const TDesC& aString);
       
   201 
       
   202         /**
       
   203         * Processes the string for pattern characters so that they will be treated
       
   204         * as normal characters.
       
   205         * @param aString source string
       
   206         * @return processed string where those pattern characters will no longer be
       
   207         *         treated as special characters, they will be treated as regular
       
   208         *         characters.
       
   209         */
       
   210         IMPORT_C static HBufC* ProcessPatternCharsLC(const TDesC& aString);
       
   211 
       
   212         /**
       
   213         * Constructs an SQL criterion (name = value)
       
   214         * @param aCriterion name string
       
   215         * @param aValue value
       
   216         * @return criterion string on the CS
       
   217         */
       
   218         IMPORT_C static HBufC* SqlCriterionLC(
       
   219             const TDesC& aCriterion, TInt aValue);
       
   220 
       
   221         /**
       
   222         * Constructs an SQL criterion (name = value)
       
   223         * @param aCriterion name string
       
   224         * @param aValue value
       
   225         * @return criterion string on the CS
       
   226         */
       
   227         IMPORT_C static HBufC* SqlCriterion64LC(
       
   228             const TDesC& aCriterion, TInt64 aValue);
       
   229 
       
   230         /**
       
   231         * Constructs an SQL criterion (name = value)
       
   232         * @param aCriterion name string
       
   233         * @param aValue1 value1
       
   234         * @param aValue2 value2
       
   235         * @return criterion string on the CS
       
   236         */
       
   237         IMPORT_C static HBufC* SqlCriterionLC(
       
   238             const TDesC& aCriterion, TInt aValue1, TInt aValue2);
       
   239 
       
   240         /**
       
   241         * Constructs an SQL criterion (name = value)
       
   242         * @param aCriterion name string
       
   243         * @param aValue1 TInt64 value1
       
   244         * @param aValue2 TInt64 value2
       
   245         * @return criterion string on the CS
       
   246         */
       
   247         IMPORT_C static HBufC* SqlCriterion64LC(
       
   248             const TDesC& aCriterion, TInt64 aValue1, TInt64 aValue2);
       
   249 
       
   250         /**
       
   251         * Constructs an SQL criterion (name = value)
       
   252         * @param aCriterion name string
       
   253         * @param aValue value string
       
   254         * @return criterion string on the CS
       
   255         */
       
   256         IMPORT_C static HBufC* SqlCriterionLC(
       
   257             const TDesC& aCriterion, const TDesC& aValue);
       
   258 
       
   259         /**
       
   260         * Constructs an SQL criterion (name = value)
       
   261         * @param aCriterion name string
       
   262         * @param aValue1 value1
       
   263         * @param aValue2 value2
       
   264         * @return criterion string on the CS
       
   265         */
       
   266         IMPORT_C static HBufC* SqlCriterionLC(
       
   267             const TDesC& aCriterion, const TDesC& aValue1, const TDesC& aValue2);
       
   268 
       
   269         /**
       
   270         * Constructs an SQL criterion (name = value)
       
   271         * @param aCriterion name string
       
   272         * @param aValue1 value1
       
   273         * @param aValue2 value2
       
   274         * @param aValue3 value3
       
   275         * @param aValue4 value4
       
   276         * @return criterion string on the CS
       
   277         */
       
   278         IMPORT_C static HBufC* SqlCriterionLC(
       
   279             const TDesC& aCriterion, const TDesC& aValue1, TInt aValue2,
       
   280             const TDesC& aValue3, TInt aValue4);
       
   281 
       
   282         /**
       
   283         * Constructs an SQL criterion (name = value) and adds it to the array
       
   284         * @param aCriteriaArray array to add the criterion to
       
   285         * @param aCriterion name
       
   286         * @param aValue value
       
   287         * @return number of characters in the criterion string
       
   288         */
       
   289         IMPORT_C static TInt AddSqlCriterionL(CDesCArray& aCriteriaArray, const TDesC& aCriterion,
       
   290             TInt aValue);
       
   291 
       
   292         /**
       
   293         * Constructs an SQL criterion (name = value) and adds it to the array
       
   294         * @param aCriteriaArray array to add the criterion to
       
   295         * @param aCriterion name
       
   296         * @param aValue value
       
   297         * @return number of characters in the criterion string
       
   298         */
       
   299         IMPORT_C static TInt AddSqlCriterionL(CDesCArray& aCriteriaArray, const TDesC& aCriterion,
       
   300             const TDesC& aValue);
       
   301 
       
   302         /**
       
   303         * Create a full path with input drive Id and path
       
   304         * @param aDriveId a drive Id to added in front of path
       
   305         * @param aPath path contains path and filename
       
   306         * @return created full path, ownership transferred to client
       
   307         */
       
   308         IMPORT_C static HBufC* CreateFullPathL(TInt aDriveId, const TDesC& aPath);
       
   309 
       
   310         /**
       
   311         * Appends a name and a string value to the parameter arrays.
       
   312         * @param aFields field names array to append to
       
   313         * @param aValues field values array to append to
       
   314         * @param aField field name
       
   315         * @param aValue field value
       
   316         */
       
   317         IMPORT_C static void AppendValueL(CDesCArray& aFields, CDesCArray& aValues,
       
   318             const TDesC& aField, const TDesC& aValue);
       
   319 
       
   320         /**
       
   321         * Appends a name and an int value to the parameter arrays.
       
   322         * @param aFields field names array to append to
       
   323         * @param aValues field values array to append to
       
   324         * @param aField field name
       
   325         * @param aValue field value
       
   326         */
       
   327         IMPORT_C static void AppendValueL(CDesCArray& aFields, CDesCArray& aValues,
       
   328             const TDesC& aField, TUint32 aValue);
       
   329 
       
   330         /**
       
   331         * Returns the MIME type for a given URI
       
   332         * @param aUri URI
       
   333         * @return the MIME type
       
   334         */
       
   335         IMPORT_C static TDataType GetMimeTypeForUriL(const TDesC& aUri);
       
   336 
       
   337         /**
       
   338         * Constructs a string from the specified array like:
       
   339         *   <item1>aSeparator<item2>aSeparator...<itemN>
       
   340         * @param aArray source array
       
   341         * @param aSeparator separator string
       
   342         * @return constructed string on the CS
       
   343         */
       
   344         IMPORT_C static HBufC* StringFromArrayLC(const CDesCArray& aArray, const TDesC& aSeparator);
       
   345 
       
   346         /**
       
   347         * Constructs a string from two arrays like:
       
   348         *   <aNameArray.item1>aValueSeparator<aValueArray.item1>aEntitySeparator...
       
   349         * @param aNameArray array containing the names
       
   350         * @param aValueArray array containing the values
       
   351         * @param aValueSeparator value separator
       
   352         * @param aEntitySeparator entity separator
       
   353         * @return constructed string on the CS
       
   354         */
       
   355         IMPORT_C static HBufC* StringFromArraysLC(const CDesCArray& aNameArray,
       
   356             const CDesCArray& aValueArray, const TDesC& aValueSeparator,
       
   357             const TDesC& aEntitySeparator);
       
   358 
       
   359         /**
       
   360         * Converts TTime to a datetime string representation.
       
   361         * @param aTime TTime object
       
   362         * @return string containing date and time on the CS
       
   363         */
       
   364         IMPORT_C static HBufC* TTimeToDesLC(const TTime& aTime);
       
   365 
       
   366         /**
       
   367         * Converts string representation of datetime into TTime.
       
   368         * @param aDateTime string, containing date and time
       
   369         * @return aTime TTime object
       
   370         */
       
   371         IMPORT_C static TTime DesToTTimeL(const TDesC& aDateTime);
       
   372 
       
   373         /**
       
   374         * Returns the current time in the string format used by the database.
       
   375         * @return string containing current date and time on the CS
       
   376         */
       
   377         IMPORT_C static HBufC* CurrentTimeDesLC();
       
   378 
       
   379         /**
       
   380         * Returns the current date in the string format used by the database.
       
   381         * @return string containing current date on the CS
       
   382         */
       
   383         IMPORT_C static HBufC* CurrentDateDesLC();
       
   384 
       
   385         /**
       
   386         * Fills the drive from the URI. if the URI does not include a drive letter
       
   387         * the method does not modify aDrive and returns KErrNotFound
       
   388         * @param aUri URI to be analysed
       
   389         * @param aDrive returns the drive
       
   390         * @return system error code
       
   391         */
       
   392         IMPORT_C static TInt GetDriveL(const TDesC& aUri, TDriveUnit& aDrive);
       
   393 
       
   394         /**
       
   395         * Checks if a specified attribute exists in the attribute array
       
   396         * @param aAttrs attribute array
       
   397         * @param aAttribute attribute to be checked
       
   398         * @return ETrue if the attribute exists, Efalse otherwise
       
   399         */
       
   400         IMPORT_C static TBool AttributeExists(const TArray<TMPXAttribute>& aAttrs,
       
   401             const TMPXAttribute& aAttribute);
       
   402 
       
   403         /**
       
   404         * Reads the value of a text field. This method is required because on ARMv5
       
   405         * the RSqlStatement::ColumnTextL method does not return KNullDesC for empty
       
   406         * text fields.
       
   407         * @param aStatement recordset to read the field from
       
   408         * @param aField field index
       
   409         * @return Text field value or KNullDesC if empty
       
   410         */
       
   411         IMPORT_C static TPtrC GetColumnTextL(RSqlStatement& aStatement, TInt aField);
       
   412 
       
   413     private:
       
   414         /**
       
   415         * Create a media object with title, type, category and ID and push onto the CS.
       
   416         * @param aTitle title
       
   417         * @param aType attribute type
       
   418         * @param aCat attribute category
       
   419         * @param aId unique ID
       
   420         * @param aNonPermissibleActions bitmask specifying the non-permissible actions for the entry
       
   421         * @param aDbflag Dbflag value for the new media entry
       
   422         */
       
   423         static CMPXMedia* ConstructMediaLC(const TDesC& aTitle, TMPXGeneralType aType,
       
   424             TMPXGeneralCategory aCat, TMPXItemId aId, TInt aNonPermissibleActions,
       
   425             TUint aDbflag);
       
   426     };
       
   427 
       
   428 #endif // MPXDBCOMMONUTIL_H
       
   429 
       
   430 // End of File
       
   431