/*

* 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 internal publisher for system owned status pane data.

*

*/

// INCLUDE FILES

#include "aknstatuspanedatapublisher.h"

#include <aknglobalpopupprioritycontroller.h>

#include "aknstatuspanedata.h"

#include "avkoninternalpskeys.h"

#include <e32property.h>

#include <AknIndicator.h>

#include <avkon.rsg>

#include <AknStatuspaneUtils.h>

#include <AknUtils.h>

#include <AknIndicatorPlugin.h>

#include <AknIndicatorPluginImplUIDs.hrh>

#include <AknPreviewPopUpController.h>

#include <eikenv.h>

#include <gulicon.h>

#include "aknindicatorpopup.h"

#include <layoutmetadata.cdl.h>

#include <coreapplicationuisdomainpskeys.h> // KCoreAppUIsAutolockStatus

#include <aknlayoutscalable_avkon.cdl.h>

// CONSTANTS

const TUint KEmpty              = 0xFFFFFFFF;

const TInt KNoIndicatorPriority = 0xFFFF;

const TInt KIndicTextBufferSize = 128;

const TInt KAknSignalLength     = EAknSignalCommonPacketDataIndicatorOff - EAknSignalGprsIndicatorOff;

class CAknStatusPanePublisherData : public CBase

	{

public:

    CAknStatusPanePublisherData():iDisabledByInput( EFalse ), iDisabledByPopup( EFalse ),

        iCoeEnv( NULL ),iProcessList(5){};

    ~CAknStatusPanePublisherData(){ iProcessList.Close(); };

public:

	TAknStatusPaneStateData iData;

	TBool iDisabledByInput;

	TBool iDisabledByPopup;

	CCoeEnv* iCoeEnv;

	RArray<TUint64> iProcessList;

    };

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

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

// CAknStatusPaneDataPublisher::NewL

// (other items were commented in a header).

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

//

EXPORT_C CAknStatusPaneDataPublisher* CAknStatusPaneDataPublisher::NewL()

	{

	CAknStatusPaneDataPublisher* self =

		new (ELeave) CAknStatusPaneDataPublisher();

  	CleanupStack::PushL( self );

  	self->ConstructL();

  	CleanupStack::Pop( self );

  	return self;

	}

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

// CAknStatusPaneDataPublisher::ConstructL

// (other items were commented in a header).

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

//

void CAknStatusPaneDataPublisher::ConstructL()

	{

	User::LeaveIfError( RProperty::Define( KPSUidAvkonInternal,

		                                   KAknStatusPaneSystemData,

		                                   RProperty::EByteArray ) );

 	User::LeaveIfError( iProperty.Attach( KPSUidAvkonInternal,

 		                                  KAknStatusPaneSystemData ) );

	iStatusPaneStateData = new (ELeave) CAknStatusPanePublisherData();

	ClearIndicatorStates();

	iPopup = CAknIndicatorPopup::NewL();

	iPopup->SetObserverL( *this );

	// Get a handle to the P&S property containing Autolock state.

	iAutolockStateProperty.Attach( KPSUidCoreApplicationUIs,

                                   KCoreAppUIsAutolockStatus );

	}

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

// CAknStatusPaneDataPublisher::CAknStatusPaneDataPublisher

// C++ default constructor can NOT contain any code, that

// might leave.

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

//

CAknStatusPaneDataPublisher::CAknStatusPaneDataPublisher()

	{

  	}

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

// Destructor

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

//

CAknStatusPaneDataPublisher::~CAknStatusPaneDataPublisher()

	{

	iProperty.Close();

	TInt count = iIndicators.Count();

	TBool pluginDeleted = EFalse;

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

	  	{

        if ( AknLayoutUtils::PenEnabled() && iIndicators[i].iPluginLoaded )

            {

            iIndicators[i].iPluginLoaded = EFalse;

            delete iIndicators[i].iPlugin;

			pluginDeleted = ETrue;

	  		}

		}

	if ( pluginDeleted )

		{

    	REComSession::FinalClose();

		}

	iIndicators.Close();

	delete iStatusPaneStateData;

	if ( iPopup )

        {

        iPopup->RemoveObserver( *this );

        }

	delete iPopup;

	iAutolockStateProperty.Close();

  	}

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

// CAknStatusPaneDataPublisher::PublishUpdateL

