/*
* Copyright (c) 2009-2010 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:
*     CBootstrapAppUi class implementation.
*
*
*/


// INCLUDE FILES
#include <aknglobalnote.h>
#include <stringloader.h>
#include <smartinstaller.rsg>
#include <apgcli.h>
#include <swi/swispubsubdefs.h>

#include "bootstrapapplication.h"
#include "bootstrapappui.h"
#include "bootstrapglobalwaitnoteobserver.h"
#include "bootstrapstatemachine.h"
#include "debug.h"
#include "globals.h"
#include "macros.h"
#include "config.h"
#include "utils.h"

#ifdef USE_LOGFILE
// Logging information
_LIT(KADMLogDir, "ADM");
_LIT(KBootstrapLogFileName, "log-boot.txt" );
_LIT(KBootstrapLogFile, "?:\\logs\\ADM\\log-boot.txt");
#endif

// -----------------------------------------------------------------------------
// CBootstrapAppUi::ConstructL()
// ConstructL of BootstrapApp.
// -----------------------------------------------------------------------------
//
void CBootstrapAppUi::ConstructL()
	{
	TRAPD(err, InitializeSIL());

	if(err != KErrNone)
		{
		LOG2( "Init failed %d", err );
		SetErrorId(EInstallationFailed);
		ExitApp(EBSStateInit);
		}
	else
		{
		iStateMachine = CStateMachine::NewL(*this,iWrapperPackageUid);
		iStateMachine->Start();
		}
	}

// -----------------------------------------------------------------------------
// CBootstrapAppUi::CBootstrapAppUi()
// C++ default constructor can NOT contain any code, that might leave.
// -----------------------------------------------------------------------------
//
CBootstrapAppUi::CBootstrapAppUi():
		iAllowForeground(EFalse)
	{
	LOG ( "SmartInstaller bootstrap begins" );
	// disable possible transition effects
	SetFullScreenApp(EFalse);
	}

// -----------------------------------------------------------------------------
// CBootstrapAppUi::~CBootstrapAppUi()
// Destructor.
// -----------------------------------------------------------------------------
//
CBootstrapAppUi::~CBootstrapAppUi()
	{
	LOG( "~SmartInstaller()" );

	delete iGlobalWaitNoteObserver;
	delete iGlobalWaitNote;
	delete iStateMachine;

	LOG( "SmartInstaller bootstrap ends" );
	CLOSE_DEBUG_LOG;
	}

// ---------------------------------------------------------------------------
// CBootstrapAppUi::InitializeSIL
// Enter function in EBSStateInit,
// Leaves if Connect failure to downloadmanager,SWI Launcher, Unable to identify ADM Presence
// ---------------------------------------------------------------------------
//
void CBootstrapAppUi::InitializeSIL()
	{
	LOG("+ Init()");

	// Create the log
	INIT_DEBUG_LOG( KBootstrapLogFile(), KADMLogDir, KBootstrapLogFileName );

	// Hide from application task list
	HideApplicationFromFSW();

	// Send application to background
	SendToBackgroundL();

	// Check if Ovi Store client is running
	// Logging purposes only at the moment
	iOviStoreRunning = CUtils::OviStoreRunning();
	if ( iOviStoreRunning )
		{
		LOG( "! Ovi Store running" );
		}

	// Wait for the installer to be free
	WaitForInstallCompleteL();

	// Initialise app UI with standard value.
	BaseConstructL( ENoScreenFurniture /* CAknAppUi::EAknEnableSkin */ );
	StatusPane()->MakeVisible(EFalse);

	LOG("- Init()");
	}

