1 /*

     2 * Copyright (c) 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:  ?Description

    15 *

    16 */

    17 

    18 

    19 // CRemConCoreApiTarget* iCoreTarget

    20 #include <remconcoreapitarget.h>

    21 // CRemConInterfaceSelector* iInterfaceSelector;

    22 #include <remconinterfaceselector.h>

    23 // using avkon constants

    24 #include <aknconsts.h>

    25 #include <j2me/jdebug.h>

    26 

    27 #include "CMIDRemConObserver.h"

    28 #include "CMIDKeyDecoder.h"

    29 

    30 

    31 // Keyboard delays and repeat periods

    32 const TInt KFirstTimerExpiryInterval = KAknKeyboardRepeatInitialDelay;

    33 // For second time onwards ,the duration of the time interval, is below

    34 // Should not be greater than 1 Minute

    35 const TInt KTimerExpiryInterval = KAknStandardKeyboardRepeatRate;

    36 

    37 

    38 CMIDRemConObserver* CMIDRemConObserver::NewL()

    39 {

    40     CMIDRemConObserver* self = new(ELeave) CMIDRemConObserver();

    41     CleanupStack::PushL(self);

    42     self->ConstructL();

    43     CleanupStack::Pop(self);

    44     return self;

    45 }

    46 

    47 

    48 CMIDRemConObserver::~CMIDRemConObserver()

    49 {

    50     DEBUG("CMIDRemConObserver::~CMIDRemConObserver() +");

    51 

    52     if (iJavaRemConManager != NULL)

    53     {

    54         iJavaRemConManager->RemoveObserver(*iJavaRemConObserver);

    55     }

    56     if (iJavaRemConObserver != NULL)

    57     {

    58         delete iJavaRemConObserver;

    59         iJavaRemConObserver = NULL;

    60     }

    61     if (iJavaRemConManager != NULL)

    62     {

    63         delete iJavaRemConManager;

    64         iJavaRemConManager = NULL;

    65     }

    66     iListeners.Close();

    67 

    68     if (iRepeatTimer)

    69     {

    70         iRepeatTimer->Cancel();

    71         delete iRepeatTimer;

    72     }

    73 

    74     DEBUG("CMIDRemConObserver::~CMIDRemConObserver() -");

    75 }

    76 

    77 

    78 void CMIDRemConObserver::AddMediaKeysListenerL(MMIDMediaKeysListener* aListener)

    79 {

    80     User::LeaveIfError(iListeners.Append(aListener));

    81 }

    82 

    83 

    84 void CMIDRemConObserver::RemoveMediaKeysListener(MMIDMediaKeysListener* aListener)

    85 {

    86     for (TInt i = 0;  i < iListeners.Count(); i++)

    87     {

    88         if (iListeners[i] == aListener)

    89         {

    90             iListeners.Remove(i);

    91         }

    92     }

    93 

    94 }

    95 

    96 

    97 // ---------------------------------------------------------------------------

    98 // This function handles the events when following buttons are press/click/rel

    99 // - Play, Stop, Forward, Backward

   100 // ---------------------------------------------------------------------------

   101 void CMIDRemConObserver::MrccatoCommand(TRemConCoreApiOperationId aOperationId,

   102                                         TRemConCoreApiButtonAction aButtonAct)

   103 {

   104     DEBUG_INT2("CMIDRemConObserver::MrccatoCommand - JAVA operationId %d JAVA buttonAct %d",

   105                aOperationId, aButtonAct);

   106 

   107     MMIDMediaKeysListener::TMediaKey mediaKey = MMIDMediaKeysListener::EMIDMediaKeyNone;

   108 

   109     switch (aOperationId)

   110     {

   111     case ERemConCoreApiPausePlayFunction:

   112         mediaKey = MMIDMediaKeysListener::EMIDMediaKeyPlay;

   113         break;

   114     case ERemConCoreApiStop:

   115         mediaKey = MMIDMediaKeysListener::EMIDMediaKeyStop;

   116         break;

   117     case ERemConCoreApiForward:

   118     case ERemConCoreApiFastForward:

   119         mediaKey = MMIDMediaKeysListener::EMIDMediaKeyNext;

   120         break;

   121     case ERemConCoreApiBackward:

   122     case ERemConCoreApiRewind:

   123         mediaKey = MMIDMediaKeysListener::EMIDMediaKeyPrevious;

   124         break;

   125     default:

   126         return;

   127     }

   128 

   129     TMIDKeyEvent::TEvent keyEvent = TMIDKeyEvent::EPressed;

   130 

   131     switch (aButtonAct)

   132     {

   133     case ERemConCoreApiButtonPress: // Long key press

   134         iKeyRepeating = mediaKey;

   135         break;

   136     case ERemConCoreApiButtonClick: // Short key press

   137         keyEvent = TMIDKeyEvent::EPressed;

   138         break;

   139     case ERemConCoreApiButtonRelease: // Key released after long key press.

   140         keyEvent = TMIDKeyEvent::EReleased;

   141         break;

   142     default:

   143         return;

   144     }

   145 

   146 

   147     // Media keys do not provide keyReleased events when a key is pressed shortly.

   148     // However, keyReleased events are posted after long key press of next and previous keys.

   149 

   150     // Play and Stop does not provide keyRepeated nor keyReleased Java events at all.

   151     // Reason for these limitation is RemCon that does not provide such events for us.

   152 

   153     iRepeatTimer->Cancel(); //Repeat timer is always canceled if any Media key event occurs.

   154 

   155     if (aButtonAct == ERemConCoreApiButtonPress

   156             && !(mediaKey == MMIDMediaKeysListener::EMIDMediaKeyPlay || mediaKey == MMIDMediaKeysListener::EMIDMediaKeyStop))

   157     {

   158         // keyPressed event is posted first, then timer for key repeats is started.

   159         PostEventToListeners(mediaKey, TMIDKeyEvent::EPressed);

   160         iRepeatTimer->Start(KFirstTimerExpiryInterval, KTimerExpiryInterval,

   161                             TCallBack(RepeatTimerCallback, this));

   162     }

   163     else if ((aButtonAct == ERemConCoreApiButtonRelease ||  aButtonAct == ERemConCoreApiButtonPress)

   164              && (mediaKey == MMIDMediaKeysListener::EMIDMediaKeyPlay || mediaKey == MMIDMediaKeysListener::EMIDMediaKeyStop))

   165     {

   166         // If Press or Release event occur for Play or Stop keys we just ignore them.

   167         // This should not happen normally, but is possible e.g. in certain error situations.

   168         // Also some media key accessories differ from each other so that some might post these events.

   169         return;

   170     }

   171     else

   172     {

   173         PostEventToListeners(mediaKey, keyEvent);

   174     }

   175 

   176     DEBUG("CMIDRemConObserver::MrccatoCommand -");

   177 }

   178 

   179 

   180 void CMIDRemConObserver::MrccatoPlay(TRemConCoreApiPlaybackSpeed aSpeed, TRemConCoreApiButtonAction aButtonAct)

   181 {

   182     DEBUG("CMIDRemConObserver::MrccatoPlay +");

   183     DEBUG_INT2("RemConObserver::MrccatoPlay - JAVA speed %d JAVA buttonAct %d", aSpeed, aButtonAct);

   184     (void)aSpeed; // Just to suppress warning in release build

   185 

   186     switch (aButtonAct)

   187     {

   188     case ERemConCoreApiButtonPress:

   189     case ERemConCoreApiButtonClick:

   190     {

   191         PostEventToListeners(MMIDMediaKeysListener::EMIDMediaKeyPlay, TMIDKeyEvent::EPressed);

   192         break;

   193     }

   194     default:

   195     {

   196         break;

   197     }

   198     }

   199     DEBUG("CMIDRemConObserver::MrccatoPlay -");

   200 }

   201 

   202 void CMIDRemConObserver::MrceoError(TInt /*aError*/)

   203 {

   204     DEBUG("CMIDRemConObserver::MrceoError +");

   205     iRepeatTimer->Cancel();

   206     DEBUG("CMIDRemConObserver::MrceoError -");

   207 }

   208 

   209 

   210 CMIDRemConObserver::CMIDRemConObserver()

   211 {

   212 }

   213 

   214 

   215 void CMIDRemConObserver::ConstructL()

   216 {

   217     DEBUG("CMIDRemConObserver::ConstructL +");

   218     iJavaRemConObserver = CJavaRemConObserver::NewL(*this);

   219     iJavaRemConManager = CJavaRemConManager::NewL();

   220     iJavaRemConManager->SetObserverL(*iJavaRemConObserver);

   221     // Timer for implementing key repeat feature.

   222     iRepeatTimer = CPeriodic::NewL(CActive::EPriorityStandard);

   223 

   224     iKeyRepeating = MMIDMediaKeysListener::EMIDMediaKeyNone;

   225 

   226     DEBUG("CMIDRemConObserver::ConstructL -");

   227 }

   228 

   229 

   230 void CMIDRemConObserver::PostEventToListeners(MMIDMediaKeysListener::TMediaKey aKeyCode, TMIDKeyEvent::TEvent aEventType)

   231 {

   232     DEBUG("CMIDRemConObserver::PostEventToListeners +");

   233 

   234     TMIDKeyEvent event;

   235     event.iKeyCode = aKeyCode;

   236     event.iEvents = aEventType;

   237 

   238     if (event.iEvents == TMIDKeyEvent::ERepeated)

   239     {

   240         event.iRepeats = 1; // repeats

   241     }

   242     else

   243     {

   244         event.iRepeats = 0; // no repeats

   245     }

   246 

   247     for (TInt i = 0;  i < iListeners.Count(); i++)

   248     {

   249         iListeners[i]->HandleMediaKeyEvent(event);

   250     }

   251 

   252     DEBUG("CMIDRemConObserver::PostEventToListeners -");

   253 }

   254 

   255 

   256 TInt CMIDRemConObserver::RepeatTimerCallback(TAny* aThis)

   257 {

   258     CMIDRemConObserver* observer = static_cast<CMIDRemConObserver*>(aThis);

   259     observer->HandleRepeatTimerEvent();

   260     return 0;

   261 }

   262 

   263 

   264 void CMIDRemConObserver::HandleRepeatTimerEvent()

   265 {

   266     DEBUG("CMIDRemConObserver::HandleTimerEvent +");

   267     if (iKeyRepeating != MMIDMediaKeysListener::EMIDMediaKeyNone)

   268     {

   269         DEBUG("CMIDRemConObserver::HandleTimerEvent calling PosTEventToListeners +");

   270         PostEventToListeners(iKeyRepeating, TMIDKeyEvent::ERepeated);

   271         DEBUG("CMIDRemConObserver::HandleTimerEvent calling PostEventToListeners -");

   272     }

   273     DEBUG("CMIDRemConObserver::HandleTimerEvent -");

   274 }

   275 

   276 //  End of File