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

// System includes
#include <e32base.h>
#include <bautils.h>
#include <e32property.h>
#include <eikapp.h>
#include <eikenv.h>
#include <vwsdef.h>
#include <akndef.h>

#include <digia/eunit/eunitmacros.h>
#include <digia/eunit/teunitassertioninfo.h>
#include <digia/eunit/eunitdecorators.h>

// User includes
#include "UT_IdleInt.h"
#include "caouserafter.h"
#include "aifweventhandler.h"

//#include <TelephonyInternalPSKeys.h>
#include <activeidle2domainpskeys.h>
#include <TelephonyDomainPSKeys.h>
#include <StartupDomainPSKeys.h>
#include <ctsydomainpskeys.h>
#define private public

// Tested classes
//#include "aifwphoneidlesynchronizer.h"
#include "aiuiidleintegration.h"
//#include "aifwphoneidlesynchronizerimpl.h"
#include "aistate.h"
#include "aiuiidleintegrationimpl.h"
#include "aiwspluginmanager.h"
#include "aiidleappregister.h"
#include "caipspropertyobserver.h"

class CNullEventHandler :
    public CBase,
    public MAiFwEventHandler
    {
public:
    // from MAiFwEventHandler
    void AppEnvReadyL()
        {
        };
    void HandleUiReadyEventL(CAiUiController& /*aUiController*/)
        {
        };

    void HandlePluginEvent(const TDesC& /*aParam*/)
        {
        };

    TBool HasMenuItem(const TDesC& /*aPluginName*/, const TDesC& /*aMenuItem*/)
        {
        	return ETrue;
        };

    void HandleUiLayoutChangeL(CAiUiController& /*aUiController*/)
        {
        };

    void HandleUiThemeChangeStartL(CAiUiController& /*aUiController*/)
        {
        };

    void HandleUiShutdown(CAiUiController& /*aUiController*/)
        {
        };

    void HandleAllPluginsLoaded()
        {
        };

    TBool RefreshContent(const TDesC& /*aContentCid*/)
        {
        	return ETrue;
        };    
        
    TBool RefreshContent( const THsPublisherInfo& /*aPublisherInfo*/, const TDesC& /*aContentCid*/ )
    {
    	return ETrue;
    };
    
    TBool SuspendContent( const THsPublisherInfo& /*aPublisherInfo*/, const TDesC& /*aContentCid*/ )
    {
    	return ETrue;
    };    

		/*
    void DestroyingPlugin( CAiContentPublisher& aPlugin )
        {
        };
		*/
		
    void CriticalStartupPhaseOver( TInt /*aStageInteger*/ )
        {
        };
    };
    
// CONSTRUCTION
UT_IdleInt* UT_IdleInt::NewL()
    {
    UT_IdleInt* self = UT_IdleInt::NewLC();
    CleanupStack::Pop();

    return self;
    }

UT_IdleInt* UT_IdleInt::NewLC()
    {
    UT_IdleInt* self = new( ELeave ) UT_IdleInt();
    CleanupStack::PushL( self );

    self->ConstructL();

    return self;
    }

// Destructor (virtual by CBase)
UT_IdleInt::~UT_IdleInt()
    {
    }

// Default constructor
UT_IdleInt::UT_IdleInt()
    {
    iPhoneStatusOwned = ETrue;
    iSystemStatusOwned = ETrue;
    iUiStartupStatusOwned = ETrue;
    }

// Second phase construct
void UT_IdleInt::ConstructL()
    {
    // The ConstructL from the base class CEUnitTestSuiteClass must be called.
    // It generates the test case table.
    CEUnitTestSuiteClass::ConstructL();
    }

//  METHODS

CPSPropertyObserver* UT_IdleInt::PSPropertyObserver( TUid aCategory, TInt aKey )
    {
    UT_IdleInt* self = reinterpret_cast<UT_IdleInt*>(Dll::Tls());
            
    if( aCategory == KPSUidCtsyCallInformation && aKey == KCTsyCallState )
        {        
        self->iPhoneStatusOwned = EFalse;
        return self->iPhoneStatusObserver;
        }
    else if( aCategory == KPSUidTelInformation && aKey == KTelPhoneUid )
        {        
        self->iPhoneStatusOwned = EFalse;
        return self->iPhoneStatusObserver;
        }
    else if( aCategory == KPSUidStartup && aKey == KPSGlobalSystemState )
        {
        self->iSystemStatusOwned = EFalse;
        return self->iSystemStatusObserver;
        }
    else if( aCategory == KPSUidStartup && aKey == KPSStartupUiPhase )
        {
        self->iUiStartupStatusOwned = EFalse;
        return self->iUiStartupStatusObserver;
        }
    else
        {
        return NULL;
        }
    }
    
