/*

* Copyright (c) 2008 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: Avkon testability hook class definitions.

*

*/

// INCLUDES

#include <AknTasHook.h>

#include <TasHookingInternalCRKeys.h>

#include "AknBatteryStrength.h"

#include "AknSignalStrength.h"

#include <centralrepository.h>

#include <AknTasPluginInterface.h>

#include <TasDataModelInterface.h>

// CONSTANTS

const TUid KUidTasHook =    { 0xE000DEC4 };

const TInt KTasHookingOff =   0;

const TInt KTasHookingOn =    1;

// MACROS

    /**

     * DEBUGPRINT

     * 

     * Simple wrapper macro for the RDebug::Print utility.

     *

     * Usage:

     * 

     *  DEBUGPRINT( ( _L( "CAknTasHook::ConstructL: Error %d in doing stuff" ), error ) )

     * 

     */

    #ifdef _DEBUG

    #define DEBUGPRINT( aFormatString ) { RDebug::Print aFormatString; }

    #else

    #define DEBUGPRINT( aFormatString ) {}

    #endif

// FORWARD DECLARATIONS

class CAknTasClassInfo;

class CAknTasObjectInfo;

// CLASS DEFINITIONS

CAknTasClassInfo::CAknTasClassInfo() :

    iClassName( NULL )

    {

    }

CAknTasClassInfo::~CAknTasClassInfo()

    {

    delete iClassName;

    }

void CAknTasClassInfo::ConstructL( TDesC& aClassName )

    {

    // Allocate a copy of the given descriptor and take ownership of it 

    iClassName = aClassName.AllocL();

    }

const TDesC& CAknTasClassInfo::GetClassName() const

    {

    return *iClassName;

    }

TInt CAknTasClassInfo::MatchName( 

    const CAknTasClassInfo& aInfo1, 

    const CAknTasClassInfo& aInfo2 )

    {

    if ( aInfo1.GetClassName() == aInfo2.GetClassName() )

        {

        return 1;

        }

    return 0;

    }

CAknTasObjectInfo::CAknTasObjectInfo()

    {    

    }

CAknTasObjectInfo::~CAknTasObjectInfo()

    {

    if ( iClassInfoArray )

        {        

        iClassInfoArray->ResetAndDestroy();

        delete iClassInfoArray;

        }

    }

void CAknTasObjectInfo::ConstructL( 

    TAny* aObjPtr, 

    TAknTasHookObjectType aObjType )

    {

    iObjPtr = aObjPtr; // not owned

    if ( aObjPtr )

        {

        iClassInfoArray = new ( ELeave ) RPointerArray<CAknTasClassInfo>; // owned

        iControlKey = TUint32( aObjPtr );

        iObjType = aObjType;

        }

    else

        {

        iControlKey = 0;

        }

    }

TInt CAknTasObjectInfo::MatchByControl(

    const CAknTasObjectInfo& aInfo1, 

    const CAknTasObjectInfo& aInfo2 )

    {

    if ( aInfo1.iControlKey == aInfo2.iControlKey )

        {

        return 1;

        }

    return 0;        

    }

void CAknTasObjectInfo::AddL( CAknTasClassInfo* aObjPtr )

    {

    iClassInfoArray->AppendL( aObjPtr );

    }

EXPORT_C TBool CAknTasObjectInfo::IsA( TPtrC aClassName )

    {

    CAknTasClassInfo* classInfo = NULL;

    TRAPD( err,

            classInfo = new ( ELeave ) CAknTasClassInfo();

            CleanupStack::PushL( classInfo );

            classInfo->ConstructL( aClassName );

            CleanupStack::Pop( classInfo ) );

    if ( err )

        {

        if ( classInfo )

            {

            CleanupStack::PopAndDestroy( classInfo );

            }

        return EFalse;

        }

    TIdentityRelation<CAknTasClassInfo> matcher( CAknTasClassInfo::MatchName );

    TInt position = iClassInfoArray->Find( classInfo, matcher );

    delete classInfo;

    if ( position != KErrNotFound )

        {        

        classInfo = ( *iClassInfoArray )[position];

        return ETrue;

        }        

    return EFalse;

    }

