1 /*

     2 * Copyright (c) 2004-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:  Video telephony engine TLS container.

    15 *

    16 */

    17 

    18 

    19 

    20 #ifndef VTENGUTILS_H

    21 #define VTENGUTILS_H

    22 

    23 //  INCLUDES

    24 #include <e32base.h>

    25 

    26 

    27 // FORWARD DECLARATIONS

    28 class CVtEngInitializer;

    29 class CVtEngHandlerContainer;

    30 class CVtEngDebug;

    31 class CVtEngStateManager;

    32 class CVtEngSettings;

    33 class CVtEngEventManager;

    34 class CVtEngCRProxy;

    35 class CVtEngAccessoryHandler;

    36 class CVtEngSATClient;

    37 class CVtEngDeviceLockMonitor;

    38 class CVtEngExtensions;

    39 class CVtEngMdtrMessageListener;

    40 class CVtEngMdtrCommandSender;

    41 

    42 // CLASS DECLARATION

    43 

    44 /**

    45 *  TLS container for pointers to essential objects.

    46 *

    47 *  @lib videoteleng.lib

    48 *  @since Series 60 2.6

    49 */

    50 NONSHARABLE_CLASS( CVtEngUtility ) : public CBase

    51     {

    52     public:  // Constructors and destructor

    53         

    54         /**

    55         * Two-phased constructor.

    56         */

    57         static CVtEngUtility* NewL();

    58         

    59         /**

    60         * Destructor.

    61         */

    62         virtual ~CVtEngUtility();

    63 

    64     public: // New functions

    65     

    66         /**

    67         * Creates SAT listener for updates.

    68         */

    69         void StartSATListenL();

    70         

    71         /**

    72         * Returns engine initializer.

    73         * @return initializer

    74         */

    75         inline CVtEngInitializer& Initializer() const;

    76 

    77         /**

    78         * Returns engine utility.

    79         * @return utility

    80         */

    81         static CVtEngUtility* EngineUtils();

    82 

    83         /**

    84         * Returns state manager.

    85         * @return state manager

    86         */

    87         static CVtEngStateManager* StateManager();

    88 

    89         /**

    90         * Returns event manager.

    91         * @return event manager

    92         */

    93         static CVtEngEventManager& EventManager();

    94 

    95         /**

    96         * Returns Central repository proxy.

    97         * @return ref to CR proxy

    98         */

    99         static CVtEngCRProxy& CRProxy();

   100 

   101         /**

   102         * Returns accessory listener.

   103         * @return accessory handler

   104         */

   105         static CVtEngAccessoryHandler& AccessoryHandler();

   106 

   107         /**

   108         * Returns settings.

   109         * @return ref to settings

   110         */

   111         static CVtEngSettings& Settings();

   112         

   113         /**

   114         * Returns mediator command sender.

   115         * @return ref to command sender

   116         */

   117         static CVtEngMdtrCommandSender& MediatorCommands();

   118 

   119         /**

   120         * Prepares the utility

   121         * @param aHandlers handler container

   122         * @param aStateManagerPtr state manager pointer ref

   123         * @param aEventManagerPtr event manager pointer ref

   124         * @param aExtensionPtr extension container pointer

   125         */

   126         void PrepareL( 

   127             CVtEngHandlerContainer& aHandlers,

   128             CVtEngStateManager*& aStateManagerPtr,

   129             CVtEngEventManager*& aEventManagerPtr,

   130             CVtEngExtensions* aExtensionPtr );

   131 

   132         /**

   133         * Notifies device lock to UI.

   134         */

   135         void NotifyLockState();

   136         

   137         /**

   138         * Returns Extension container.

   139         * @since S60 v3.2

   140         * @return pointer to extensions

   141         */

   142         static CVtEngExtensions* Extensions();

   143         /**

   144         * Starts listening mediator messages.

   145         */

   146         void StartMediatorListenerL();

   147         

   148     private:

   149 

   150         /**

   151         * C++ default constructor.

   152         */

   153         CVtEngUtility();

   154 

   155         /**

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

   157         */

   158         void ConstructL();

   159         

   160     private:    // Data

   161 

   162         // Initializater for the engine

   163         CVtEngInitializer*   iEngineInit;

   164 

   165         // State manager pointer

   166         CVtEngStateManager** iStateManager;

   167 

   168         // Settigs

   169         CVtEngSettings*      iSettings;

   170 

   171         // Event manager pointer

   172         CVtEngEventManager** iEventManager;

   173 

   174         // Central repository interface

   175         CVtEngCRProxy*       iCRProxy;

   176 

   177         // Accessory handler

   178         CVtEngAccessoryHandler* iAccessoryHandler;

   179         

   180         // SAT refresh listener

   181         CVtEngSATClient* iSATClient;

   182         

   183         // Monitor for device lock state

   184         CVtEngDeviceLockMonitor* iLockMonitor;

   185         

   186         // Extension pointer

   187         CVtEngExtensions* iExtensions;

   188         // For receiving Mediator commands and events        

   189         CVtEngMdtrMessageListener* iMdtrMessageListener;

   190 

   191         // For sending Mediator commands

   192         CVtEngMdtrCommandSender*   iMdtrCommandSender;

   193         

   194     };

   195 

   196 #include "VtEngUtils.inl"

   197 

   198 #endif      // VTENGUTILS_H

   199             

   200 // End of File