1 /*

     2 * Copyright (c) 2006-2007 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:  Thumbnail server

    15  *

    16 */

    17 

    18 

    19 #ifndef THUMBNAILSERVER_H

    20 #define THUMBNAILSERVER_H

    21 

    22 #include <e32base.h>

    23 #include <fbs.h>

    24 #include <w32std.h>

    25 #include <apmrec.h>

    26 #include <apgcli.h>

    27 #include <e32hashtab.h>

    28 

    29 #include <mdesession.h>

    30 

    31 #include "thumbnailmanager.h"

    32 #include "thumbnailmanagerconstants.h" // TThumbnailServerRequestId

    33 #include "thumbnailstore.h"     // TThumbnailPersistentSize

    34 #include "tmshutdownobserver.h"

    35 

    36 // Needed for creating server thread.

    37 const TUint KDefaultHeapSize = 160 * 1024;

    38 

    39 class CThumbnailTaskProcessor;

    40 class CThumbnailProvider;

    41 class CThumbnailTask;

    42 class CThumbnailStore;

    43 class MIHLScaler;

    44 class CThumbnailServerSession;

    45 class CThumbnailDiskUnmountObserver;

    46 class CThumbnailMemoryCardObserver;

    47 class CThumbnailFormatObserver;

    48 

    49 /**

    50  * Helper function to destroy all objects which are referred to

    51  * by pointers in a hash table.

    52  * @since S60 v5.0

    53  * @param aHashMap Reference to hash map

    54  */

    55 template <class K, class V> void ResetAndDestroyHashMap( RHashMap<K, V* > &

    56     aHashMap )

    57     {

    58     THashMapIter<K, V* > iter( aHashMap );

    59 

    60     // const pointer to a non-const object

    61     V* const * item = iter.NextValue();

    62 

    63     while ( item )

    64         {

    65         delete * item;

    66         item = iter.NextValue();

    67         }

    68     aHashMap.Close();

    69     }

    70 

    71 /**

    72  *  Thumbnail server.

    73  *

    74  *  @since S60 v5.0

    75  */

    76 NONSHARABLE_CLASS( CThumbnailServer ): public CPolicyServer,

    77                                        public MMdESessionObserver,

    78                                        public MTMShutdownObserver

    79     {

    80 public:

    81 

    82     /**

    83      * Two-phased constructor

    84      *

    85      * @since S60 v5.0

    86      * @return New CThumbnailServer server.

    87      */

    88     static CThumbnailServer* NewL();

    89 

    90     /**

    91      * Destructor

    92      *

    93      * @since S60 v5.0

    94      */

    95     virtual ~CThumbnailServer();

    96 

    97 public:

    98 

    99     /**

   100      * Creates new server session.

   101      *

   102      * @since S60 v5.0

   103      * @param aVersion Version info.

   104      * @param aMessage Message to be passed.

   105      * @return New session.

   106      */

   107     CSession2* NewSessionL( const TVersion& aVersion, const RMessage2& aMessage

   108         )const;

   109 

   110     /**

   111      * ThreadFunctionL

   112      *

   113      * @since S60 v5.0

   114      */

   115     static void ThreadFunctionL();

   116 

   117     /**

   118      * AddSession

   119      *

   120      * @since S60 v5.0

   121      */

   122     void AddSession();

   123 

   124     /**

   125      * DropSession

   126      *

   127      * @since S60 v5.0

   128      */

   129     void DropSession(CThumbnailServerSession* aSession);

   130     

   131     // from MMdESessionObserver

   132     void HandleSessionOpened( CMdESession& aSession, TInt aError );

   133     void HandleSessionError( CMdESession& aSession, TInt aError );    

   134     

   135     // from MTMShutdownObserver

   136     void ShutdownNotification();

   137 

   138     /**

   139      * Adds bitmap to bitmap pool. Server assumes ownership of the bitmap and

   140      * implements reference counting to know when it is safe to delete

   141      * the object. Reference count is increased if the bitmap already

   142      * exists in the pool.

   143      *

   144      * @since S60 v5.0

   145      * @param aSession Server side session which owns the bitmap.

   146      * @param aBitmap Bitmap to be added to pool.

   147      */

   148     void AddBitmapToPoolL( CThumbnailServerSession* aSession, CFbsBitmap*

   149         aBitmap );

   150 

   151     /**

   152      * Store thumbnail.

   153      *

   154      * @since S60 v5.0

   155      * @param aPath Image path.

   156      * @param aBitmap Thumbnail image.

   157      * @param aOriginalSize Original size of image.

   158      * @param aCropped Enabled if the thumbnail was cropped.

   159      * @param aThumbnailSize Prededined size of requested thumbnail.

   160      * @param aThumbFromPath Thumbnail created from associated path.

   161      * @param aThumbFromPath Check first if source uri exists.

   162      */

   163     void StoreThumbnailL( const TDesC& aPath, CFbsBitmap* aBitmap, const TSize&

   164         aOriginalSize, const TBool aCropped, const TThumbnailSize aThumbnailSize,

   165         const TThumbnailId aThumbnailId, const TBool aThumbFromPath = ETrue,

   166         const TBool aCheckExist = ETrue);

   167 

   168     /**

   169      * Fetch thumbnail image.

   170      *

   171      * @since S60 v5.0

   172      * @param aPath Path of the media object whose thumbnail is to be

   173      *              retrieved.

   174      * @param aThumbnail Pointer to get the fetched thumbnail bitmap.

   175      *                   Caller assumes ownership.

   176      * @param aMinimumSize Minimum size of the thumbnail.

   177      * @param aOriginalSize Original size of the object file in pixels

   178      * @param aCropped If true, match cropped images only.

   179      * @param aAllowUpscaling If enabled, allow fetching thumbnails that

   180      *                        are smaller than requested.

   181      * @param aThumbnailSize Prededined size of requested thumbnail.

   182      */

   183     void FetchThumbnailL( const TDesC& aPath, CFbsBitmap* & aThumbnail, 

   184              TDesC8* & aData, const TThumbnailSize aThumbnailSize, TSize &aOriginalSize );

   185     

   186     /**

   187      * Fetch thumbnail image.

   188      *

   189      * @since S60 v5.0

   190      * @param aThumbnailId ID of the media object whose thumbnail is to be

   191      *              retrieved.

   192      * @param aThumbnail Pointer to get the fetched thumbnail bitmap.

   193      *                   Caller assumes ownership.

   194      */    

   195     void FetchThumbnailL( TThumbnailId aThumbnailId, CFbsBitmap* &

   196         aThumbnail, TDesC8* & aData, TThumbnailSize aThumbnailSize, TSize &aOriginalSize );

   197 

   198     /**

   199      * Delete thumbnails.

   200      *

   201      * @since S60 v5.0

   202      * @param aPath           Path of the media object whose thumbnail is

   203      *                        to be deleted.

   204      */

   205     void DeleteThumbnailsL( const TDesC& aPath );

   206 

   207     /**

   208      * Delete thumbnails by Id.

   209      *

   210      * @since S60 v5.0

   211      * @param aItemId         Id of item whose thumbnails are to be deleted.

   212      */

   213     void DeleteThumbnailsByIdL( TThumbnailId aItemId );    

   214     

   215     /**

   216      * Resolve the MIME-type of given file using recognizer framework.

   217      *

   218      * @since S60 v5.0

   219      * @param aFile File to be recognized.

   220      * @return MIME-type

   221      */

   222     TDataType ResolveMimeTypeL( RFile& aFile );

   223 

   224     /**

   225      * Removes bitmap from bitmap pool. Reference count is decremented

   226      * and if it reaches zero, the bitmap object is deleted.

   227      *

   228      * @since S60 v5.0

   229      * @param aHandle Bitmap handle.

   230      */

   231     void DeleteBitmapFromPool( TInt aHandle );

   232 

   233     /**

   234      * Resolve plugin to be used in thumbnail creation by mime type.

   235      *

   236      * @since S60 v5.0

   237      * @param aMimeType Mime type of the file from which a thumbnail is to be

   238      *                  created.

   239      * @return Thumbnail provider.

   240      */

   241     CThumbnailProvider* ResolveProviderL( const TDesC8& aMimeType );

   242 

   243     /**

   244      * Add thumbnailtask to processor queue.

   245      *

   246      * @since S60 v5.0

   247      * @param aTask Task to be added to queue.

   248      */

   249     void QueueTaskL( CThumbnailTask* aTask );

   250 

   251     /**

   252      * Remove thumbnailtask from processor queue.

   253      *

   254      * @since S60 v5.0

   255      * @param aRequestId ID of the task to be removed from queue.

   256      * @return Error code.

   257      */

   258     TInt DequeTask( const TThumbnailServerRequestId& aRequestId );

   259 

   260     /**

   261      * Change priority of specific task.

   262      *

   263      * @since S60 v5.0

   264      * @param aRequestId ID of the task to be assigned new priority.

   265      * @param aNewPriority New priority for the task.

   266      * @return Error code.

   267      */

   268     TInt ChangeTaskPriority( const TThumbnailServerRequestId& aRequestId, TInt

   269         aNewPriority );

   270 

   271     /**

   272      * Scale bitmap

   273      *

   274      * @since S60 v5.0

   275      * @param aStatus      Request status.

   276      * @param aSource      Source bitmap.

   277      * @param aDest        Destination bitmap.

   278      * @param aSourceRect  Source rectangle for cropping.

   279      */

   280     void ScaleBitmapL( TRequestStatus& aStatus, const CFbsBitmap& aSource,

   281         CFbsBitmap& aDest, const TRect& aSourceRect );

   282 

   283     /**

   284      * Cancel scaling operation

   285      *

   286      * @since S60 v5.0

   287      */

   288     void CancelScale();

   289 

   290     /**

   291      * Returns processor.

   292      *

   293      * @since S60 v5.0

   294      * @return Reference to processor instance.

   295      */

   296     CThumbnailTaskProcessor& Processor();

   297 

   298     /**

   299      * Get persistent size.

   300      *

   301      * @since S60 v5.0

   302      * @param aThumbnailSize Relative thumbnail size 

   303      * @return Persistent size object

   304      */    

   305     TThumbnailPersistentSize & PersistentSizeL( TThumbnailSize

   306             aThumbnailSize ); 

   307     

   308     /**

   309      * Persistent sizes.

   310      *

   311      * @since S60 v5.0

   312      * @return List of thumbnail sizes (including othe parameters) which

   313      *         are stored for later access.

   314      */

   315     RArray < TThumbnailPersistentSize > PersistentSizesL();

   316 

   317     /**

   318      * Get missing thumbnail sizes.

   319      *

   320      * @since S60 v5.0

   321      * @param aPath Path associated to missing thumbnails

   322      * @param aMissingSizes Returns a list of thumbnail sizes not yet create related to the path

   323      */

   324     void GetMissingSizesAndIDsL( const TDesC& aPath, TInt aSourceType, RArray <

   325         TThumbnailPersistentSize > & aMissingSizes, TBool& aMissingIDs);

   326 

   327     /**

   328      * Fileserver

   329      *

   330      * @since S60 v5.0

   331      * @return File server

   332      */

   333     RFs& Fs();

   334 

   335     /**

   336      * Get the required size (in characters) for a buffer that contains the

   337      * list of supported MIME types

   338      * 

   339      * @since S60 v5.0

   340      */

   341     TInt GetMimeTypeBufferSize()const;

   342 

   343     /**

   344      * Get the list of supported MIME types and store them in the buffer.

   345      *

   346      * @since S60 v5.0

   347      * @param aBuffer A buffer to receive the space delimited list of MIME

   348      *                types. Must be as least as large as the size returned

   349      *                by GetMimeTypeBufferSizeL()

   350      */

   351     void GetMimeTypeList( TDes& aBuffer )const;

   352     

   353     /**

   354      * Close store instance for given drive.

   355      *

   356      * @since S60 v5.0

   357      * @param aDrive Drive for which the store is used, such as EDriveC,

   358      *               EDriveE, etc.

   359      */

   360     void CloseStoreForDriveL( const TInt aDrive );     

   361     

   362     /**

   363      * React to change in memory card status.

   364      *

   365      * @since S60 v5.0     

   366      */

   367     void MemoryCardStatusChangedL();

   368 

   369     /**

   370      * Update thumbnails in database

   371      *

   372      * @since S60 v5.0

   373      * @param aItemId       TThumbnailId

   374      * @param aPath         (New) path for the Thumbnail

   375      * @param aOrientation  Thumbnail orientation

   376      * @param aModified     Last modified

   377      * @param TBool         EFalse, if new thumbs need to be created

   378      */  

   379     TBool UpdateThumbnailsL( const TThumbnailId aItemId, const TDesC& aPath,

   380                              const TInt aOrientation, const TInt64 aModified );

   381     

   382     /** 

   383      * Resolve mime type from file extension

   384      *

   385      * @since S60 v5.0     

   386      * @param aFileName Image file

   387      * @param aMimeType Mime type

   388      * @return TInt KErrNone/KErrNotFound

   389      */

   390     TInt MimeTypeFromFileExt( const TDesC& aFileName, TDataType& aMimeType );

   391     

   392     /** 

   393      * Resolve source type from mime type

   394      *

   395      * @since S60 v5.0     

   396      * @param aMimeType Mime type

   397      * @return TInt TThumbnailPersistentSize enum

   398      */

   399     TInt SourceTypeFromMimeType( const TDataType& aMimeType );

   400     

   401     /** 

   402      * Resolve source type from size type

   403      *

   404      * @since S60 v5.0     

   405      * @param aSizeType size type enum

   406      * @return TInt TThumbnailPersistentSize enum

   407      */

   408     TInt SourceTypeFromSizeType( const TInt aSizeType );

   409     

   410     /** 

   411      * Is mime type supported

   412      *

   413      * @since S60 v5.0     

   414      * @param aMimeType Mime type

   415      * @return TBool supported

   416      */

   417     TBool SupportedMimeType( const TDataType& aMimeType );    

   418     

   419     /** 

   420      * Get MDS session

   421      *

   422      * @since S60 v5.0     

   423      * @return CMdESession

   424      */

   425     CMdESession* GetMdESession();

   426     

   427     /**

   428      * Get store instance for given path.

   429      *

   430      * @since S60 v5.0

   431      * @param aPath Path to a file

   432      * @return CThumbnailStore object

   433      */

   434     CThumbnailStore* StoreForPathL( const TDesC& aPath );  

   435     

   436     /**

   437      * Update ID in database

   438      *

   439      * @since S60 v5.0

   440      * @param aItemId Id of item whose thumbnails are to be updated.

   441      * @param aNewPath Path property of the object to be updated.

   442      */  

   443     void UpdateIDL( const TDesC& aPath, const TThumbnailId aNewId );

   444     

   445     /**

   446      * Close Removable Stores

   447      *

   448      * @since S60 v5.0

   449      */  

   450     

   451     void CloseRemovableDrivesL();

   452     

   453     /**

   454      * Open Removable Stores

   455      *

   456      * @since S60 v5.o

   457      */  

   458     

   459     void OpenRemovableDrivesL();

   460     

   461     /**

   462      * Checks if formatting is ongoing

   463      *

   464      * @since S60 v5.o

   465      */ 

   466     

   467     TBool IsFormatting();

   468   

   469 protected: // Functions from base classes

   470 

   471     /**

   472     * From CPolicyServer.

   473     * Handles capability checking for certain server requests.

   474     * @param aMsg  Message which was received from the client side

   475     * @param aAction  

   476     * @param aMissing

   477     * @result return one of TCustomResult set {EPass, EFail, EAsync}.

   478     */

   479     CPolicyServer::TCustomResult CustomSecurityCheckL( 

   480         const RMessage2 &aMsg, TInt &aAction, TSecurityInfo &aMissing );

   481 

   482     /**

   483     * From CPolicyServer.

   484     * Handles failure

   485     * @param aMsg  Message which was received from the client side

   486     * @param aAction  

   487     * @param aMissing

   488     * @result return one of TCustomResult set {EPass, EFail, EAsync}.

   489     */

   490     CPolicyServer::TCustomResult CustomFailureActionL(

   491         const RMessage2 &aMsg, TInt aAction, const TSecurityInfo &aMissing );

   492     

   493 private:

   494 

   495     /**

   496      * Get a provider plug-in by the given UID

   497      *

   498      * @since S60 v5.0

   499      * @param aImplUid UID of the provider plug-in.

   500      * @return Provider instance.

   501      */

   502     CThumbnailProvider* GetProviderL( const TUid& aImplUid );

   503 

   504     /**

   505      * Get store instance for given drive.

   506      *

   507      * @since S60 v5.0

   508      * @param aDrive Drive for which the store is used, such as EDriveC,

   509      *               EDriveE, etc.

   510      * @return CThumbnailStore object

   511      */

   512     CThumbnailStore* StoreForDriveL( const TInt aDrive );

   513  

   514     

   515     /**

   516      * Add unmount observer for each unmountable drive.

   517      *

   518      * @since S60 v5.0

   519      */

   520     void AddUnmountObserversL();

   521     

   522     /** 

   523      * Open store for each mounted drive.

   524      *

   525      * @since S60 v5.0     

   526      */

   527     void OpenStoresL();

   528     

   529  

   530 

   531 private:

   532 

   533     /**

   534      * C++ default constructor

   535      *

   536      * @since S60 v5.0

   537      * @return New CThumbnailServer instance.

   538      */

   539     CThumbnailServer();

   540 

   541     /**

   542      * Symbian 2nd phase constructor can leave.

   543      *

   544      * @since S60 v5.0

   545      */

   546     void ConstructL();

   547 

   548 private:

   549     /**

   550      * Reference counted pointer to a CFbsBitmap object used for the bitmap

   551      * pool.

   552      */

   553     struct TThumbnailBitmapRef

   554         {

   555 public:

   556         /**

   557          * CThumbnailServerSession can be used to identify which client

   558          * session is responsible for calling ReleaseBitmap() for this

   559          * bitmap. Not own.

   560          */

   561         CThumbnailServerSession* iSession;

   562 

   563         /**

   564          * Reference count for this bitmap. If reference count reaches zero,

   565          * the bitmap is deleted by the server.

   566          */

   567         TInt iRefCount;

   568 

   569         /**

   570          * Bitmap object. Not owned directly by TThumbnailBitmapRef, but by

   571          * the server.

   572          * Not own.

   573          */

   574         CFbsBitmap* iBitmap;

   575         };

   576 

   577 private:

   578     // data

   579 

   580     TBool iShutdown;

   581     CTMShutdownObserver* iShutdownObserver;

   582     

   583     /**

   584      * Fileserver, own.

   585      */

   586     RFs iFs;

   587 

   588     /**

   589      * Sessioncount.

   590      */

   591     TInt iSessionCount;

   592 

   593     /**

   594      * FbsSession.

   595      */

   596     RFbsSession iFbsSession;

   597 

   598     /**

   599      * Bitmap pool. Reference counted pointers to CFbsBitmaps stored

   600      * in a hash table with bitmap handle as the key.

   601      * Own.

   602      */

   603     RHashMap < TInt, TThumbnailBitmapRef > iBitmapPool;

   604 

   605     /**

   606      * Processor for running tasks.

   607      * Own.

   608      */

   609     CThumbnailTaskProcessor* iProcessor;

   610 

   611     /**

   612      * Central repository data handler

   613      * Own.

   614      */

   615     CThumbnailCenRep* iCenrep;

   616 

   617     /**

   618      * Recognizer.

   619      * Own.

   620      */

   621     RApaLsSession iRecognizer;

   622 

   623     /**

   624      * Result of recognition.

   625      */

   626     TDataRecognitionResult iResult;

   627 

   628     /**

   629      * Plug-in info.

   630      */

   631     RImplInfoPtrArray iPluginInfoArray;

   632 

   633     /**

   634      * Thumbnail providers. Stored in a hash table with the implementation

   635      * UID as the key.

   636      * Own.

   637      */

   638     RHashMap < TInt32, CThumbnailProvider*  > iProviders;

   639 

   640     /**

   641      * Scaler.

   642      * Own.

   643      */

   644     MIHLScaler* iScaler;

   645 

   646     /**

   647     * Array of unmount observers.

   648     */

   649     RPointerArray<CThumbnailDiskUnmountObserver> iUnmountObservers;

   650     

   651     CThumbnailMemoryCardObserver* iMMCObserver;

   652     

   653     CThumbnailFormatObserver* iFormatObserver;

   654 

   655     /**

   656      * Databases for each drive, identified by drive (EDriveC, etc).

   657      * New databases and created on-the-fly as new requests are received.

   658      * Databases are closed when drives are dismounted.

   659      * Own.

   660      */

   661     RHashMap < TInt, CThumbnailStore*  > iStores;

   662     

   663     // own

   664     CMdESession* iMdESession;

   665     

   666     TBuf<KImeiBufferSize> iImei;

   667     

   668     /**

   669      * Persistent sizes.

   670      */

   671     RArray < TThumbnailPersistentSize > iPersistentSizes;

   672     

   673     TBool iFormatting;

   674     

   675 #ifdef _DEBUG

   676     TUint32 iPlaceholderCounter;

   677 #endif

   678 };

   679 

   680 #endif // THUMBNAILSERVER_H