1 /*

     2 * Copyright (c) 2002-2009 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: 

    15 *

    16 */

    17 

    18 

    19 #ifndef CCLFENGINEIMPL_H

    20 #define CCLFENGINEIMPL_H

    21 

    22 //  INCLUDES

    23 #include "MCLFContentListingEngine.h"

    24 #include "MCLFEventHandlerObserver.h"

    25 #include "MCLFProcessObserver.h"

    26 #include "CCLFServerProxy.h"

    27 #include "MCLFItemProviderObserver.h"

    28 #include "MCLFChangedItemProvider.h"

    29 #include <MCLFItem.h>

    30 #include <badesca.h>

    31 #include <mdesession.h>

    32 

    33 // FORWARD DECLARATIONS

    34 class CCLFEventHandler;

    35 class CCLFDbItemContainer;

    36 class CCLFDbItemProvider;

    37 class CCLFQueryAdapter;

    38 class CCLFServerProxy;

    39 

    40 // CLASS DECLARATION

    41 

    42 /**

    43 *  Implements MCLFContentListingEngine, MCLFEventHandlerObserver and MCLFItemProviderObserver

    44 *  interfaces

    45 *

    46 *  @lib ContentListingFramework.lib

    47 *  @since Series 60 3.0

    48 */

    49 NONSHARABLE_CLASS( CCLFEngineImpl ) : public CBase,

    50                                       public MCLFContentListingEngine,

    51                                       public MCLFEventHandlerObserver,

    52                                       public MCLFItemProviderObserver,

    53                                       public MMdESessionObserver

    54     {

    55     private:

    56 

    57         NONSHARABLE_CLASS( CCLFTempModel ) : public CBase,

    58                                              public MCLFChangedItemProvider

    59             {

    60             public: // Constructors and destructor

    61 

    62                 /**

    63                 * Two-phased constructor.

    64                 */

    65                 CCLFTempModel();

    66 

    67                  /**

    68                 * Destructor.

    69                 */               

    70                 virtual ~CCLFTempModel();

    71 

    72             public: // New functions

    73 

    74                 void AddObserverL( MCLFChangedItemProviderObserver* aObserver );

    75 

    76                 void ResetModelArray();

    77 

    78                 void NotifyObserverL();

    79 

    80             protected: // Functions from base classes

    81 

    82                 /**

    83                 * From MCLFChangedItemProvider

    84                 */

    85                 TBool IsItemsForModel(

    86                                 const MDesCArray& aMimeTypes,

    87                                 const TArray<TInt>& aMediaTypes,

    88                                 const TArray<TCLFItemId>& aModelItemIds );

    89 

    90                 /**

    91                 * From MCLFChangedItemProvider

    92                 */

    93                 void RemoveChangedItemProviderObserver(

    94                             MCLFChangedItemProviderObserver* aObserver );

    95 

    96             protected: // New functions

    97 

    98                 void PrepareModelL();

    99 

   100 

   101             public: // Data

   102             

   103                 // Own: temp model for changed items

   104                 RPointerArray<MCLFItem> iItemArray;

   105                 RArray<TCLFItemId> iChangedItemIdArray;

   106 

   107             private: // Data

   108 

   109                 // Ref. observers

   110                 RPointerArray<MCLFChangedItemProviderObserver>

   111                                             iChangedItemProviderObserverArray;

   112                 CDesCArraySeg iMimeTypeArray;

   113                 RArray<TInt> iMediaTypeArray;

   114 

   115             };

   116 

   117     public:  // Constructors and destructor

   118 

   119         /**

   120         * Two-phased constructor.

   121         */

   122         static CCLFEngineImpl* NewLC();

   123 

   124         /**

   125         * Destructor.

   126         */

   127         virtual ~CCLFEngineImpl();

   128 

   129     protected:  // Functions from base classes

   130 

   131         /**

   132         * From MCLFContentListingEngine

   133         */

   134         MCLFItemListModel* CreateListModelLC(

   135                                     MCLFOperationObserver& aObserver );

   136 

   137         /**

   138         * From MCLFContentListingEngine

   139         */

   140         MCLFItemListModel* CreateListModelLC(

   141                                     MCLFOperationObserver& aObserver,

   142                                     TResourceReader& aReader );

   143 

   144         /**

   145         * From MCLFContentListingEngine

   146         */

   147         void UpdateItemsL();

   148 

   149         /**

   150         * From MCLFContentListingEngine

   151         */

   152         void UpdateItemsL( const TArray<TCLFItemId>& aItemIDArray );

   153 

   154         /**

   155         * From MCLFContentListingEngine

   156         */

   157         void AddChangedItemObserverL(

   158                                     MCLFChangedItemObserver& aObserver );

   159 

   160         /**

   161         * From MCLFContentListingEngine

   162         */

   163         void RemoveChangedItemObserver(

   164                                     MCLFChangedItemObserver& aObserver );

   165 

   166         /**

   167         * From MCLFContentListingEngine

   168         */

   169         void UpdateItemsL( TInt aSemanticId, const TDesC8& aOpaqueData );

   170 

   171         /**

   172         * From MCLFContentListingEngine

   173         */

   174         void AddCLFProcessObserverL(

   175                         MCLFProcessObserver& aObserver );

   176 

   177         /**

   178         * From MCLFContentListingEngine

   179         */

   180         void RemoveCLFProcessObserver(

   181                         MCLFProcessObserver& aObserver );

   182 

   183         /**

   184         * From MCLFEventHandlerObserver

   185         */

   186         void HandleUpdateEndEventL( TInt aError );

   187 

   188         /**

   189         * From MCLFEventHandlerObserver

   190         */

   191         void HandleUpdateStartEventL( TInt aError );

   192 

   193         /**

   194         * From MCLFItemProviderObserver

   195         */

   196         void OperationCompleteL( TInt aError );

   197 

   198         /**

   199          * From MMdESessionObserver

   200          */

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

   202 

   203         /**

   204          * From MMdESessionObserver

   205          */

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

   207         

   208         

   209     private:  // New functions

   210 

   211         void StopEventHandling();

   212 

   213         void NotifyProcessObserversL( TCLFProcessEvent aEvent );

   214 

   215         static void CleanupTempModel( TAny* aObj );

   216 

   217     private:

   218 

   219         /**

   220         * C++ default constructor.

   221         */

   222         CCLFEngineImpl();

   223 

   224         /**

   225         * By default Symbian 2nd phase constructor is private.

   226         */

   227         void ConstructL();

   228 

   229     private:    // Data

   230         // Own

   231         CCLFServerProxy* iCLFServerProxy;

   232         // Own

   233         CMdESession* iMdESession;

   234         // Own

   235         TInt iError;

   236         // Own

   237         CActiveSchedulerWait iActiveSchedulerWait;

   238         // Own

   239         CCLFEventHandler* iUpdateStartEventHandler;

   240         // Own

   241         CCLFEventHandler* iUpdateEndEventHandler;

   242         // Ref. observers

   243         RPointerArray< MCLFChangedItemObserver > iChangedItemObserverArray;

   244         // Ref. observers

   245         RPointerArray< MCLFProcessObserver > iProcessObserverArray;

   246         // Own:

   247         CCLFDbItemContainer* iDbItemContainer;

   248         // Own. to get changed items

   249         CCLFDbItemProvider* iItemProvider;

   250         // Own:

   251         CCLFTempModel iChangedItemModel;

   252         // Own

   253         CCLFQueryAdapter* iQueryAdapter;        

   254     };

   255 

   256 #endif      // CCLFENGINEIMPL_H

   257 

   258 // End of File