/*
* Copyright (c) 2006-2007 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:  Idle integration
*
*/


// System includes
#include <startupdomainpskeys.h>
#include <coeaui.h>
#include <eikenv.h>
#include <AknIncallBubbleNotify.h>
#include <aknsoundsystem.h>
#include <AknDef.h>
#include <ctsydomainpskeys.h>
#include <apgtask.h>


// User includes
#include <aisystemuids.hrh>
#include <aiutility.h>
#include <aipspropertyobserver.h>
#include "activeidle2domainpskeys.h"
#include "aiuiidleintegrationimpl.h"
#include "aifweventhandler.h"
#include "aistate.h"
#include "aifwpanic.h"
#include "debug.h"


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

// ----------------------------------------------------------------------------
// CAiUiIdleIntegrationImpl::NewL()
// ----------------------------------------------------------------------------
//
CAiUiIdleIntegrationImpl* CAiUiIdleIntegrationImpl::NewL( CEikonEnv& aEikEnv,         
    const TAiIdleKeySoundConfig& aKeySoundConfig,
    MAiFwEventHandler* aAiFwEventHandler )
    {
    CAiUiIdleIntegrationImpl* self = 
        new ( ELeave ) CAiUiIdleIntegrationImpl( aEikEnv, aAiFwEventHandler );
                                              
    CleanupStack::PushL( self );
    self->ConstructL( aKeySoundConfig );
    CleanupStack::Pop( self );
    return self;
    }

// ----------------------------------------------------------------------------
// CAiUiIdleIntegrationImpl::~CAiUiIdleIntegrationImpl()
// ----------------------------------------------------------------------------
//
CAiUiIdleIntegrationImpl::~CAiUiIdleIntegrationImpl()
    {
    delete iActiveIdleState;
    
    delete iIncallBubble;
    
    Release( iCallStatusObserver );       
    
    Release( iUiStartupStateObserver );
    }

// ----------------------------------------------------------------------------
// CAiUiIdleIntegrationImpl::CAiUiIdleIntegrationImpl()
// ----------------------------------------------------------------------------
//
CAiUiIdleIntegrationImpl::CAiUiIdleIntegrationImpl( CEikonEnv& aEikEnv,
    MAiFwEventHandler* aAiFwEventHandler )
    : iEikEnv( aEikEnv ),
      iAiFwEventHandler( aAiFwEventHandler )
    {
    }

// ----------------------------------------------------------------------------
// CAiUiIdleIntegrationImpl::ConstructL()
// ----------------------------------------------------------------------------
//
void CAiUiIdleIntegrationImpl::ConstructL(
    const TAiIdleKeySoundConfig& aKeySoundConfig )       
    {   
    __PRINTS( "*** CAiUiIdleIntegrationImpl::ConstructL" );
    __TIME_MARK( time );
    
	iIncallBubble = CAknIncallBubble::NewL();
	
    iActiveIdleState = CActiveIdleState::NewL();
           
    // Set up keysounds
    if( aKeySoundConfig.iKeySounds )
        {
        aKeySoundConfig.iKeySounds->PushContextL( 
            aKeySoundConfig.iContextResId );                       
        }
    
    iEikEnv.SetSystem( ETrue );
             
    RWindowGroup& windowGroup = iEikEnv.RootWin();
    windowGroup.AutoForeground(EFalse);
    TInt wgId( windowGroup.Identifier() );
    TInt focusWgId( iEikEnv.WsSession().GetFocusWindowGroup() );
    
    if ( focusWgId == wgId )
        {
        __PRINTS( "*** CAiUiIdleIntegrationImpl::ConstructL - iForeground: 1" );
    
        iForeground = ETrue;
        }
    
    iActiveIdleState->SetIsIdleForeground( iForeground );
      
    iCallStatusObserver = AiUtility::CreatePSPropertyObserverL(          
                            TCallBack( HandleCallEvent, this ),  
                                       KPSUidCtsyCallInformation, 
                                       KCTsyCallState );  
    
    iUiStartupStateObserver = AiUtility::CreatePSPropertyObserverL(                           
                                TCallBack( HandleUiStartupStateChange, this ),            
                                           KPSUidStartup, 
                                           KPSStartupUiPhase );        
    
    HandleUiStartupStateChange( this );
                 
    __TIME_ENDMARK( "CAiUiIdleIntegrationImpl::ConstructL, done", time );
    }

