addressbookengine.cpp

symbian v9.1 下的地址本程序

/*
* ==============================================================================
*  Name        : AddressBookEngine.cpp
*  Part of     : AddressBook
*  Interface   : 
*  Description : Application Engine class, CAddressBookEngine - 
*				 performs engine related operations
*  Version     : 
*
*  Copyright (c) 2002-2006 Nokia Corporation.
*  This material, including documentation and any related 
*  computer programs, is protected by copyright controlled by 
*  Nokia Corporation.
* ==============================================================================
*/

// INCLUDES
#include "AddressBookEngine.h"
#include "AddressBookAppUi.h"
#include "AddressBookConstants.h"

#include <SenServiceManager.h>
#include <SenXmlServiceDescription.h>
#include <SenXmlUtils.h>
#include <SenIdentityProvider.h>

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

// ----------------------------------------------------------------------------
// CAddressBookEngine::CAddressBookEngine(MAddressBookEngineObserver& aObserver)
// constructor
// ----------------------------------------------------------------------------
//
CAddressBookEngine::CAddressBookEngine(MAddressBookEngineObserver& aObserver)
: iConnection(NULL),
  iSession(NULL),
  iXmlReader(NULL),
  iObserver(aObserver),
  iManager(NULL),
  iFaultDelegate(NULL),
  iErrorState(ENoError),
  iInitialized(EFalse)
	{
	}
	
// ---------------------------------------------------------------------------- 
// CAddressBookEngine::CAddressBookEngine()
// destructor
// ----------------------------------------------------------------------------
//
CAddressBookEngine::~CAddressBookEngine()
	{
	_LIT( KLogFileClosed, "CAddressBookEngine::~CAddressBookEngine() - Log file closed.");
	LOG(KLogFileClosed);
	iContacts.ResetAndDestroy();
	delete iXmlReader;
	delete iFaultDelegate;
	delete iManager;
	delete iConnection;
	delete iSession;
	delete iFaultDelegate;
	}

// ---------------------------------------------------------------------------- 
// CAddressBookEngine::NewL(MAddressBookEngineObserver& aObserver)
// Two-phased constructor
// ----------------------------------------------------------------------------
//
CAddressBookEngine* CAddressBookEngine::NewL(
									MAddressBookEngineObserver& aObserver)
	{
	CAddressBookEngine* newEngine = new (ELeave) CAddressBookEngine(aObserver);
	CleanupStack::PushL(newEngine);
	newEngine->ConstructL();
	CleanupStack::Pop(newEngine);
	return newEngine;
	}
	
// ----------------------------------------------------------------------------
// CAddressBookEngine::ConstructL()
// EPOC default constructor can leave
// ----------------------------------------------------------------------------
//
void CAddressBookEngine::ConstructL()
	{
	LOG_OPEN();
	_LIT( KConstructL, "CAddressBookEngine::ConstructL() ***");
	LOG(KConstructL);
	CSenBaseFragment::BaseConstructL(KPpContract, KQueryResponseLocalName);
	iXmlReader = CSenXmlReader::NewL();
	}

// ----------------------------------------------------------------------------
// CAddressBookEngine::HandleMessageL(const TDesC8& aMessage)
// It is overridden from interface MSenServiceConsumer function
// for receiving messages from the SendL()(CSenServiceConnection)function call
// ----------------------------------------------------------------------------
//
void CAddressBookEngine::HandleMessageL(const TDesC8& aMessage)
	{
	_LIT(KHandleMessageL, "CAddressBookEngine::HandleMessageL()");
	LOG( KHandleMessageL);
	LOG_ALL(aMessage);
	iContacts.ResetAndDestroy();
	SetReader(*iXmlReader);
	
	// ------------------------------------------------------------------------
	// Xmlparser calls CAddressBook::StartElementL every time a new element tag is found
	// and CAddressBookEngine::EndElementL every time a closing element tag is found.
	// ------------------------------------------------------------------------
	// 
	ParseL(aMessage);
	iObserver.SearchFinishedL(iContacts);
	}

// ----------------------------------------------------------------------------
// CAddressBookEngine::HandleErrorL(const TInt aErrorCode, const TDesC8& aError)	
// It is the overridden function from MSenServiceConsumer interface
// for receiving errors about the connection to be initialized or from the
// SendL() (CSenServiceConnection) function call.
// ----------------------------------------------------------------------------
//
void CAddressBookEngine::HandleErrorL(const TInt aErrorCode, const TDesC8& aError)
	{
	_LIT( KHandleErrorL, "CAddressBookEngine::HandleErrorL()");
	LOG( KHandleErrorL);
	TBuf<24> code;
	code.AppendNum(aErrorCode);
	LOG(code);
	LOG_ALL(aError);
	iContacts.ResetAndDestroy();
	
	// ------------------------------------------------------------------------
	// Every error reported here is not nested XML error,
	// probably SOAP error, so show general error.
    // More sophisticated applications could resolve service
	// specific info about failure by inspecting soap fault
	// received in here.
	// ------------------------------------------------------------------------
	//
	iObserver.ErrorL(ESearchFailed);
	}

