1 /*

     2 * Copyright (c) 2002-2005 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:  A container/accessor class for all CRemConKeyEvent -instances.

    15 *

    16 */

    17 

    18 

    19 

    20 // INCLUDE FILES

    21 #include "RemConKeyEventContainer.h"

    22 #include "RemConDebug.h"

    23 #include <remconcoreapi.h>

    24 #include <RemConExtensionApi.h>

    25 

    26 // ============================ MEMBER FUNCTIONS ===============================

    27 

    28 // -----------------------------------------------------------------------------

    29 // CRemConKeyEventContainer::CRemConKeyEventContainer

    30 // C++ default constructor can NOT contain any code, that

    31 // might leave.

    32 // -----------------------------------------------------------------------------

    33 //

    34 CRemConKeyEventContainer::CRemConKeyEventContainer()

    35     {

    36     COM_TRACE_( "[AccFW:RemConConverter] CRemConKeyEventContainer::CRemConKeyEventContainer()" );

    37     }

    38 

    39 // -----------------------------------------------------------------------------

    40 // CRemConKeyEventContainer::ConstructL

    41 // Symbian 2nd phase constructor can leave.

    42 // -----------------------------------------------------------------------------

    43 //

    44 void CRemConKeyEventContainer::ConstructL()

    45     {

    46     COM_TRACE_( "[AccFW:RemConConverter] CRemConKeyEventContainer::ConstructL()" );

    47 

    48     TUid coreAPIUid;

    49     TUid pocAPIUid;

    50     TUid syncAPIUid;

    51     coreAPIUid.iUid = KRemConCoreApiUid;

    52     TUid extensionAPIUid;

    53     extensionAPIUid.iUid = KRemConExtCallHandlingApiUid;

    54     pocAPIUid.iUid = KRemConExtPocApiUid;

    55     syncAPIUid.iUid = KRemConExtSynchronizationApiUid;

    56     CRemConKeyEvent* event( NULL );

    57     TBuf8< KRemConExtParamMaxLength > parameter;

    58   	

    59   	//

    60     // Simple call handling key events:

    61     //

    62     

    63     // send/end key pressed shortly: answer call or end call

    64     TRemConKeyEventData k1 = { ERemConKeyCodeSendEnd, 

    65     						   ERemConKeyModifierNone, 

    66     						   ERemConKeyStateUp, 

    67     						   ERemConKeyEventShortPress };

    68     

    69     event = CRemConKeyEvent::NewL( k1, 

    70     							   extensionAPIUid, 

    71     							   ERemConExtAnswerEnd, 

    72     							   ERemConCoreApiButtonClick );

    73     							   

    74  	CleanupStack::PushL( event );   

    75     AddEventL(event);

    76     CleanupStack::Pop( event );

    77     	

    78     // send/end key pressed long time: reject ongoing call

    79     TRemConKeyEventData k2 = { ERemConKeyCodeSendEnd, 

    80     						   ERemConKeyModifierNone, 

    81     						   ERemConKeyStateUp, 

    82     						   ERemConKeyEventLongPress };

    83 

    84     event = CRemConKeyEvent::NewL( k2, 

    85     							   extensionAPIUid,

    86         						   ERemConExtEndCall, 

    87         						   ERemConCoreApiButtonRelease );

    88     CleanupStack::PushL( event );   

    89     AddEventL(event);

    90     CleanupStack::Pop( event );

    91         

    92     // send/end key has been down long time: voice call

    93     TRemConKeyEventData k3 = { ERemConKeyCodeSendEnd, 

    94     						   ERemConKeyModifierNone, 

    95     						   ERemConKeyStateDown, 

    96     						   ERemConKeyEventLongPress };

    97     // set parameter

    98     TBool param( ETrue );

    99     parameter.AppendNum( param );

   100  	

   101  	event = CRemConKeyEvent::NewL( k3, 

   102     							   extensionAPIUid, 

   103     							   ERemConExtVoiceDial, 

   104     							   parameter );

   105     							   

   106     CleanupStack::PushL( event );   

   107     AddEventL(event);

   108     CleanupStack::Pop( event );

   109     

   110     //

   111     // POC key events:

   112     //

   113         

   114     // POC key down

   115     TRemConKeyEventData k4 = { ERemConKeyCodePOC, 

   116                                ERemConKeyModifierNone, 

   117                                ERemConKeyStateDown, 

   118                                ERemConKeyEventRepeat };

   119                                

   120     event = CRemConKeyEvent::NewL( k4, 

   121     							   pocAPIUid, 

   122         						   ERemConExtAPOCButtonDown, 

   123         						   ERemConCoreApiButtonPress );

   124     CleanupStack::PushL( event );   

   125     AddEventL(event);

   126     CleanupStack::Pop( event );

   127     

   128     

   129     // POC key up (long)

   130     TRemConKeyEventData k5 = { ERemConKeyCodePOC, 

   131                                ERemConKeyModifierNone, 

   132                                ERemConKeyStateUp, 

   133                                ERemConKeyEventLongPress };

   134                                

   135     event = CRemConKeyEvent::NewL( k5, 

   136     							   pocAPIUid, 

   137         						   ERemConExtAPOCButtonUp, 

   138         						   ERemConCoreApiButtonRelease );

   139     CleanupStack::PushL( event );   

   140     AddEventL(event);

   141     CleanupStack::Pop( event );

   142     

   143     //

   144     // Volume control key events:

   145     //

   146     

   147     // Volume up: ERemConKeyCodeVolumeUp down; volume up/press

   148     TRemConKeyEventData k6 = { ERemConKeyCodeVolumeUp, 

   149                                  ERemConKeyModifierNone, 

   150                                  ERemConKeyStateDown, 

   151                                  ERemConKeyEventNone };

   152 

   153     event = CRemConKeyEvent::NewL( k6, 

   154     							   coreAPIUid, 

   155         						   ERemConCoreApiVolumeUp, 

   156         						   ERemConCoreApiButtonPress );

   157     CleanupStack::PushL( event );   

   158     AddEventL(event);

   159     CleanupStack::Pop( event );

   160     

   161     // Volume up: ERemConKeyCodeVolumeUp up&short press; volume up/release

   162     TRemConKeyEventData k7 = { ERemConKeyCodeVolumeUp, 

   163                                ERemConKeyModifierNone, 

   164                                ERemConKeyStateUp, 

   165                                ERemConKeyEventShortPress };

   166 

   167     event = CRemConKeyEvent::NewL( k7, 

   168     							   coreAPIUid, 

   169         						   ERemConCoreApiVolumeUp, 

   170         						   ERemConCoreApiButtonRelease );

   171     CleanupStack::PushL( event );   

   172     AddEventL(event);

   173     CleanupStack::Pop( event );

   174     

   175     // Volume up: ERemConKeyCodeVolumeUp up&long press; volume up/release

   176     TRemConKeyEventData k8 = { ERemConKeyCodeVolumeUp, 

   177                                ERemConKeyModifierNone, 

   178                                ERemConKeyStateUp, 

   179                                ERemConKeyEventLongPress };

   180 

   181     event = CRemConKeyEvent::NewL( k8, 

   182     							   coreAPIUid, 

   183         						   ERemConCoreApiVolumeUp, 

   184         						   ERemConCoreApiButtonRelease );

   185     CleanupStack::PushL( event );   

   186     AddEventL(event);

   187     CleanupStack::Pop( event );

   188         

   189     // Volume down: ERemConKeyCodeVolumeDown down; volume down/press

   190     TRemConKeyEventData k9 =  { ERemConKeyCodeVolumeDown, 

   191                                 ERemConKeyModifierNone, 

   192                                 ERemConKeyStateDown, 

   193                                 ERemConKeyEventNone };

   194                                 

   195     event = CRemConKeyEvent::NewL( k9, 

   196     							   coreAPIUid, 

   197         						   ERemConCoreApiVolumeDown, 

   198         						   ERemConCoreApiButtonPress );

   199     CleanupStack::PushL( event );   

   200     AddEventL(event);

   201     CleanupStack::Pop( event );

   202     

   203     // Volume down: ERemConKeyCodeVolumeDown down&short press; volume down

   204     TRemConKeyEventData k10 =  { ERemConKeyCodeVolumeDown, 

   205                                 ERemConKeyModifierNone, 

   206                                 ERemConKeyStateUp, 

   207                                 ERemConKeyEventShortPress };

   208                                 

   209     event = CRemConKeyEvent::NewL( k10, 

   210     							   coreAPIUid, 

   211         						   ERemConCoreApiVolumeDown, 

   212         						   ERemConCoreApiButtonRelease );

   213     CleanupStack::PushL( event );   

   214     AddEventL(event);

   215     CleanupStack::Pop( event );

   216     

   217     // Volume down: ERemConKeyCodeVolumeDown down&long press; volume down

   218     TRemConKeyEventData k11 = { ERemConKeyCodeVolumeDown, 

   219                                 ERemConKeyModifierNone, 

   220                                 ERemConKeyStateUp, 

   221                                 ERemConKeyEventLongPress };

   222                                 

   223     event = CRemConKeyEvent::NewL( k11, 

   224     							   coreAPIUid, 

   225         						   ERemConCoreApiVolumeDown, 

   226         						   ERemConCoreApiButtonRelease );

   227     CleanupStack::PushL( event );   

   228     AddEventL(event);

   229     CleanupStack::Pop( event );

   230         

   231     //

   232     // Media key events:

   233     //

   234 	    

   235     // Play or Pause has been pressed in accessory: 

   236     // ERemConCoreApiPausePlayFunction is delivered to S60 application. 

   237     // It's S60 application's responsibility to interpret whether play 

   238     // or pause was pressed.

   239     TRemConKeyEventData k12 = { ERemConKeyCodePlayPause, 

   240                                 ERemConKeyModifierNone, 

   241                                 ERemConKeyStateUp, 

   242                                 ERemConKeyEventShortPress };

   243                                 

   244     event = CRemConKeyEvent::NewL( k12, 

   245     							   coreAPIUid, 

   246         						   ERemConCoreApiPausePlayFunction, 

   247         						   ERemConCoreApiButtonClick );

   248     CleanupStack::PushL( event );   

   249     AddEventL(event);

   250     CleanupStack::Pop( event );

   251     

   252        // Stop: ERemConKeyCodeStop down; stop.

   253     TRemConKeyEventData k13 = { ERemConKeyCodeStop, 

   254                                 ERemConKeyModifierNone, 

   255                                 ERemConKeyStateUp, 

   256                                 ERemConKeyEventShortPress };

   257                                 

   258     event = CRemConKeyEvent::NewL( k13, 

   259     							   coreAPIUid, 

   260         						   ERemConCoreApiStop, 

   261         						   ERemConCoreApiButtonClick );

   262     CleanupStack::PushL( event );   

   263     AddEventL(event);

   264     CleanupStack::Pop( event );

   265     

   266        // Fast forward 1: ERemConCoreApiFastForward down&repeating; fast 

   267        // forward.

   268     TRemConKeyEventData k14 = { ERemConKeyCodeForward, 

   269                                 ERemConKeyModifierNone, 

   270                                 ERemConKeyStateDown, 

   271                                 ERemConKeyEventRepeat };

   272                                 

   273     event = CRemConKeyEvent::NewL( k14, 

   274     							   coreAPIUid, 

   275         						   ERemConCoreApiFastForward, 

   276         						   ERemConCoreApiButtonPress );

   277     CleanupStack::PushL( event );   

   278     AddEventL(event);

   279     CleanupStack::Pop( event );

   280     

   281        // Fast forward 2: ERemConCoreApiFastForward up; fast forward.

   282     TRemConKeyEventData k15 = { ERemConKeyCodeForward, 

   283                                 ERemConKeyModifierNone, 

   284                                 ERemConKeyStateUp, 

   285                                 ERemConKeyEventLongPress };

   286                                 

   287     event = CRemConKeyEvent::NewL( k15, 

   288     							   coreAPIUid, 

   289         						   ERemConCoreApiFastForward, 

   290         						   ERemConCoreApiButtonRelease );

   291     CleanupStack::PushL( event );   

   292     AddEventL(event);

   293     CleanupStack::Pop( event );

   294     

   295        // Rewind 1: ERemConKeyCodeRewind down&repeating; rewind.

   296     TRemConKeyEventData k16 = { ERemConKeyCodeBack, 

   297                                 ERemConKeyModifierNone, 

   298                                 ERemConKeyStateDown, 

   299                                 ERemConKeyEventRepeat };

   300                                 

   301     event = CRemConKeyEvent::NewL( k16, 

   302     							   coreAPIUid, 

   303         						   ERemConCoreApiRewind, 

   304         						   ERemConCoreApiButtonPress );

   305     CleanupStack::PushL( event );   

   306     AddEventL(event);

   307     CleanupStack::Pop( event );

   308     

   309     // Rewind 2: ERemConKeyCodeRewind up; rewind.

   310     TRemConKeyEventData k17 = { ERemConKeyCodeBack, 

   311                                 ERemConKeyModifierNone, 

   312                                 ERemConKeyStateUp, 

   313                                 ERemConKeyEventLongPress };

   314                                 

   315     event = CRemConKeyEvent::NewL( k17, 

   316     							   coreAPIUid, 

   317         						   ERemConCoreApiRewind, 

   318         						   ERemConCoreApiButtonRelease );

   319     CleanupStack::PushL( event );   

   320     AddEventL(event);

   321     CleanupStack::Pop( event );

   322     

   323     // Next track: ERemConCoreApiFastForward up & short press; next track.

   324     TRemConKeyEventData k18 = { ERemConKeyCodeForward, 

   325                                 ERemConKeyModifierNone, 

   326                                 ERemConKeyStateUp, 

   327                                 ERemConKeyEventShortPress };

   328                                 

   329     event = CRemConKeyEvent::NewL( k18, 

   330     							   coreAPIUid, 

   331         						   ERemConCoreApiForward, 

   332         						   ERemConCoreApiButtonClick );

   333     CleanupStack::PushL( event );   

   334     AddEventL(event);

   335     CleanupStack::Pop( event );

   336     

   337     // Previous track: ERemConKeyCodeRewind up & short press; previous 

   338     // track.

   339     TRemConKeyEventData k19 = { ERemConKeyCodeBack, 

   340                                 ERemConKeyModifierNone, 

   341                                 ERemConKeyStateUp, 

   342                                 ERemConKeyEventShortPress };

   343                                 

   344     event = CRemConKeyEvent::NewL( k19, 

   345     							   coreAPIUid, 

   346         						   ERemConCoreApiBackward, 

   347         						   ERemConCoreApiButtonClick );

   348     CleanupStack::PushL( event );   

   349     AddEventL(event);

   350     CleanupStack::Pop( event );

   351     

   352     //

   353     // Radio key events:

   354     //

   355 

   356     // RemConKeyEventConverter does not support specific Radio event op IDs, 

   357     // the media op IDs are used instead.

   358     // It is up to the application to interpret the media operation IDs to

   359     // next channel, previous track etc.

   360     

   361     //

   362     // Sync key events:

   363     //

   364     

   365        // Sync: ERemConKeyCodeSync down.

   366     TRemConKeyEventData k20 = { ERemConKeyCodeSync, 

   367                                 ERemConKeyModifierNone, 

   368                                 ERemConKeyStateDown, 

   369                                 ERemConKeyEventShortPress };

   370                                 

   371     event = CRemConKeyEvent::NewL( k20, 

   372     							   syncAPIUid, 

   373         						   ERemConExtSynchronization, 

   374         						   ERemConCoreApiButtonClick );

   375     CleanupStack::PushL( event );   

   376     AddEventL(event);

   377     CleanupStack::Pop( event );

   378     

   379     //

   380     // Mute key event:

   381     //

   382     

   383        // Mute: ERemConKeyCodeMute up.

   384     TRemConKeyEventData k21 = { ERemConKeyCodeMute, 

   385                                 ERemConKeyModifierNone, 

   386                                 ERemConKeyStateUp, 

   387                                 ERemConKeyEventShortPress };

   388                                 

   389     event = CRemConKeyEvent::NewL( k21, 

   390     							   coreAPIUid, 

   391         						   ERemConCoreApiMute, 

   392         						   ERemConCoreApiButtonClick );

   393     CleanupStack::PushL( event );   

   394     AddEventL(event);

   395     CleanupStack::Pop( event );

   396 

   397     // Redial

   398     TRemConKeyEventData k22 = { ERemConKeyCodeRedial, 

   399     						   ERemConKeyModifierNone, 

   400     						   ERemConKeyStateUp, 

   401     						   ERemConKeyEventShortPress };

   402     

   403     event = CRemConKeyEvent::NewL( k22, 

   404     							   extensionAPIUid, 

   405     							   ERemConExtLastNumberRedial, 

   406     							   ERemConCoreApiButtonClick );

   407     							   

   408  	CleanupStack::PushL( event );   

   409     AddEventL(event);

   410     CleanupStack::Pop( event );

   411     

   412     /*

   413     // Send key

   414     TRemConKeyEventData k23 = { ERemConKeyCodeSend, 

   415     						   ERemConKeyModifierNone, 

   416     						   ERemConKeyStateUp, 

   417     						   ERemConKeyEventShortPress };

   418     

   419     event = CRemConKeyEvent::NewL( k23, 

   420     							   extensionAPIUid, 

   421     							   ERemConExtAnswerCall, 

   422     							   ERemConCoreApiButtonClick );

   423     							   

   424  	CleanupStack::PushL( event );   

   425     AddEventL(event);

   426     CleanupStack::Pop( event );    

   427 

   428     // End key

   429     TRemConKeyEventData k24 = { ERemConKeyCodeEnd, 

   430     						   ERemConKeyModifierNone, 

   431     						   ERemConKeyStateUp, 

   432     						   ERemConKeyEventShortPress };

   433     

   434     event = CRemConKeyEvent::NewL( k24, 

   435     							   extensionAPIUid, 

   436     							   ERemConExtEndCall, 

   437     							   ERemConCoreApiButtonClick );

   438     							   

   439  	CleanupStack::PushL( event );   

   440     AddEventL(event);

   441     CleanupStack::Pop( event );    

   442     */

   443     }

   444 

   445 // -----------------------------------------------------------------------------

   446 // CRemConKeyEventContainer::NewL

   447 // Two-phased constructor.

   448 // -----------------------------------------------------------------------------

   449 //

   450 CRemConKeyEventContainer* CRemConKeyEventContainer::NewL()

   451     {

   452     COM_TRACE_( "[AccFW:RemConConverter] CRemConKeyEventContainer::NewL()" );

   453 	

   454     CRemConKeyEventContainer* self = new( ELeave ) CRemConKeyEventContainer;

   455     

   456     CleanupStack::PushL( self );

   457     self->ConstructL();

   458     CleanupStack::Pop( self );

   459 

   460     return self;

   461     }

   462    

   463 // Destructor

   464 CRemConKeyEventContainer::~CRemConKeyEventContainer()

   465     {

   466     COM_TRACE_( "[AccFW:RemConConverter] CRemConKeyEventContainer::~CRemConKeyEventContainer()" );

   467     iKeyEventArray.ResetAndDestroy();

   468     COM_TRACE_( "[AccFW:RemConConverter] CRemConKeyEventContainer::~CRemConKeyEventContainer() return void" );

   469     }

   470 

   471 // -----------------------------------------------------------------------------

   472 // CRemConKeyEventContainer::AddEventL

   473 // Add a key event instance to container.

   474 // (other items were commented in a header).

   475 // -----------------------------------------------------------------------------

   476 //

   477 void CRemConKeyEventContainer::AddEventL( 

   478     const CRemConKeyEvent* aKeyEvent )

   479     {

   480     COM_TRACE_1( "[AccFW:RemConConverter] CRemConKeyEvent::AddEventL( %d )", aKeyEvent );

   481 

   482     iKeyEventArray.AppendL( aKeyEvent );

   483     }

   484 

   485 // -----------------------------------------------------------------------------

   486 // CRemConKeyEventContainer::GetEvents

   487 // Return key event instances.

   488 // (other items were commented in a header).

   489 // -----------------------------------------------------------------------------

   490 //

   491 const RPointerArray<CRemConKeyEvent>& CRemConKeyEventContainer::GetEvents() const

   492     {

   493     COM_TRACE_( "[AccFW:RemConConverter] CRemConKeyEvent::GetEvents()" );

   494     return iKeyEventArray;

   495     }

   496 

   497 //  End of File