/*

* Copyright (c) 2003 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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:  COperatorMenuAppUi implementation

*

*/

// INCLUDE FILES

#include "OperatorMenuAppUi.h"

#include <featmgr.h>

#include <bldvariant.hrh>

#include <FeatMgr.h>

#include <centralrepository.h>

#include <menu2internalCRkeys.h>

// CONSTANTS

_LIT(KUrlLaunchParameter, "4 ");

_LIT(KLongZeroLaunchParameter, "5");

const TInt KUrlLaunchParamLength = 2;

const TInt KCenRepBufferSize = 255;

const TText KStrComma = ',';

#define KOperatorMenuUID 0x10008D5E

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

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

// OperatorMenuUIDText

//

// @param aOperatorMenuUid buffer to set OperatorMenu UID as text

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

//

void OperatorMenuUIDText( TDes& aOperatorMenuUid )

    {

    // TUid method name return UID in format [UID], but we need only UID part.

    TUidName uidName( TUid::Uid( KOperatorMenuUID ).Name() );

    aOperatorMenuUid.Copy( uidName.Mid( 1, KMaxUidName - 2 ) );

    aOperatorMenuUid.UpperCase();

    }

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

// SetOperatorMenuHiddenInAppShellL

//

// @param aHidden Whether OperatorMenu should be hidden

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

//

void SetOperatorMenuHiddenInAppShellL( TBool aHidden )

    {

    CRepository* appShellRepository = CRepository::NewL( KCRUidMenu );

    CleanupStack::PushL( appShellRepository );

    // Read current value of the app shell hidden apps key

    TBuf<KCenRepBufferSize> keyContent;

    TInt err = appShellRepository->Get( KMenuHideApplication, keyContent );

    if ( err != KErrNone )

        {

        User::Leave( err );

        }

    TBool updated( EFalse );

    TBuf<8> OperatorMenuUid;

    OperatorMenuUIDText( OperatorMenuUid );

    // Search for PoC uid in the content (ignore case)

    TInt offset = keyContent.FindC( OperatorMenuUid );

    if ( offset == KErrNotFound && aHidden )

        {

        // PoC is not in the list but should be

        //

        __ASSERT_ALWAYS( keyContent.Length() + 9 < KCenRepBufferSize,

                         User::Leave( KErrOverflow ) );

        if ( keyContent.Length() > 0 )

            {

            keyContent.Append( KStrComma );

            }

        keyContent.Append( OperatorMenuUid );

        updated = ETrue;

        }

    else if ( offset != KErrNotFound && !aHidden )

        {

        // PoC is in the list but shouldn't be

        //

        if ( offset == 0 )

            {

            // Delete PoC uid and following comma (if any)

            keyContent.Delete( 0, Min( 9, keyContent.Length() ) );

            updated = ETrue;

            }

        else if ( keyContent[offset - 1] == ',' )

            {

            // Delete PoC uid and preceding comma

            keyContent.Delete( offset - 1, 9 );

            updated = ETrue;

            }

        else

            {

            User::Leave( KErrCorrupt );

            }

        }

    if ( updated )

        {

        err = appShellRepository->Set( KMenuHideApplication, keyContent );

        if ( err != KErrNone )

            {

            User::Leave( err );

            }

        }

    CleanupStack::PopAndDestroy( appShellRepository );

    }

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

// COperatorDelayedStarter::COperatorDelayedStarter(COperatorMenuAppUi* aOperatorMenuAppUi)

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

//

COperatorDelayedStarter::COperatorDelayedStarter(COperatorMenuAppUi* aOperatorMenuAppUi)

:   CActive( EPriorityLow )

	{

	CActiveScheduler::Add( this );

	iOperatorMenuAppUi = aOperatorMenuAppUi;

	}

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

// COperatorDelayedStarter::~COperatorDelayedStarter()

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

//

