/*

* Copyright (c) 2005-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:  Controls device backlight

*

*/

// INCLUDE FILES

#include    "CMIDDeviceControl.h"

#include <jdebug.h>

// CONSTANTS

namespace

{

// Light devices supported by this API.

const TInt KSupportedLightCount = 4;

const TInt KSupportedLights[] = { CHWRMLight::EPrimaryDisplay,

                                  CHWRMLight::EPrimaryKeyboard, CHWRMLight::ESecondaryDisplay,

                                  CHWRMLight::ESecondaryKeyboard

                                };

const TInt KMIDMaxLightLevel = 100;

}

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

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

// CMIDDeviceControl::CMIDDeviceControl

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

// might leave.

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

//

CMIDDeviceControl::CMIDDeviceControl(MMIDEnv& aEnv)

        : iEnv(aEnv),

        iLightLevel(KErrNotFound),

        iSupportedLights(CHWRMLight::ENoTarget)

{

}

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

// CMIDDeviceControl::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CMIDDeviceControl::ConstructL()

{

    DEBUG("nokialcdui::CMIDDeviceControl::ConstructL +");

    iLight = CHWRMLight::NewL(this);

    iEnv.AddObserverL(*this);

    // Find out light devices on the phone that are supported

    // by our API.

    TInt supportedLights = iLight->SupportedTargets();

    TInt mask = (CHWRMLight::EPrimaryDisplayAndKeyboard |

                 CHWRMLight::ESecondaryDisplayAndKeyboard);

    iSupportedLights = (supportedLights & mask);

    DEBUG("nokialcdui::CMIDDeviceControl::ConstructL -");

}

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

// CMIDDeviceControl::NewLC

// Two-phased constructor. Leaves object in cleanup stack.

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

//

CMIDDeviceControl* CMIDDeviceControl::NewLC(MMIDEnv& aEnv)

{

    CMIDDeviceControl* self = new(ELeave) CMIDDeviceControl(aEnv);

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

}

// Destructor

CMIDDeviceControl::~CMIDDeviceControl()

{

    Release();

    delete iLight;

}

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

// CMIDDeviceControl::resetUserInactivityTime

// Reset the user inactivity time

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

//

void CMIDDeviceControl::GetUserInactivityTimeL(TInt* aRetVal)

{

    DEBUG("nokialcdui::CMIDDeviceControl::GetUserInactivityTimeL +");

    TTimeIntervalSeconds ValInterval = User::InactivityTime() ;

    *aRetVal = ValInterval.Int();

    DEBUG("nokialcdui::CMIDDeviceControl::GetUserInactivityTimeL -");

}

void CMIDDeviceControl::StaticGetUserInactivityTimeL(CMIDDeviceControl* aDC,

        TInt* aRetVal)

{

    aDC->GetUserInactivityTimeL(aRetVal);

}

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

// CMIDDeviceControl::resetUserInactivityTime

// Reset the user inactivity time

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

//

void CMIDDeviceControl::ResetUserInactivityTimeL()

{

    DEBUG("nokialcdui::CMIDDeviceControl::ResetUserInactivityTime +");

    User::ResetInactivityTime();

    DEBUG("nokialcdui::CMIDDeviceControl::ResetUserInactivityTime -");

}

void CMIDDeviceControl::StaticResetUserInactivityTimeL(CMIDDeviceControl* aDC)

{

    aDC->ResetUserInactivityTimeL();

}

/**

 * Requests a flashing effect for the device's backlight

 * Returns false as the emulator does not support this feature.

 */

#if defined(__WINSCW__)

TBool CMIDDeviceControl::FlashBacklightL(TInt /*aDuration*/)

{

    DEBUG("nokialcdui::CMIDDeviceControl::FlashBacklightL");

    return EFalse;

}

#else // __WINSCW__

/**

 * Requests a flashing effect for the device's backlight

 * Must return true if the backlight can be controlled by the application

 */

