/*

* Copyright (c) 2009 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:  Implementation for controlling S60 device lights.

*

*/

// INCLUDE FILES

#include <HtiDispatcherInterface.h>

#include <HTILogging.h>

#include "HtiLightsController.h"

// CONSTANTS

const static TUid KSysInfoServiceUid = { 0x10210CC7 };

const static TInt KLightStatusCmdLength = 2;

const static TInt KLightOnCmdLength     = 6;

const static TInt KLightOffCmdLength    = 5;

const static TInt KLightBlinkCmdLength  = 9;

enum TSysInfoLightControlCommand

    {

    ELightStatus = 0x30,

    ELightOn =     0x31,

    ELightOff =    0x32,

    ELightBlink =  0x33

    };

_LIT8( KErrDescrArgument,     "Invalid argument" );

_LIT8( KErrDescrLightOn,      "LightOn failed" );

_LIT8( KErrDescrLightOff,     "LightOff failed" );

_LIT8( KErrDescrLightBlink,   "LightBlink failed" );

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

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

// CHtiLightsController::NewL

// Two-phased constructor.

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

//

CHtiLightsController* CHtiLightsController::NewL( MHtiDispatcher* aDispatcher )

    {

    CHtiLightsController* self = new (ELeave) CHtiLightsController(

                                                  aDispatcher );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop();

    return self;

    }

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

// CHtiLightsController::CHtiLightsController

// C++ default constructor.

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

//

CHtiLightsController::CHtiLightsController(

        MHtiDispatcher* aDispatcher ):iDispatcher( aDispatcher ),

                                      iCommand( 0 ),

                                      iTarget( 0 ),

                                      iDuration( 0 ),

                                      iOnDuration( 0 ),

                                      iOffDuration( 0 ),

                                      iIntensity( 0 ),

                                      iFade( EFalse )

    {

    }

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

// CHtiLightsController::~CHtiLightsController()

// Destructor

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

//

CHtiLightsController::~CHtiLightsController()

    {

    HTI_LOG_TEXT("CHtiLightsController destroy");

    delete iLight;

    }

// Second phase construction

void CHtiLightsController::ConstructL()

    {

    HTI_LOG_TEXT("CHtiLightsController::ConstructL");

    iLight = CHWRMLight::NewL( this );

    }

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

// CHtiLightsController::ProcessMessageL

// Called by the plugin when there is a message to be processed by

// the lights controller.

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

//

void CHtiLightsController::ProcessMessageL( const TDesC8& aMessage,

                                            TDes8& aReply )

    {

    HTI_LOG_FUNC_IN( "CHtiLightsController::ProcessMessageL" );

    iCommand = aMessage[0];

    iReply.Zero();

    switch ( iCommand )

        {

        case ELightStatus:

            {

            HTI_LOG_TEXT( "ELightStatus" );

            HandleLightStatusL( aMessage );

            break;

            }

        case ELightOn:

            {

            HTI_LOG_TEXT( "ELightOn" );

            HandleLightOnL( aMessage );

            break;

            }

        case ELightOff:

            {

            HTI_LOG_TEXT( "ELightOff" );

            HandleLightOffL( aMessage );

            break;

            }

        case ELightBlink:

            {

            HTI_LOG_TEXT( "ELightBlink" );

            HandleLightBlinkL( aMessage );

            break;

            }

        default:

            {

            // If comes here it's an error from caller.

            User::Leave( KErrArgument );

            }

        }

    aReply.Copy( iReply );

    HTI_LOG_FUNC_OUT("CHtiLightsController::ProcessMessageL");

    }

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

// CHtiLightsController::HandleLightStatusL

// Gets the status of the given light target.

// Returns "Not supported" for S60 2.x

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

//

void CHtiLightsController::HandleLightStatusL( const TDesC8& aMessage )

    {

    HTI_LOG_FUNC_IN( "CHtiLightsController::HandleLightStatusL" );

    if ( aMessage.Length() != KLightStatusCmdLength )

        {

        iDispatcher->DispatchOutgoingErrorMessage(

            KErrArgument, KErrDescrArgument, KSysInfoServiceUid );

        }

    else

        {

        iTarget = aMessage[1];

        iReply.Append( iLight->LightStatus( iTarget ) );

        }

    HTI_LOG_FUNC_OUT( "CHtiLightsController::HandleLightStatusL" );

    }

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

// CHtiLightsController::HandleLightOnL

// Turns on light with specified parameters.

// For S60 2.x just turns on lights forever, parameters are ignored.

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

//

void CHtiLightsController::HandleLightOnL( const TDesC8& aMessage )

    {

    HTI_LOG_FUNC_IN( "CHtiLightsController::HandleLightOnL" );

    if ( aMessage.Length() != KLightOnCmdLength )

        {

        iDispatcher->DispatchOutgoingErrorMessage(

            KErrArgument, KErrDescrArgument, KSysInfoServiceUid );

        return;

        }

    // parse values from message

    iTarget    = aMessage[1];

    iDuration  = aMessage[2] + ( aMessage[3] << 8 );

    iIntensity = aMessage[4];

    iFade      = (TBool)aMessage[5];

    TInt err = KErrNone;

    // normalize possibly abnormal values

    if ( iIntensity < KHWRMLightMinIntensity )

        iIntensity = KHWRMDefaultIntensity;

    if ( iIntensity > KHWRMLightMaxIntensity )

        iIntensity = KHWRMLightMaxIntensity;

    if ( iDuration < 1 ) iDuration = KHWRMInfiniteDuration;

    // shoot

    TRAP( err, iLight->LightOnL( iTarget, iDuration, iIntensity, iFade ) );

    if ( err )

        {

        iDispatcher->DispatchOutgoingErrorMessage(

            err, KErrDescrLightOn, KSysInfoServiceUid );

        }

    else

        {

        iReply.Append( 0 );

        }

    HTI_LOG_FUNC_OUT( "CHtiLightsController::HandleLightOnL ");

    }

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