//

// Heap descriptor ownership passed to caller!

//

EXPORT_C HBufC* CAknTasObjectInfo::GetClassNames()

    {

    // Sum up the class name lengths and add room for the separators

    TInt bufLength( 0 );

    for ( TInt i = 0; i < iClassInfoArray->Count(); i++ )

        {

        bufLength += ( *iClassInfoArray )[i]->GetClassName().Length() + 1;

        }

    // Create a buffer of needed length and make it empty

    HBufC* buf = NULL;

    TRAPD( err, 

            buf = HBufC::NewLC( bufLength );

            CleanupStack::Pop( buf ) );

    if ( err )

        {

        return NULL;

        }

    TPtr modifiableBuf = buf->Des();

    modifiableBuf.Zero();

    if ( iClassInfoArray->Count() <= 0 )

        {

        return buf;

        }

    // Append class names and separators

    for ( TInt i = 0; i < iClassInfoArray->Count(); i++ )

        {

        modifiableBuf.Append( ( *iClassInfoArray )[i]->GetClassName() );

        if ( i + 1 < iClassInfoArray->Count() )

            {

            modifiableBuf.Append( _L( ":" ) );

            }

        }

    return buf;

    }

EXPORT_C TAny* CAknTasObjectInfo::GetControl() const

    {

    return iObjPtr;

    }

EXPORT_C TAknTasHookObjectType CAknTasObjectInfo::Type() const

    {

    return iObjType;

    }

CAknTasHook::CAknTasHook() :

    CCoeStatic( KUidTasHook ),

    iTasHookingEnabled( EFalse ),

    iTasHookStoringEnabled( EFalse )

    {    

    }

CAknTasHook* CAknTasHook::InstanceL()

    {

    CAknTasHook* instance = 

        static_cast<CAknTasHook*> ( CCoeEnv::Static( KUidTasHook ) );

    if ( !instance )

        {

        instance = new ( ELeave ) CAknTasHook();

        CleanupStack::PushL( instance );

        instance->ConstructL();

        CleanupStack::Pop( instance );

        }

    return instance;

    }

CAknTasHook* CAknTasHook::Self()

    {

    CAknTasHook* instance = 

        static_cast<CAknTasHook*> ( CCoeEnv::Static( KUidTasHook ) );

    if ( !instance )

        {

        return NULL;

        }

    return instance;

    }

CAknTasHook::~CAknTasHook()

    {

    delete iTasPlugin;

    REComSession::FinalClose();

    if ( iHookingNotifyHandler )

        {

        iHookingNotifyHandler->StopListening();

        delete iHookingNotifyHandler;

        }

    if ( iHookStoringNotifyHandler )

        {

        iHookStoringNotifyHandler->StopListening();

        delete iHookStoringNotifyHandler;

        }

    delete iTasHookingRepo;

    if ( iObjectInfoArray )

        {           

        iObjectInfoArray->ResetAndDestroy();

        delete iObjectInfoArray;

        }

    }