// (other items were commented in a header).

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

//

EXPORT_C void CAknStatusPaneDataPublisher::PublishDataL()

	{

	// check if the bubble is disabled by either popup or input

	if ( iStatusPaneStateData->iDisabledByPopup

	    || iStatusPaneStateData->iDisabledByInput )

	    {

	    iStatusPaneStateData->iData.iIndicatorState.iIncallBubbleDisabled = ETrue;

	    }

	else

	    {

	    iStatusPaneStateData->iData.iIndicatorState.iIncallBubbleDisabled = EFalse;

	    }

	TAknStatusPaneStateData::TAknStatusPaneStateDataPckg

		statusPaneStateDataPckg( iStatusPaneStateData->iData );

	iProperty.Set( statusPaneStateDataPckg );

	}

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

// CAknStatusPaneDataPublisher::SetForegroundSubscriberId

// (other items were commented in a header).

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

//

EXPORT_C void CAknStatusPaneDataPublisher::SetForegroundSubscriberId( TInt aId )

	{

	if ( iStatusPaneStateData->iData.iForegroundSubscriberId != aId &&

	     iPopup )

	    {

	    // Hide the indicator popup if it's visible when an

	    // applications loses foreground,

	    iPopup->HidePopup();

	    }

	iStatusPaneStateData->iData.iForegroundSubscriberId = aId;

	}

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

// CAknStatusPaneDataPublisher::SetBatteryLevel

// (other items were commented in a header).

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

//

EXPORT_C void CAknStatusPaneDataPublisher::SetBatteryLevel( TInt aLevel )

	{

	iStatusPaneStateData->iData.iBatteryState.iBatteryStrength = aLevel;

	}

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

// CAknStatusPaneDataPublisher::SetRecharge

// (other items were commented in a header).

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

//

EXPORT_C void CAknStatusPaneDataPublisher::SetRecharge( TBool aRecharging )

	{

	iStatusPaneStateData->iData.iBatteryState.iRecharging = aRecharging;

	}

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

// CAknStatusPaneDataPublisher::SetSignalLevel

// (other items were commented in a header).

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

//

EXPORT_C void CAknStatusPaneDataPublisher::SetSignalLevel( TInt aLevel )

	{

	iStatusPaneStateData->iData.iSignalState.iSignalStrength = aLevel;

	}

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

// CAknStatusPaneDataPublisher::SetSignalIcon

// (other items were commented in a header).

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

//

EXPORT_C void CAknStatusPaneDataPublisher::SetSignalIcon( TInt aIcon )

	{

	TBool iconChanged( ETrue );

	if ( !( aIcon % KAknSignalLength ) ) // Signal off state

        {

        // If the off state signal type is not the same type signal as

        // the currently active one, no need to change signal.

        // This is done to filter out unnecessary signal state changes

        // sent by SysAp, since the icon for off state of all signal types

        // is the same.

        iconChanged = aIcon / KAknSignalLength ==

        	iStatusPaneStateData->iData.iSignalState.iIconState / KAknSignalLength;

        }

	if ( iconChanged )

		{

		iStatusPaneStateData->iData.iSignalState.iIconState = aIcon;

		}

	}

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

// CAknStatusPaneDataPublisher::SetIncallBubbleFlags

// (other items were commented in a header).

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

//

EXPORT_C void CAknStatusPaneDataPublisher::SetIncallBubbleFlags( TInt aFlags )

	{

	// if the flag is ESBTouchInput, do not remove previous setting

	if ( aFlags & EAknStatusBubbleInputShow || aFlags & EAknStatusBubbleInputHide )

	    {

		TInt bBubbleDisabled =  ( ( aFlags & EAknStatusBubbleInputShow ) == EAknStatusBubbleInputShow )? ETrue : EFalse;

	    iStatusPaneStateData->iDisabledByInput = bBubbleDisabled;

	    }

	else

	    {

	    iStatusPaneStateData->iData.iIndicatorState.iIncallBubbleFlags = aFlags;

	    }

	}

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

// CAknStatusPaneDataPublisher::SetIncallBubbleAllowedInUsual

// (other items were commented in a header).

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

//