void UT_IdleInt::KeySetTo( TInt aValue )
    {
    UT_IdleInt* self = reinterpret_cast<UT_IdleInt*>(Dll::Tls());
    self->iIdleStatus = aValue;
    }

void UT_IdleInt::SetupL(  )
    {
    iPhoneStatusObserver = CPSPropertyObserver::NewL(KPSUidAiInformation,
                                                     KActiveIdleUid);
    iSystemStatusObserver = CPSPropertyObserver::NewL(KPSUidStartup,
                                                      KPSGlobalSystemState);
    iUiStartupStatusObserver = CPSPropertyObserver::NewL(KPSUidStartup,
                                   KPSStartupUiPhase);

    iPhoneStatusObserver->SetOtherObserver( iSystemStatusObserver );
    iSystemStatusObserver->SetOtherObserver( iPhoneStatusObserver );
    iUiStartupStatusObserver->SetOtherObserver( iSystemStatusObserver );
    

    Dll::SetTls( this );
    TAiIdleKeySoundConfig config;
    config.iKeySounds = &iSoundSystemStub;
    iIdleInt = CAiUiIdleIntegrationImpl::NewL( *CEikonEnv::Static(), config, this );
    iState = CActiveIdleState::NewL();
    }

void UT_IdleInt::Teardown(  )
    {
    delete iState;
    delete iIdleInt;
    if( iPhoneStatusOwned )
        delete iPhoneStatusObserver;
    if( iSystemStatusOwned )
        delete iSystemStatusObserver;
    if( iUiStartupStatusOwned )
        delete iUiStartupStatusObserver;
    }

void UT_IdleInt::TestStartUpL()
    { 
    iIdleInt->ActivateUI();
    iSystemStatusObserver->DoEvent();
    TWsEvent event;
    event.SetType( KAknFullOrPartialForegroundGained );
    iIdleInt->HandleWsEventL( event, NULL );
    CAOUserAfter::AfterLD( 1000*1000 ); // wait a second for ps to update
//    EUNIT_ASSERT( iIdleStatus != 0 ); // assert we have foreground
                                      // means that status updated correctly

    event.SetType( KAknFullOrPartialForegroundGained );
    iIdleInt->HandleWsEventL( event, NULL );
    CAOUserAfter::AfterLD( 1000*1000 ); // wait a second for ps to update
//    EUNIT_ASSERT( iIdleStatus != 0 ); // assert we have foreground
                                      // means that status updated correctly
    
    event.SetType( KAknFullOrPartialForegroundLost );
    iIdleInt->HandleWsEventL( event, NULL );
    CAOUserAfter::AfterLD( 1000*1000 ); // wait a second for ps to update
//    EUNIT_ASSERT( iIdleStatus == 0 ); // assert we dont have foreground
                                      // means that status updated correctly

    event.SetType( KAknFullOrPartialForegroundLost );
    iIdleInt->HandleWsEventL( event, NULL );
    CAOUserAfter::AfterLD( 1000*1000 ); // wait a second for ps to update
//    EUNIT_ASSERT( iIdleStatus == 0 ); // assert we dont have foreground
                                      // means that status updated correctly
                
    iAiWsPluginManagerImpl = CAiWsPluginManager::NewL( *CCoeEnv::Static() );
      CAOUserAfter::AfterLD( 1000*1000 ); // wait a second for ps to update
      
    iAiIdleAppRegister = CAiIdleAppRegister::NewLC();
      CAOUserAfter::AfterLD( 1000*1000 ); // wait a second for ps to update
    
    iAiIdleAppRegister->RegisterL();
      CAOUserAfter::AfterLD( 1000*1000 ); // wait a second for ps to update

      if (iAiIdleAppRegister)
          {
          delete iAiIdleAppRegister;    
          iAiIdleAppRegister = NULL;    
          }
      
      if (iAiWsPluginManagerImpl)
          {
          delete iAiWsPluginManagerImpl;    
          iAiWsPluginManagerImpl = NULL;    
          }


    }    
    
void UT_IdleInt::TestIdleIntEventControlNullAndOthersL()
    {
    TWsEvent event;
    iIdleInt->HandleWsEventL( event, NULL );

    event.SetType( EEventWindowGroupsChanged );
    iIdleInt->HandleWsEventL( event, NULL );

    event.SetType( EEventFocusGroupChanged );
    iIdleInt->HandleWsEventL( event, NULL );

    event.SetType( EEventFocusGained );
    iIdleInt->HandleWsEventL( event, NULL );
    }
//  TEST TABLE

