1 /*

     2 * Copyright (c) 2010 Nokia Corporation and/or its subsidiary(-ies).

     3 * All rights reserved.

     4 * This component and the accompanying materials are made available

     5 * under the terms of "Eclipse Public License v1.0"

     6 * which accompanies this distribution, and is available

     7 * at the URL "http://www.eclipse.org/legal/epl-v10.html".

     8 *

     9 * Initial Contributors:

    10 * Nokia Corporation - initial contribution.

    11 *

    12 * Contributors:

    13 *

    14 * Description: 

    15 *

    16 */

    17 

    18 #include <S32MEM.H>

    19 #include <e32svr.h>

    20 #include <e32uid.h>

    21 #include <common.h>

    22 

    23 #include "CSearchServerSession.h"

    24 #include "CSearchServerSubSession.h"

    25 #include "CCPixAsyncronizer.h"

    26 #include "CCPixIdxDb.h"

    27 #include "CCPixSearch.h"

    28 #include "CSearchDocument.h"

    29 #include "SearchServerLogger.h"

    30 #include "SearchServer.pan"

    31 #include "CLogPlayerRecorder.h"

    32 

    33 // Contants

    34 //_LIT8( KFileBaseAppClass, "root file" );

    35 

    36 CSearchServerSubSession* CSearchServerSubSession::NewLC(CSearchServerSession* aSession)

    37 {

    38 	CSearchServerSubSession* self = new (ELeave)CSearchServerSubSession(aSession);

    39 	CleanupStack::PushL(self);

    40 	self->ConstructL();

    41 	return self;

    42 }

    43 

    44 CSearchServerSubSession* CSearchServerSubSession::NewL(CSearchServerSession* aSession)

    45 {

    46 	CSearchServerSubSession* self = CSearchServerSubSession::NewLC(aSession);

    47 	CleanupStack::Pop();

    48 	return self;

    49 }

    50 

    51 CSearchServerSubSession::CSearchServerSubSession(CSearchServerSession* aSession) : iSession(aSession)

    52 {

    53     CPIXLOGSTRING("Creating search server subsession");

    54 	

    55     // Dont ask why but I seem to have a compulsion to set everything NULL in constructor - AL

    56 	iIndexDb = NULL;

    57 	iSearchDb = NULL;

    58 	iNextDocument = NULL;

    59 }

    60 

    61 CSearchServerSubSession::~CSearchServerSubSession()

    62 {

    63     CPIXLOGSTRING("Deleting search server subsession");

    64 

    65 	delete iIndexDb;

    66 	delete iSearchDb;	

    67 	delete iNextDocument;

    68 }

    69 

    70 void CSearchServerSubSession::ConstructL()

    71 {

    72 	iIndexDb = CCPixIdxDb::NewL();

    73 	iSearchDb = CCPixSearch::NewL();

    74 }

    75 

    76 // CSearchServerSession::CancelAll()

    77 void CSearchServerSubSession::CancelAll(const RMessage2& aMessage)

    78 	{

    79 	if (iSearchDb->IsOpen())

    80 	    {

    81 	    // Cancel searching 

    82 	    iSearchDb->CancelAll(aMessage);

    83 	    }

    84 	else if (iIndexDb->IsOpen())

    85 	    {

    86 	    // Cancel indexing

    87 	    iIndexDb->CancelAll(aMessage);

    88 	    }

    89 	else

    90 	    {

    91 	    // Nothing to cancel. Just complete request

    92 	    aMessage.Complete(KErrNone);

    93 	    }

    94 	

    95 	TRAP_IGNORE( LOG_PLAYER_RECORD( CLogPlayerRecorder::LogCancelL( reinterpret_cast<TUint>( this ) ) ) );

    96 	}

    97 

    98 void CSearchServerSubSession::OpenDatabaseL(const RMessage2& aMessage)

    99 	{

   100 	HBufC* baseAppClass = HBufC::NewLC(aMessage.GetDesLength(0));

   101 	TPtr baseAppClassPtr = baseAppClass->Des();

   102 	aMessage.ReadL(0, baseAppClassPtr);

   103 	

   104 	HBufC* defaultSearchField = HBufC::NewLC(aMessage.GetDesLength(1));

   105 	TPtr defaultSearchFieldPtr = defaultSearchField->Des();

   106 	aMessage.ReadL(1, defaultSearchFieldPtr);

   107 	

   108 	const TBool search = aMessage.Int2();

   109     

   110 	LOG_PLAYER_RECORD( CLogPlayerRecorder::LogDatabaseOpenL(reinterpret_cast<TUint>(this), search, *baseAppClass) );

   111 

   112 	if (!search)

   113 	{

   114     	iIndexDb->OpenDatabaseL(*baseAppClass);

   115 	}

   116 	else

   117 	{

   118 		iSearchDb->OpenDatabaseL(*baseAppClass, *defaultSearchField);

   119 	}

   120 	

   121 	CleanupStack::PopAndDestroy(defaultSearchField);

   122 	CleanupStack::PopAndDestroy(baseAppClass);

   123 

   124 	// Complete the request

   125 	aMessage.Complete(KErrNone);	

   126 	}

   127 

   128 void CSearchServerSubSession::SetAnalyzerL(const RMessage2& aMessage)

   129 	{

   130 	if (!iSearchDb->IsOpen() && !iIndexDb->IsOpen())

   131 		{

   132 		iSession->PanicClient(aMessage, EDatabaseNotOpen);

   133 		return;

   134 		}

   135 	

   136 	HBufC* analyzer = HBufC::NewLC(aMessage.GetDesLength(0));

   137 	TPtr analyzerPtr = analyzer->Des();

   138 	aMessage.ReadL(0, analyzerPtr);

   139 

   140 	if (iSearchDb->IsOpen()) {

   141 		iSearchDb->SetAnalyzerL( *analyzer ); 

   142 	}

   143 	if (iIndexDb->IsOpen()) {

   144 		iIndexDb->SetAnalyzerL( *analyzer ); 

   145 	}

   146 	CleanupStack::PopAndDestroy( analyzer );

   147 	

   148 	// Complete the request

   149 	aMessage.Complete(KErrNone);	

   150 	}

   151 

   152 void CSearchServerSubSession::SearchL(const RMessage2& aMessage)

   153 	{

   154 	PERFORMANCE_LOG_START("CSearchServerSubSession::SearchL");

   155 	

   156 	// Sanity check

   157 	if (!iSearchDb->IsOpen())

   158 		{

   159 		iSession->PanicClient(aMessage, EDatabaseNotOpen);

   160 		return;

   161 		}

   162 	

   163 	// buf for the search terms

   164 	HBufC* searchTerms = HBufC::NewLC(aMessage.GetDesLength(0));

   165 	

   166 	// read the search terms

   167 	TPtr ptr = searchTerms->Des();

   168 	aMessage.ReadL(0, ptr);

   169 

   170 	// Commit search

   171 	LOG_PLAYER_RECORD( CLogPlayerRecorder::LogSearchL( reinterpret_cast<TUint>(this), *searchTerms ) );

   172 	if (!iSearchDb->SearchL(*searchTerms, this, aMessage))

   173 		{

   174 		// Not commited, complete with zero count

   175 		TPckgBuf<TInt> resultCountPackage(0);

   176 		aMessage.WriteL(1, resultCountPackage);

   177 

   178 		// Complete the request

   179 		aMessage.Complete(KErrNone);	

   180 		}

   181 	

   182 	// Cleanup search terms

   183 	CleanupStack::PopAndDestroy(searchTerms);

   184 	}

   185 	

   186 void CSearchServerSubSession::SearchCompleteL(const RMessage2& aMessage)

   187 	{

   188 	PERFORMANCE_LOG_START("CSearchServerSubSession::SearchCompleteL");

   189 	

   190 	// Complete search

   191 	const TInt resultCount = iSearchDb->SearchCompleteL();

   192 		

   193 	// Return the size of the search results in first parameter

   194 	TPckgBuf<TInt> resultCountPackage(resultCount);

   195 	aMessage.WriteL(1, resultCountPackage);

   196 	

   197 	}

   198 

   199 // CSearchServerSession::GetDocumentL().

   200 // Client gets the next documents (result) when SearchL has completed

   201 void CSearchServerSubSession::GetDocumentL(const RMessage2& aMessage)

   202 	{

   203 	PERFORMANCE_LOG_START("CSearchServerSubSession::GetDocumentL");

   204 	

   205 	// Sanity check

   206 	if (!iSearchDb->IsOpen())

   207 		{

   208 		iSession->PanicClient(aMessage, EDatabaseNotOpen);

   209 		return;

   210 		}

   211 	

   212 	// buf for the search terms

   213 	TInt index = aMessage.Int0();

   214 	

   215 	delete iNextDocument; 

   216 	iNextDocument = NULL;

   217 	LOG_PLAYER_RECORD( CLogPlayerRecorder::LogGetDocumentL( reinterpret_cast<TUint>( this ), index ) );

   218 	iSearchDb->GetDocumentL(index, this, aMessage);

   219 	}

   220 	

   221 void CSearchServerSubSession::GetDocumentCompleteL(const RMessage2& aMessage)

   222 	{

   223 	PERFORMANCE_LOG_START("CSearchServerSubSession::GetDocumentCompleteL");

   224 	

   225 	iNextDocument = iSearchDb->GetDocumentCompleteL();	

   226 	TPckgBuf<TInt> documentSizePackage(iNextDocument ? iNextDocument->Size() : 0);

   227 	aMessage.WriteL(1, documentSizePackage);

   228 	}

   229 

   230 // CSearchServerSession::GetDocumentObjectL()

   231 // Client gets the object after GetDocumentL() has completed 

   232 void CSearchServerSubSession::GetDocumentObjectL(const RMessage2& aMessage)

   233 	{

   234 	PERFORMANCE_LOG_START("CSearchServerSubSession::GetDocumentObjectL");

   235 	

   236 	// Sanity check

   237 	if (!iSearchDb->IsOpen())

   238 		{

   239 		iSession->PanicClient(aMessage, EDatabaseNotOpen);

   240 		return;

   241 		}

   242 	

   243 	if (iNextDocument)

   244 		{

   245 		// Create long enough descriptor for serialized hits

   246 		HBufC8* buf = HBufC8::NewLC(iNextDocument->Size());

   247 		TPtr8 ptr = buf->Des();

   248 	

   249 		// Initialize a new stream

   250 		RDesWriteStream stream;

   251 		stream.Open(ptr);

   252 		stream.PushL();

   253 	

   254 		// Externalize hits to the stream

   255 		iNextDocument->ExternalizeL(stream);

   256 	

   257 		// Commit and destroy the stream

   258 		stream.CommitL();

   259 		CleanupStack::PopAndDestroy(&stream);

   260 	

   261 		// write the serialized hits in to the message

   262 		aMessage.WriteL(0, ptr);

   263 	

   264 		// Delete descriptor

   265 		CleanupStack::PopAndDestroy(buf);

   266 		}

   267 	else

   268 		{

   269 		// Empty

   270 		aMessage.WriteL(0, KNullDesC8);

   271 		}

   272 	

   273 	// Complete the request

   274 	aMessage.Complete(KErrNone);		

   275 	}

   276 

   277 void CSearchServerSubSession::AddL(const RMessage2& aMessage)

   278 	{

   279 	// Sanity check

   280 	if (!iIndexDb->IsOpen())

   281 		{

   282 		iSession->PanicClient(aMessage, EDatabaseNotOpen);

   283 		return;

   284 		}

   285 	

   286 	// buf for the search terms

   287 	HBufC8* serializedDocument = HBufC8::NewLC(aMessage.GetDesLength(0));

   288 	

   289 	// read the search terms

   290 	TPtr8 ptr = serializedDocument->Des();

   291 	aMessage.ReadL(0, ptr);

   292 

   293 	RDesReadStream stream;

   294 	stream.Open(ptr);

   295 	stream.PushL();

   296 	CSearchDocument* document = CSearchDocument::NewL(stream);

   297 	CleanupStack::PopAndDestroy(&stream);

   298 	CleanupStack::PushL(document);

   299 	

   300 	// Index the thing

   301 	LOG_PLAYER_RECORD(

   302 	if ( iIndexDb->BaseAppClass().Find( KFileBaseAppClass ) == KErrNotFound )

   303 	    {

   304 		CLogPlayerRecorder::LogAddL( reinterpret_cast<TUint>(this), *document );

   305 	    }

   306 	);

   307 	iIndexDb->AddL(*document, this, aMessage);

   308 	

   309 	CleanupStack::PopAndDestroy(document);

   310 	CleanupStack::PopAndDestroy(serializedDocument);

   311 	}

   312 

   313 void CSearchServerSubSession::AddCompleteL(const RMessage2& /*aMessage*/)

   314 	{

   315 	iIndexDb->AddCompleteL();	

   316 	}

   317 

   318 

   319 void CSearchServerSubSession::UpdateL(const RMessage2& aMessage)

   320 	{

   321 	// Sanity check

   322 	if (!iIndexDb->IsOpen())

   323 		{

   324 		iSession->PanicClient(aMessage, EDatabaseNotOpen);

   325 		return;

   326 		}

   327 

   328 	// buf for the search terms

   329 	HBufC8* serializedDocument = HBufC8::NewLC(aMessage.GetDesLength(0));

   330 	

   331 	// read the search terms

   332 	TPtr8 ptr = serializedDocument->Des();

   333 	aMessage.ReadL(0, ptr);

   334 

   335 	RDesReadStream stream;

   336 	stream.Open(ptr);

   337 	stream.PushL();

   338 	CSearchDocument* document = CSearchDocument::NewL(stream);

   339 	CleanupStack::PopAndDestroy(&stream);

   340 	CleanupStack::PushL(document);

   341 	

   342 	// Index the thing

   343 	LOG_PLAYER_RECORD( CLogPlayerRecorder::LogUpdateL( reinterpret_cast<TUint>(this), *document ) );

   344 	iIndexDb->UpdateL(*document, this, aMessage);

   345 	

   346 	CleanupStack::PopAndDestroy(document);

   347 	CleanupStack::PopAndDestroy(serializedDocument);

   348 	}

   349 

   350 void CSearchServerSubSession::UpdateCompleteL(const RMessage2& /*aMessage*/)

   351 	{

   352 	iIndexDb->UpdateCompleteL();	

   353 	}

   354 

   355 

   356 void CSearchServerSubSession::DeleteL(const RMessage2& aMessage)

   357 	{

   358 	// Sanity check

   359 	if (!iIndexDb->IsOpen())

   360 		{

   361 		iSession->PanicClient(aMessage, EDatabaseNotOpen);

   362 		return;

   363 		}

   364 

   365 	HBufC* docUid = HBufC::NewLC(aMessage.GetDesLength(0));

   366 

   367 	TPtr ptr = docUid->Des();

   368 	aMessage.ReadL(0, ptr);

   369 

   370 	LOG_PLAYER_RECORD( CLogPlayerRecorder::LogDeleteL( reinterpret_cast<TUint>(this), *docUid ) );

   371 	iIndexDb->DeleteDocumentsL(*docUid, this, aMessage);

   372 

   373 	CleanupStack::PopAndDestroy(docUid);

   374 	}

   375 

   376 void CSearchServerSubSession::DeleteCompleteL(const RMessage2& /*aMessage*/)

   377 	{

   378 	iIndexDb->DeleteDocumentsCompleteL();	

   379 	}

   380 

   381 void CSearchServerSubSession::FlushCompleteL(const RMessage2& /*aMessage*/)

   382 	{

   383 	iIndexDb->FlushCompleteL();	

   384 	}

   385 

   386 void CSearchServerSubSession::ResetL(const RMessage2& aMessage)

   387 	{

   388 	// Sanity check

   389 	if (!iIndexDb->IsOpen())

   390 		{

   391 		iSession->PanicClient(aMessage, EDatabaseNotOpen);

   392 		return;

   393 		}

   394 

   395 	// Reset database

   396 	LOG_PLAYER_RECORD( CLogPlayerRecorder::LogResetL( reinterpret_cast<TUint>(this) ) );

   397 	iIndexDb->ResetL();

   398 	

   399 	// Complete the request

   400 	aMessage.Complete(KErrNone);		

   401 	}

   402 

   403 void CSearchServerSubSession::FlushL(const RMessage2& aMessage)

   404     {

   405     // Sanity check

   406     if (!iIndexDb->IsOpen())

   407         {

   408         iSession->PanicClient(aMessage, EDatabaseNotOpen);

   409         return;

   410         }

   411     

   412     LOG_PLAYER_RECORD( CLogPlayerRecorder::LogFlushL( reinterpret_cast<TUint>(this) ) );

   413     iIndexDb->FlushL(this, aMessage);

   414     }

   415 

   416 

   417 void CSearchServerSubSession::HandleAsyncronizerComplete(TCPixTaskType aType, TInt aError, const RMessage2& aMessage)

   418 	{

   419 	if (aError == KErrNone)

   420 		{

   421 		switch (aType)

   422 			{

   423 			case ECPixTaskTypeSearch:

   424 				{

   425 				TRAP(aError, SearchCompleteL(aMessage));

   426 				break;

   427 				}

   428 			case ECPixTaskTypeGetDocument:

   429 				{

   430 				TRAP(aError, GetDocumentCompleteL(aMessage));

   431 				break;

   432 				}

   433 			case ECPixTaskTypeAdd:

   434 				{

   435 				TRAP(aError, AddCompleteL(aMessage));

   436 				break;

   437 				}

   438 			case ECPixTaskTypeUpdate:

   439 				{

   440 				TRAP(aError, UpdateCompleteL(aMessage));

   441 				break;

   442 				}

   443 			case ECPixTaskTypeDelete:

   444 				{

   445 				TRAP(aError, DeleteCompleteL(aMessage));

   446 				break;

   447 				}

   448 			case ECPixTaskTypeFlush:

   449 				{

   450 				TRAP(aError, FlushCompleteL(aMessage));

   451 				break;

   452 				}

   453 			default:

   454 				{

   455 				// No need for completion code for the rest

   456 				break;

   457 				}

   458 			}

   459 		}

   460 	

   461 	// Complete the request

   462 	aMessage.Complete(aError);		

   463 	}

   464