EXPORT_C void CAknStatusPaneDataPublisher::SetIncallBubbleAllowedInUsual(

    TBool aAllowed )

	{

	iStatusPaneStateData->iData.iIndicatorState.iIncallBubbleAllowedInUsual =

	    aAllowed;

	}

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

// CAknStatusPaneDataPublisher::SetIncallBubbleAllowedInUsual

// (other items were commented in a header).

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

//

EXPORT_C void CAknStatusPaneDataPublisher::SetIncallBubbleAllowedInUsual( TBool aAllowed, const TUint64& aClientId )

    {

    if ( aClientId == 0 )

        {

        iStatusPaneStateData->iData.iIndicatorState.iIncallBubbleAllowedInUsual = aAllowed ;

        return;

        }

    // To store the list when switch from a view disabling the bubble to the other view disabling

    // the buble,too. Currently, this list will not bu used not.

    if ( !aAllowed )

        {

        if( iStatusPaneStateData->iProcessList.Find( aClientId ) == KErrNotFound )

            {

            iStatusPaneStateData->iProcessList.Append( aClientId );

            }

        }

    else

        {

        TInt index = iStatusPaneStateData->iProcessList.Find( aClientId );

        if(  index != KErrNotFound )

            {

            iStatusPaneStateData->iProcessList.Remove( index );

            }

        // if the focused process has disabled the bubble ,ignore the bubble enable flag

        if ( !iStatusPaneStateData->iCoeEnv )

            {

            iStatusPaneStateData->iCoeEnv = CCoeEnv::Static( );

            }

        RWsSession &ws = iStatusPaneStateData->iCoeEnv->WsSession();

        TInt focusId =  ws.GetFocusWindowGroup();

        RThread focusThread;

        TThreadId threadId = 0;

        if ( KErrNone == ws.GetWindowGroupClientThreadId( focusId, threadId ) )

            {

            // if focused window has disable the bubble,ignore it

            if ( KErrNotFound != iStatusPaneStateData->iProcessList.Find( threadId.Id() ) )

                {

                aAllowed = EFalse;

                }

            }

        // reset the process list

        iStatusPaneStateData->iProcessList.Reset();

        }

    iStatusPaneStateData->iData.iIndicatorState.iIncallBubbleAllowedInUsual = aAllowed ;

    }

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

// CAknStatusPaneDataPublisher::SetIncallBubbleAllowedInIdle

// (other items were commented in a header).

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

//

EXPORT_C void CAknStatusPaneDataPublisher::SetIncallBubbleAllowedInIdle(

    TBool aAllowed )

	{

	iStatusPaneStateData->iData.iIndicatorState.iIncallBubbleAllowedInIdle =

	    aAllowed;

	}

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

// CAknStatusPaneDataPublisher::SetIndicatorState

// (other items were commented in a header).

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

//

EXPORT_C void CAknStatusPaneDataPublisher::SetIndicatorState( TUid aUid,

                                                              TInt aState )

	{

	TRAP_IGNORE( SetIndicatorStateL( aUid, aState ) );

	}

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

// CAknStatusPaneDataPublisher::SetIndicatorStateL

// (other items were commented in a header).

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

//