// CHtiLightsController::HandleLightOffL

// Turns off light with specified parameters.

// Returns "Not supported" for S60 2.x

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

//

void CHtiLightsController::HandleLightOffL( const TDesC8& aMessage )

    {

    HTI_LOG_FUNC_IN( "CHtiLightsController::HandleLightOffL" );

    if ( aMessage.Length() != KLightOffCmdLength )

        {

        iDispatcher->DispatchOutgoingErrorMessage(

            KErrArgument, KErrDescrArgument, KSysInfoServiceUid );

        return;

        }

    // parse values from message

    iTarget   = aMessage[1];

    iDuration = aMessage[2] + ( aMessage[3] << 8 );

    iFade     = (TBool)aMessage[4];

    // normalize possibly abnormal values

    if ( iDuration < 1 ) iDuration = KHWRMInfiniteDuration;

    // shoot

    TRAPD( err, iLight->LightOffL( iTarget, iDuration, iFade ) );

    if ( err )

        {

        iDispatcher->DispatchOutgoingErrorMessage(

            err, KErrDescrLightOff, KSysInfoServiceUid );

        }

    else

        {

        iReply.Append( 0 );

        }

    HTI_LOG_FUNC_OUT( "CHtiLightsController::HandleLightOffL" );

    }

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

// CHtiLightsController::HandleLightBlinkL

// Blinks light with specified parameters.

// Returns "Not supported" for S60 2.x

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

//

void CHtiLightsController::HandleLightBlinkL( const TDesC8& aMessage )

    {

    HTI_LOG_FUNC_IN( "CHtiLightsController::HandleLightBlinkL" );

    if ( aMessage.Length() != KLightBlinkCmdLength )

        {

        iDispatcher->DispatchOutgoingErrorMessage(

            KErrArgument, KErrDescrArgument, KSysInfoServiceUid );

        return;

        }

    // parse values from message

    iTarget      = aMessage[1];

    iDuration    = aMessage[2] + ( aMessage[3] << 8 );

    iOnDuration  = aMessage[4] + ( aMessage[5] << 8 );

    iOffDuration = aMessage[6] + ( aMessage[7] << 8 );

    iIntensity   = aMessage[8];

    // normalize possibly abnormal values

    if ( iIntensity < KHWRMLightMinIntensity )

        iIntensity = KHWRMDefaultIntensity;

    if ( iIntensity > KHWRMLightMaxIntensity )

        iIntensity = KHWRMLightMaxIntensity;

    if ( iDuration < 1 ) iDuration = KHWRMInfiniteDuration;

    if ( iOnDuration < 1 || iOffDuration < 1 )

        {

        iOnDuration = KHWRMDefaultCycleTime;

        iOffDuration = KHWRMDefaultCycleTime;

        }

    // shoot

    TRAPD( err, iLight->LightBlinkL(

            iTarget, iDuration, iOnDuration, iOffDuration, iIntensity ) );

    if ( err )

        {

        iDispatcher->DispatchOutgoingErrorMessage(

            err, KErrDescrLightBlink, KSysInfoServiceUid );

        }

    else

        {

        iReply.Append( 0 );

        }

    HTI_LOG_FUNC_OUT( "CHtiLightsController::HandleLightBlinkL" );

    }

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

// CHtiLightsController::LightStatusChanged

// Called when status of any light target changes.

// If infinite duration is requested, restores the state back to what was

// last requested.

// This method does not exist for S60 2.x

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

//

void CHtiLightsController::LightStatusChanged( TInt aTarget,

                                     CHWRMLight::TLightStatus aStatus )

    {

    HTI_LOG_FORMAT( "Light status changed for target %d", aTarget );

    HTI_LOG_FORMAT( "New status = %d", aStatus );

    HTI_LOG_FORMAT( "Current target = %d", iTarget );

    TInt target = aTarget & iTarget;

    if ( !target )

        {

        HTI_LOG_TEXT( "Not interested about the target" );

        return;

        }

    HTI_LOG_TEXT( "Matches current target" );

    if ( iDuration != KHWRMInfiniteDuration )

        {

        return;

        }

    if ( ( aStatus == CHWRMLight::ELightOn && iCommand == ELightOn ) ||

         ( aStatus == CHWRMLight::ELightOff && iCommand == ELightOff ) ||

         ( aStatus == CHWRMLight::ELightBlink && iCommand == ELightBlink ) )

        {

        HTI_LOG_TEXT( "Status already OK" );

        return;

        }

    HTI_LOG_TEXT( "Infinite duration wanted - restore light status" );

    switch ( iCommand )

        {

        case ELightOn:

            {

            // Ignore error

            TRAPD( err, iLight->LightOnL(

                    target, iDuration, iIntensity, iFade ) );

            HTI_LOG_FORMAT( "LightOnL return code %d", err );

            err = err; // to get rid of compiler warning for non-logging

            break;

            }

        case ELightOff:

            {

            // Ignore error

            TRAPD( err, iLight->LightOffL( target, iDuration, iFade ) );

            HTI_LOG_FORMAT( "LightOffL return code %d", err );

            err = err; // to get rid of compiler warning for non-logging

            break;

            }

        case ELightBlink:

            {

            // Ignore error

            TRAPD( err, iLight->LightBlinkL(

                    target, iDuration, iOnDuration,

                    iOffDuration, iIntensity ) );

            HTI_LOG_FORMAT( "LightBlinkL return code %d", err );

            err = err; // to get rid of compiler warning for non-logging

            break;

            }

        default:

            break;

        }

    }

// End of file