/*

* Copyright (c) 2007-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:  This is the actual Client API implementation.

* Part of:      Tactile Feedback.

*

*/

#include <eikenv.h>

#include <coecntrl.h>

#include <featmgr.h>

#include <AknUtils.h> 

#include <tactilefeedbacktrace.h>

#include <touchfeedbackspec.h>

#include "touchfeedbackimpl.h"

#include "touchfeedbackclient.h"

#include "touchfeedbackregistry.h"

#include "touchfeedbackclientpanic.h"

/**

 * This is the maximum number that can be used as feedback area identifier.

 * after this the values starting from 1 are taken into use again when

 * new areas are added. This also defines the maximum number of feedback

 * areas that one application can have.

 */

const TInt KTouchMaxFeedbackAreaIdentifier = 5000;

// ======== LOCAL FUNCTIONS ========

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

// Cleanup items for removing latest item from the given array. These are used

// for cleanup in case something leaves when we are adding new area

// to the registry.

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

//

void CleanupCacheArray( TAny* aPtr )

    {

    RArray<TControlCacheEntry>* array = 

        static_cast<RArray<TControlCacheEntry>*> ( aPtr );

    TInt index = array->Count() - 1;

    // If we are removing control from cache, then we have to clean the

    // associated area array also, or otherwise there will be a memory leak.

    (*array)[index].iAreaArray.Reset();

    (*array)[index].iAreaArray.Close();

    array->Remove( array->Count()-1 );        

    }

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

//

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

//

void CleanupAreaArray( TAny* aPtr )

    {

    RArray<TAreaIndexEntry>* array = 

        static_cast<RArray<TAreaIndexEntry>*> ( aPtr );

    array->Remove( array->Count()-1 );    

    }

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

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

// Constructor.

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

//

CTouchFeedbackImpl::CTouchFeedbackImpl() :

    iAudioEnabledForThisApp( ETrue ), 

    iVibraEnabledForThisApp( ETrue )

    {

    }

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

// We check first if Tactile Feedback feature is supported in this device

// and only construct the iClient -member in case needed. We thus use 

// the existence of iClient as feature check in other API functions.

//

// This also means that iClient member needs to be checked in all the API

// functions, so that we won't cause a KERN-EXEC 3 by trying to access

// a NULL pointer in case the feature is disabled.

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

//

void CTouchFeedbackImpl::ConstructL()

    { 

    TRACE("CTouchFeedbackImpl::ConstructL - Begin");

    // Check if the whole Tactile Feedback feature is supported or not

    // Initialize feature manager, just in case we happen to be the first

    // one using it in this thread.

    FeatureManager::InitializeLibL();

    TBool featureSupported =

        FeatureManager::FeatureSupported( KFeatureIdTactileFeedback );

    // We don't need feature manager anymore, as it is not possible

    // to change this feature on/off at run-time

    FeatureManager::UnInitializeLib();

    // Only create client in case feature is supported

    if ( featureSupported )

        {

        iClient = CTouchFeedbackClient::NewL( *this );

        }

    else

        {

        TRACE("Tactile Feedback feature is not supported");

        }

    // Check if pen usage is enabled. We use this information later for

    // disabling area registry -based feedback in case pen usage is not

    // enabled.    

    iPenEnabled = AknLayoutUtils::PenEnabled();

    TRACE3("CTouchFeedbackImpl::ConstructL - End, feature supported = %d, pen Enabled: %d", featureSupported, iPenEnabled);

    }

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

// We cannot afford to leave here (at least for the moment), because

// in that case the whole system won't boot up. Constructing of the

// client (in ConstructL) will fail if click plugin is not configured in

// WSINI.INI file, and that can happen very easily at least in the beginning

// when this is a new feature. Thus we TRAP any leaves here.

//

// This also means that iClient member needs to be checked in all the API

// functions. We will also use this for recognizing the situation when

// touch feedback is not supported (in that case we won't even try to

// instantiate the client).

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

//

CTouchFeedbackImpl* CTouchFeedbackImpl::New()

    {

    CTouchFeedbackImpl* self = new CTouchFeedbackImpl;

    if ( self )

        {

        TRAP_IGNORE( self->ConstructL() );    

        }    

    return self;

    }

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

// Destructor.

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

//

CTouchFeedbackImpl::~CTouchFeedbackImpl()

    {

    TRACE("CTouchFeedbackImpl::~CTouchFeedbackImpl");

    delete iClient;

    TInt i = 0;

    for ( i=0; i < iRegistryArray.Count(); i++ )

        {

        delete iRegistryArray[i];

        }

    for ( i=iControlCache.Count()-1; i >= 0; i-- )

        {

        RemoveControlFromCache( i );

        }

    iRegistryArray.Close();

    iControlCache.Close();

    }

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

// We return ETrue if iClient exist, because instantiation of the client is

// not done in case the feature is not enabled. And on the other hand if 

// instantiation of client fails, then using of feedback is not possible

