/*
* 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 "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:    LandmarksUi Content File -
*
*/






/*
Change History
22-05-2007	To resolve tool IDO warnings	Komala Nagaraju
*/
#define PRINTTOSCREEN
#define WRITETOLOG


// INCLUDE FILES
//#include "BCAppLmkSelectorContainer.h"
#include "BCAppLmkSelectorEngine.h"
#include <BCAppLmkSelector.rsg>
#include <apgtask.h>
#include <bacline.h>
#include <in_sock.h>
#include <coecntrl.h>
#include <gulicon.h>
#include <eikfrlb.h>
#include <AknIconArray.h>
#include <in_sock.h>
#include <barsread.h>

_LIT(KAppName, "BCAppLmkSelector");


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

/*void CBCAppLmkSelectorEngine::ExecuteTestL()
    {

    switch (iCurrentTest)
        {
		case 0:
            {
            SetTestCase(_L("CLmkLandmarkSelectorDlg"), _L("CLmkLandmarkSelectorDlg::NewL"));

			CLmkLandmarkSelectorDlg* iLmkSelectDlg = CLmkLandmarkSelectorDlg::NewL();
			delete iLmkSelectDlg;
			iLmkSelectDlg = NULL;
			}
            break;

        case 1:
            {
            SetTestCase(_L("CLmkLandmarkSelectorDlg"), _L("CLmkLandmarkSelectorDlg::SetMopParent"));

			CLmkLandmarkSelectorDlg* iLmkSelectDlg = CLmkLandmarkSelectorDlg::NewL();
			iLmkSelectDlg->SetMopParent(this);
			delete iLmkSelectDlg;
			iLmkSelectDlg = NULL;
			}
            break;

        case 2:
            {
            SetTestCase(_L("CLmkLandmarkSelectorDlg"), _L("CLmkLandmarkSelectorDlg::ExecuteLD"));

			TLmkItemIdDbCombiInfo selItem;
			CLmkLandmarkSelectorDlg* iLmkSelectDlg = CLmkLandmarkSelectorDlg::NewL();
        	TRAPD( result, iLmkSelectDlg->ExecuteLD(selItem));
        	}
            break;

        case 3:
            {
            SetTestCase(_L("CLmkLandmarkSelectorDlg"), _L("CLmkLandmarkSelectorDlg::ExecuteLD#1"));

			RArray<TLmkItemIdDbCombiInfo> selItems;

			CLmkLandmarkSelectorDlg* iLmkSelectDlg = CLmkLandmarkSelectorDlg::NewL();
        	TRAPD( result, iLmkSelectDlg->ExecuteLD(selItems));
        	selItems.Close();
        	}
            break;

        case 4:
            {
            SetTestCase(_L("CLmkCategorySelectorDlg"), _L("CLmkCategorySelectorDlg::NewL"));

			CLmkCategorySelectorDlg* iLmkCategoryDlg = CLmkCategorySelectorDlg::NewL();
			delete iLmkCategoryDlg;
			iLmkCategoryDlg = NULL;
            }
            break;

        case 5:
            {
            SetTestCase(_L("CLmkCategorySelectorDlg"), _L("CLmkCategorySelectorDlg::SetMopParent"));

			CLmkCategorySelectorDlg* iLmkCategoryDlg = CLmkCategorySelectorDlg::NewL();
			iLmkCategoryDlg->SetMopParent(this);
			delete iLmkCategoryDlg;
			iLmkCategoryDlg = NULL;
            }
            break;

        case 6:
            {
            SetTestCase(_L("CLmkCategorySelectorDlg"), _L("CLmkCategorySelectorDlg::ExecuteLD"));

			TLmkItemIdDbCombiInfo selItem;
			CLmkCategorySelectorDlg* iLmkCategoryDlg = CLmkCategorySelectorDlg::NewL();
        	TRAPD( result, iLmkCategoryDlg->ExecuteLD(selItem));
            }
            break;

        case 7:
            {
            SetTestCase(_L("CLmkCategorySelectorDlg"), _L("CLmkCategorySelectorDlg::ExecuteLD#1"));

			RArray<TLmkItemIdDbCombiInfo> selItems;
            CLmkCategorySelectorDlg* iLmkCategoryDlg = CLmkCategorySelectorDlg::NewL();
        	TRAPD( result, iLmkCategoryDlg->ExecuteLD(selItems));
        	selItems.Close();
            }
            break;

		default:
            {
            iAllTestsDone = ETrue;
            }
        }
    }
*/
TTypeUid::Ptr CBCAppLmkSelectorEngine::MopSupplyObject(TTypeUid /*aId*/)
{
}

MObjectProvider* CBCAppLmkSelectorEngine:: MopNext()
{
}

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

CBCAppLmkSelectorEngine* CBCAppLmkSelectorEngine::NewL(/*CBCAppLmkSelectorContainer* aContainer*/)
    {
    CBCAppLmkSelectorEngine* self = new(ELeave) CBCAppLmkSelectorEngine;
    CleanupStack::PushL(self);
    //self->ConstructL(/*aContainer*/);
    //self->CreateNewLandmark();
    CleanupStack::Pop();
    return self;
    }

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