void CAknTasHook::ConstructL()

    {

    iObjectInfoArray = new ( ELeave ) RPointerArray<CAknTasObjectInfo>; // owned

    // Connect to TAS hooking CenRep repository

    TRAPD( error, iTasHookingRepo = CRepository::NewL( KCRUidTasHooking ) );

    if ( error != KErrNone )

        {

        DEBUGPRINT( ( _L( "   CAknTasHook::ConstructL: Error %d in connecting to key 0x%x" ), error, KCRUidTasHooking.iUid ) )

        User::Leave( error );

        }

    // Process the initial values and start listening 

    // for key changes in this repository

    TRAP( error, iHookingNotifyHandler = CreateNotifyHandlerL( *iTasHookingRepo, KTasHooking ) );

    if ( error != KErrNone )

        {

        DEBUGPRINT( ( _L( "   CAknTasHook::ConstructL: Error %d in creating CenRep notify handler" ), error ) )

        User::Leave( error );

        }

    TRAP( error, iHookingNotifyHandler->StartListeningL() );

    if ( error != KErrNone )

        {

        DEBUGPRINT( ( _L( "   CAknTasHook::ConstructL: Error %d in starting to listen" ), error ) )

        User::Leave( error );

        }

    TRAP( error, iHookStoringNotifyHandler = CreateNotifyHandlerL( *iTasHookingRepo, KTasHookStoring ) );

    if ( error != KErrNone )

        {

        DEBUGPRINT( ( _L( "   CAknTasHook::ConstructL: Error %d in creating CenRep notify handler" ), error ) )

        User::Leave( error );

        }

    TRAP( error, iHookStoringNotifyHandler->StartListeningL() );

    if ( error != KErrNone )

        {

        DEBUGPRINT( ( _L( "   CAknTasHook::ConstructL: Error %d in starting to listen" ), error ) )

        User::Leave( error );

        }

    }

CCenRepNotifyHandler* CAknTasHook::CreateNotifyHandlerL( 

    CRepository& aRepository, 

    TUint32 aKey )

    {

    // Process the initial value, the 1st notication is only received when the

    // value changes so we need to see if the hooking has already been activated

    TInt initialValue;

    TInt error = aRepository.Get( aKey, initialValue );

    if ( error != KErrNone )

        {

        DEBUGPRINT( ( _L( "   CAknTasHook::CreateNotifyHandlerL: Error %d in getting key value" ), error ) )

        User::Leave( error );

        }

    else

        {

        HandleNotifyInt( aKey, initialValue );

        }

    // Create a new notify handler for the given integer key

    return CCenRepNotifyHandler::NewL( *this, aRepository, CCenRepNotifyHandler::EIntKey, aKey );

    }

TBool CAknTasHook::Initialized()

    {

    if ( iObjectInfoArray )

        {

        return ETrue;

        }

    return EFalse;

    }

EXPORT_C void CAknTasHook::AddL( 

    TAny* aObjPtr, 

    TPtrC aStrPtr, 

    TAknTasHookObjectType aObjType )

    {

    if ( !aObjPtr )

        {

        return;

        }

    CAknTasHook* mePtr = InstanceL();   

    if ( mePtr )

        {

        mePtr->AddInfoL( aObjPtr, aStrPtr, aObjType );

        }

    }

void CAknTasHook::AddInfoL( 

    TAny* aObjPtr, 

    TPtrC aStrPtr, 

    TAknTasHookObjectType aObjType )

    {    

    if ( iTasHookStoringEnabled )

        {

        CAknTasObjectInfo* objInfo = new ( ELeave ) CAknTasObjectInfo();

        CleanupStack::PushL( objInfo );

        objInfo->ConstructL( aObjPtr, aObjType );

        CleanupStack::Pop( objInfo );

        CAknTasClassInfo* classInfo = new ( ELeave ) CAknTasClassInfo();

        CleanupStack::PushL( classInfo );

        classInfo->ConstructL( aStrPtr );

        CleanupStack::Pop( classInfo );

        if ( iObjectInfoArray->Count() <= 0 )

            {

            objInfo->AddL( classInfo );

            iObjectInfoArray->AppendL( objInfo );

            return;

            }

        TIdentityRelation<CAknTasObjectInfo> matcher( CAknTasObjectInfo::MatchByControl );

        TInt position = iObjectInfoArray->Find( objInfo, matcher );

        if ( position != KErrNotFound )

            {

            delete objInfo;

            objInfo = ( *iObjectInfoArray )[position];

            }

        else

            {

            iObjectInfoArray->AppendL( objInfo );

            }

        objInfo->AddL( classInfo );

        }

    }