void UT_IdleInt::TestStateChangesL()
    {
    iState->SetIsIdleForeground( ETrue );
    CAOUserAfter::AfterLD( 1 * 500000 );
    iState->SetIsIdleForeground( EFalse );
    CAOUserAfter::AfterLD( 1 * 500000 );
    iState->SetIsIdleForeground( ETrue );
    CAOUserAfter::AfterLD( 1 * 500000 );
    iState->SetIsIdleForeground( EFalse );
    iState->SetIsIdleForeground( ETrue );
    iState->SetIsIdleForeground( EFalse );
    iState->SetIsIdleForeground( ETrue ); 
    iState->SetIsIdleForeground( EFalse );
    }

void UT_IdleInt::AppEnvReadyL()
    {
    }

void UT_IdleInt::HandleUiReadyEventL( CAiUiController& /*aUiController*/ )
    {
    }

void UT_IdleInt::HandlePluginEvent( const TDesC& /*aParam*/ )
    {
    }

TBool UT_IdleInt::HasMenuItem(const TDesC& /*aPluginName*/, const TDesC& /*aMenuItem*/)
    {
    return ETrue;
    }

void UT_IdleInt::HandleUiLayoutChangeL( CAiUiController& /*aUiController*/ )
    {
    }

void UT_IdleInt::HandleUiThemeChangeStartL( CAiUiController& /*aUiController*/ )
    {
    }

void UT_IdleInt::HandleUiShutdown( CAiUiController& /*aUiController*/ )
    {
    }

void UT_IdleInt::HandleAllPluginsLoaded()
    {
    }

void UT_IdleInt::HandleEnterEditMode()
    {
    }

void UT_IdleInt::HandleExitEditMode()
    {
    }

void UT_IdleInt::HandleUIChangeEventL()
    {
    }

void UT_IdleInt::HandleActivateUI()
    {
    }

void UT_IdleInt::HandleLoadPluginL( const THsPublisherInfo& /*aPublisherInfo*/ )
    {
    }

void UT_IdleInt::HandleDestroyPluginL( const THsPublisherInfo& /*aPublisherInfo*/ )
    {
    }

void UT_IdleInt::HandlePluginEventL( const THsPublisherInfo& /*aPublisherInfo*/, const TDesC& /*aParam*/ )
    {
    }

TBool UT_IdleInt::HasMenuItemL( const THsPublisherInfo& /*aPublisherInfo*/, const TDesC& /*aMenuItem*/ )
    {
    }

TBool UT_IdleInt::IsPluginsOnline()
    {
    return ETrue;
    }

void UT_IdleInt::SetPluginsOnlineStatus(TBool /*aStatus*/)
    {
    }

TBool UT_IdleInt::IsRoaming()
    {
    return ETrue;
    }

void UT_IdleInt::ShowRoamingNotificationL()
    {
    }

TBool UT_IdleInt::RefreshContent( const TDesC& /*aContentCid*/ )
    {
    return ETrue;
    }

TBool UT_IdleInt::RefreshContent( const THsPublisherInfo& /*aPublisherInfo*/, const TDesC& /*aContentCid*/ )
{
	return ETrue;
}
    
TBool UT_IdleInt::SuspendContent( const THsPublisherInfo& /*aPublisherInfo*/, const TDesC& /*aContentCid*/ )
{
	return ETrue;
};   
/*
void UT_IdleInt::DestroyingPlugin( CAiContentPublisher& aPlugin )
    {
    }
*/
void UT_IdleInt::CriticalStartupPhaseOver( TInt /*aStageInteger*/ )
    {
    }

TBool UT_IdleInt::QueryIsMenuOpen()
    {
    return ETrue;
    }

/*
void UT_IdleInt::ProcessStateChange( TAifwStates aState )
	{
	}
*/
/*
void UT_IdleInt::HandlePluginsOnlineStatus( 
    const RAiPublisherInfoArray& aPlugins,TBool aStatus )
    {
    }
*/
void UT_IdleInt::SetPluginsVisibility( TBool /*aStatus*/ )
    {
    }

void UT_IdleInt::ProcessOnlineState( TBool /*aOnline*/ )
    {
    }


EUNIT_BEGIN_TEST_TABLE(
    UT_IdleInt,
    "Unit test suite for class Active Idle Framework",
    "CAiFw" )

EUNIT_TEST(
    "Test IdleInt event control NULL",
    "CAiUiIdleIntegrationImpl",
    "",
    "FUNCTIONALITY",
    SetupL, TestIdleIntEventControlNullAndOthersL, Teardown)

EUNIT_TEST(
    "Test State changes",
    "CActiveIdleState",
    "",
    "FUNCTIONALITY",
    SetupL, TestStateChangesL, Teardown)

    /*
EUNIT_TEST(
    "Test Start Up",
    "CAiFwPhoneIdleSynchronizerImpl",
    "",
    "FUNCTIONALITY",
    SetupL, TestStartUpL, Teardown)   
*/

EUNIT_END_TEST_TABLE

//  END OF FILE