// ssyreferencecontrol.cpp

// Copyright (c) 2006-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:
//




#include <sensors/spi/ssycallback.h>                     // MSsyCallback
#include "ssyreferencecontrol.h"
#include "ssyreferencetrace.h"
#include "ssyreferencechannel.h"
#include "ssyreferencecmdhandler.h"


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

// ---------------------------------------------------------------------------
// CSsyReferenceControl C++ constructor
// ---------------------------------------------------------------------------
//
CSsyReferenceControl::CSsyReferenceControl( MSsyCallback& aSsyCallback ) :
    iSsyCallback( aSsyCallback )
    {
    COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceControl::CSsyReferenceControl()" ) ) );
    COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceControl::CSsyReferenceControl() - return" ) ) );
    }


// ---------------------------------------------------------------------------
// Symbian 2nd phase constructor
// ---------------------------------------------------------------------------
//
void CSsyReferenceControl::ConstructL()
    {
    COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceControl::ConstructL()" ) ) );

    // Create configurator and start config file parsing
    iConfigFile = CSsyReferenceConfig::NewL();
    TRAPD( err, iConfigFile->InitConfigL() ); // This will block until config is ready

    if ( KErrNone != err )
        {
        COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceControl::ConstructL() - Init config failed: %i" ), err ) );
        }

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

    // Store channel count for later use
    const TInt channelCount( iConfigFile->ChannelCount() );

    // Instantiate channel info list
    RSensrvChannelInfoList channelInfoList( channelCount );
    CleanupClosePushL( channelInfoList );

    // Fills channel info list with generated channel info objects
    iConfigFile->GenerateChannels( channelInfoList );

    // Register channels. Sensor Server generates unique ID for each channel
    iSsyCallback.RegisterChannelsL( channelInfoList );

    // Update channel IDs to ConfigFile
    iConfigFile->UpdateChannelIds( channelInfoList );

    // Create channels
    iChannelArray = new ( ELeave ) CArrayPtrFlat<CSsyReferenceChannel>( channelCount );
    for ( TInt i = 0; i < channelCount; i++ )
        {
        CSsyReferenceChannel* channel = CSsyReferenceChannel::NewL( *this, channelInfoList[i] );
        iChannelArray->AppendL( channel );
        }

    // Clean up
    CleanupStack::PopAndDestroy( &channelInfoList );

    // Get properties of this SSY. Leaves with KErrNotFound if not found. These properties are 
    // not mandatory, so we can ignore that leave
    TRAP_IGNORE( iConfigFile->GetSensorPropertiesL( iProperties ) );

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


// ---------------------------------------------------------------------------
// CSsyReferenceControl::NewL
// ---------------------------------------------------------------------------
//
CSsyReferenceControl* CSsyReferenceControl::NewL( MSsyCallback& aSsyCallback )
    {
    COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceControl::NewL()" ) ) );
    CSsyReferenceControl* self = new ( ELeave ) CSsyReferenceControl( aSsyCallback );
    CleanupStack::PushL( self );
    self->ConstructL();
    CleanupStack::Pop( self );
    COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceControl::NewL() - return" ) ) );
    return self;
    }

// ---------------------------------------------------------------------------
// Destructor
// ---------------------------------------------------------------------------
//
CSsyReferenceControl::~CSsyReferenceControl()
    {
    COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceControl::~CSsyReferenceControl()" ) ) );

    if ( iChannelArray )
        {
        if ( iChannelArray->Count() )
            {
            iChannelArray->ResetAndDestroy();
            }
        
        delete iChannelArray;
        }

    if ( iConfigFile ) 
        {
        delete iConfigFile;
        iConfigFile = NULL;
        }

    iProperties.Reset();

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

// ---------------------------------------------------------------------------
// CSsyReferenceControl::SsyCallback
// ---------------------------------------------------------------------------
//
MSsyCallback& CSsyReferenceControl::SsyCallback() const
    {
    COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceControl::SsyCallback()" ) ) );
    return iSsyCallback;
    }

// ---------------------------------------------------------------------------
// CSsyReferenceControl::SsyConfig
// ---------------------------------------------------------------------------
//
CSsyReferenceConfig& CSsyReferenceControl::SsyConfig() const
    {
    COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceControl::SsyConfig()" ) ) );
    return *iConfigFile;
    }

// ---------------------------------------------------------------------------
// CSsyReferenceControl::FindPropertyL
// ---------------------------------------------------------------------------
//
void CSsyReferenceControl::FindPropertyL( 
    const TSensrvPropertyId aPropertyId, 
    const TInt aArrayIndex,
    TSensrvProperty& aProperty )
    {
    COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceControl::FindPropertyL()" ) ) );
    TSensrvProperty* property = NULL;
    TBool propertyFound( EFalse );

    // Search property
    for ( TInt i = 0; i < iProperties.Count() && !propertyFound; i++ )
        {
        property = static_cast<TSensrvProperty*>( &iProperties[i] );

        // Compare property IDs
        if ( property->GetPropertyId() == aPropertyId )
            {
            // Correct property ID is found, now check is it array type of property.
            // Either array indexes must match or propertys array index has to be array info
            if ( ( property->GetArrayIndex() == aArrayIndex ) || 
                 ( ( property->GetArrayIndex() == ESensrvArrayPropertyInfo ) && 
                   ( ESensrvSingleProperty == aArrayIndex ) ) )
                {
                // Correct array index found
                propertyFound = ETrue;    
                }
            }
        }

    // Leave if not found
    if ( !propertyFound )
        {
        User::Leave( KErrNotFound );
        }

    aProperty = *property;

    COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceControl::FindPropertyL() - return" ) ) );
    }


// ---------------------------------------------------------------------------
// CSsyReferenceControl::FindChannel
// ---------------------------------------------------------------------------
//
CSsyReferenceChannel* CSsyReferenceControl::FindChannelL( TSensrvChannelId aChannelID )
    {
    COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceControl::FindChannel()" ) ) );
    
    if ( !iChannelArray )
        {
        User::Leave( KErrNotFound );
        }

    const TInt channelCount( iChannelArray->Count() );
    CSsyReferenceChannel* channel = NULL;

    // Check that there are channels
    if ( channelCount ) 
        {
        // Loop channels until correct channel is found
        for ( TInt i = 0; i < channelCount; i++ ) 
            {
            channel = iChannelArray->At( i );
            
            // Compare channel id
            if ( channel->ChannelId() == aChannelID )
                {
                // Channel found, no need to loop rest
                i = channelCount;
                }
            }
        }

    // Leave if channel is not found
    if ( !channel )
        {
        User::Leave( KErrNotFound );
        }

    COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceControl::FindChannel() - return" ) ) );
    return channel;
    }

// ---------------------------------------------------------------------------
// CSsyReferenceControl::OpenChannelL
// ---------------------------------------------------------------------------
//
void CSsyReferenceControl::OpenChannelL( TSensrvChannelId aChannelID )
    {
    COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceControl::OpenChannelL()" ) ) );
    // Find and open channel
    User::LeaveIfError( FindChannelL( aChannelID )->OpenChannel() );
    COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceControl::OpenChannelL() - return" ) ) );
    }

// ---------------------------------------------------------------------------
// CSsyReferenceControl::CloseChannelL
// ---------------------------------------------------------------------------
//
void CSsyReferenceControl::CloseChannelL( TSensrvChannelId aChannelID )
    {
    COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceControl::CloseChannelL()" ) ) );
    // Find and close channel
    User::LeaveIfError( FindChannelL( aChannelID )->CloseChannel() );
    COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceControl::CloseChannelL() - return" ) ) );
    }

// ---------------------------------------------------------------------------
// CSsyReferenceControl::ProcessResponse
// ---------------------------------------------------------------------------
//
void CSsyReferenceControl::ProcessResponse( TSsyReferenceMsg* /*aMessage*/ )
    {
    COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceControl::ProcessResponse()" ) ) );
    COMPONENT_TRACE( ( _L( "SSY Reference Plugin - CSsyReferenceControl::ProcessResponse() - return" ) ) );
    }