/*******************************************************************************
 * Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).
 * All rights reserved. This program and the accompanying materials
 * are made available under the terms of the Eclipse Public License v1.0
 * which accompanies this distribution, and is available at
 * http://www.eclipse.org/legal/epl-v10.html
 *
 * Contributors:
 *     Nokia Corporation - initial implementation
 *******************************************************************************/

#include <org_eclipse_swt_internal_qt_OS.h>
#include <hwrmdomainpskeys.h>

#include "swtflipwatch.h"
#include "swtapplication.h"
#include "swts60.h"

namespace Java { namespace eSWT {

// Priority of the flip watch CActive. If for some reason the flip watch
// CActive gets blocked, the watch timer should wait also. Therefore the
// priority of the watch timer should be lower than this.
const TInt KSwtFlipWatchPriority = 0;

// Using a short delay on the flip watch will avoid ui unresponsiveness when
// fast swaping the flip back and forth.
const TInt KSwtFlipWatchTimeout = 250000;


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


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

// ---------------------------------------------------------------------------
// CSwtFlipWatch::~CSwtFlipWatch
// ---------------------------------------------------------------------------
//
CSwtFlipWatch::~CSwtFlipWatch()
{
    Cancel();
    iProperty.Close();

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


// ---------------------------------------------------------------------------
// CSwtFlipWatch::CSwtFlipWatch
// ---------------------------------------------------------------------------
//
CSwtFlipWatch::CSwtFlipWatch()
        : CActive(KSwtFlipWatchPriority)
{
  
}

// ---------------------------------------------------------------------------
// CSwtFlipWatch::ConstructL
// ---------------------------------------------------------------------------
//
void CSwtFlipWatch::ConstructL()
{
    isInitializationState = ETrue;
    User::LeaveIfError(iProperty.Attach(KPSUidHWRM, KHWRMFlipStatus));
    iTimer = CSwtFlipWatchTimer::NewL(this);
    CActiveScheduler::Add(this);
    RunL();
}

// ---------------------------------------------------------------------------
// CSwtFlipWatch::DoCancel
// ---------------------------------------------------------------------------
//
void CSwtFlipWatch::DoCancel()
{
    iProperty.Cancel();
}

// ---------------------------------------------------------------------------
// CSwtFlipWatch::RunL
// ---------------------------------------------------------------------------
//
void CSwtFlipWatch::RunL()
{
    iTimer->Cancel();
    iProperty.Subscribe(iStatus);
    // For performance reasons while in fast sequence of swaps the observers
    // will get screen deactivated event only once.
    if (!iFlipChanging)
        {
        SymbianUtils::eventFilter( swtApp, -1, org_eclipse_swt_internal_qt_OS_QSWTEVENT_SCREENDEACTIVATED);
        }
    iFlipChanging = ETrue;
    iTimer->SetTimer(KSwtFlipWatchTimeout);
    SetActive();
}

// ---------------------------------------------------------------------------
// CSwtFlipWatch::HandleTimeoutL
// ---------------------------------------------------------------------------
//
void CSwtFlipWatch::HandleTimeoutL()
{
    TInt flipStatus = 0;
    TInt err = iProperty.Get(flipStatus);
    if ( !isInitializationState && err == KErrNone)
        {
        iFlipChanging = EFalse;
        // Report flip change
        if (flipStatus ==  EPSHWRMFlipClosed)
            {
            SymbianUtils::eventFilter( swtApp, -1, org_eclipse_swt_internal_qt_OS_QSWTEVENT_MOBILEDEVICECLOSED);
            } else{
            SymbianUtils::eventFilter( swtApp, -1, org_eclipse_swt_internal_qt_OS_QSWTEVENT_MOBILEDEVICEOPENED);
            }
        // For performance reasons while in fast sequence of swaps the observers
        // will get screen deactivated event only once.
        // ASSUMPTION: The screen changes if the flip changes.
        SymbianUtils::eventFilter( swtApp, -1, org_eclipse_swt_internal_qt_OS_QSWTEVENT_SCREENACTIVATED);
        }
    isInitializationState = EFalse;
}

// ---------------------------------------------------------------------------
// CSwtFlipWatchTimer::NewL
// ---------------------------------------------------------------------------
//
CSwtFlipWatchTimer* CSwtFlipWatchTimer::NewL(MSwtFlipWatchTimerHandler* aHandler)
{
    CSwtFlipWatchTimer* self = new(ELeave) CSwtFlipWatchTimer(aHandler);
    CleanupStack::PushL(self);
    self->ConstructL();
    CleanupStack::Pop(self);
    return self;
}

// ---------------------------------------------------------------------------
// CSwtFlipWatchTimer::CSwtFlipWatchTimer
// ---------------------------------------------------------------------------
//
CSwtFlipWatchTimer::CSwtFlipWatchTimer(MSwtFlipWatchTimerHandler* aHandler)
        : CActive(KSwtFlipWatchPriority - 1)
        , iHandler(aHandler)
{
    ASSERT(iHandler);
}

// ---------------------------------------------------------------------------
// CSwtFlipWatchTimer::ConstructL
// ---------------------------------------------------------------------------
//
void CSwtFlipWatchTimer::ConstructL()
{
    TInt err = iTimer.CreateLocal();
    User::LeaveIfError(err);
    CActiveScheduler::Add(this);
}

// ---------------------------------------------------------------------------
// CSwtFlipWatchTimer::~CSwtFlipWatchTimer
// ---------------------------------------------------------------------------
//
CSwtFlipWatchTimer::~CSwtFlipWatchTimer()
{
    Cancel();
    iTimer.Close();
}

// ---------------------------------------------------------------------------
// CSwtFlipWatchTimer::RunL
// ---------------------------------------------------------------------------
//
void CSwtFlipWatchTimer::RunL()
{
    iHandler->HandleTimeoutL();
}

// ---------------------------------------------------------------------------
// CSwtFlipWatchTimer::DoCancel
// ---------------------------------------------------------------------------
//
void CSwtFlipWatchTimer::DoCancel()
{
    iTimer.Cancel();
}

// ---------------------------------------------------------------------------
// CSwtFlipWatchTimer::SetTimer
// ---------------------------------------------------------------------------
//
void CSwtFlipWatchTimer::SetTimer(TTimeIntervalMicroSeconds32 aDelay)
{
    Cancel();
    iTimer.After(iStatus, aDelay);
    SetActive();
}

}}