// ----------------------------------------------------------------------------
// CAddressBookEngine::SetStatus(const TInt aStatus)
// It is overridden function from MSenServiceConsumer interface
// for receiving status info about the connection to be initialized.
// It is called by CSenServiceConnectionImpl::RunL() that is called by active
// scheduler from CAddressBookAppUi::HandleCommandL(TInt aCommand) in case
// "EAddressBookCmdAppConnect"
// ----------------------------------------------------------------------------
//
void CAddressBookEngine::SetStatus(const TInt aStatus)
	{
	_LIT( KSetStatus, "CAddressBookEngine::SetStatus()");
	LOG( KSetStatus);
	iConnectionState = aStatus;
	switch(iConnectionState)
		{
		case KSenConnectionStatusNew:
			_LIT( KSenConnStatNew, "KSenConnectionStatusNew");
			LOG( KSenConnStatNew);
			break;
		case KSenConnectionStatusReady:
			_LIT( KSenConnStatRdy, "KSenConnectionStatusReady");
			LOG( KSenConnStatRdy);
			iInitialized = ETrue;
			iObserver.ConnectionReady();
			break;
		case KSenConnectionStatusExpired:
			_LIT( KSenConnStatEx, "KSenConnectionStatusExpired");
			LOG( KSenConnStatEx);
			break;
		default:
			TBuf<32> num;
			num.AppendNum(iConnectionState);
			_LIT( KUknStat, "UNKNOWN STATUS: (%S)");
			LOG_FORMAT((KUknStat, num));
			break;
		}
	if(!iInitialized)
		{
		TInt leaveCode(KErrNone);
		TRAP(leaveCode, iObserver.ErrorL(EConnectionNotReady));
		leaveCode = 0; // not used
		}
	}

// ---------------------------------------------------------------------------
// CAddressBookEngine::ResolveResourceIdL()
// This helper function resolves the ResourceID from WSF using
// ServiceDescriptionL() getter method.
// return pointer to resolved ResourceID element,
// which content indicates whether it is encrypted or not; 
// content of encrypted ResourceID includes "EncryptedData" element.
//----------------------------------------------------------------------------
//
CSenElement* CAddressBookEngine::ResolveResourceIdL()
	{
	_LIT( KResolveResourceIdL, "ResolveResourceIdL()");
	LOG( KResolveResourceIdL);
	TInt parseLeaveCode(KErrNone);
	HBufC8* sd = NULL;
	CSenElement* resourceID = NULL;

	if(iInitialized && iConnection)  
		{
		TInt err0 = iConnection->ServiceDescriptionL(sd);
		if(err0 == KErrNone && sd)
			{
			_LIT( KServDescRet, "iConnection->ServiceDescriptionL(sd) returned:");
			LOG( KServDescRet);
			CleanupStack::PushL(sd);
			LOG_ALL((*sd));
			delete iSession;
			iSession = NULL;
			iSession = CSenXmlServiceDescription::NewL();
			iSession->SetReader(*iXmlReader);
			iXmlReader->SetContentHandler(*iSession);
			TRAP(parseLeaveCode, iSession->ParseL(*sd));
			CleanupStack::PopAndDestroy(sd); 
			if(parseLeaveCode!=KErrNone)
				{
				_LIT( KParServDescFailed, "Parsing of service description (session) failed!");
				LOG( KParServDescFailed);
				}
			else
				{
				_LIT8 (KResourceID, "ResourceID");
				resourceID = iSession->AsElement().Element(KResourceID);
				if(resourceID)
					{
					_LIT( KResID, "ResourceID:");
					LOG(KResID);
					LOG_ALL((resourceID->Content()));
					}
				else
					{
					_LIT( KResIdNotFound, "ResourceID not found from service description.");
					LOG( KResIdNotFound);
					}
				}
			}
		}
	return resourceID;
	}

