/*

* Copyright (c) 2006-2007 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:     CSrchUiGeneral class is the main UI class which creates UI Manager and also acts as an observer for the retrieved results 

*

*/

#include <eikenv.h>

#include <aknViewAppUi.h>

#include <aknview.h>

#include <searchlightresult.h>

#include <searchresult.h>

#include <aknnotewrappers.h>

#include <data_caging_path_literals.hrh>

#include <bautils.h>

#include <utf.h>

#include <srchui.rsg>

#include <FileManager.rsg>

#include <bautils.h>

#include "srchuigeneral.h"

#include "srchuiserviceview.h"

#include "srchuimainview.h"

#include "srchuiappuids.h"

#include "srchuiresfolder.h"

#include "srchuiresfolderview.h"

#include "srchuidefines.h"

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

// CSrchUiGeneral::NewL

// Symbian OS 2 phased constructor.

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

//

EXPORT_C CSrchUiGeneral* CSrchUiGeneral::NewL( CAknViewAppUi* aAppUi )

    {

    CSrchUiGeneral* self = CSrchUiGeneral::NewLC( aAppUi);

    CleanupStack::Pop( self );

    return self;

    }

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

// CSrchUiGeneral::NewL

// Symbian OS 2 phased constructor.

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

//

EXPORT_C CSrchUiGeneral* CSrchUiGeneral::NewL( CAknViewAppUi* aAppUi, 

		RDesReadStream& aReadStream )

    {

    CSrchUiGeneral* self = CSrchUiGeneral::NewLC( aAppUi, aReadStream );

    CleanupStack::Pop( self );

    return self;

    }

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

// CSrchUiGeneral::NewLC

// Symbian OS 2 phased constructor.

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

//

CSrchUiGeneral* CSrchUiGeneral::NewLC( CAknViewAppUi* aAppUi )

    {

    CSrchUiGeneral* self = new ( ELeave ) CSrchUiGeneral( );

    CleanupStack::PushL( self );

    self->ConstructL( aAppUi );

    return self;

    }

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

// CSrchUiGeneral::NewLC

// Symbian OS 2 phased constructor.

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

//

CSrchUiGeneral* CSrchUiGeneral::NewLC( CAknViewAppUi* aAppUi, 

		RDesReadStream& aReadStream )

    {

    CSrchUiGeneral* self = new ( ELeave ) CSrchUiGeneral();

    CleanupStack::PushL( self );

    self->ConstructL( aAppUi, aReadStream );

    return self;

    }

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

// CSrchUiGeneral::~CSrchUiGeneral

// Destructor

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

//

CSrchUiGeneral::~CSrchUiGeneral() // destruct - virtual, so no export

    {

    iViewIds.Close();

    iResultViewers.Reset();

    delete( iQueryString );

    delete( iSrchUiResRootFolder );

   	iResultViewers.Reset();

    REComSession::FinalClose();

    //Remove the resource files from the stack...

    TInt count = iResFileOffset.Count();

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

        {

        CEikonEnv::Static()->DeleteResourceFile( iResFileOffset[i] );			

        }

    iResFileOffset.Reset();

    iSelectedContentTypes.Close();

    for ( TInt i = 0; i<iServiceInfoArray.Count(); i++ )

        {

        TServiceInfo* service = iServiceInfoArray[i];

        delete( service->iPrimaryCaption );

        delete( service->iSecondaryCaption );

        }

    iServiceInfoArray.ResetAndDestroy();

    //RMD

    iSupportedContentClasses.ResetAndDestroy();

    //RMD

    if(iSearchString)

        {

        delete(iSearchString);

        iSearchString = NULL;

        }

    delete iManager;

    }

void CSrchUiGeneral::SearchPartiallyCompletedL( TUid aPluginId )

{

}

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

// CSrchUiGeneral::ConstructSearchMainViewL

// Other items are commented in the header

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

//

void CSrchUiGeneral::ConstructSearchMainViewL()

    {

    LaunchViewL( KSearchViewUid );	

    }

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

// CSrchUiGeneral::ConstructServiceSpecificMainViewL

//

//  Other Items are mentioned in the Header

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

//

void CSrchUiGeneral::ConstructServiceSpecificMainViewL( TUid /*aServiceUid*/ )

    {

	 LaunchViewL( KSearchServiceViewUid );

    }

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

// CGenralSrchUi::ConstructResultFolderViewL

//

//  Other Items are mentioned in the Header

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

//

