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



//  INCLUDES
#include "ctlbsclientstepfallbackinstall.h"
#include "ctlbsclientdefs.h"
#include <badesca.h>
#include <epos_cposmodules.h>
#include <epos_cposmoduleupdate.h>
#include <epos_cposmoduleidlist.h>
#include <lbscommon.h>
#include <lbspositioninfo.h>
#include <swi/launcher.h>
#include "tctlbsclientmodulesobserver.h"
#include "ctlbsinstallui.h"

// temp:
// #include <implementationinformation.h>

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

// ---------------------------------------------------------
// Constructor.
// ---------------------------------------------------------
CT_LbsClientStepFallbackInstall::CT_LbsClientStepFallbackInstall(CT_LbsServer& aParent): CT_LbsPortedStepBase(aParent)
	{
	_LIT(KTestName, "TP301 - Error on Uninstall");
	SetTestStepName(KTestName); 
	}


// ---------------------------------------------------------
// Destructor.
// ---------------------------------------------------------
CT_LbsClientStepFallbackInstall::~CT_LbsClientStepFallbackInstall()
	{
	}

// ---------------------------------------------------------
// CT_LbsClientStepFallbackInstall::StartL
//
// ---------------------------------------------------------
//
void CT_LbsClientStepFallbackInstall::StartL()
    {
    iError = EFalse;
    
    // Make sure the psy is uninstalled to begin with
	TInt appId;
	TInt installedpsyId;
	User::LeaveIfError(GetIntFromConfig(ConfigSection(),KLbsSisInstallAppId,appId));
	User::LeaveIfError(GetIntFromConfig(ConfigSection(),KLbsPsyId,installedpsyId));
	SISUninstallPsyL(TUid::Uid(appId));	// may return an error, but that's ok
	User::After(2000000);
	
    // Register as an observer to listen for events
    CPosModules* db = CPosModules::OpenL();
    CleanupStack::PushL(db);

    db->SetObserverL(*this);
	
    // Make sure that only the delayed response (integrated, non-gps) test psy is enabled:
    SetupPsyL(iUidDelayedResponsePsy);
    
	////////////////////////////////////
	// Make a request using default proxy psy:
    RPositionServer	posServer;
    CleanupClosePushL(posServer);
	TInt err = posServer.Connect();
	_LIT(KConnectErr, "Error when connecing to EPos server, %d");
	AssertTrueL(err == KErrNone, KConnectErr, err);  	
	
    RPositioner positioner;
    CleanupClosePushL(positioner);
    err = positioner.Open(posServer); // default proxy
	_LIT(KOpenErr, "Error when opening positioner,  %d");
	AssertTrueL(err == KErrNone, KOpenErr, err);
		
	// Set a fairly long timeout for the request
	TInt timeout = 60000000;
	TTimeIntervalMicroSeconds maxtime(timeout); 
	TPositionUpdateOptions posOption;
	posOption.SetUpdateTimeOut(maxtime);
	
	err = positioner.SetUpdateOptions(posOption);
	_LIT(KUpdateErr, "Error when setting update interval, %d");
	AssertTrueL(err == KErrNone, KUpdateErr, err);	
	
	// tell the psy to delay its response
	TInt32 delay(10000000);	// 10 secs
	TPositionInfo positionInfo; 
	positionInfo.SetUpdateType(delay);
	TRequestStatus status;
	INFO_PRINTF1(_L("NotifyPositionUpdate()\n"));
    positioner.NotifyPositionUpdate(positionInfo, status);
	////////////////////////////////////
	
	////////////////////////////////////
	// Install another ( the installable tracking) test psy :
	TPtrC sispath;
	GetStringFromConfig(ConfigSection(),KLbsSisInstallSisLocation,sispath);
	err = SISInstallPsyL(sispath);	
	if(err != KErrNone)
		{
		INFO_PRINTF2(_L("Failing: SISInstallPsyL returned %d\n"), err);
		SetTestStepResult(EFail);
		}
	iExpectedEvent = EPosModulesEventModuleInstalled;
	// Wait for event
	INFO_PRINTF1(_L("Wait for EPosModulesEventModuleInstalled event\n"));
	DoEventHandlingL();	
	////////////////////////////////////
	
	// verify that the new installed psy is in the prioritised list of psys:	
	CPosModuleIdList* prioList = db->ModuleIdListLC();
	TBool	found = EFalse;
	
	for (TInt i = 0 ; i < prioList->Count(); i++)
		{
		TUid psyUid = (*prioList)[i];
		if (psyUid == TUid::Uid(installedpsyId))
			{
			INFO_PRINTF1(_L("Found installed psy in priority list\n"));
			found = ETrue;
			}
		}	
	if(!found)
		{
		INFO_PRINTF2(_L("Failed: New psy with id 0x%x not found in prioritised list\n"), TUid::Uid(installedpsyId));
		SetTestStepResult(EFail);		
		}
	
	// Wait for the update request to complete 
	INFO_PRINTF1(_L("Wait for NotifyPositionUpdate() to complete\n"));
	User::WaitForRequest(status);
	INFO_PRINTF2(_L("NotifyPositionUpdate completed with %d\n"), err);
    err = status.Int(); 
	if(err != KErrNone)
		{
		SetTestStepResult(EFail);
		}
	// Verify that we got our response from the original test psy (not the installed one)
	else if(positionInfo.ModuleId().iUid != iUidDelayedResponsePsy.iUid)
		{
		INFO_PRINTF2(_L("Received an update from the wrong module 0x%x\n"), positionInfo.ModuleId().iUid );
		SetTestStepResult(EFail);		
		}
	
	CleanupStack::PopAndDestroy(prioList);
	CleanupStack::PopAndDestroy(&positioner);
    CleanupStack::PopAndDestroy(&posServer);
    
	db->RemoveObserver();
	CleanupStack::PopAndDestroy(db);
	
	// Uninstall the installed psy (tidyup):
	err = SISUninstallPsyL(TUid::Uid(appId));	
			
    }

