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:  Accessory observer

    15 *

    16 */

    17 

    18 

    19 #ifndef CMPXACCESSORYOBSERVER_H

    20 #define CMPXACCESSORYOBSERVER_H

    21 

    22 //  INCLUDES

    23 #ifdef __ACCESSORY_FW

    24 #include <AccessoryMode.h>

    25 #include <AccessoryServer.h>

    26 #include <AccPolAccessoryMode.h>

    27 #else

    28 #include <e32base.h>

    29 #include <DosSvrServices.h>

    30 #endif // __ACCESSORY_FW

    31 

    32 #include <mpxplaybackframeworkdefs.h>

    33 

    34 // FORWARD DECLARATIONS

    35 #ifndef __ACCESSORY_FW

    36 class RDosServer;

    37 #endif // __ACCESSORY_FW

    38 

    39 /**

    40 *  Interface for handling accessory event

    41 */

    42 NONSHARABLE_CLASS(MMPXAccessoryEventObserver)

    43     {

    44 public:

    45     /**

    46     *   Handle accessory event

    47     *

    48     *   @param aMode playback accessory mode

    49     */

    50     virtual void HandleAccesoryEventL(TMPXPlaybackAccessoryMode aMode)=0;

    51     };

    52 

    53 

    54 #ifdef __ACCESSORY_FW

    55 

    56 NONSHARABLE_CLASS( CMPXAccessoryObserver ): public CActive

    57     {

    58     public: // constructor & destructor

    59 

    60         /** 

    61         * Two phase constructor

    62         * @param aObs  Reference to an event observer

    63         */

    64         static CMPXAccessoryObserver* NewL(MMPXAccessoryEventObserver& aObs);

    65 

    66         /**

    67         * Destructor.

    68         */

    69         virtual ~CMPXAccessoryObserver();

    70 

    71     public: 

    72 

    73         /**

    74         * Starts listening to Accessory events.

    75         * @param None

    76         * @return None

    77         */

    78         void StartL();

    79         

    80         /*

    81         * Gets current accessory mode

    82         */

    83         TMPXPlaybackAccessoryMode AccessoryModeL();

    84         

    85     private:    // New functions

    86     

    87         /**

    88         * Converts from accessory mode to internal MPX mode enum

    89         * @param aMode Accessory framework mode

    90         * @ret MPX Accessory Mode

    91         */

    92         TMPXPlaybackAccessoryMode ConvertToMpxMode( 

    93             TAccPolAccessoryMode& aMode );

    94         

    95     private: // from CActive

    96         /** @see CActive::RunL */

    97         void RunL();

    98 

    99         /** @see CActive::DoCancel */

   100         void DoCancel();

   101         

   102     private: // Constructor

   103         

   104         /**

   105         * C++ default constructor.

   106         * @param aObs  Reference to an event observer

   107         */

   108         CMPXAccessoryObserver(MMPXAccessoryEventObserver& aObs);

   109 

   110         /**

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

   112         */

   113         void ConstructL();

   114 

   115     private:

   116         // Event observer

   117         MMPXAccessoryEventObserver& iObs;

   118         // Accessory Server session 

   119         RAccessoryServer     iServer;

   120         // Accessory mode 

   121         RAccessoryMode       iMode;

   122         TAccPolAccessoryMode iAccessory_mode;

   123         

   124     };

   125 

   126 #else

   127 /**

   128 *  Accessary event observer

   129 */

   130 NONSHARABLE_CLASS(CMPXAccessoryObserver): public CDosEventListenerBase

   131     {

   132 public: 

   133 

   134     /**

   135     *  Two-phased constructor

   136     *

   137     *  @param aObs observer

   138     *  @return object of constructed

   139     */

   140     static CMPXAccessoryObserver* NewL(MMPXAccessoryEventObserver& aObs);

   141     

   142     /**

   143     * Destructor.

   144     */

   145     virtual ~CMPXAccessoryObserver();

   146     

   147 public: // from CDosEventListenerBase

   148     /**

   149     *  From CDosEventListenerBase

   150     *  Accessory mode changed

   151     *

   152     *  @param aState accessory state

   153     */

   154     void AccessoryModeChangedL(TDosAccessoryMode aState);

   155     

   156     /**

   157     *  From CDosEventListenerBase

   158     *  Start monitoring

   159     */

   160     void StartL();

   161 

   162     /*

   163     * Gets current accessory mode

   164     */

   165     TMPXPlaybackAccessoryMode AccessoryModeL();

   166         

   167 private:    // New functions

   168 

   169     /**

   170     * Converts from accessory mode to internal MPX mode enum

   171     * @param aMode Dos Accessory framework mode

   172     * @ret MPX Accessory Mode

   173     */

   174     TMPXPlaybackAccessoryMode ConvertToMpxMode( 

   175         TDosAccessoryMode& aMode );

   176         

   177 private: 

   178 

   179     /**

   180     *  C++ constructor

   181     *

   182     *  @param aObs observer

   183     */

   184     CMPXAccessoryObserver(MMPXAccessoryEventObserver& aObs);

   185 

   186     /**

   187     *  2nd phase constructor

   188     */

   189     void ConstructL();

   190 private:

   191     MMPXAccessoryEventObserver& iObs;

   192     };

   193 #endif // __ACCESSORY_FW

   194     

   195 #endif      // CMPXACCESSORYOBSERVER_H