EXPORT_C CAknTasObjectInfo* CAknTasHook::Get( TAny* aObjPtr )

    {

    CAknTasHook* mePtr = Self();

    if ( !mePtr->iTasHookingEnabled )

        {

        return NULL;

        }

    if ( mePtr )

        {

        return mePtr->GetInfo( aObjPtr );

        }

    return NULL;

    }

CAknTasObjectInfo* CAknTasHook::GetInfo( TAny* aObjPtr )

    {

    CAknTasObjectInfo* objInfo = NULL;

    TRAPD( err,

            objInfo = new ( ELeave ) CAknTasObjectInfo();

            CleanupStack::PushL( objInfo );

            objInfo->ConstructL( aObjPtr ) );

            CleanupStack::Pop( objInfo );

    if ( err )

        {

        if ( objInfo )

            {

            CleanupStack::PopAndDestroy( objInfo );

            }

        return NULL;

        }

    TIdentityRelation<CAknTasObjectInfo> matcher( CAknTasObjectInfo::MatchByControl );

    TInt position = iObjectInfoArray->Find( objInfo, matcher );

    delete objInfo;

    if ( position != KErrNotFound )

        {

        return ( *iObjectInfoArray )[position];

        }

    else

        {

        return NULL;

        }

    }

TBool CAknTasHook::ExistsL( TAny* aObjPtr )

    {    

    CAknTasHook* mePtr = InstanceL();

    return mePtr->InfoExistsL( aObjPtr );

    }

TBool CAknTasHook::InfoExistsL( TAny* aObjPtr )

    {

    if ( iObjectInfoArray->Count() <= 0 )

        {

        return EFalse;

        }

    CAknTasObjectInfo* objInfo = new ( ELeave ) CAknTasObjectInfo();

    CleanupStack::PushL( objInfo );

    objInfo->ConstructL( aObjPtr );

    CleanupStack::Pop( objInfo );

    TIdentityRelation<CAknTasObjectInfo> matcher( CAknTasObjectInfo::MatchByControl );

    TInt position = iObjectInfoArray->Find( objInfo, matcher );

    delete objInfo;

    if ( position != KErrNotFound )

        {

        return ETrue;

        }

    else

        {

        return EFalse;

        }    

    }

EXPORT_C void CAknTasHook::Remove( TAny* aObjPtr )

    {

    CAknTasHook* mePtr = Self();

    if ( mePtr )

        {

        TInt err( KErrNone );

        TRAP( err, mePtr->RemoveInfoL( aObjPtr ) );

        }

    }

void CAknTasHook::RemoveInfoL( TAny* aObjPtr )

    {

    if ( iTasHookStoringEnabled )

        {

        if ( iObjectInfoArray->Count() <= 0 )

            {

            return;

            }

        CAknTasObjectInfo* objInfo = new ( ELeave ) CAknTasObjectInfo();

        CleanupStack::PushL( objInfo );

        objInfo->ConstructL( aObjPtr );

        CleanupStack::Pop( objInfo );

        TIdentityRelation<CAknTasObjectInfo> matcher( CAknTasObjectInfo::MatchByControl );

        TInt position = iObjectInfoArray->Find( objInfo, matcher );

        delete objInfo;

        if ( position != KErrNotFound )

            {

            objInfo = ( *iObjectInfoArray )[position];

            iObjectInfoArray->Remove( position );

            delete objInfo;

            }

        }

    }

EXPORT_C RPointerArray<CAknTasObjectInfo>* CAknTasHook::GetAll()

    {

    if ( !iTasHookingEnabled )

        {

        return NULL;

        }

    return iObjectInfoArray;

    }

EXPORT_C void CAknTasHook::GetAknUiLC( MTasObject& aParentApplication )

    {

    if ( !iTasHookingEnabled )

        {

        return;

        }

    TInt numObjects = iObjectInfoArray->Count();

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

        {