TInt CT_LbsClientStepFallbackInstall::SISUninstallPsyL(const TUid& appId)
	{
	CUISisAdaptor* ui = CUISisAdaptor::NewLC(Logger());

	TInt err = Swi::Launcher::Uninstall(*ui, appId);
	
	CleanupStack::PopAndDestroy(ui);
	
	INFO_PRINTF2(_L("Launcher::UnInstall returned %d\n"), err);
	
	return err;
	}

TInt CT_LbsClientStepFallbackInstall::SISInstallPsyL(const TDesC& aSisPath)
	{
	CUISisAdaptor *ui = CUISisAdaptor::NewLC(Logger());
	CInstallPrefs* prefs = CInstallPrefs::NewLC();

	TInt err = Swi::Launcher::Install(*ui, aSisPath, *prefs);

	CleanupStack::PopAndDestroy(prefs);
	CleanupStack::PopAndDestroy(ui);

	INFO_PRINTF2(_L("Launcher::Install returned %d\n"), err);
	
	return err;
	}

// ---------------------------------------------------------
// CT_LbsClientStepFallbackInstall::DoEventHandlingL
//
// ---------------------------------------------------------
//
void CT_LbsClientStepFallbackInstall::DoEventHandlingL()
    {
    iStopped = EFalse;
	CActiveScheduler::Start();
    CheckErrorL();
    }

// ---------------------------------------------------------
// CT_LbsClientStepFallbackInstall::CheckErrorL
//
// ---------------------------------------------------------
//
void CT_LbsClientStepFallbackInstall::CheckErrorL()
    {
    if (iError)
        {
        LogErrorAndLeaveL(iErrorText);
        }
    }

// ---------------------------------------------------------
// CT_LbsClientStepFallbackInstall::HandleDatabaseChangeL
//
// ---------------------------------------------------------
void CT_LbsClientStepFallbackInstall::HandleSettingsChangeL(TPosModulesEvent aModuleEvent)
    {
    if(!iStopped)
    	{
    	CActiveScheduler::Stop();
    	iStopped = ETrue;
    	}
    if (aModuleEvent.iType != iExpectedEvent)
        {
        INFO_PRINTF2(_L("Unexpected Event received %d\n"), aModuleEvent);
    	SetTestStepResult(EFail);
        }
    }