// ---------------------------------------------------------------------------
// CBootstrapAppUi::WaitForInstallCompleteL
// called in EBSStateInit,
// Wait for the wrapper package to be completed. Then fetch the wrapper package UID
// ---------------------------------------------------------------------------
//
void CBootstrapAppUi::WaitForInstallCompleteL()
	{
	LOG( "+ WaitForInstallComplete()" );

	// Use publish and subscribe mechanism to
	// get notified when installer is free.
	RProperty installComplete;
	User::LeaveIfError(installComplete.Attach(KUidSystemCategory, Swi::KUidSoftwareInstallKey));

	TInt value(-1);
	TInt err(-1);
	err = installComplete.Get( KUidSystemCategory, Swi::KUidSoftwareInstallKey, value );
	if ( err != KErrNone)
		{
		LOG( "! Unable to get installer" );
		installComplete.Close();
		User::Leave(err);
		}
	else if((value & Swi::KSwisOperationMask) == Swi::ESwisNone)
		{
		LOG( "Installer is idle" );
		// Installer is idle.
		}
	else
		{
		LOG( "Waiting for installer to become idle" );
		TRequestStatus status;
		installComplete.Subscribe(status);
		User::WaitForRequest( status );
		if ( status.Int() != KErrNone )
			{
			LOG2( "Failed to subscribe: %d", status.Int() );
			installComplete.Close();
			User::Leave( status.Int() );
			}
		}

	// Get the Uid of the latest installed package
	iWrapperPackageUid = GetLatestInstalledL();

	iAllowForeground = ETrue;

	installComplete.Close();

	ShowGlobalWaitNoteL();

	SendToBackgroundL(EFalse);

	LOG( "- WaitForInstallComplete()" );
	}

// ---------------------------------------------------------------------------
// CBootstrapAppUi::GetLatestInstalledL
// Get the latest package installed in the device.
// Called in EBSStateInit on completion of wrapper installation.
// ---------------------------------------------------------------------------
//
TUint32 CBootstrapAppUi::GetLatestInstalledL()
	{
	LOG( "+ GetLatestInstalled()" );

	// Use publish and subscribe mechanism to
	// get Uid of the latest installed package.
	RProperty lastInstall;
	User::LeaveIfError(lastInstall.Attach(KUidSystemCategory, KUidSwiLatestInstallation));

	TInt value = -1;
	User::LeaveIfError(lastInstall.Get( KUidSystemCategory, KUidSwiLatestInstallation, value ));

	LOG2( "- GetLatestInstalled(): 0x%08x", value );
	return value;
	}

// ---------------------------------------------------------------------------
// CBootstrapAppUi::HandleGlobalWaitNoteCancel
// Call OnExitOfState() when the process is cancelled.
// ---------------------------------------------------------------------------
//
void CBootstrapAppUi::HandleGlobalWaitNoteCancel(const TInt& aStatus)
	{
	LOG2( "+ CancelNoteEvent(%d) ", aStatus );

	// Do the cleanup based on the state
	if (aStatus == -1)
		{
		iGlobalWaitNoteId = -1;
		//TODO: Is there a possibility of statemachine not being present here.?
		iStateMachine->HandleWaitNoteCancel();
		}

	LOG( "- CancelNoteEvent() ");
	}

// ---------------------------------------------------------------------------
// CBootstrapAppUi::SendToBackgroundL
// Called to move the app background/foreground.
// ---------------------------------------------------------------------------
//
void CBootstrapAppUi::SendToBackgroundL(TBool aBackground)
	{
	LOG2( "+ SendToBackground(%d)", aBackground );
	// We have gained the focus
	RWsSession aWsSession;
	User::LeaveIfError( aWsSession.Connect() );
	TApaTask task(aWsSession);

	// Initialise the object with the window group id of
	// our application (so that it represent our app)
	task.SetWgId(CEikonEnv::Static()->RootWin().Identifier());
	if (aBackground)
		{
		task.SendToBackground();
		}
	else
		{
		task.BringToForeground();
		}
	aWsSession.Close();
	LOG( "- SendToBackground() ");
	}

// ---------------------------------------------------------------------------
// CBootstrapAppUi::ShowGlobalWaitNoteL
// Show the Global wait note. (starts in EBSStateInit)
// ---------------------------------------------------------------------------
//
void CBootstrapAppUi::ShowGlobalWaitNoteL()
	{
	// Allocate TBuf with constant length.
	TBuf<KMaxMsgSize> text( NULL );

	// Reads a resource into a descriptor.
	CEikonEnv::Static()->ReadResource( text, R_ADM_VERIFYING_SW_TEXT );

	// Create new CAknGlobalNote instance.
	iGlobalWaitNote = CAknGlobalNote::NewL();

	iGlobalWaitNoteObserver = new (ELeave) CGlobalWaitNoteObserver(this);
	iGlobalWaitNoteObserver->iStatus = KRequestPending;
	iGlobalWaitNoteObserver->Start();

	iGlobalWaitNoteId = iGlobalWaitNote->ShowNoteL(
					iGlobalWaitNoteObserver->iStatus,
					EAknGlobalWaitNote,
					text );
	}