void CSrchUiGeneral::ConstructResultFolderViewL( TUid /*aServiceUid*/ )

    {

    // Give a name to the root folder

    //First form the result folders                                   

    iSelectedContentCount = 0;

    //iSelectedContentTypes ( iManager->SelectedContentTypes() )

    RArray<TBool>& selectedContentTypes ( iManager->SelectedContentTypes() );

    for ( TInt i = 0; i < selectedContentTypes.Count(); i++ ) 

    	{

    	iSelectedContentTypes[i] = selectedContentTypes[i];

    	}

    FormResultFoldersL( iSelectedContentTypes );

    for ( TInt i = 0; i < selectedContentTypes.Count(); i++ ) 

	    	{

	    	TBool boolean = selectedContentTypes[i];

	    	if ( boolean ) 

	        	{

	    			iSelectedContentCount++;	

	        	}

	    	}

  	if ( 1 < iSelectedContentCount ) 

  			{

				RPointerArray<CSrchUiResFolder> folders;

	    	if ( !iResultFolderView )

	      		{

	        	iResultFolderView = CSrchUiResFolderView::NewL( this, folders );

	        	( ( CAknViewAppUi* )iSrchEikonEnv->EikAppUi() )->AddViewL( 

	        		iResultFolderView );	

	        	}

				LaunchViewL( KSearchResultFolderViewUid );

				folders.Reset();

  			}

    }

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

// CGenralSrchUi::GetSupportedContentClassesL

//

//  Other Items are mentioned in the Header

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

//

void CSrchUiGeneral::GetSupportedContentClassesL( const TUid& aServiceId )

    {

    //Establish connection with the client

    //RMD

    iSupportedContentClasses.ResetAndDestroy();

    iManager->GetSupportedContentClassesL( iSupportedContentClasses, 

    			aServiceId );

    for ( TInt i = 0; i < iSupportedContentClasses.Count(); i++ ) 

    	{

    	iSelectedContentTypes.AppendL( EFalse );

    	}

    }

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

// CSrchUiManager::AllContentClassesSelected

// Getter for iAllContentClassesSelected.

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

//

TBool CSrchUiGeneral::AllContentClassesSelected() const

    {

    return iManager->AllContentClassesSelected();

    }

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

// CSrchUiGeneral::SetAllContentClassesSelected

// Setter for iAllContentClassesSelected

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

//

void CSrchUiGeneral::SetAllContentClassesSelected( TBool aSelected )

    {

    iManager->SetAllContentClassesSelected( aSelected );

    }

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

// CSrchUiGeneral::GetContentTypes

// Returns the content type

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

//

RPointerArray<CSearchContent>& CSrchUiGeneral:: GetContentTypes()

    {

    return( iSupportedContentClasses );

    }                

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

// CSrchUiGeneral::SelectedContentTypes

// Other items are commented in the header

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

//

RArray<TBool>& CSrchUiGeneral::SelectedContentTypes()

    {

    return iManager->SelectedContentTypes();

    }

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

// CSrchUiResFolderView::AiwFlag

// Checks whether the search application is launched from AIW Consumer

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

//

TBool CSrchUiGeneral::AiwFlag()

		{

		return iAiwFlag;

		}

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

// CSrchUiManager::HandleSelectionL

// Other items are commented in the header

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

//

void CSrchUiGeneral::HandleSelectionL( TDesC8& aQueryString, TUid aServiceUid )

    {

		TUid uidtest;

    uidtest.iUid = 10;

    iSearchOn = ETrue;

    {

    	//Show result folder view only if more than one content class is selected

    ConstructResultFolderViewL( uidtest );

    }

    iNumOfResultsFound = 0;

    if(iQueryString)

    {

        delete(iQueryString);

        iQueryString = NULL;

    }

    iQueryString = aQueryString.AllocL();

    for ( TInt i = 0; i<iSrchUiResRootFolder->GetAllSubFoldersCount(); i++ )

        {

        MSrchUiFolder* subfolder = iSrchUiResRootFolder->GetSubFolder( i );

        RPointerArray<CSearchLightResult>& lightresults = subfolder->Results();

        lightresults.Reset();

        }

    iLightResultCount = 0;

	iManager->HandleSelectionL( *iQueryString, aServiceUid, 

					iSelectedContentTypes, this );

	if ( iSelectedContentCount == 1)

		{

		LoadResultViewerL( 0 );

  	    }

  	iIsNewSearch = EFalse;

  }    

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

// CSrchUiGeneral::SrchUiResRoot

//

//  Returns root of the result folder

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

//

MSrchUiFolder* CSrchUiGeneral::SrchUiResRoot() 

	{

	return iSrchUiResRootFolder;

	}	

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

// CSrchUiGeneral::LoadResultViewerL

// Getter for iSrchUiResRootFolder.

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

//

void CSrchUiGeneral::LoadResultViewerL( TInt aSelectedFolderIdx )

	{

    iSelectedFolderIdx = aSelectedFolderIdx;

    //iManager->GetResultL( this );

    GetResultsFromManagerL();

    iResRetriveComplete = EFalse;

    LaunchResultViewL( iSelectedFolderIdx, !iSearchOn );

    iIsResultViewerLaunched = ETrue;

	}

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