// anyway.

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

//

TBool CTouchFeedbackImpl::TouchFeedbackSupported()

    {

    if ( iClient )

        {

        return ETrue;        

        }

    else

        {

        return EFalse;

        }

    }

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

// Store the current status of feedback for this application, and

// notify server of the change.

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

//

void CTouchFeedbackImpl::SetFeedbackEnabledForThisApp( TBool aEnabled )

    {

    TRACE2( "CTouchFeedbackImpl::SetFeedbackEnabledForThisApp %d", aEnabled );

    // Only notify server when enabled value really changes.

    if ( iClient && 

       (( aEnabled != iAudioEnabledForThisApp ) || 

         (aEnabled != iVibraEnabledForThisApp ) ))

        {

        iClient->RegistryChanged();        

        }

    iAudioEnabledForThisApp = aEnabled;      

    iVibraEnabledForThisApp = aEnabled;      

    }

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

// Here we just return the current status.

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

//

TBool CTouchFeedbackImpl::FeedbackEnabledForThisApp() 

    {

    return iAudioEnabledForThisApp || iVibraEnabledForThisApp;

    }

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

// This functions main purpose is to do all possible parameter checks to

// the arguments before actually setting the area.

// 

// #1 Check that feedback is enabled

// #2 Check that we weren't given a NULL pointer as control.

// #3 Check that feedback type and pointer event are supported

// #4 Check that we can generate a client handle from the control

//    (if not, then there is something wrong with given control)

// #5 Call overridden method SetFeedbackArea for actually setting the 

//    feedback area.

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

//

TInt CTouchFeedbackImpl::SetFeedbackArea( 

    const CCoeControl* aControl, 

    TUint32 aIndex, 

    TRect aRect, 

    TTouchLogicalFeedback aFeedbackType, 

    TTouchEventType aEventType )

    {

    TRACE("CTouchFeedbackImpl::SetFeedbackArea - Begin");

    // #1

    if ( !iClient )

        {

        return KErrNone;

        }

    // #2

    if ( !aControl )

        {

        TRACE("CTouchFeedbackImpl::SetFeedbackArea - Err: NULL Control");

        return KErrArgument;

        }

    // #3    

    if ( aFeedbackType > ETouchFeedbackSensitive || 

        ( aEventType!= ETouchEventStylusDown ) )

        {

        TRACE("CTouchFeedbackImpl::SetFeedbackArea - Err: Unsupported params");

        return KErrNotSupported;

        }

    // #4        

    TUint32 clientHandle = ClientHandle( aControl );

    if ( !clientHandle )

        {

        TRACE("CTouchFeedbackImpl::SetFeedbackArea - Err: Invalid Control");        

        return KErrArgument;

        }

    // #5    

    TInt err(KErrGeneral);

    CFeedbackSpec* spec = CFeedbackSpec::New();

    if (spec)

        {

        spec->AddFeedback(aEventType, aFeedbackType);

        err = SetFeedbackArea(aControl, aIndex, aRect, spec);

        delete spec;

        spec = NULL;

        }

    TRACE2("CTouchFeedbackImpl::SetFeedbackArea - End, err = %d", err );

    return err;    

    }

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

// Here we remove the given area from registry. 

//

// We still keep the control in the registry even if would have no areas,

// because otherwise we'll lose feedback disabled/enabled information.

//

// #1 First check that given area is actually found

// #2 Find corresponsing registry entry

// #3 Remove feedback area entry from control cache

// #4 Finally remove the actual area from registry, and notify server

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

//

void CTouchFeedbackImpl::RemoveFeedbackArea( 

    const CCoeControl* aControl, 

    TUint32 aIndex )

    {

    TRACE3( "CTouchFeedbackImpl::RemoveFeedbackArea: 0x%x, %d", aControl, aIndex );

    if ( iClient )

        {

        TInt cacheIndex = KErrNotFound;

        TInt areaIndex = KErrNotFound;

        FindAreaFromCache( aControl, aIndex, cacheIndex, areaIndex );

        // #1 Only do something in case the area was found

        if ( cacheIndex >=0 && areaIndex >= 0 )

            {

            // #2

            TInt registryIndex = FindWindowFromRegistry ( 

                iControlCache[cacheIndex].iClientHandle );

            TInt areaId = 

                iControlCache[cacheIndex].iAreaArray[areaIndex].iAreaId;

            // #3 Remove this feedback area entry

            iControlCache[cacheIndex].iAreaArray.Remove( areaIndex );

            iNbOfFeedbackAreas--;

            // #4 Remove the area from registry

            if ( registryIndex != KErrNotFound )

                {

                iRegistryArray[registryIndex]->RemoveFeedbackArea( areaId );

                iClient->RegistryChanged();

                }        

            }

        }

    }

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

// Here we return all areas related to given control.

//

// #1 Only do something in case the control is found from cache

// #2 Find corresponding registry index.

// #3 Remove all feedback areas from the registry.

// #4 Remove the control from cache

