/*
* Copyright (c) 2006-2006 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: This class is the interface class between the UI and Search Framework. It implements the * functionality needed by Search Framework to perform a search operation.
*
*/
#include <srchui.rsg>
#include <searchcontent.h>
#include <searchlightresult.h>
#include <searchresult.h>
#include <searchiconinfo.h>
#include <aknnotewrappers.h>
#include <AknsUtils.h>
#include <srchuiindevice.rsg>
#include <srchuiindevicesvg.mbg>
#include <searchcommon.hrh>
#include "srchuimanager.h"
#include "srchuidefines.h"
#include "srchuiresfolder.h"
#include "utf.h"
// ----------------------------------------------------------------------------
// CSrchUiManager::NewL
// Symbian OS 2 phased constructor.
// ----------------------------------------------------------------------------
//
CSrchUiManager* CSrchUiManager::NewL()
{
CSrchUiManager* self = CSrchUiManager::NewLC();
CleanupStack::Pop( self );
return self;
}
// ----------------------------------------------------------------------------
// CSrchUiManager::NewLC
// Symbian OS 2 phased constructor.
// ----------------------------------------------------------------------------
//
CSrchUiManager* CSrchUiManager::NewLC()
{
CSrchUiManager* self = new ( ELeave ) CSrchUiManager;
CleanupStack::PushL( self );
self->ConstructL();
return self;
}
// ----------------------------------------------------------------------------
// CSearchClientSession::NewLC
// Destructor
// ----------------------------------------------------------------------------
//
CSrchUiManager::~CSrchUiManager()
{
delete( iClientSession );
iServices.ResetAndDestroy();
iSelectedContentTypes.Reset();
REComSession::FinalClose();
//RMD
iSupportedContentClasses.Reset/*AndDestroy*/();
}
// ----------------------------------------------------------------------------
// CSrchUiManager::LoadServicesL
// Loads the services that are implemented as the SearchUiCustomPlugIns
// ----------------------------------------------------------------------------
//
void CSrchUiManager::LoadUiServicesL( RPointerArray<TServiceInfo>& aServiceInfoArray )
{
// Get list of all available ecom implementations information
RImplInfoPtrArray infoArray;
CSrchUiServicePlugin::ListAllImplementationsL( infoArray );
// Scan through the list of available implementations
for ( TInt i=0; i<infoArray.Count(); i++ )
{
CImplementationInformation& info( *infoArray[i] );
// Construct plug-in and pass it to the search session
TUid impUid ( info.ImplementationUid() );
CSrchUiServicePlugin* service = NULL;
TRAPD ( err, service = InitializeUiPlugInsL( impUid ) );
if ( err == KErrNone && service )
{
CleanupStack::PushL( service );
iServices.AppendL( service );
CleanupStack::Pop(service);
}
}
//Get the Plugin infos
LoadPluginInfoL( aServiceInfoArray );
infoArray.ResetAndDestroy();
}
// ----------------------------------------------------------------------------
// CSrchUiManager::HandleSelectionL
// Other items are commented in the header
// ----------------------------------------------------------------------------
//
void CSrchUiManager::HandleSelectionL( TDesC8& aQueryString,TUid aServiceId,
RArray <TBool> /*aSelectedContentTypes*/, MSearchQueryObserver* aObserver )
{
FireSeacrhL( aQueryString, aServiceId, aObserver );
return ;
}
// ----------------------------------------------------------------------------
// CSrchUiManager::GetSupportedContentClassesL
// Other items are commented in the header
// ----------------------------------------------------------------------------
//
void CSrchUiManager::GetSupportedContentClassesL(
RPointerArray<CSearchContent>& aSupportedContentClasses,
const TUid& aServiceId )
{
iSelectedContentTypes.Reset();
TInt i = 0;
for ( i=0; i<iSupportedContentClasses.Count(); i++ )
{
iSelectedContentTypes.Append( EFalse );
}
SetAllContentClassesSelected( EFalse );
if ( iSupportedContentClasses.Count() > 0 )
{
return;
}
iClientSession->GetSupportedContentL(iSupportedContentClasses,aServiceId);
i = 0;
RArray<TBool> supportedFound;
//Set the all elements in array to false
for ( i = 0; i < iSupportedContentClasses.Count(); i++ )
{
supportedFound.AppendL( EFalse );
}
i = 0;
TInt allPluginsCount = 0;
RArray<TInt> pluginsArray;
//All plugins in the order given by UI Spec
pluginsArray.AppendL( KSearchCClassMessages );
pluginsArray.AppendL( KSearchCClassMusic );
pluginsArray.AppendL( KSearchCClassImages );
pluginsArray.AppendL( KSearchCClassVideos );
pluginsArray.AppendL( KSearchCClassCalendar );
pluginsArray.AppendL( KSearchCClassNotes );
pluginsArray.AppendL( KSearchCClassContacts );
pluginsArray.AppendL( KSearchCClassFilenames );
//Arrange elements in iSupportedContentClasses in the order
//of pluginsArray into aSupportedContentClasses
for ( i = 0; i < pluginsArray.Count(); i++ )
{
for ( TInt j = 0; j < iSupportedContentClasses.Count(); j++ )
{
CSearchContent* tmpContent = NULL;
tmpContent = iSupportedContentClasses[j];
TInt pluginId = pluginsArray[i];
if ( tmpContent->ContentId().iUid == pluginId )
{
supportedFound[j] = ETrue;
aSupportedContentClasses.AppendL( tmpContent );
allPluginsCount++;
break;
}
}
}
pluginsArray.Reset();
//Copy rest of the pluginIds that are not there in pluginsArray
//into aSupportedContentClasses
if( iSupportedContentClasses.Count() != allPluginsCount )
{
for ( i = 0; i < supportedFound.Count(); i++ )
{
if ( EFalse == supportedFound[i] )
{
aSupportedContentClasses.AppendL(
iSupportedContentClasses[i] );
}
}
}
supportedFound.Reset();
//Copy the same into iSupportedContentClasses
i = 0;
iSupportedContentClasses.Reset();
iSelectedContentTypes.Reset();
for ( ; i < aSupportedContentClasses.Count(); i++ )
{
CSearchContent* tmpContent = NULL;
tmpContent = aSupportedContentClasses[i] ;
iSupportedContentClasses.AppendL( aSupportedContentClasses[i] );
tmpContent = iSupportedContentClasses[i];
iSelectedContentTypes.Append( EFalse );
}
SetAllContentClassesSelected( EFalse );
}
// ----------------------------------------------------------------------------
// CSrchUiManager::SetThreshold
// Other items are commented in the header
// ----------------------------------------------------------------------------
//
void CSrchUiManager::SetThreshold( TSearchThreshold aThreshold )
{
iThreshold = aThreshold;
}
void CSrchUiManager::GetResultL( RPointerArray<CSearchDocumentId>& aResultIDArray,
MSearchResultRetrieveObserver* aObserver )
{
iClientSession->GetResultsL( aResultIDArray,*aObserver );
}
// -------------------------------------------------------------------------------------------------
// CSrchUiManager::CancelSearch
// Cancels the search operation
// -------------------------------------------------------------------------------------------------
//
TInt CSrchUiManager::CancelSearch()
{
//TInt numberofResults = 0;
iClientSession->CancelSearch();
return(0);
}
// ----------------------------------------------------------------------------
// CSrchUiManager::AllContentClassesSelected
// Getter for iAllContentClassesSelected.
// ----------------------------------------------------------------------------
//
TBool CSrchUiManager::AllContentClassesSelected() const
{
return iAllContentClassesSelected;
}
// ----------------------------------------------------------------------------
// CSrchUiGeneral::SetAllContentClassesSelected
// Setter for iAllContentClassesSelected
// ----------------------------------------------------------------------------
//
void CSrchUiManager::SetAllContentClassesSelected( TBool aSelected )
{
iAllContentClassesSelected = aSelected;
}
// ----------------------------------------------------------------------------
// CSrchUiGeneral::SelectedContentTypes
// Other items are commented in the header
// ----------------------------------------------------------------------------
//
RArray<TBool>& CSrchUiManager::SelectedContentTypes()
{
return iSelectedContentTypes;
}
// ----------------------------------------------------------------------------
// CSrchUiGeneral::SelectedContentTypes
// Other items are commented in the header
// ----------------------------------------------------------------------------
//
void CSrchUiManager::SetSelectedContentTypesL( RArray<TBool>&
aSelectedContentTypes )
{
iSelectedContentTypes.Reset();
for ( TInt i = 0; i < aSelectedContentTypes.Count(); i++ )
{
iSelectedContentTypes.Append( aSelectedContentTypes[i] );
}
}
// ----------------------------------------------------------------------------
// CSrchUiGeneral::UpdateContentClassesL
// Updates the content class ( for Context Sensitivity )
// ----------------------------------------------------------------------------
//
void CSrchUiManager::UpdateContentClassesL(
RPointerArray< CSearchContent> aContentClass)//, TInt aCheckedCount )
{
iSupportedContentClasses.Reset();
CSearchContent const * tmpContent;
for ( TInt i = 0; i < aContentClass.Count(); i++ )
{
tmpContent = aContentClass[i];
iSupportedContentClasses.Append( tmpContent );
}
}
TInt CSrchUiManager::MaxResults()
{
return iThreshold.iMaxResults;
}
// ----------------------------------------------------------------------------
// CSearchClientSession::NewLC
// constructor
// ----------------------------------------------------------------------------
//
CSrchUiManager::CSrchUiManager()//:iSupportedContentClasses( 20 )
{
}
// ----------------------------------------------------------------------------
// CSrchUiManager::ConstructL
// Performs the second phase construction.
// ----------------------------------------------------------------------------
//
void CSrchUiManager::ConstructL()
{
iClientSession = CSearchClientSession::NewL();
iThreshold.iMaxResults = 1000;
iThreshold.iUpdateGranularity = 5 ;
TTimeIntervalMicroSeconds32 ams( 1000000 );
iThreshold.iUpdateInterval = ams;
}
// ----------------------------------------------------------------------------
// CSrchUiManager::InitializeUiPlugInsL
// Other items are commented in the header
// ----------------------------------------------------------------------------
//
CSrchUiServicePlugin* CSrchUiManager::InitializeUiPlugInsL( TUid aImpUid )
{
CSrchUiServicePlugin* service = CSrchUiServicePlugin::NewL( aImpUid );
return service;
}
// ----------------------------------------------------------------------------
// CSrchUiManager::LoadPluginInfoL
// Other items are commented in the header
// ----------------------------------------------------------------------------
//
void CSrchUiManager::LoadPluginInfoL( RPointerArray<TServiceInfo>&
aServiceInfoArray )
{
//
//Get the service id that are supported
RArray<TUid> serviceidarray;
iClientSession->GetSupportedServicesL( serviceidarray );
serviceidarray.Reset();
serviceidarray.Close();
for ( TInt i=0; i<iServices.Count(); i++ )
{
TServiceInfo* serviceInfo = new ( ELeave ) TServiceInfo;
CleanupStack::PushL( serviceInfo );
serviceInfo->iServiceId = iServices[i]->ServiceId();
serviceInfo->iPrimaryCaption = HBufC::NewL(
iServices[i]->PrimaryCaptionL().Length() );
*( serviceInfo->iPrimaryCaption ) = iServices[i]->PrimaryCaptionL();
serviceInfo->iSecondaryCaption = HBufC::NewL(
iServices[i]->SecondaryCaptionL().Length());
*( serviceInfo->iSecondaryCaption ) = iServices[i]->SecondaryCaptionL();
serviceInfo->iVisible = iServices[i]->IsVisible();
serviceInfo->iServiceIcon = iServices[i]->ServiceIconL();
serviceInfo->iServiceIconMask = iServices[i]->ServiceIconMaskL();
//The below comments will have to be removed once service id is finalised
aServiceInfoArray.AppendL( serviceInfo );
CleanupStack::Pop( serviceInfo );
}
}
// -----------------------------------------------------------------------
// CSrchUiManager::FireSeacrhL
// Calls clients searchL function with the query to be searched
// -----------------------------------------------------------------------
//
void CSrchUiManager::FireSeacrhL( TDesC8& aQueryString,TUid aServiceId,
MSearchQueryObserver* aObserver )
{
//First get supported snippet formats
//Create the search requirement
iSearchRequirement = CSearchRequirement::NewL();
RArray<TUid> contentidArray;
for ( TInt i = 0; i<iSelectedContentTypes.Count() ; i++ )
{
TUid tmpUid;
if ( iSelectedContentTypes[i] )
{
tmpUid.iUid = iSupportedContentClasses[i]->ContentId().iUid;
contentidArray.AppendL( tmpUid );
}
}
CSearchQuery* query = iSearchRequirement->CreateRequestL( aQueryString,
aServiceId, contentidArray );
CleanupStack::PushL( query );
//The search request
iClientSession->SearchL( *query,*aObserver, iThreshold );
CleanupStack::Pop( query );
if ( iSearchRequirement )
{
delete( iSearchRequirement );
iSearchRequirement = NULL;
}
contentidArray.Reset();
}
// -----------------------------------------------------------------------
// Launches a document
// -----------------------------------------------------------------------
//
void CSrchUiManager::LaunchApplicationL( const CSearchDocumentId& aResultId )
{
iClientSession->LaunchApplicationL( aResultId ) ;
}
// -----------------------------------------------------------------------------
// CSrchUiManager::GetLaunchInfoL
// Get the file launch information from Search Server
// -----------------------------------------------------------------------------
//
HBufC8* CSrchUiManager::GetLaunchInfoL( const CSearchDocumentId& aDocumentID )
{
return iClientSession->GetLaunchInfoL( aDocumentID );
}