/*
* Copyright (c) 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:
*
*/
#include "applicationsplugin.h"
#include "harvesterserverlogger.h"
#include <common.h>
#include <ccpixindexer.h>
#include <csearchdocument.h>
#include <e32base.h>
//#include <menu2internalcrkeys.h> //for KCRUidMenu
//#include <WidgetPropertyValue.h> // EBundleDisplayName
#include <centralrepository.h>
#include <opensystemtrace.h>
#include "OstTraceDefinitions.h"
#ifdef OST_TRACE_COMPILER_IN_USE
#include "applicationspluginTraces.h"
#endif
#include<usif/scr/appreginfo.h>
//Hidden applications
//#define KHiddenAppRepositoryUid KCRUidMenu
#define KNumberOfAppInfoToBeRead 1
_LIT( KMimeTypeField, CPIX_MIMETYPE_FIELD );
_LIT( KMimeTypeApplication, APPLICATION_MIMETYPE);
/** Field names */
_LIT(KApplicationFieldShortCaption, "Name");
_LIT(KApplicationFieldCaption, "CaptionName");
_LIT(KApplicationFieldUid, "Uid");
_LIT(KApplicationFieldAbsolutePath, "Path");
// TAppInfo.Name() returns [121345678]. The below constants are used to extract '[' & ']'
const TInt KUidStartIndex = 1;
const TInt KUidEndIndex = 8;
/** The delay between harvesting chunks. */
const TInt KHarvestingDelay = 1000;
// -----------------------------------------------------------------------------
CApplicationsPlugin* CApplicationsPlugin::NewL()
{
OstTraceFunctionEntry0( CAPPLICATIONSPLUGIN_NEWL_ENTRY );
CPIXLOGSTRING("CApplicationsPlugin::NewL()");
CApplicationsPlugin* instance = CApplicationsPlugin::NewLC();
CleanupStack::Pop(instance);
OstTraceFunctionExit0( CAPPLICATIONSPLUGIN_NEWL_EXIT );
return instance;
}
// -----------------------------------------------------------------------------
CApplicationsPlugin* CApplicationsPlugin::NewLC()
{
CApplicationsPlugin* instance = new (ELeave) CApplicationsPlugin();
CleanupStack::PushL(instance);
instance->ConstructL();
return instance;
}
// -----------------------------------------------------------------------------
CApplicationsPlugin::CApplicationsPlugin()
{
}
// -----------------------------------------------------------------------------
CApplicationsPlugin::~CApplicationsPlugin()
{
OstTraceFunctionEntry0( CAPPLICATIONSPLUGIN_CAPPLICATIONSPLUGIN_ENTRY );
if (iAsynchronizer)
iAsynchronizer->CancelCallback();
//iApplicationServerSession.Close();
iScrView.Close();
iScrSession.Close();
//iWidgetRegistry.Close();
//delete iHiddenApplicationsRepository;
delete iAsynchronizer;
delete iNotifier;
delete iIndexer;
OstTraceFunctionExit0( CAPPLICATIONSPLUGIN_CAPPLICATIONSPLUGIN_EXIT );
}
// -----------------------------------------------------------------------------
void CApplicationsPlugin::ConstructL()
{
OstTraceFunctionEntry0( CAPPLICATIONSPLUGIN_CONSTRUCTL_ENTRY );
iIndexState = ETrue;
iAsynchronizer = CDelayedCallback::NewL(CActive::EPriorityIdle);
iNotifier = CApaAppListNotifier::NewL(this, CActive::EPriorityHigh);
//iHiddenApplicationsRepository = CRepository::NewL( KHiddenAppRepositoryUid );
//User::LeaveIfError( iWidgetRegistry.Connect() );
OstTraceFunctionExit0( CAPPLICATIONSPLUGIN_CONSTRUCTL_EXIT );
}
// -----------------------------------------------------------------------------
void CApplicationsPlugin::StartPluginL()
{
OstTraceFunctionEntry0( CAPPLICATIONSPLUGIN_STARTPLUGINL_ENTRY );
TRAPD(error,iScrSession.Connect());
if (error != KErrNone)
return;
User::LeaveIfError(iSearchSession.DefineVolume(
_L(APPLICATIONS_QBASEAPPCLASS), KNullDesC));
// Open database
iIndexer = CCPixIndexer::NewL(iSearchSession);
iIndexer->OpenDatabaseL(_L(APPLICATIONS_QBASEAPPCLASS));
// Start harvester for this plugin
iObserver->AddHarvestingQueue(this, iIndexer->GetBaseAppClass());
OstTraceFunctionExit0( CAPPLICATIONSPLUGIN_STARTPLUGINL_EXIT );
}
// -----------------------------------------------------------------------------
void CApplicationsPlugin::StartHarvestingL(const TDesC& /* aQualifiedBaseAppClass */)
{
OstTraceFunctionEntry0( CAPPLICATIONSPLUGIN_STARTHARVESTINGL_ENTRY );
// Harvest items on each call
iScrView.OpenViewL(iScrSession);
iIndexer->ResetL();
iHarvestState = EHarvesterStartHarvest;
//No need to check IsStatred() since this is the first start.
#ifdef __PERFORMANCE_DATA
iStartTime.UniversalTime();
#endif
iAsynchronizer->Start(0, this, KHarvestingDelay);
OstTraceFunctionExit0( CAPPLICATIONSPLUGIN_STARTHARVESTINGL_EXIT );
}
// -----------------------------------------------------------------------------
//This need not be a member function.
void AddApplicationInfoL(CSearchDocument* aDocument,
Usif::TAppRegInfo& aAppInfo)
{
OstTraceFunctionEntry0( _ADDAPPLICATIONINFOL_ENTRY );
TBuf<KMaxFileName> docidString = aAppInfo.Uid().Name(); //This returns stuff in the form "[UID]". So remove the brackets.
docidString = docidString.Mid(KUidStartIndex, KUidEndIndex);
//We index the exe name (without extension), only if the title is not present.
if (aAppInfo.ShortCaption().Compare(KNullDesC))
{
aDocument->AddFieldL(KApplicationFieldShortCaption,
aAppInfo.ShortCaption(), CDocumentField::EStoreYes
| CDocumentField::EIndexTokenized
| CDocumentField::EIndexFreeText);
if (aAppInfo.Caption().Compare(KNullDesC))
{
aDocument->AddFieldL(KApplicationFieldCaption,
aAppInfo.Caption(), CDocumentField::EStoreYes
| CDocumentField::EIndexTokenized
| CDocumentField::EIndexFreeText);
}
aDocument->AddHLDisplayFieldL(aAppInfo.ShortCaption());
}
else if (aAppInfo.Caption().Compare(KNullDesC))
{
aDocument->AddFieldL(KApplicationFieldShortCaption,
aAppInfo.Caption(), CDocumentField::EStoreYes
| CDocumentField::EIndexTokenized
| CDocumentField::EIndexFreeText);
aDocument->AddFieldL(KApplicationFieldCaption, aAppInfo.Caption(),
CDocumentField::EStoreYes | CDocumentField::EIndexTokenized);
}
else
{
//Find the *last* location of '\' and remove the .exe to get just the filename.
TInt location = aAppInfo.FullName().LocateReverse('\\');
if (location > 0)
{
TInt lengthOfNameWithoutExtention = aAppInfo.FullName().Length()
- location - 1; //-1 to increment one past '\'.
TPtrC appName = aAppInfo.FullName().Right(
lengthOfNameWithoutExtention);
aDocument->AddFieldL(KApplicationFieldShortCaption, appName.Left(
appName.Length() - 4 /*remove ".exe"*/),
CDocumentField::EStoreYes
| CDocumentField::EIndexTokenized);
aDocument->AddFieldL(KApplicationFieldCaption, KNullDesC,
CDocumentField::EStoreYes
| CDocumentField::EIndexTokenized);
aDocument->AddHLDisplayFieldL(
appName.Left(appName.Length() - 4 /*remove ".exe"*/));
}
}
if (aAppInfo.FullName().Compare(KNullDesC))
{
aDocument->AddFieldL(KApplicationFieldAbsolutePath,
aAppInfo.FullName(), CDocumentField::EStoreYes
| CDocumentField::EIndexTokenized
| CDocumentField::EAggregateNo);
}
//For applications, no content to go into exceprt field, for more info, check the appclass-hierarchy.txt
//aDocument->AddExcerptL( aAppInfo.iCaption );
aDocument->AddExcerptL(KNullDesC);
OstTraceExt2( TRACE_NORMAL, _ADDAPPLICATIONINFOL, "::AddApplicationInfoL;UID=%S;PATH=%S", &docidString, &aAppInfo.FullName() );
OstTraceExt2( TRACE_NORMAL, DUP1__ADDAPPLICATIONINFOL, "::AddApplicationInfoL;Excerpt=%S;Caption=%S", &aAppInfo.Caption(), &aAppInfo.ShortCaption() );
OstTraceFunctionExit0( _ADDAPPLICATIONINFOL_EXIT );
}
// -----------------------------------------------------------------------------
TBool CApplicationsPlugin::IsAppHiddenL(TUid aUid)
{
//Application should not have 'hidden' capability.
TBool ret( EFalse );
OstTrace1( TRACE_NORMAL, CAPPLICATIONSPLUGIN_ISAPPHIDDENL, "CApplicationsPlugin::IsAppHiddenL;UID=%d", aUid );
CPIXLOGSTRING2("CApplicationsPlugin::IsAppHidden(): UID = %d", aUid );
Usif::RRegistrationInfoForApplication appRegInfo;
appRegInfo.OpenL(iScrSession, aUid);
Usif::TApplicationCharacteristics appCharacteristics;
appRegInfo.GetAppCharacteristicsL(appCharacteristics);
ret = appCharacteristics.iAppIsHidden;
appRegInfo.Close();
OstTrace1( TRACE_NORMAL, DUP1_CAPPLICATIONSPLUGIN_ISAPPHIDDENL, "CApplicationsPlugin::IsAppHiddenL;Return Value=%d", &ret );
CPIXLOGSTRING2("CApplicationsPlugin::IsAppHidden(): %d", &ret);
return ret;
}
// -----------------------------------------------------------------------------
void CApplicationsPlugin::CreateApplicationsIndexItemL(RPointerArray<
Usif::TAppRegInfo>& aAppInfo, TCPixActionType /*aActionType*/)
{
//If application has 'hidden' capability, don't index.
for (TInt i = 0; i < aAppInfo.Count(); i++)
{
if (!IsAppHiddenL(aAppInfo[i]->Uid()))
{
OstTrace0( TRACE_NORMAL, DUP2_CAPPLICATIONSPLUGIN_CREATEAPPLICATIONSINDEXITEML, "CApplicationsPlugin::Indexing Application" );
TBuf<KMaxFileName> docidString;
docidString.Append(aAppInfo[i]->Uid().Name()); //This returns descriptor in the form "[UID]". So remove the brackets.
docidString = docidString.Mid(KUidStartIndex, KUidEndIndex);
CSearchDocument* document = CSearchDocument::NewLC(docidString,
_L(APPLICATIONS_APPCLASS));
//The UID field should not be aggregated for now as we dont want it to be searchable by default.
//By default, all tokenized fields are aggregated and therefore searchable.
//If we dont tokenize, then the field will not be searchable at all.
//As a middle path, we tokenize this field, but explicitly chose NOT to aggregate it.
//That way, if a client is interested in the UID field, he can choose to query it explicitly.
document->AddFieldL(KMimeTypeField, KMimeTypeApplication,
CDocumentField::EStoreYes | CDocumentField::EIndexUnTokenized);
document->AddFieldL(KApplicationFieldUid, docidString,
CDocumentField::EStoreYes | CDocumentField::EIndexTokenized
| CDocumentField::EAggregateNo);
TInt excerptLength = docidString.Length();
HBufC* excerpt = HBufC::NewL(excerptLength);
TPtr excerptPtr = excerpt->Des();
CleanupStack::PushL(excerpt);
document->AddExcerptL(excerptPtr);
CleanupStack::PopAndDestroy(excerpt);
/*if( iWidgetRegistry.IsWidget( aAppInfo.iUid ) ) //Widget support
AddWidgetInfoL( document, aAppInfo.iUid );
else*/
AddApplicationInfoL(document, *aAppInfo[i]);
TRAPD( error, iIndexer->AddL( *document ) );
if (KErrNone == error)
{
OstTrace0( TRACE_NORMAL, CAPPLICATIONSPLUGIN_CREATEAPPLICATIONSINDEXITEML, "CApplicationsPlugin::CreateApplicationsIndexItemL : No Error" );
CPIXLOGSTRING("CApplicationsPlugin::CreateApplicationsIndexItemL(): No Error" );
}
else
{
OstTrace1( TRACE_NORMAL, DUP1_CAPPLICATIONSPLUGIN_CREATEAPPLICATIONSINDEXITEML, "CApplicationsPlugin::CreateApplicationsIndexItemL;Error=%d", error );
CPIXLOGSTRING2("CApplicationsPlugin::CreateApplicationsIndexItemL(): Error = %d", error );
}
CleanupStack::PopAndDestroy(document);
}
}
}
// -----------------------------------------------------------------------------
void CApplicationsPlugin::DelayedCallbackL( TInt /*aCode*/ )
{
if( !iIndexState )
return;
RPointerArray<Usif::TAppRegInfo> appInfo;
//const TInt error = iApplicationServerSession.GetNextApp(appInfo);
iScrView.GetNextAppInfoL(KNumberOfAppInfoToBeRead, appInfo);
if (appInfo.Count() > 0)
{
CreateApplicationsIndexItemL( appInfo, ECPixAddAction );
iAsynchronizer->Start( 0, this, KHarvestingDelay );
}
else
{
OstTrace0( TRACE_NORMAL, CAPPLICATIONSPLUGIN_DELAYEDCALLBACKL, "CApplicationsPlugin::DelayedCallbackL:Flushing" );
Flush(*iIndexer);
#ifdef __PERFORMANCE_DATA
UpdatePerformaceDataL();
#endif
iHarvestState = EHarvesterIdleState;
iObserver->HarvestingCompleted( this, iIndexer->GetBaseAppClass(), KErrNone );
}
appInfo.ResetAndDestroy();
}
// -----------------------------------------------------------------------------
void CApplicationsPlugin::DelayedError( TInt aCode )
{
Flush(*iIndexer);
iHarvestState = EHarvesterIdleState;
iObserver->HarvestingCompleted(this, iIndexer->GetBaseAppClass(), aCode);
}
// -----------------------------------------------------------------------------
void CApplicationsPlugin::HandleAppListEvent( TInt aEvent )
{
OstTraceFunctionEntry0( CAPPLICATIONSPLUGIN_HANDLEAPPLISTEVENT_ENTRY );
OstTrace1( TRACE_NORMAL, CAPPLICATIONSPLUGIN_HANDLEAPPLISTEVENT, "CApplicationsPlugin::HandleAppListEvent;Event=%d", aEvent );
CPIXLOGSTRING2("CApplicationsPlugin::HandleAppListEvent: Start with Event = %d", aEvent );
if( aEvent == EAppListChanged )
{
if( iAsynchronizer->CallbackPending() )
{
iAsynchronizer->CancelCallback(); //first cancel any ongoing harvesting.
}
TRAP_IGNORE( StartHarvestingL( KNullDesC ) ); //simply reharvest
}
CPIXLOGSTRING("CApplicationsPlugin::HandleAppListEvent: Exit" );
OstTraceFunctionExit0( CAPPLICATIONSPLUGIN_HANDLEAPPLISTEVENT_EXIT );
}
void CApplicationsPlugin::PausePluginL()
{
OstTraceFunctionEntry0( CAPPLICATIONSPLUGIN_PAUSEPLUGINL_ENTRY );
iIndexState = EFalse;
OstTraceFunctionExit0( CAPPLICATIONSPLUGIN_PAUSEPLUGINL_EXIT );
}
void CApplicationsPlugin::ResumePluginL()
{
OstTraceFunctionEntry0( CAPPLICATIONSPLUGIN_RESUMEPLUGINL_ENTRY );
iIndexState = ETrue;
if(iHarvestState == EHarvesterStartHarvest)
{
if(iAsynchronizer->CallbackPending())
iAsynchronizer->CancelCallback();
iAsynchronizer->Start( 0, this, KHarvestingDelay );
}
OstTraceFunctionExit0( CAPPLICATIONSPLUGIN_RESUMEPLUGINL_EXIT );
}
void CApplicationsPlugin::SaveL()
{
}
#ifdef __PERFORMANCE_DATA
void CApplicationsPlugin::UpdatePerformaceDataL()
{
TTime now;
iCompleteTime.UniversalTime();
TTimeIntervalMicroSeconds timeDiff = iCompleteTime.MicroSecondsFrom(iStartTime);
RFs fileSession;
RFile perfFile;
User::LeaveIfError( fileSession.Connect () );
/* Open file if it exists, otherwise create it and write content in it */
if(perfFile.Open(fileSession, _L("c:\\data\\ApplicationsPerf.txt"), EFileWrite))
User::LeaveIfError(perfFile.Create (fileSession, _L("c:\\data\\ApplicationsPerf.txt"), EFileWrite));
HBufC8 *heap = HBufC8::NewL(100);
TPtr8 ptr = heap->Des();
now.HomeTime();
TBuf<50> timeString;
_LIT(KOwnTimeFormat,"%:0%H%:1%T%:2%S");
now.FormatL(timeString,KOwnTimeFormat);
ptr.AppendNum(now.DateTime().Day());
ptr.Append(_L("/"));
ptr.AppendNum(now.DateTime().Month());
ptr.Append(_L("/"));
ptr.AppendNum(now.DateTime().Year());
ptr.Append(_L(":"));
ptr.Append(timeString);
ptr.Append( _L(": Ani: Time took for Harvesting Applications is : "));
ptr.AppendNum(timeDiff.Int64()/1000) ;
ptr.Append(_L(" MilliSeonds \n"));
TInt myInt = 0;
perfFile.Seek(ESeekEnd,myInt);
perfFile.Write (ptr);
perfFile.Close ();
fileSession.Close ();
delete heap;
}
#endif
// End of file