COperatorDelayedStarter::~COperatorDelayedStarter()

	{

	Cancel();

	Deque();

	}

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

// COperatorDelayedStarter::Start()

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

//

void COperatorDelayedStarter::Start()

	{

	SetActive();

	TRequestStatus* reqStat= &iStatus;

	User::RequestComplete( reqStat, KErrNone );

	}

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

// COperatorDelayedStarter::RunL()

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

//

void COperatorDelayedStarter::RunL()

	{

	iOperatorMenuAppUi->LaunchBrowserL();

	}

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

// COperatorDelayedStarter::

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

//

void COperatorDelayedStarter::DoCancel()

	{

	}

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

//

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

// COperatorMenuAppUi::COperatorMenuAppUi()

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

//

COperatorMenuAppUi::COperatorMenuAppUi()

	{	

	}

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

// COperatorMenuAppUi::ConstructL()

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

//

void COperatorMenuAppUi::ConstructL()

    {

    BaseConstructL(/* ENoScreenFurniture |*/ ENonStandardResourceFile /*| ENoAppResourceFile | EAknEnableSkin*/ );

	// Connect to HttpCacheManager central repository

    iRepository = CRepository::NewL( KCRUidCacheManager );

	// Connect to OperatorMenu central repository

    iRepositoryOp = CRepository::NewL( KCrUidOperatorMenu );

	//Launch the browser with the Operator specific Url

	//or with default AP's homepage if Operator domain url not available

	//LaunchBrowserL();

	iLaunched = EFalse;

    TBool OperatorMenuSupport = FeatureManager::FeatureSupported( KFeatureIdOperatorMenu );

    if ( OperatorMenuSupport )

        {

        iDelayedStarter = new (ELeave) COperatorDelayedStarter( this );

	    iDelayedStarter->Start();

        }

    else

        {

        SetOperatorMenuHiddenInAppShellL( ETrue );

		Exit();

		}

	}

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

// COperatorMenuAppUi::~COperatorMenuAppUi()

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

//

COperatorMenuAppUi::~COperatorMenuAppUi()

    {

    delete iRepository;

    delete iRepositoryOp;

	if( iOverriddenSettings )

		{

		delete iOverriddenSettings;

		iOverriddenSettings = NULL;

		}

	if( iDelayedStarter )

		{

		delete iDelayedStarter;

		iDelayedStarter = NULL;

		}

   }

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

// COperatorMenuAppUi::HandleKeyEventL(

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

//

TKeyResponse COperatorMenuAppUi::HandleKeyEventL( 

    const TKeyEvent& /*aKeyEvent*/,TEventCode /*aType*/ )

    {

    return EKeyWasNotConsumed;

    }

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

// COperatorMenuAppUi::HandleCommandL(TInt aCommand)

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

//

void COperatorMenuAppUi::HandleCommandL( TInt aCommand )

    {

    switch ( aCommand )

        {

        case EAknSoftkeyBack:

		case EAknSoftkeyExit:

        case EEikCmdExit:

		case EAknCmdExit:

            {

            Exit();

            break;

            }

        default:

            break;      

        }

    }

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

// COperatorMenuAppUi::HandleContentL

// Handles the content coming from the embedded browser.

// Returns EFalse: content will be passed on to framework

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

//    

TBool COperatorMenuAppUi::HandleContentL( const TDesC& /*aFileName*/, const CAiwGenericParamList& /*aParamList*/, TBool& aContinue )

	{

	aContinue = EFalse;

	return EFalse;

	}                                      

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

// COperatorMenuAppUi::DownloadedContentHandlerReserved1

// ( Reserved for future use )

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

//

TAny* COperatorMenuAppUi::DownloadedContentHandlerReserved1( TAny* /*aAnyParam*/ )

	{

	// Empty implementation.		

	return NULL;

	}

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

// COperatorMenuAppUi::LaunchBrowserL()

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

//

