/*

* Copyright (c) 2007 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of "Eclipse Public License v1.0"

* which accompanies this distribution, and is available

* at the URL "http://www.eclipse.org/legal/epl-v10.html".

*

* Initial Contributors:

* Nokia Corporation - initial contribution.

*

* Contributors:

*

* Description:  THIS FILE IS NOT INCLUDED INTO ECLIPSE CVS DELIVERY

*

*/

#include <remconcoreapitarget.h>

#include <remconinterfaceselector.h>

#include <aknconsts.h>

#include <javaremconobserver.h>

#include <javaremconmanager.h>

#include "swtmidremconobserver.h"

// Keyboard delays and repeat periods

const TInt KFirstTimerExpiryInterval = KAknKeyboardRepeatInitialDelay;

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

// Should not be greater than 1 Minute

const TInt KTimerExpiryInterval = KAknStandardKeyboardRepeatRate;

EXPORT_C CSwtMIDRemConObserver* CSwtMIDRemConObserver::NewL()

{

    CSwtMIDRemConObserver* self = new(ELeave) CSwtMIDRemConObserver();

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

}

EXPORT_C CSwtMIDRemConObserver::~CSwtMIDRemConObserver()

{

    iListeners.Close();

    if (iJavaRemConManager)

    {

        iJavaRemConManager->RemoveObserver(*iJavaRemConObserver);

        delete iJavaRemConObserver;

        iJavaRemConObserver = NULL;

        delete iJavaRemConManager;

        iJavaRemConManager = NULL;

    }

    if (iRepeatTimer)

    {

        iRepeatTimer->Cancel();

        delete iRepeatTimer;

    }

}

EXPORT_C void CSwtMIDRemConObserver::AddMediaKeysListenerL(MSwtMediaKeysListener* aListener)

{

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

}

EXPORT_C void CSwtMIDRemConObserver::RemoveMediaKeysListener(MSwtMediaKeysListener* aListener)

{

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

    {

        if (iListeners[i] == aListener)

        {

            iListeners.Remove(i);

        }

    }

}

// ---------------------------------------------------------------------------

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

// - Play, Stop, Forward, Backward

// ---------------------------------------------------------------------------

void CSwtMIDRemConObserver::MrccatoCommand(TRemConCoreApiOperationId aOperationId,

        TRemConCoreApiButtonAction aButtonAct)

{

    MSwtMediaKeysListener::TMediaKey mediaKey = MSwtMediaKeysListener::ESwtMediaKeyNone;

    switch (aOperationId)

    {

    case ERemConCoreApiPausePlayFunction:

        mediaKey = MSwtMediaKeysListener::ESwtMediaKeyPlay;

        break;

    case ERemConCoreApiStop:

        mediaKey = MSwtMediaKeysListener::ESwtMediaKeyStop;

        break;

    case ERemConCoreApiForward:

    case ERemConCoreApiFastForward:

        mediaKey = MSwtMediaKeysListener::ESwtMediaKeyNext;

        break;

    case ERemConCoreApiBackward:

    case ERemConCoreApiRewind:

        mediaKey = MSwtMediaKeysListener::ESwtMediaKeyPrevious;

        break;

    default:

        return;

    }

    TInt eventType = EEventKeyDown;

    // Next/Previous keys produce Click event only if pressed briefly, otherwise they

    // produce Press events followed by Release event when the key is released.

    // Play/Stop keys produce Click event immediately when the key is pressed.

    switch (aButtonAct)

    {

    case ERemConCoreApiButtonPress: // Long key press

        iKeyRepeating = mediaKey;

        break;

    case ERemConCoreApiButtonClick: // Short key press

        eventType = EEventKeyDown;

        break;

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

        eventType = EEventKeyUp;

        break;

    default:

        return;

    }

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

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

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

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

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

    if (aButtonAct == ERemConCoreApiButtonPress

            && !(mediaKey == MSwtMediaKeysListener::ESwtMediaKeyPlay || mediaKey == MSwtMediaKeysListener::ESwtMediaKeyStop))

    {

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

        PostRawEventToListeners(mediaKey, eventType);

        iRepeatTimer->Start(KFirstTimerExpiryInterval, KTimerExpiryInterval,

                            TCallBack(RepeatTimerCallback, this));

    }

    else if (aButtonAct == ERemConCoreApiButtonRelease

             && !(mediaKey == MSwtMediaKeysListener::ESwtMediaKeyPlay || mediaKey == MSwtMediaKeysListener::ESwtMediaKeyStop))

    {

        // post key release event after holding Next/Previous key.

        PostRawEventToListeners(mediaKey, eventType);

        iKeyRepeating = MSwtMediaKeysListener::ESwtMediaKeyNone;

    }

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

             && (mediaKey == MSwtMediaKeysListener::ESwtMediaKeyPlay || mediaKey == MSwtMediaKeysListener::ESwtMediaKeyStop))

    {

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

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

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

        iKeyRepeating = MSwtMediaKeysListener::ESwtMediaKeyNone;

        return;

    }

    else

    {

        PostClickEventToListeners(mediaKey);

        iKeyRepeating = MSwtMediaKeysListener::ESwtMediaKeyNone;

    }

}

