diff -r 000000000000 -r e686773b3f54 pimprotocols/pbap/server/pbapchexporter.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/pimprotocols/pbap/server/pbapchexporter.cpp Tue Feb 02 10:12:17 2010 +0200 @@ -0,0 +1,451 @@ +// Copyright (c) 2006-2009 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 + +#include "pbapchexporter.h" +#include "pbapserver.h" +#include "pbapexporter.h" +#include "pbapfolderclient.h" +#include "pbapcontactdbviews.h" +#include "pbaplogeng.h" + +#include "btaccesshostlog.h" + + +// +// CPbapChExporter +// +CPbapChExporter::CPbapChExporter(MVirtualFolderClient& aClient, + MPbapExporterCallback& aCallback, + CPbapChView& aViewToExport, + CPbapChView* aReadViewToExport, + TUint aStartIndex, + TInt aCount) +: CPbapExporterBase(aClient, aCallback), + iState(EIdle), + iStartIndex(aStartIndex), + iCount(aCount) + { + LOG_FUNC + + // iCurrentEventIndex starts from 0, because CLogView can only start from the first event. + iCurrentEventIndex = 0; + + // get views to export + iLogView = aViewToExport.LogView(); + + // read view optional, used for missed calls only + if (aReadViewToExport) + { + iReadEventView = aReadViewToExport->LogView(); + } + + CActiveScheduler::Add(this); + } + +void CPbapChExporter::ConstructL() + { + LOG_FUNC + + iState = EStartExport; + + // complete ourselves to kick-off the async processing + TRequestStatus* status=&iStatus; + User::RequestComplete(status, KErrNone); + + SetActive(); + } + +CPbapChExporter::~CPbapChExporter() + { + LOG_FUNC + + Cancel(); + } + +TBool CPbapChExporter::PrepareForFetchingL(TUint aNumberOfEvents) + { + LOG_FUNC + + // reset the number of items to be exported based on the view size + iCount = Min(iCount, (aNumberOfEvents - iStartIndex)); + return (iCount > 0); + } + +void CPbapChExporter::StartExportL() + { + LOG_FUNC + + iClient.Exporter().StartExport(); + + // check to see if we need to export number of unread events + if (iReadEventView) + { + iClient.Exporter().ExportNewMissedCallsL(iLogView->CountL() - iReadEventView->CountL()); + } + + TBool startFetching = PrepareForFetchingL(iLogView->CountL()); + if (startFetching && iLogView->FirstL(iStatus)) + { + iState = EFetchingLogEvents; + SetActive(); + } + else + { + // no events to fetch + FinaliseFetchLogEventsL(); + } + } + +void CPbapChExporter::FetchLogEventsL() + { + LOG_FUNC + + // call derived class to process fetched event + TBool continueFetching = EventFetchedL(iLogView->Event(), iCurrentEventIndex); + ++iCurrentEventIndex; + if (continueFetching && iLogView->NextL(iStatus)) + { + SetActive(); + } + else + { + // all events fetched + FinaliseFetchLogEventsL(); + } + } + +void CPbapChExporter::RunL() + { + LOG_FUNC + + User::LeaveIfError(iStatus.Int()); + + switch (iState) + { + case EStartExport: + StartExportL(); + break; + case EFetchingLogEvents: + FetchLogEventsL(); + break; + default: + break; + } + } + +void CPbapChExporter::DoCancel() + { + LOG_FUNC + + iLogView->Cancel(); + + // export aborted + iClient.Exporter().CancelExport(); + iCallback.HandleExportComplete(KErrCancel); + } + + +TInt CPbapChExporter::RunError(TInt aError) + { + LOG_FUNC + + // abort the export + iClient.Exporter().CancelExport(); + + // notify observer + iCallback.HandleExportComplete(aError); + return KErrNone; + } + +void CPbapChExporter::FinaliseFetchLogEventsL() + { + LOG_FUNC + + // no event to fetch + FetchingCompleteL(); + iClient.Exporter().FinaliseExportL(); + iCallback.HandleExportComplete(KErrNone); + } + + +// +// CPbapChListingExporter +// +CPbapChListingExporter* CPbapChListingExporter::NewL(MVirtualFolderClient& aClient, + MPbapExporterCallback& aCallback, + CPbapChView& aViewToExport, + CPbapChView* aReadViewToExport, + TUint aStartIndex, + TInt aCount) + { + LOG_STATIC_FUNC + CPbapChListingExporter* self = + new(ELeave) CPbapChListingExporter(aClient, aCallback, aViewToExport, + aReadViewToExport, aStartIndex, aCount); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + return self; + } + +CPbapChListingExporter::CPbapChListingExporter(MVirtualFolderClient& aClient, + MPbapExporterCallback& aCallback, + CPbapChView& aViewToExport, + CPbapChView* aReadViewToExport, + TUint aStartIndex, + TInt aCount) +: CPbapChExporter(aClient, aCallback, aViewToExport, aReadViewToExport, aStartIndex, aCount) + { + LOG_FUNC + } + +TBool CPbapChListingExporter::PrepareForFetchingL(TUint aNumberOfEvents) + { + LOG_FUNC + // add listing header before first entry is exported + iClient.Exporter().ExportListingBeginL(); + + return CPbapChExporter::PrepareForFetchingL(aNumberOfEvents); + } + +TBool CPbapChListingExporter::EventFetchedL(const CLogEvent& aEvent, TInt aEventIndex) + { + LOG_FUNC + + TBool moreItemsToExport = EFalse; + + if (aEventIndex < iStartIndex) + { + // skip this event + moreItemsToExport = ETrue; + } + else if (aEventIndex < iStartIndex + iCount) + { + // export event as a listing entry + TInt handle = aEventIndex + 1; // call history handles start from 1 + + TContactItemId contactId = aEvent.Contact(); + if (contactId != KNullContactId) + { + // a contact is associated with the log event so read its name from the database + RBuf name; + TRAPD(error , name.Assign(iClient.ContactDbViews().GetContactNameFromIdL(contactId))); + if (error != KErrNone || !name.Size()) + { + // cannot read contact name (e.g. the contact id doesnot exist + // anymore) so fallback to using the log events phone number + name.Assign(aEvent.Number().AllocL()); + } + name.CleanupClosePushL(); + iClient.Exporter().ExportListingEntryL(handle, name); + CleanupStack::PopAndDestroy(&name); + + } + else + { + // no contact associated with log event so use number instead of name + const TDesC& phoneNumber = aEvent.Number(); + iClient.Exporter().ExportListingEntryL(handle, phoneNumber); + } + moreItemsToExport = ETrue; + } + return moreItemsToExport; + } + +void CPbapChListingExporter::FetchingCompleteL() + { + LOG_FUNC + // no more listing entries to be exported so close listing + iClient.Exporter().ExportListingEndL(); + } + + +// +// CPbapChItemExporter +// +CPbapChItemExporter* CPbapChItemExporter::NewL(MVirtualFolderClient& aClient, + MPbapExporterCallback& aCallback, + CPbapChView& aViewToExport, + CPbapChView* aReadViewToExport, + TUint aStartIndex, + TInt aCount, + TVCardVersion aFormat, + TUint64 aFilter) + { + LOG_STATIC_FUNC + CPbapChItemExporter* self = + new(ELeave) CPbapChItemExporter(aClient, aCallback, aViewToExport, aReadViewToExport, + aStartIndex, aCount, aFormat, aFilter); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + return self; + } + +CPbapChItemExporter::CPbapChItemExporter(MVirtualFolderClient& aClient, + MPbapExporterCallback& aCallback, + CPbapChView& aViewToExport, + CPbapChView* aReadViewToExport, + TUint aStartIndex, + TInt aCount, + TVCardVersion aFormat, + TUint64 aFilter) +: CPbapChExporter(aClient, aCallback, aViewToExport, aReadViewToExport, aStartIndex, aCount), +iFormat(aFormat), +iFilter(aFilter) + { + LOG_FUNC + } + +TBool CPbapChItemExporter::EventFetchedL(const CLogEvent& aEvent, TInt aEventIndex) + { + LOG_FUNC + + TBool moreItemsToExport = EFalse; + + if(aEventIndex < iStartIndex) + { + // skip this event + moreItemsToExport =ETrue; + } + else if (aEventIndex < iStartIndex + iCount) + { + // export the event + iClient.Exporter().ExportCallHistoryL(aEvent, iFormat, iFilter); + moreItemsToExport = ETrue; + } + return moreItemsToExport; + } + +void CPbapChItemExporter::FetchingCompleteL() + { + LOG_FUNC + // do nothing + } + +// +// CPbapChSingleItemExporter +// +CPbapChSingleItemExporter* CPbapChSingleItemExporter::NewL(MVirtualFolderClient& aClient, + MPbapExporterCallback& aCallback, + CPbapChView& aViewToExport, + TInt aIndex, + TVCardVersion aFormat, + TUint64 aFilter) + { + LOG_STATIC_FUNC + CPbapChSingleItemExporter* self = + new(ELeave) CPbapChSingleItemExporter(aClient, aCallback, aViewToExport, aIndex, aFormat, aFilter); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + return self; + } + + +CPbapChSingleItemExporter::CPbapChSingleItemExporter(MVirtualFolderClient& aClient, + MPbapExporterCallback& aCallback, + CPbapChView& aViewToExport, + TInt aIndex, + TVCardVersion aFormat, + TUint64 aFilter) +: CPbapChExporter(aClient, aCallback, aViewToExport), iIndex(aIndex), iFormat(aFormat), iFilter(aFilter) + { + LOG_FUNC + } + +TBool CPbapChSingleItemExporter::PrepareForFetchingL(TUint aNumberOfEvents) + { + LOG_FUNC + if (iIndex < 0 || iIndex >= aNumberOfEvents) + { + // attempting to export an event which doesnot exist + User::Leave(KErrNotFound); + } + return ETrue; + } + +TBool CPbapChSingleItemExporter::EventFetchedL(const CLogEvent& aEvent, TInt aEventIndex) + { + LOG_FUNC + + if (aEventIndex == iIndex) + { + iClient.Exporter().ExportCallHistoryL(aEvent, iFormat, iFilter); + return EFalse; + } + return ETrue; + } + +void CPbapChSingleItemExporter::FetchingCompleteL() + { + LOG_FUNC + // do nothing + } + +// +// CPbapChCountExporter +// +CPbapChCountExporter* CPbapChCountExporter::NewL(MVirtualFolderClient& aClient, + MPbapExporterCallback& aCallback, + CPbapChView& aViewToExport, + CPbapChView* aReadViewToExport) + { + LOG_STATIC_FUNC + CPbapChCountExporter* self = new(ELeave) CPbapChCountExporter(aClient, aCallback, + aViewToExport, aReadViewToExport); + CleanupStack::PushL(self); + self->ConstructL(); + CleanupStack::Pop(self); + return self; + } + +CPbapChCountExporter::CPbapChCountExporter(MVirtualFolderClient& aClient, + MPbapExporterCallback& aCallback, + CPbapChView& aViewToExport, + CPbapChView* aReadViewToExport) + +: CPbapChExporter(aClient, aCallback, aViewToExport, aReadViewToExport) + { + LOG_FUNC + } + +TBool CPbapChCountExporter::PrepareForFetchingL(TUint aNumberOfEvents) + { + LOG_FUNC + + // the size of the phonebook is equal to the number of events in the log view + iClient.Exporter().ExportPhonebookSizeL(aNumberOfEvents); + + // the phonebook size has been exported, so abort fetch + return EFalse; + } + +TBool CPbapChCountExporter::EventFetchedL(const CLogEvent& /*aEvent*/, TInt /*aEventIndex*/) + { + LOG_FUNC + //Release build should silently ignore the event + __ASSERT_DEBUG(EFalse, Panic(EPbapChCountExporterFetchingFails)); + // do nothing (fetching should have been aborted) + return EFalse; + } + +void CPbapChCountExporter::FetchingCompleteL() + { + LOG_FUNC + // do nothing + }