void CAknStatusPaneDataPublisher::SetIndicatorStateL( TUid aUid, TInt aState )

	{

	TBool indicatorExists = EFalse;

	TBool found           = EFalse;

	TInt  count           = iIndicators.Count();

	// Whether or not an indicator is added to or removed from the popup.

	TBool resizePopup     = EFalse;

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

	  	{

	  	if ( iIndicators[i].iUid == aUid.iUid )

	  		{

	  		indicatorExists = ETrue;

			iIndicators[i].iState = aState;

		    if ( aState == EAknIndicatorStateOff )

		        {

		        if ( AknLayoutUtils::PenEnabled() &&

		             iIndicators[i].iPluginLoaded )

		            {

		            if ( iPopup && iIndicators[i].iPopupItemExists )

		                {

		                iPopup->RemoveItem( aUid.iUid );

		                iIndicators[i].iPopupItemExists = EFalse;

		                resizePopup = ETrue;

		                }

                    // We don't delete the ECOM plugins here, as they don't

                    // have such a major impact on memory consumption.

                    // If the plugin would be destroyed here,

                    // REComSession::FinalClose() should also be called

                    // to avoid leaking memory, and it could cause

                    // KERN-EXEC panics with certain plugin implementations

                    // in which part of the plugin DLL is still on the

                    // call stack when the library is unloaded.

			  		}

		        }

	  		break;

	  		}

		}

	if ( !indicatorExists )

		{

		TInt widePriority   = KNoIndicatorPriority;

		TInt narrowPriority = KNoIndicatorPriority;

		TResourceReader res;

		// Check first the status indicators

		CCoeEnv::Static()->CreateResourceReaderLC(

				res,

				R_AVKON_STATUS_PANE_INDICATOR_DEFAULT );

	   	TInt indicatorCount = res.ReadInt16();

	    for ( TInt ii = 0; ii < indicatorCount; ii++ )

	        {

		    TInt foundUid = res.ReadInt16();

			if ( foundUid == aUid.iUid )

				{

				found 		   = ETrue;

		    	widePriority   = res.ReadInt16();

		    	narrowPriority = res.ReadInt16();

		        break;

				}

			else

			 	{

		    	res.ReadInt16();

		    	res.ReadInt16();

		    	HBufC* bitmapFile = res.ReadHBufCL(); // bmp filename

		    	delete bitmapFile;

		    	bitmapFile = NULL;

			    TInt numberOfStates = res.ReadInt16();  // Number of states

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

		        	{

		        	res.ReadInt16(); // State id

					TInt numberOfIcons = res.ReadInt16();

				    for ( TInt iii = 0; iii < numberOfIcons; iii++ )

				        {

				        for ( TInt jj = 0; jj <= 1; jj++ )

				            {

			                res.ReadInt16(); // bitmaps

			                res.ReadInt16(); // mask

				            }

		                }

		            }

		        }

	        }

		CleanupStack::PopAndDestroy();	// res

		// If not found then check the editor indicators

		if ( !indicatorExists && !found )

		    {

		    CCoeEnv::Static()->CreateResourceReaderLC( res, R_AVKON_NAVI_PANE_EDITOR_INDICATORS );

	   	    indicatorCount = res.ReadInt16();

	        for (TInt ii = 0; ii < indicatorCount; ii++)

    	        {

    		    TInt foundUid = res.ReadInt16();

    			if (foundUid == aUid.iUid)

    				{

    				found = ETrue;

    		    	widePriority = res.ReadInt16();

    		    	narrowPriority = res.ReadInt16();

    		        break;

    				}

    			else

    			 	{

    		    	res.ReadInt16();

    		    	res.ReadInt16();

    		    	HBufC* bitmapFile = res.ReadHBufCL(); // bmp filename

    		    	delete bitmapFile;

    		    	bitmapFile = NULL;

    			    TInt numberOfStates = res.ReadInt16();  // Number of states

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

    		        	{

    		        	res.ReadInt16(); // State id

    					TInt numberOfIcons = res.ReadInt16();

    				    for (TInt ii = 0; ii < numberOfIcons; ii++)

    				        {

    				        for (TInt jj = 0; jj <= 1; jj++)

    				            {

    			                res.ReadInt16(); // bitmaps

    			                res.ReadInt16(); // mask

    				            }

    		                }

    		            }

    		        }

    	        }

    		CleanupStack::PopAndDestroy();	// res

    		}

		TAknStatusIndicator newIndicator;

		newIndicator.iUid = aUid.iUid;

		newIndicator.iNarrowPriority = narrowPriority;

		newIndicator.iWidePriority = widePriority;

		newIndicator.iState = aState;

		iIndicators.AppendL( newIndicator );

		}

	PrioritizeIndicatorsL();

	ClearIndicatorStates();

    TInt prioritizedIndicatorCount = iIndicators.Count();

    TInt publishedCount = 0;

	for ( TInt ii = 0; ii < prioritizedIndicatorCount; ii++ )

	  	{

	  	if ( publishedCount < TAknIndicatorState::EMaxVisibleIndicators )

	  		{

	  		if ( iIndicators[ii].iState != MAknIndicator::EIndicatorOff )

	  			{

			  	iStatusPaneStateData->iData.iIndicatorState.visibleIndicators[publishedCount] =

			  	    iIndicators[ii].iUid;

			  	iStatusPaneStateData->iData.iIndicatorState.visibleIndicatorStates[publishedCount] =

			  	    iIndicators[ii].iState;

	  			publishedCount++;

	  			if ( iPopup )

                    {