/*CBCAppLmkSelectorEngine::CBCAppLmkSelectorEngine() : CActive(0)
    {
    }

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

void CBCAppLmkSelectorEngine::IssueTest()
    {
    __ASSERT_ALWAYS(!IsActive(), User::Panic(_L("active"), 1));

    iTimer.After(iStatus, 50000);
    SetActive();
    }

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

void CBCAppLmkSelectorEngine::RunL()
    {

    // Execute the test case
    TRAPD(err, ExecuteTestL());

    if (iExecuteAllTests)
        {
        if (iAllTestsDone)
            {
            // All tests are done  (don't have to exit the program, just print a text)
            Print(_L("All tests done.\n"));
            }
        else
            {
            // We have more tests to be run, move to the next one
            Print(iCurrentFunctionName);
            Print(_L("\n"));
            iCurrentTest++;
            IssueTest();
            }
        }
    else
        {
        if (iAllTestsDone)
            {
            // Signal the main application that there are no more tests to be run
            Print(_L("All tests done.\n"));
            User::Exit(7777);
            }
        else
            {
            // Only one test case executed, exit normally
            Print(iCurrentFunctionName);
            Print(_L("\n"));
            User::Exit(0);
            }
        }

    }

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

void CBCAppLmkSelectorEngine::DoCancel()
    {
    iTimer.Cancel();
    }

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

void CBCAppLmkSelectorEngine::Init()
    {
    iCurrentTest = 0;
    iWarningIssued = EFalse;
    iExecuteAllTests = EFalse;
    iAllTestsDone = EFalse;
	iText.Append(_L("Setting Title"));
    }

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

void CBCAppLmkSelectorEngine::Print(const TDesC& aDes)
    {
    #ifdef PRINTTOSCREEN
	iContainer->PrintNotify(aDes, 0);
    #endif
    }

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

void CBCAppLmkSelectorEngine::Print(const TDesC8& aDes)
    {
    #ifdef PRINTTOSCREEN
	iContainer->PrintNotify(aDes, 0);
    #endif
    }

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

void CBCAppLmkSelectorEngine::Print(TInt aInt)
    {
    #ifdef PRINTTOSCREEN
	iContainer->PrintNotify(aInt);
    #endif
    }

// ---------------------------------------------------------
// ---------------------------------------------------------
*/
/*void CBCAppLmkSelectorEngine::ConstructL(CBCAppLmkSelectorContainer* aContainer)
    {
    iEnv = CEikonEnv::Static();
    TInt err = iWs.Connect();
    err = err;
    User::LeaveIfError(iTimer.CreateLocal());
    //iContainer = aContainer;

    Init();
    CActiveScheduler::Add(this);


    // check if BCAppMain is running
    TApaTaskList taskList(iWs);
    TApaTask thisTask = taskList.FindApp(TUid::Uid(0x101FD6FF));

    if (thisTask.Exists())
        {
    	// ask the BCAppMain to send the test case number
    	thisTask.SendMessage(TUid::Uid( KUidApaMessageSwitchOpenFileValue ), _L8("SendNewTestCaseNumber"));
        iExecuteAllTests = EFalse;
        }
    else
        {
        // BCAppMain not running, execute all cases immediately
        iExecuteAllTests = ETrue;
        IssueTest();
        }
    }
*/
// ---------------------------------------------------------

/*CBCAppLmkSelectorEngine::~CBCAppLmkSelectorEngine()
    {
    Cancel();
    iWs.Close();
    iTimer.Close();
    }

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

void CBCAppLmkSelectorEngine::SetTestCase(const TDesC& aHeaderName, const TDesC& aFunctionName)
    {
    // copy names to our variables
    iCurrentHeaderName.Copy(aHeaderName);
    iCurrentFunctionName.Copy(aFunctionName);

    // send this information to BCAppMain
    TApaTaskList taskList(iWs);
    TApaTask thisTask = taskList.FindApp(TUid::Uid(0x101FD6FF));

    if (thisTask.Exists())
        {
        TBuf8<400> msg;
        msg.Copy(iCurrentHeaderName);
        msg.Append(_L8("@"));
        msg.Append(iCurrentFunctionName);
        thisTask.SendMessage(TUid::Uid( KUidApaMessageSwitchOpenFileValue ), msg);

        // now start waiting till BCAppMain has acknowledged our message
        iWait.Start();
        }

    }

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

void CBCAppLmkSelectorEngine::ExecuteTestCase()
    {
    // stop waiting
    iWait.AsyncStop();
    }

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

void CBCAppLmkSelectorEngine::SetTestCaseNumber(const TDesC8 &aNumber)
    {
    // set the test case number
    TLex8 msgConv(aNumber);
    msgConv.Val(iCurrentTest);

    // start the active object
    IssueTest();
    }

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

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

void CBCAppLmkSelectorEngine::CreateNewLandmark()
    {

  TRAP_IGNORE(
	CPosLandmarkDatabase* dBase = CPosLandmarkDatabase::OpenL();
	CleanupStack::PushL( dBase );
	if (dBase->IsInitializingNeeded())
		{
	ExecuteAndDeleteLD(dBase->InitializeL()); // Synchronous since no argument
		}

	CPosLmItemIterator*  iterator = dBase->LandmarkIteratorL();
    CleanupStack::PushL(iterator);


    if( iterator->NumOfItemsL() == 0 )
	    {
	    CPosLandmark* landmark = CPosLandmark::NewL();
		CleanupStack::PushL( landmark );

		landmark->SetLandmarkNameL(_L("Nokia"));

		dBase->AddLandmarkL(*landmark);
		CleanupStack::PopAndDestroy();//landmark
	    }

 	CleanupStack::PopAndDestroy(2);	//iterator,dBase
 	)
	}
*/

// End of File