void COperatorMenuAppUi::LaunchBrowserL() 

    {

	TBool LaunchWithUrl( EFalse );

    TInt value;

	if( !iLaunched )

	    {

	    iLaunched = ETrue;

	    //If centralrepository of HttpCahemanager is available...

        if ( iRepository )

	        {

    		// Read the URL from CacheManager central repository

	        if ( KErrNone == iRepository->Get( KOperatorDomainUrl, iUrl ) )

				{

				LaunchWithUrl = ETrue;

				}

	        }

	    //If centralrepository of OperatorMenu is available...

        if ( iRepositoryOp )

	        {

            delete iOverriddenSettings;

            iOverriddenSettings = NULL;

            iOverriddenSettings = new (ELeave) TBrowserOverriddenSettings;

            //Read the values to override

            if ( KErrNone == iRepositoryOp->Get( KOpMenuVerticalLayoutEnabled, value ) )

                {

                iOverriddenSettings->SetBrowserSetting( EBrowserOverSettingsSmallScreen, (TUint) value);

                }

            if ( KErrNone == iRepositoryOp->Get( KOpMenuAutoLoadImages, value ) )

                {

                iOverriddenSettings->SetBrowserSetting( EBrowserOverSettingsAutoLoadImages, (TUint) value);

                }

            if ( KErrNone == iRepositoryOp->Get( KOpMenuFontSize, value ) )

                {

                iOverriddenSettings->SetBrowserSetting( EBrowserOverSettingsFontSize, (TUint) value);

                }

            if ( KErrNone == iRepositoryOp->Get( KOpMenuFullScreen, value ) )

                {

                iOverriddenSettings->SetBrowserSetting( EBrowserOverSettingsFullScreen, (TUint) value);

                }

            if ( KErrNone == iRepositoryOp->Get( KOpMenuDefAp, value ) )

	            {

                iOverriddenSettings->SetBrowserSetting( EBrowserOverSettingsCustomAp, (TUint) value);

	            }

            }

        }

	// Launch browser according to the given launch type

	if( LaunchWithUrl && iUrl.Length() )

		{

		LaunchBrowserEmbeddedWithOperatorUrlL();

		} 

	else

		{

		LaunchBrowserEmbeddedWithDefaultAPHomepageL();

		}

    Exit();

    }

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

// COperatorMenuAppUi::LaunchBrowserEmbeddedWithUrlL

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

//

void COperatorMenuAppUi::LaunchBrowserEmbeddedWithOperatorUrlL()

	{

	//Pass the operator specific url to browser

	//(read from cachemanager ini file in LaunchBrowserL)

    HBufC* url = NULL;

	url = HBufC::NewLC( iUrl.Length() + KUrlLaunchParamLength );

	url->Des().Append( KUrlLaunchParameter );

	url->Des().Append( iUrl );

	CBrowserLauncher* launcher = CBrowserLauncher::NewLC();

    launcher->LaunchBrowserSyncEmbeddedL( url->Des(), this, iOverriddenSettings );

	CleanupStack::PopAndDestroy(); //Launcher

	CleanupStack::PopAndDestroy();  // url HBufC

	}

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

// COperatorMenuAppUi::NotifyExit

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

//

void COperatorMenuAppUi::NotifyExit(TExitMode /*aMode*/)

	{

	}

void COperatorMenuAppUi::LaunchBrowserEmbeddedWithDefaultAPHomepageL()

	{

	//Start the browser with parameter "5" to launch to default AP homepage

	CBrowserLauncher* launcher = CBrowserLauncher::NewLC();

    launcher->LaunchBrowserSyncEmbeddedL( KLongZeroLaunchParameter, this, iOverriddenSettings );

	CleanupStack::PopAndDestroy();

	}

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

// COperatorMenuAppUi::HandleStatusPaneSizeChange

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

//

void COperatorMenuAppUi::HandleStatusPaneSizeChange()

	{

	}

// End of File