TBool CMIDDeviceControl::FlashBacklightL(TInt aDuration)

{

    DEBUG_INT("nokialcdui::CMIDDeviceControl::FlashBacklightL( %d ) +",

              aDuration);

    // Return EFalse if backlights cannot be controlled.

    if (iSupportedLights == CHWRMLight::ENoTarget)

    {

        return EFalse;

    }

    // Delay the screen saver starting.

    User::ResetInactivityTime();

    // Reserve the light(s) if not yet reserved.

    if (iLightLevel == KErrNotFound)

    {

        iLight->ReserveLightL(iSupportedLights);

    }

    if (!aDuration)

    {

        // 0 would be infinite

        aDuration = 1;

    }

    iDuration = aDuration;

    iStartTime = new TTime();

    iStartTime->HomeTime();

    iLight->LightBlinkL(iSupportedLights, aDuration);

    DEBUG_INT("nokialcdui::CMIDDeviceControl::FlashBacklightL( %d ) -",

              aDuration);

    return ETrue;

}

#endif // __WINSCW__

void CMIDDeviceControl::StaticFlashBacklightL(

    CMIDDeviceControl* aDC,

    TInt aDuration,

    TBool* aRetVal)

{

    *aRetVal = aDC->FlashBacklightL(aDuration);

}

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

// CMIDDeviceControl::SetLightL

// sets the backlight level

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

//

void CMIDDeviceControl::SetLightL(TInt aLevel)

{

    DEBUG_INT("nokialcdui::CMIDDeviceControl::SetLightL( %d ) +", aLevel);

    if ((aLevel < 0) || (aLevel > KMIDMaxLightLevel))

    {

        User::Leave(KErrArgument);

    }

    // Delay the screen saver starting.

    User::ResetInactivityTime();

    // Do nothing if backlights cannot be controlled.

    if (iSupportedLights != CHWRMLight::ENoTarget)

    {

        iLightLevel = aLevel;

        // Do nothing at the moment if the blinking is ongoing.

        // Adjust the new light level when the blinking has finished

        // (LightStatusChanged() is called).

        TBool isBlinking = LightsBlinking();

        if (!isBlinking)

        {

            DoSetLightsL(aLevel);

        }

    }

    DEBUG_INT("nokialcdui::CMIDDeviceControl::SetLightL( %d ) -", aLevel);

}

void CMIDDeviceControl::HandleSwitchOnL(TBool /*aSwitchOn*/)

{

}

void CMIDDeviceControl::HandleForegroundL(TBool aForeground)

{

    DEBUG_INT2("nokialcdui::CMIDDeviceControl::HandleForegroundL; aForeground=%d; iDuration=%d", aForeground, iDuration);

    if (aForeground && iDuration > 0)

    {

        TTime* now = new TTime();

        now->HomeTime();

        TInt nowDuration = now->MicroSecondsFrom(*iStartTime).Int64()/1000;

        if (nowDuration >= iDuration)

        {

            iDuration = 0;

        }

        else

        {

            DEBUG_INT("nokialcdui::CMIDDeviceControl::HandleForegroundL - continue blinking for ( %d ) -", (iDuration - nowDuration));

            FlashBacklightL(iDuration - nowDuration);

        }

    }

}

void CMIDDeviceControl::HandleResourceChangeL(TInt /*aType*/)

{

}

void CMIDDeviceControl::StaticSetLightL(CMIDDeviceControl* aDC, TInt aLevel)

{

    aDC->SetLightL(aLevel);

}

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

// CMIDDeviceControl::Release

// Returns the backlight mode to sensor and releases resources

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

//

void CMIDDeviceControl::Release()

{

    DEBUG("nokialcdui::CMIDDeviceControl::Release +");

    // Do nothing if backlights cannot be controlled.

    if (iSupportedLights != CHWRMLight::ENoTarget)

    {

        TRAP_IGNORE(iLight->LightOnL(iSupportedLights,

                                     KHWRMInfiniteDuration,

                                     KHWRMDefaultIntensity, EFalse));

        iLight->ReleaseLight(iSupportedLights);

    }

    DEBUG("nokialcdui::CMIDDeviceControl::Release -");

}

