/*
* 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:  ?Description
*
*/


// CRemConCoreApiTarget* iCoreTarget
#include <remconcoreapitarget.h>
// CRemConInterfaceSelector* iInterfaceSelector;
#include <remconinterfaceselector.h>
// using avkon constants
#include <aknconsts.h>
#include <j2me/jdebug.h>

#include "CMIDRemConObserver.h"
#include "CMIDKeyDecoder.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;


CMIDRemConObserver* CMIDRemConObserver::NewL()
{
    CMIDRemConObserver* self = new(ELeave) CMIDRemConObserver();
    CleanupStack::PushL(self);
    self->ConstructL();
    CleanupStack::Pop(self);
    return self;
}


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

    if (iJavaRemConManager != NULL)
    {
        iJavaRemConManager->RemoveObserver(*iJavaRemConObserver);
    }
    if (iJavaRemConObserver != NULL)
    {
        delete iJavaRemConObserver;
        iJavaRemConObserver = NULL;
    }
    if (iJavaRemConManager != NULL)
    {
        delete iJavaRemConManager;
        iJavaRemConManager = NULL;
    }
    iListeners.Close();

    if (iRepeatTimer)
    {
        iRepeatTimer->Cancel();
        delete iRepeatTimer;
    }

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


void CMIDRemConObserver::AddMediaKeysListenerL(MMIDMediaKeysListener* aListener)
{
    User::LeaveIfError(iListeners.Append(aListener));
}


void CMIDRemConObserver::RemoveMediaKeysListener(MMIDMediaKeysListener* 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 CMIDRemConObserver::MrccatoCommand(TRemConCoreApiOperationId aOperationId,
                                        TRemConCoreApiButtonAction aButtonAct)
{
    DEBUG_INT2("CMIDRemConObserver::MrccatoCommand - JAVA operationId %d JAVA buttonAct %d",
               aOperationId, aButtonAct);

    MMIDMediaKeysListener::TMediaKey mediaKey = MMIDMediaKeysListener::EMIDMediaKeyNone;

    switch (aOperationId)
    {
    case ERemConCoreApiPausePlayFunction:
        mediaKey = MMIDMediaKeysListener::EMIDMediaKeyPlay;
        break;
    case ERemConCoreApiStop:
        mediaKey = MMIDMediaKeysListener::EMIDMediaKeyStop;
        break;
    case ERemConCoreApiForward:
    case ERemConCoreApiFastForward:
        mediaKey = MMIDMediaKeysListener::EMIDMediaKeyNext;
        break;
    case ERemConCoreApiBackward:
    case ERemConCoreApiRewind:
        mediaKey = MMIDMediaKeysListener::EMIDMediaKeyPrevious;
        break;
    default:
        return;
    }

    TMIDKeyEvent::TEvent keyEvent = TMIDKeyEvent::EPressed;

    switch (aButtonAct)
    {
    case ERemConCoreApiButtonPress: // Long key press
        iKeyRepeating = mediaKey;
        break;
    case ERemConCoreApiButtonClick: // Short key press
        keyEvent = TMIDKeyEvent::EPressed;
        break;
    case ERemConCoreApiButtonRelease: // Key released after long key press.
        keyEvent = TMIDKeyEvent::EReleased;
        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 == MMIDMediaKeysListener::EMIDMediaKeyPlay || mediaKey == MMIDMediaKeysListener::EMIDMediaKeyStop))
    {
        // keyPressed event is posted first, then timer for key repeats is started.
        PostEventToListeners(mediaKey, TMIDKeyEvent::EPressed);
        iRepeatTimer->Start(KFirstTimerExpiryInterval, KTimerExpiryInterval,
                            TCallBack(RepeatTimerCallback, this));
    }
    else if ((aButtonAct == ERemConCoreApiButtonRelease ||  aButtonAct == ERemConCoreApiButtonPress)
             && (mediaKey == MMIDMediaKeysListener::EMIDMediaKeyPlay || mediaKey == MMIDMediaKeysListener::EMIDMediaKeyStop))
    {
        // 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.
        return;
    }
    else
    {
        PostEventToListeners(mediaKey, keyEvent);
    }

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


void CMIDRemConObserver::MrccatoPlay(TRemConCoreApiPlaybackSpeed aSpeed, TRemConCoreApiButtonAction aButtonAct)
{
    DEBUG("CMIDRemConObserver::MrccatoPlay +");
    DEBUG_INT2("RemConObserver::MrccatoPlay - JAVA speed %d JAVA buttonAct %d", aSpeed, aButtonAct);
    (void)aSpeed; // Just to suppress warning in release build

    switch (aButtonAct)
    {
    case ERemConCoreApiButtonPress:
    case ERemConCoreApiButtonClick:
    {
        PostEventToListeners(MMIDMediaKeysListener::EMIDMediaKeyPlay, TMIDKeyEvent::EPressed);
        break;
    }
    default:
    {
        break;
    }
    }
    DEBUG("CMIDRemConObserver::MrccatoPlay -");
}

void CMIDRemConObserver::MrceoError(TInt /*aError*/)
{
    DEBUG("CMIDRemConObserver::MrceoError +");
    iRepeatTimer->Cancel();
    DEBUG("CMIDRemConObserver::MrceoError -");
}


CMIDRemConObserver::CMIDRemConObserver()
{
}


void CMIDRemConObserver::ConstructL()
{
    DEBUG("CMIDRemConObserver::ConstructL +");
    iJavaRemConObserver = CJavaRemConObserver::NewL(*this);
    iJavaRemConManager = CJavaRemConManager::NewL();
    iJavaRemConManager->SetObserverL(*iJavaRemConObserver);
    // Timer for implementing key repeat feature.
    iRepeatTimer = CPeriodic::NewL(CActive::EPriorityStandard);

    iKeyRepeating = MMIDMediaKeysListener::EMIDMediaKeyNone;

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


void CMIDRemConObserver::PostEventToListeners(MMIDMediaKeysListener::TMediaKey aKeyCode, TMIDKeyEvent::TEvent aEventType)
{
    DEBUG("CMIDRemConObserver::PostEventToListeners +");

    TMIDKeyEvent event;
    event.iKeyCode = aKeyCode;
    event.iEvents = aEventType;

    if (event.iEvents == TMIDKeyEvent::ERepeated)
    {
        event.iRepeats = 1; // repeats
    }
    else
    {
        event.iRepeats = 0; // no repeats
    }

    for (TInt i = 0;  i < iListeners.Count(); i++)
    {
        iListeners[i]->HandleMediaKeyEvent(event);
    }

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


TInt CMIDRemConObserver::RepeatTimerCallback(TAny* aThis)
{
    CMIDRemConObserver* observer = static_cast<CMIDRemConObserver*>(aThis);
    observer->HandleRepeatTimerEvent();
    return 0;
}


void CMIDRemConObserver::HandleRepeatTimerEvent()
{
    DEBUG("CMIDRemConObserver::HandleTimerEvent +");
    if (iKeyRepeating != MMIDMediaKeysListener::EMIDMediaKeyNone)
    {
        DEBUG("CMIDRemConObserver::HandleTimerEvent calling PosTEventToListeners +");
        PostEventToListeners(iKeyRepeating, TMIDKeyEvent::ERepeated);
        DEBUG("CMIDRemConObserver::HandleTimerEvent calling PostEventToListeners -");
    }
    DEBUG("CMIDRemConObserver::HandleTimerEvent -");
}

//  End of File