void CSwtMIDRemConObserver::MrccatoPlay(TRemConCoreApiPlaybackSpeed /*aSpeed*/, TRemConCoreApiButtonAction aButtonAct)

{

    switch (aButtonAct)

    {

    case ERemConCoreApiButtonPress:

    case ERemConCoreApiButtonClick:

    {

        PostClickEventToListeners(MSwtMediaKeysListener::ESwtMediaKeyPlay);

        break;

    }

    default:

    {

        break;

    }

    }

}

void CSwtMIDRemConObserver::MrceoError(TInt /*aError*/)

{

    iRepeatTimer->Cancel();

    iKeyRepeating = MSwtMediaKeysListener::ESwtMediaKeyNone;

}

CSwtMIDRemConObserver::CSwtMIDRemConObserver()

{

}

void CSwtMIDRemConObserver::ConstructL()

{

    iJavaRemConObserver = CJavaRemConObserver::NewL(*this);

    iJavaRemConManager = CJavaRemConManager::NewL();

    iJavaRemConManager->SetObserverL(*iJavaRemConObserver);

    // Timer for implementing key repeat feature.

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

    iKeyRepeating = MSwtMediaKeysListener::ESwtMediaKeyNone;

}

void CSwtMIDRemConObserver::PostRawEventToListeners(MSwtMediaKeysListener::TMediaKey aKeyCode, TInt aEventType)

{

    TKeyEvent event;

    event.iCode = 0;

    event.iScanCode = aKeyCode;

    event.iModifiers = 0;

    event.iRepeats = 0; // no repeats

    if (iKeyRepeating != MSwtMediaKeysListener::ESwtMediaKeyNone)

    {

        event.iRepeats = 1; // repeats

    }

    else if (aEventType == EEventKeyUp)

    {

        event.iModifiers |= EModifierKeyUp;

    }

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

    {

        iListeners[i]->HandleMediaKeyEvent(event, aEventType);

    }

}

void CSwtMIDRemConObserver::PostClickEventToListeners(MSwtMediaKeysListener::TMediaKey aKeyCode)

{

    PostRawEventToListeners(aKeyCode, EEventKeyDown);

    PostRawEventToListeners(aKeyCode, EEventKey);

    PostRawEventToListeners(aKeyCode, EEventKeyUp);

}

TInt CSwtMIDRemConObserver::RepeatTimerCallback(TAny* aThis)

{

    CSwtMIDRemConObserver* observer = static_cast<CSwtMIDRemConObserver*>(aThis);

    observer->HandleRepeatTimerEvent();

    return 0;

}

void CSwtMIDRemConObserver::HandleRepeatTimerEvent()

{

    if (iKeyRepeating != MSwtMediaKeysListener::ESwtMediaKeyNone)

    {

        PostRawEventToListeners(iKeyRepeating, EEventKey);

    }

}

//  End of File