void CMIDDeviceControl::StaticRelease(CMIDDeviceControl* aDC)

{

    aDC->Release();

}

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

// CMIDDeviceControl::Dispose

// Deletes this object

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

//

void CMIDDeviceControl::Dispose()

{

    delete this;

}

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

// CMIDDeviceControl::LightStatusChanged

// If there is pending setLights call, do it now

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

//

void CMIDDeviceControl::LightStatusChanged(

    TInt aTarget,

    CHWRMLight::TLightStatus aStatus)

{

    DEBUG_INT2("nokialcdui::CMIDDeviceControl::LightStatusChanged( %d, %d ) +",

               aTarget, aStatus);

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

    // Do nothing if the backlights cannot be controlled.

    // Adjust the lights only if blinking has finished.

    // If the status informs about some error, the light devices have to be

    // released if blinking is not ongoing.

    if ((aStatus != CHWRMLight::ELightBlink) &&

            (iSupportedLights != CHWRMLight::ENoTarget))

    {

        // Check whether the blinking has stopped. Check that none of the light

        // devices is blinking.

        TBool isBlinking = LightsBlinking();

        // Adjust the lights only if blinking has finished.

        if (!isBlinking)

        {

            if (KErrNotFound == iLightLevel)

            {

                // lights haven't been set yet, so lights must be released after

                // blinking

                iLight->ReleaseLight(iSupportedLights);

            }

            // Set the stored level to the lights only if the lights are in a

            // valid state (if the given status informed about some error, the

            // level is not tried to be set to the lights).

            else if ((aStatus == CHWRMLight::ELightOn) ||

                     (aStatus == CHWRMLight::ELightOff))

            {

                TInt err;

                TRAP(err, DoSetLightsL(iLightLevel));

                DEBUG_INT(

                    "nokialcdui::CMIDDeviceControl::DoSetLightsL, err=%d", err);

            }

        }

    }

    DEBUG_INT2("nokialcdui::CMIDDeviceControl::LightStatusChanged( %d, %d ) -",

               aTarget, aStatus);

}

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

// CMIDDeviceControl::DoSetLightsL

// Actually sets the lights

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

//

void CMIDDeviceControl::DoSetLightsL(TInt aLevel)

{

    DEBUG_INT("nokialcdui::CMIDDeviceControl::DoSetLightsL( %d ) +", aLevel);

    iLight->ReserveLightL(iSupportedLights);

    // 0 means off in our API, but default in HWRMLight API.

    if (aLevel == 0)

    {

        iLight->LightOffL(iSupportedLights,

                          KHWRMInfiniteDuration,

                          EFalse);

    }

    else

    {

        iLight->LightOnL(iSupportedLights,

                         KHWRMInfiniteDuration,

                         aLevel, EFalse);

    }

    DEBUG_INT("nokialcdui::CMIDDeviceControl::DoSetLightsL( %d ) -", aLevel);

}

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

// CMIDDeviceControl::LightsBlinking

// Checks whether lights are blinking.

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

//

TBool CMIDDeviceControl::LightsBlinking()

{

    DEBUG("nokialcdui::CMIDDeviceControl::LightsBlinking +");

    // Check all the supported lights.

    TBool isBlinking = EFalse;

    for (TInt i = 0; i < KSupportedLightCount; i++)

    {

        TInt light = KSupportedLights[ i ];

        if ((iSupportedLights & light) == light)

        {

            CHWRMLight::TLightStatus lightStatus = iLight->LightStatus(light);

            TBool blinking = (lightStatus == CHWRMLight::ELightBlink);

            isBlinking |= blinking;

        }

    }

    DEBUG_INT("nokialcdui::CMIDDeviceControl::LightsBlinking - %d",

              isBlinking);

    return isBlinking;

}

//  End of File