// #5 Notify server, if some areas were really removed.

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

//

void CTouchFeedbackImpl::RemoveFeedbackForControl( 

    const CCoeControl* aControl )

    {

    TRACE2("CTouchFeedbackImpl::RemoveFeedbackForControl: 0x%x", aControl);

    if ( iClient )

        {

        TInt controlIndex = FindControlFromCache( aControl );

        // #1

        if ( controlIndex >= 0 ) // If control was found

            {

            TBool changesMade = EFalse;

            TControlCacheEntry& entry( iControlCache[controlIndex] );

            // #2

            TInt registryIndex = 

                FindWindowFromRegistry( entry.iClientHandle );

            // #3 If registry entry was found, then remove all feedback

            // areas.

            if ( registryIndex >= 0) 

                {

                for ( TInt i=0; i < entry.iAreaArray.Count(); i++ )

                    {

                    iRegistryArray[registryIndex]->

                            RemoveFeedbackArea( 

                            entry.iAreaArray[i].iAreaId );

                    changesMade = ETrue;   

                    iNbOfFeedbackAreas--;     

                    }

                }

            // #4 Anyway remove controls feedback areas from cache

            RemoveControlFromCache( controlIndex );

            // #5 Notify server of changes

            if ( changesMade )

                {

                iClient->RegistryChanged();

                }

            }        

        }

    }

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

// Here we change the rectangle of existing feedback area.

//

// #1 Only do something in case the area is really found.

// #2 Find corresponding registry entry

// #3 If the entry was found, then change the feedback area

// #4 Only notify the server when the area really changed

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

//

void CTouchFeedbackImpl::ChangeFeedbackArea( const CCoeControl* aControl,

                                             TUint32 aIndex, 

                                             TRect aNewRect )

    {

    TRACE( "CTouchFeedbackImpl::ChangeFeedbackArea: 0x%x" );

    if ( iClient )

        {

        TInt cacheIndex = KErrNotFound;

        TInt areaIndex  = KErrNotFound;

        FindAreaFromCache( aControl, aIndex, cacheIndex, areaIndex );

        // #1

        if ( cacheIndex >= 0 && areaIndex >= 0 )

            {

            TInt id = 

                iControlCache[cacheIndex].iAreaArray[areaIndex].iAreaId;

            // #2 

            TInt registryIndex = 

                FindWindowFromRegistry ( 

                    iControlCache[cacheIndex].iClientHandle );

            // #3

            if ( registryIndex != KErrNotFound )

                {

                TBool changed = 

                    iRegistryArray[registryIndex]->ChangeFeedbackArea( 

                        id, 

                        aNewRect );

                // #4 Only send upates to server when something 

                //    really changed.

                if ( changed )

                    {

                    iClient->RegistryChanged();                

                    }

                }           

            }        

        }

    }

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

// Here we change the feedback type of existing feedback area.

//

// #1 Only do something in case the area is really found.

// #2 Find corresponding registry entry

// #3 If the entry was found, then change the feedback area

// #4 Only notify the server when the feedback type really changed

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

//

void CTouchFeedbackImpl::ChangeFeedbackType( const CCoeControl* aControl,

                                             TUint32 aIndex, 

                                             TTouchLogicalFeedback aNewType )

    {

    TRACE4("CTouchFeedbackImpl::ChangeFeedbackType: 0x%x, %d, %d", aControl, aIndex, aNewType);

    if ( iClient )

        {

        TInt cacheIndex = KErrNotFound;

        TInt areaIndex  = KErrNotFound;

        FindAreaFromCache( aControl, aIndex, cacheIndex, areaIndex );

        // #1

        if ( cacheIndex >= 0 && areaIndex >= 0 )

            {

            TInt id = iControlCache[cacheIndex].iAreaArray[areaIndex].iAreaId;

            // #2

            TInt registryIndex = 

                FindWindowFromRegistry ( 

                    iControlCache[cacheIndex].iClientHandle );

            // #3

            if ( registryIndex != KErrNotFound )

                {

                TBool changed = 

                    iRegistryArray[registryIndex]->ChangeFeedbackType( 

                        id, 

                        aNewType,

                        // Feedback type change for up event is not supported 

                        // by this function.

                        static_cast<TTouchLogicalFeedback>( 0xFFFFFFFF ) );

                // #4 Only send upates to server when something 

                //    really changed.

                if ( changed )

                    {

                    iClient->RegistryChanged();                

                    }

                }           

            }        

        }

    }    

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

// Here we change move the given feedback area to first priority, so that

// it will be the topmost in its window.

//

// #1 Only do something in case the area is really found.

// #2 Find corresponding registry entry

// #3 If the entry was found, then change the feedback area

// #4 Only notify the server when the move was successfull

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

//

void CTouchFeedbackImpl::MoveFeedbackAreaToFirstPriority( 

    const CCoeControl* aControl, 

    TUint32 aIndex )

    {

    if ( iClient )

        {