// ----------------------------------------------------------------------------
// CAddressBookEngine::GenerateQueryRequestL(const TDesC& aSearchPattern)
// gets the XML query based on the search parameter passed
// SAMPLE XML Request is 
// 
// <ab:Query xmlns:ab=\"urn:nokia:test:addrbook:2004-09\">
//	 <ab:QueryItem>
//		<ab:Select> 
//		        ab:Card[contains(ab:N ab:FAMILY,"%S") or contains(ab:N ab:GIVEN, "%S") or contains(ab:TEL, "%S")]
//		</ab:Select>
// 	 </ab:QueryItem>
//	 <ab:ResourceID>
//	      XYZ
//	 </ab:ResourceID>
// </ab:Query>
//
// The %S will be replaced with the value entered by user as search string
// ----------------------------------------------------------------------------
//
HBufC8* CAddressBookEngine::GenerateQueryRequestL(const TDesC& aSearchPattern)
	{
	_LIT( KGenQueryReqL, "CAddressBookEngine::GenerateQueryRequestL(const TDesC& aSearchPattern)");
	LOG( KGenQueryReqL);
 
 	// Create Query Tag
 	_LIT8 (KElement, "Query");
    CSenElement* element = CSenBaseElement::NewL(KElement);
	CleanupStack::PushL(element);
	element->SetNamespaceL(KQueryNS, KPpContract);
	
	// Create QueryItem element
	_LIT8 (KQueryItem, "ab:QueryItem");	
	CSenElement* queryItem = CSenBaseElement::NewL(KQueryItem);
	CleanupStack::PushL(queryItem);
	
	// Create Select element
	_LIT8 (KSelectElement, "ab:Select");
	CSenBaseElement* selectElement=CSenBaseElement::NewL(KSelectElement);	
	CleanupStack::PushL(selectElement);
	
	//Create temporary buffer and perform UTF8 conversion for parameter passed	
	HBufC8* tempBuffer = HBufC8::NewLC(512);  	
	TPtr8 ptrSelectQuery = tempBuffer->Des();	
	HBufC8* pattern = SenXmlUtils::ToUtf8LC(aSearchPattern); 
	//Replace %S with pattern passed in parameter
	ptrSelectQuery.Format(KSelectQuery, pattern, pattern, pattern);	
		
	selectElement->SetContentL(ptrSelectQuery);	
	// Add select element to QueryItem
	queryItem->AddElementL(*selectElement);
		
	//Add QueryItemto Query
	element->AddElementL(*queryItem);

	// Next phase is to create and add ResourceID element into the query.
	CSenElement* resourceID = ResolveResourceIdL();
	CSenBaseElement* resourceElement = NULL; 
	if(resourceID)
		{
		// (Encrypted)Resource was successfully resolved. Now check
		// whether plain ResourceID or EncryptedResourceID is
		// available and create according element into the query.
		if (resourceID->Content().Find(KEncrypted()) != KErrNotFound) 
			{
			_LIT( KEncResID, "EncryptedResourceID exists.");
			LOG(KEncResID);
			_LIT8 (KResourceElement, "ab:EncryptedResourceID");
			resourceElement = CSenBaseElement::NewL(KResourceElement);
			CleanupStack::PushL(resourceElement);	
			// copy the actual resource id content
			resourceElement->CopyFromL(*resourceID);
			}
		else
			{
			_LIT( KOnlyPlainResID, "Only plain ResourceID should be used (not encrypted).");
			LOG( KOnlyPlainResID);
			_LIT8 (KResourceElement, "ab:ResourceID");
			resourceElement = CSenBaseElement::NewL(KResourceElement);
			CleanupStack::PushL(resourceElement);	
			// Copy the actual resource id content
			resourceElement->CopyFromL(*resourceID);
			}
		}
	else
		{
		_LIT( KErrResID, "Error: could not resolve ResourceID!");
		LOG( KErrResID);
		_LIT8 (KResourceElement, "ab:ResourceID");
		resourceElement=CSenBaseElement::NewL(KResourceElement);	
		CleanupStack::PushL(resourceElement);	
		resourceElement->SetContentL(KResourceIDVal); // example content
		}
	element->AddElementL(*resourceElement);
	CleanupStack::Pop(resourceElement); 
	
	//Get the XML
	HBufC8* soapBuf = element->AsXmlL();

	// Log the XML request
    _LIT( KGenQuery, "Generated Query:");
    LOG( KGenQuery);
	LOG_ALL(( soapBuf->Des() ));
	
	//Destroy the objects pushed on cleanup stack
	CleanupStack::PopAndDestroy(pattern);
	CleanupStack::PopAndDestroy(tempBuffer);
	CleanupStack::Pop(selectElement);
	CleanupStack::Pop(queryItem);
	CleanupStack::PopAndDestroy(element);
	//return Pointer to Soap Request Buffer;
	return soapBuf;