// ----------------------------------------------------------------------------
// CAiUiIdleIntegrationImpl::ActivateUI()
// ----------------------------------------------------------------------------
//
void CAiUiIdleIntegrationImpl::ActivateUI()
    {   
    __TICK( "CAiUiIdleIntegrationImpl::ActivateUI" );
    
    Release( iUiStartupStateObserver );
    iUiStartupStateObserver = NULL;
    
    iAiFwEventHandler->HandleActivateUI();
    
    RWsSession& wsSession( iEikEnv.WsSession() );
    
    TApaTaskList taskList( wsSession );
    
    TApaTask task( taskList.FindApp( TUid::Uid( AI_UID3_AIFW_EXE ) ) );
    
    task.BringToForeground(); 
        
    __PRINTS( "*** CAiUiIdleIntegrationImpl::ActivateUI - done" );    
    }

// ----------------------------------------------------------------------------
// CAiUiIdleIntegrationImpl::HandleWsEventL()
// ----------------------------------------------------------------------------
//
void CAiUiIdleIntegrationImpl::HandleWsEventL( const TWsEvent& aEvent, 
    CCoeControl* /*aDestination*/ )
    {
    TInt type( aEvent.Type() );
    
    if ( type == KAknFullOrPartialForegroundGained )
        {
        __PRINTS( "*** CAiUiIdleIntegrationImpl::HandleWsEventL - Foreground" );
        
        if ( !iForeground )
            {
            iForeground = ETrue;
            iActiveIdleState->SetIsIdleForeground( ETrue );
            SetCallBubbleIfNeededL();
            }    
        }
    else if ( type == KAknFullOrPartialForegroundLost )
        {
        __PRINTS( "*** CAiUiIdleIntegrationImpl::HandleWsEventL - Background" );
    
        if ( iForeground )
            {
            iForeground = EFalse;
            iActiveIdleState->SetIsIdleForeground( EFalse );
            ClearCallBubbleL();
            }    
        }
    else if ( type == EEventKeyDown )
        {
        if( aEvent.Key()->iScanCode == EStdKeyDevice0 )
            {
            TBool isDialog( iEikEnv.AppUi()->IsDisplayingMenuOrDialog() );
            
            if( isDialog || iAiFwEventHandler->QueryIsMenuOpen() )
                {
                RProperty::Set(
                    KPSUidAiInformation, 
                    KActiveIdlePopupState, 
                    EPSAiDisplayingMenuOrDialog );
                }
            else
                {
                RProperty::Set(
                    KPSUidAiInformation, 
                    KActiveIdlePopupState, 
                    EPSAiNotDisplayingMenuOrDialog );
                }    
            }
        }        
    }

// ----------------------------------------------------------------------------
// CAiUiIdleIntegrationImpl::SetCallBubbleIfNeededL()
// ----------------------------------------------------------------------------
//
void CAiUiIdleIntegrationImpl::SetCallBubbleIfNeededL()
	{
    if( !iIncallBubbleAllowed )
    	{
        TInt callStatus( 0 );
            	
        TInt err( RProperty::Get( KPSUidCtsyCallInformation,
                                  KCTsyCallState,
                                  callStatus ) );
        
        // Call ongoing => show bubble
	  	if( err == KErrNone && callStatus > EPSCTsyCallStateNone )
	      	{
	       	iIncallBubble->SetIncallBubbleAllowedInIdleL( ETrue );                	
	       	iIncallBubbleAllowed = ETrue;
	       	}    
    	}
	}

