/*

* Copyright (c) 2006 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:  Command handler for SSY <--> Sensor messages

*

*/

#include <e32property.h>

#include "ssyreferencecmdhandler.h"

#include "ssyreferencecontrol.h"

#include "ssyreferencechannel.h"

#include "ssyreferencetrace.h"

// ======== CONSTANTS ========

const TInt KSsyRefShortDelay = 100; 

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

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

// CSsyReferenceCmdHandler C++ constructor

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

//

CSsyReferenceCmdHandler::CSsyReferenceCmdHandler( CSsyReferenceChannel& aSsyChannel ) :

    CActive( EPriorityNormal ),

    iSsyChannel( aSsyChannel )

    {

    COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceCmdHandler::CSsyReferenceCmdHandler()" ) ) );

    CActiveScheduler::Add( this );

    COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceCmdHandler::CSsyReferenceCmdHandler() - return" ) ) );

    }

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

// Symbian 2nd phase constructor

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

//

void CSsyReferenceCmdHandler::ConstructL()

    {

    COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceCmdHandler::ConstructL()" ) ) );

    COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceCmdHandler::ConstructL() - return" ) ) );

    }

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

// CSsyReferenceCmdHandler::NewL

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

//

CSsyReferenceCmdHandler* CSsyReferenceCmdHandler::NewL( CSsyReferenceChannel& aSsyChannel )

    {

    COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceCmdHandler::NewL()" ) ) );

    CSsyReferenceCmdHandler* self = new ( ELeave ) CSsyReferenceCmdHandler( aSsyChannel );

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceCmdHandler::NewL() - return" ) ) );

    return self;

    }

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

// Destructor

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

//

CSsyReferenceCmdHandler::~CSsyReferenceCmdHandler()

    {

    COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceCmdHandler::~CSsyReferenceCmdHandler()" ) ) );

    if ( iMessage )

        {

        // Send ProcessResponse

        iMessage->SetError( KErrCancel );

        iSsyChannel.ProcessResponse( iMessage );

        delete iMessage;

        iMessage = NULL;

        }

    if ( iTimer )

        {

        iTimer->Cancel();

        delete iTimer;

        }

    COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceCmdHandler::~CSsyReferenceCmdHandler() - return" ) ) );

    }

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

// CSsyReferenceCmdHandler::ProcessCommand

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

//

TInt CSsyReferenceCmdHandler::ProcessCommand( TSsyReferenceMsg aMessage )

    {

    COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceCmdHandler::ProcessCommand()" ) ) );

    TInt err( KErrAlreadyExists );

    // Special case, when channel is reciving, iMessage is not deleted after ProcessCommand

    if ( aMessage.Function() == ESsyReferenceStopChannelData )

        {

        // Stop 'receiving'. No need to handle this asynchronously

        if ( iTimer )

            {

            iTimer->Cancel();

            delete iTimer;

            iTimer = NULL;

            }

        iDataItemArray.Reset();

        iDataItemPtr = 0;

        err = KErrNone;

        // No need to send ProcessResponse either

        delete iMessage;

        iMessage = NULL;

        }

    else if ( !iMessage )

        {

        TRAP(err, iMessage = new ( ELeave ) TSsyReferenceMsg( aMessage ));

        COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceCmdHandler::ProcessCommand() - error %d creatig TSsyReferenceMsg" ), err ) );

        switch( aMessage.Function() )

            {

            case ESsyReferenceStartChannelData:

                {

                // Get channel data items and start 'receiving'

                IssueRequest();

                err = KErrNone;

                break;

                }

            case ESsyReferenceOpenChannel:

                {

                // Open channel specific handling here

                IssueRequest();

                err = KErrNone;

                break;

                }

            case ESsyReferenceCloseChannel:

                {

                // Close channel specific handling here

                IssueRequest();

                err = KErrNone;

                break;  

                }

            default:

                {

                COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceCmdHandler::ProcessCommand() - Unknown function" ) ) );

                err = KErrNotFound;

                }

            }

        }

    else

        {

        err = KErrUnknown;

        }

    COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceCmdHandler::ProcessCommand() - return" ) ) );

    return err;

    }

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

// CSsyReferenceCmdHandler::IssueRequest

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

//

void CSsyReferenceCmdHandler::IssueRequest( TInt aError )

    {

    COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceCmdHandler::IssueRequest()" ) ) );

    // Provides synchronous function calls to be handled as asynchronous

    if ( !IsActive() )

        {

        TRequestStatus *s = &iStatus;

	    User::RequestComplete( s, aError );

	    SetActive();

        }

    COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceCmdHandler::IssueRequest() - return" ) ) );

    }

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

// CSsyReferenceCmdHandler::SendResponse

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

//