// ---------------------------------------------------------------------------
// CBootstrapAppUi::StopGlobalWaitNoteL
// Stop the Global wait note, incase of any exit.
// ---------------------------------------------------------------------------
//
void CBootstrapAppUi::StopGlobalWaitNoteL()
	{
	LOG2( "+ StopWaitNote(%d)", iGlobalWaitNoteId );
	if ( iGlobalWaitNote && (iGlobalWaitNoteId >= 0) )
		{
		iGlobalWaitNote->CancelNoteL(iGlobalWaitNoteId);
		}
	iGlobalWaitNoteId = -1;

	DELETE_IF_NONNULL( iGlobalWaitNote         );
	DELETE_IF_NONNULL( iGlobalWaitNoteObserver );
	LOG( "- StopWaitNote()" );
	}

// ---------------------------------------------------------------------------
// CBootstrapAppUi::ShowNoteL
// Show the note on Exit on Error
// ---------------------------------------------------------------------------
//
void CBootstrapAppUi::ShowNoteL( const TAknGlobalNoteType& aType, const TInt& aResourceId )
	{
	// Allocate TBuf with constant length.
	TBuf<KMaxMsgSize> text;

	// Reads a resource into a descriptor.
	CEikonEnv::Static()->ReadResource( text, aResourceId );

	// Create new CAknGlobalNote instance.
	CAknGlobalNote* globalNote = CAknGlobalNote::NewLC();
	globalNote->ShowNoteL( aType , text );
	CleanupStack::PopAndDestroy(globalNote);
	}

// ---------------------------------------------------------------------------
// CBootstrapAppUi::HandleForegroundEventL
// On receiving the foreground event, send the app to background.
// ---------------------------------------------------------------------------
//
void CBootstrapAppUi::HandleForegroundEventL(TBool aForeground)
	{
	LOG3("+ HandleForegroundEvent(%d): %d", aForeground, iAllowForeground );
	CAknAppUi::HandleForegroundEventL(aForeground);

	if (aForeground && !iAllowForeground)
		{
		SendToBackgroundL();
		}
	LOG("- HandleForegroundEvent()" );
	}

// ---------------------------------------------------------------------------
// CBootstrapAppUi::ExitApp
// Handle success and failures on all cases
// Display an error notice and exit the application.
// Perform the necessary state specific cleanup.
// ---------------------------------------------------------------------------
//
void CBootstrapAppUi::ExitApp(TInt aAppState)
	{
	LOG3( "+ ExitApp(%d): %d", aAppState, iErrorId );

	TInt resourceId = ENoAppError;

	switch ( iErrorId )
		{
		case ENoAppError:
			break;
		case EInstallationFailed:
			{
			resourceId = R_INSTALLATION_FAILURE_ERR;
			}
			break;
		case EDownloadFailed:
			{
			resourceId = R_HTTP_TRANSACTION_ERR;
			}
			break;
		default:
			LOG2( "Unknown error %d, ignoring", iErrorId );
			break;
		}

	if (resourceId != 0)
		{
		// Display error message
		TRAP_IGNORE( {
			StopGlobalWaitNoteL();
			ShowNoteL(EAknGlobalErrorNote, resourceId);
			} );
		}
	else
		{
		// the final error note is displayed by ADM.
		// make a pause before removing the note to hide the "installation OK"
		// note displayed by S60 installer
		User::After(1500000);
		TRAP_IGNORE( StopGlobalWaitNoteL() );
		}

	// Stop the state machine
	iStateMachine->Stop();

	LOG( "StateMachine stopped" );

	Exit();

	LOG( "- ExitApp()" );
	}