// CSrchUiGeneral::ActivatePreviousViewL

// Launches the previous view

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

//

void CSrchUiGeneral::ActivatePreviousViewL()

    {

    LaunchPreviousViewL();

    iIsResultViewerLaunched = EFalse;

    }

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

// CSrchUiResFolderView::GetQueryString

// Gets the query string

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

//

TDesC8& CSrchUiGeneral::GetQueryString()

		{

    return ( *iQueryString );

 		}

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

// CSrchUiResFolderView::IsSearchOngoing

// return : ETrue if search is ongoing else EFalse

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

//

TBool CSrchUiGeneral::IsSearchOngoing()

		{

    return( iSearchOn );

		}

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

// CSrchUiGeneral::GoToMainViewL

// Takes to the main view

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

//

void CSrchUiGeneral::GoToMainViewL()

	{

	if ( iQueryString )

		{

	    delete ( iQueryString );

	    iQueryString = NULL;

		}

    iQueryString = KNullDesC8().AllocL();

   	iSelectedContentTypes.Reset();

    for ( TInt i=0; i<iSupportedContentClasses.Count(); i++ )

        {

        iSelectedContentTypes.Append( EFalse );

        }

	SetAllContentClassesSelected(EFalse);

    for ( TInt i = iViewIds.Count() - 1; i>=0;i-- )

    	{

        iViewIds.Remove(i);

    	}

    TUid ids;

    ids.iUid = 5;

    iViewIds.Append( ids );

    TVwsViewId viewid( TUid::Uid( 0x10282411 ),ids );

	CEikonEnv::Static()->AppUi()->ActivateViewL( viewid );     

	}				 						 

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

// CSrchUiGeneral::SetSearchStringL

// Sets the query string to be searched

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

//

EXPORT_C void CSrchUiGeneral::SetSearchStringL( const TDesC& aString )

    {

    if ( iSearchString )

        {

        delete iSearchString;

        iSearchString = NULL;

        iSearchString = HBufC8::NewL( aString.Length() );

        }

		TPtr8 ptr1( iSearchString->Des() );

    CnvUtfConverter::ConvertFromUnicodeToUtf8( ptr1, aString );

    }		   

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

// CSrchUiGeneral::SearchString

// gets the query string 

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

//

EXPORT_C TDesC8& CSrchUiGeneral::SearchStringL()

    {

    if ( iIsNewSearch )

    	{

        HBufC* string = KNullDesC().Alloc();

        CleanupStack::PushL(string);

        SetSearchStringL( *string );

        CleanupStack::PopAndDestroy(string);

    	}

    return *iSearchString;

    }

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

// CSrchUiResFolderView::SetLastLaunchViewId

//

// Sets the last visited view id

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

//

void CSrchUiGeneral::SetLastLaunchViewId( const TUid aViewId )

    {

    iLastLaunchViewId = aViewId;

    }

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

// CSrchUiGeneral::UpdateSearchProgressL

//

//  Other Items are mentioned in the Header

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

//

void CSrchUiGeneral::UpdateSearchProgressL( RPointerArray<CSearchLightResult>& 

		aResultArray, TInt /*aSearchFinished*/, TInt /*aTotalProgressValue*/ )

    {

		//	iManager->UpdateContentClassesL( iSupportedContentClasses );

    iNumOfResultsFound +=  aResultArray.Count();

    AddResultsToFolderL( aResultArray );

    if ( 1 < iSelectedContentCount ) 

        {

        iResultFolderView->HandleItemAdditionL();	

        }

    if(iIsResultViewerLaunched)

    {

        if(iResRetriveComplete)

        {

        iResRetriveComplete = EFalse;

            iGetResAgain = EFalse;

        }

        else

        {

            iGetResAgain = ETrue;

        }

    }

    }

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

// CSrchUiGeneral::SearchCompletedL

//

//  Other Items are mentioned in the Header

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

//

void CSrchUiGeneral::SearchCompletedL( TInt /*aSrchUiRes*/, 

		TInt aActuallyFinished )

    {

    iNumOfResultsFound = iLightResultCount;

    if ( iManager->MaxResults() <= iNumOfResultsFound && !aActuallyFinished ) 

       	{

       	//Show a note here

        HBufC* infoNote = CCoeEnv::Static()->AllocReadResourceAsDes16L(

                          R_QTN_SEARCH_INFO_MAX );

	      CAknInformationNote* note = new ( ELeave ) CAknInformationNote ();

	      note->ExecuteLD( *infoNote );

       	}

    if(!aActuallyFinished )

    	{

    	CancelSearch();

    	iSelectedContentCount =0;

    	return ;

    	}

    iSearchOn = EFalse;

    if ( 1 < iSelectedContentCount ) 

        {