// ----------------------------------------------------------------------------
// CAiUiIdleIntegrationImpl::ClearCallBubbleL()
// ----------------------------------------------------------------------------
//
void CAiUiIdleIntegrationImpl::ClearCallBubbleL()
	{
	 if( iIncallBubbleAllowed )
    	{
    	iIncallBubble->SetIncallBubbleAllowedInIdleL( EFalse );
    	iIncallBubbleAllowed = EFalse;
    	}        
	}
    
// ----------------------------------------------------------------------------
// CAiUiIdleIntegration::NewL()
// ----------------------------------------------------------------------------
//
EXPORT_C CAiUiIdleIntegration* CAiUiIdleIntegration::NewL( CEikonEnv& aEikEnv, 
    const TAiIdleKeySoundConfig& aKeySoundConfig,
    MAiFwEventHandler* aAiFwEventHandler )
    {
    return CAiUiIdleIntegrationImpl::NewL( aEikEnv, aKeySoundConfig,                                             
                                           aAiFwEventHandler );
    }

// ----------------------------------------------------------------------------
// CAiUiIdleIntegrationImpl::HandleCallEvent()
// ----------------------------------------------------------------------------
//
TInt CAiUiIdleIntegrationImpl::HandleCallEvent( TAny* aPtr )
	{
	__ASSERT_DEBUG( aPtr, 
        AiFwPanic::Panic( AiFwPanic::EAiFwPanic_NullPointerReference ) );
    
	CAiUiIdleIntegrationImpl* self = 
        static_cast< CAiUiIdleIntegrationImpl* >( aPtr );
        
	TInt callStatus( EPSCTsyCallStateNone );
	
	TInt err( self->iCallStatusObserver->Get( callStatus ) );
	
	if ( err == KErrNone )
		{
		// Call ongoing => show bubble if not showing already
		TBool allowed = EFalse;
		
		if ( !self->iIncallBubbleAllowed &&
		     self->iForeground &&
		    ( callStatus > EPSCTsyCallStateNone ) )
			{
			allowed = ETrue;
    		
			TRAP( err, 
                self->iIncallBubble->SetIncallBubbleAllowedInIdleL( allowed ) );
			            		
			if ( err == KErrNone )
    		    {
    			self->iIncallBubbleAllowed = allowed;
    		    }
			}
		// No call ongoing => hide if bubble is visible			
		else if ( self->iIncallBubbleAllowed && callStatus <= EPSCTsyCallStateNone )
			{
			allowed = EFalse;
			
    		TRAP( err, 
                self->iIncallBubble->SetIncallBubbleAllowedInIdleL( allowed ) );
    		
    		if ( err == KErrNone )
    		    {
    			self->iIncallBubbleAllowed = allowed;
    		    }
			}
		}
	
	return err;
	}

// ----------------------------------------------------------------------------
// CAiUiIdleIntegrationImpl::HandleUiStartupStateChange()
// ----------------------------------------------------------------------------
//
TInt CAiUiIdleIntegrationImpl::HandleUiStartupStateChange( TAny *aPtr )
    {
    __ASSERT_DEBUG( aPtr, 
        AiFwPanic::Panic( AiFwPanic::EAiFwPanic_NullPointerReference ) );
    
    CAiUiIdleIntegrationImpl* self = 
        static_cast< CAiUiIdleIntegrationImpl* >( aPtr );

    if ( !self->iUiStartupPhaseOk )
        {
        TInt state( 0 );
        
        self->iUiStartupStateObserver->Get( state );
        
        if ( state == EStartupUiPhaseAllDone )
            {
            self->iUiStartupPhaseOk = ETrue;
            
            self->ActivateUI();                        
            }
        }
    
    return KErrNone;
    }

// End of file