void CSsyReferenceCmdHandler::SendResponse( TInt aError )

    {

    COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceCmdHandler::SendResponse()" ) ) );

    // Send response to channel

    if ( iMessage )

        {

        iMessage->SetError( aError );

        iSsyChannel.ProcessResponse( iMessage );

        delete iMessage;

        iMessage = NULL;

        }

    COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceCmdHandler::SendResponse() - return" ) ) );

    }

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

// CSsyReferenceCmdHandler::RunL

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

//

void CSsyReferenceCmdHandler::RunL()

    {

    COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceCmdHandler::RunL() - %i" ), iStatus.Int() ) );

    TInt err( iStatus.Int() );

    if ( iMessage )

        {

        switch( iMessage->Function() )

            {

            case ESsyReferenceStartChannelData:

                {

                TInt startInterval( 0 );

                // Get all Channel data information from config file

                iSsyChannel.SsyControl().SsyConfig().

                    GetChannelDataInformationL( iMessage->ChannelId(), iDataItemArray, startInterval );

                // Check that channel data items were found

                if ( iDataItemArray.Count() )

                    {

                    // If interval is zero, set small interval

                    if ( startInterval == 0 )

                        {

                        startInterval = KSsyRefShortDelay;

                        }

                    // wait that interval

                    if ( iTimer )

                        {

                        iTimer->Cancel();

                        delete iTimer;

                        iTimer = NULL;

                        }

                    // Reset pointer

                    iDataItemPtr = 0;

                    // Start timer and continue processing in callback function

                    iTimer = CPeriodic::NewL( EPriorityNormal );

                    iTimer->Start( startInterval * 1000, 0, TCallBack( DataItemCallback, this ) );

                    }

                break;

                }

            case ESsyReferenceOpenChannel:

                {

                // Open channel response specific handling here

                iMessage->SetFunction( ESsyReferenceOpenChannelResp );

                SendResponse();

                break;

                }

            case ESsyReferenceCloseChannel:

                {

                // Close channel response specific handling here

                iMessage->SetFunction( ESsyReferenceCloseChannelResp );

                SendResponse();

                break;  

                }

            default:

                {

                COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceCmdHandler::ProcessCommand() - Unknown function" ) ) );

                err = KErrNotFound;

                }

            }

        }

    COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceCmdHandler::RunL() - return" ) ) );

    }

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

// CSsyReferenceCmdHandler::DoCancel

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

//

void CSsyReferenceCmdHandler::DoCancel()

    {

    COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceCmdHandler::DoCancel()" ) ) );

    // Handle cancel for this channel. Cancel any ongoing requests

    COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceCmdHandler::DoCancel() - return" ) ) );

    }

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

// CSsyReferenceCmdHandler::RunError

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

//

TInt CSsyReferenceCmdHandler::RunError( TInt /*aError*/ )

    {

    COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceCmdHandler::RunError()" ) ) );

    // Handle possible errors here and return KErrNone to prevent SSY from panic

    COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceCmdHandler::RunError() - return" ) ) );

    return KErrNone;

    }

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

// CSsyReferenceCmdHandler::DataItemCallback

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

//

TInt CSsyReferenceCmdHandler::DataItemCallback( TAny* aThis )

    {

    COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceCmdHandler::DataItemCallback()" ) ) );

    return static_cast<CSsyReferenceCmdHandler*>( aThis )->GenerateChannelDataItem();

    }

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

// CSsyReferenceCmdHandler::GenerateChannelDataItem

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

//

TInt CSsyReferenceCmdHandler::GenerateChannelDataItem()

    {

    COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceCmdHandler::GenerateChannelDataItem()" ) ) );

    // Get next item from list and set pointer to next item

    TSsyRefChannelDataBase dataItem = iDataItemArray[iDataItemPtr++];

    // Get next item interval from data item

    TInt nextInterval( dataItem.Interval() );

    // Set timestamp to data item

    TTime time;

    time.HomeTime();

    dataItem.SetTimestamp( time );

    // If interval is zero, set small interval

    if ( nextInterval == 0 )

        {

        nextInterval = KSsyRefShortDelay;

        }

    // Add data item to message

    iMessage->SetDataItem( &dataItem );

    // If in last data item, set pointer back to first item

    if ( iDataItemArray.Count() == iDataItemPtr )

        {

        iDataItemPtr = 0;

        }

    // Send response and start new timer

    iMessage->SetFunction( ESsyReferenceDataItemReceived );

    iSsyChannel.ProcessResponse( iMessage );

    if ( iTimer )

        {

        delete iTimer;

        iTimer = NULL;

        }

    TRAP_IGNORE( iTimer = CPeriodic::NewL( EPriorityNormal );

                 iTimer->Start( nextInterval * 1000, 0, TCallBack( DataItemCallback, this ) ); )

    COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceCmdHandler::GenerateChannelDataItem() - return" ) ) );

    return KErrNone;

    }

// End of file