/*
* Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).
* All rights reserved.
* This component and the accompanying materials are made available
* under the terms of the License "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:
*
*/
//System Includes
#include <e32cmn.h> //for RPointerArray
#include <calsession.h> //For CCalSession
#include <calentryview.h>
#include <CalenInterimUtils2.h>
#include <s32mem.h>
#include <s32file.h>
#include <e32base.h>
#include <calinstanceview.h>
#include <calinstance.h>
#include <calentry.h>
//User Include
#include "calendarheader.h"
#include "calendarconstants.h"
#include "asyncreqobserver.h"
#include "calendargetlist.h"
#include "calendarheader.h"
void CleanupCCalEntryArray(TAny* aPointer);
void CleanupCCalInstanceArray(TAny* aPointer);
// --------------------------------------------------------------------------------------------------------
// Static Method which either returns the Two Phase constructed Object or Leave
// NOTE: Ownership of any of the parameters is not taken through this function call
// NOTE: Therefore the User of this function needs to take care of neccessary cleanup of passed parameters
// --------------------------------------------------------------------------------------------------------
//
CCalendarGetList* CCalendarGetList::NewL ( CCalendarSessionInfo* aCalSessionInfo,
const TDesC8& aGuid,
CAsyncRequestObserver* aAsyncRequestObserver,
MCalCallbackBase* aCallBack )
{
CCalendarGetList* self = new (ELeave) CCalendarGetList( aCalSessionInfo, aAsyncRequestObserver, aCallBack );
CleanupStack::PushL(self);
self->ConstructL( aGuid );
CleanupStack::Pop(self);
return self;
}
// --------------------------------------------------------------------------------------------------------
// Static Method which either returns the Two Phase constructed Object or Leave
// NOTE: Ownership of any of the parameters is not taken through this function call
// NOTE: Therefore the User of this function needs to take care of neccessary cleanup of passed parameters
// --------------------------------------------------------------------------------------------------------
//
CCalendarGetList* CCalendarGetList::NewL ( CCalendarSessionInfo* aCalSessionInfo,
const TCalLocalUid aLocalUid,
CAsyncRequestObserver* aAsyncRequestObserver,
MCalCallbackBase* aCallBack )
{
CCalendarGetList* self = new (ELeave) CCalendarGetList( aCalSessionInfo, aAsyncRequestObserver, aCallBack );
CleanupStack::PushL(self);
self->ConstructL( aLocalUid );
CleanupStack::Pop(self);
return self;
}
// --------------------------------------------------------------------------------------------------------
// Static Method which either returns the Two Phase constructed Object or Leave
// NOTE: Ownership of any of the parameters is not taken through this function call
// NOTE: Therefore the User of this function needs to take care of neccessary cleanup of passed parameters
// --------------------------------------------------------------------------------------------------------
//
CCalendarGetList* CCalendarGetList::NewL ( CCalendarSessionInfo* aCalSessionInfo,
CCalendarFilter* aFilter,
CAsyncRequestObserver* aAsyncRequestObserver,
MCalCallbackBase* aCallBack )
{
CCalendarGetList* self = new (ELeave) CCalendarGetList( aCalSessionInfo, aAsyncRequestObserver, aCallBack );
CleanupStack::PushL(self);
// Construct filter object which determines the type of get
self->ConstructL( aFilter );
CleanupStack::Pop(self);
return self;
}
// --------------------------------------------------------------------------------------------------------
// Destructor.
// --------------------------------------------------------------------------------------------------------
//
CCalendarGetList::~CCalendarGetList()
{
Cancel();
delete iFilter;
delete iGuid;
iEntryList.Reset();
iInstanceList.Reset();
}
// --------------------------------------------------------------------------------------------------------
// Constructor.
// --------------------------------------------------------------------------------------------------------
//
CCalendarGetList::CCalendarGetList( CCalendarSessionInfo* aCalSessionInfo,
CAsyncRequestObserver* aAsyncRequestObserver,
MCalCallbackBase* aCallBack ):
//CActive( EPriorityStandard ),
iSessionInfo (aCalSessionInfo ),
iCallBack( aCallBack ),
iAsyncRequestObserver(aAsyncRequestObserver)
{
}
// --------------------------------------------------------------------------------------------------------
// 2nd-phased constructor of two phase construction
// --------------------------------------------------------------------------------------------------------
//
void CCalendarGetList::ConstructL( const TDesC8& aGuid )
{
if(aGuid.Length())
{
iGuid = aGuid.AllocL();// = aGuid ;
iGetListOption = EGetListGUid;
}
}
void CCalendarGetList::ConstructL( const TCalLocalUid aLocalUid )
{
iLocalUid = aLocalUid;
iGetListOption = EGetListLocalUid;
}
// --------------------------------------------------------------------------------------------------------
// GetList implementation
// --------------------------------------------------------------------------------------------------------
//
void CCalendarGetList::ConstructL( CCalendarFilter* aFilter )
{
iFilter = CCalendarFilter::NewL();
*iFilter = *aFilter;
iGetListOption = EGetListTimeRange;
}
void CCalendarGetList::GetListL( const TDesC8& aGuid, RPointerArray<CCalEntry>& aEntryList )
{
iSessionInfo ->EntryView()->FetchL( aGuid, aEntryList );
}
void CCalendarGetList::GetListL(const TCalLocalUid aLocalUid, RPointerArray<CCalEntry>& aEntryList )
{
CCalEntry* entry = iSessionInfo ->EntryView()->FetchL( aLocalUid );
if( entry )
{
aEntryList.Append( entry );
}
}
void CCalendarGetList::GetListL( RPointerArray<CCalInstance>& aInstanceList )
{
// iInstanceList = aInstanceList;
CalCommon::TCalTimeRange range = iFilter->TimeRange();
if( (range.EndTime().TimeLocalL()) < (range.StartTime().TimeLocalL()) )
User::Leave( KErrArgument );
if ( iFilter->FilterText().Length() )
{
// Search and return all instances which match filter text and time range
CCalInstanceView::TCalSearchParams searchParam( iFilter->FilterText(), CalCommon::EFoldedTextSearch );
iSessionInfo ->InstanceView()->FindInstanceL( aInstanceList,
iFilter->FilterType(),
iFilter->TimeRange(), searchParam ) ;
}
else
{
// Search and return all instances which match filter type and time range
iSessionInfo ->InstanceView()->FindInstanceL( aInstanceList,
iFilter->FilterType(),
iFilter->TimeRange() ) ;
}
}
void CCalendarGetList::GetListL()
{
if( iCallBack ) // making call as asynchronous
{
if(!iAsyncRequestObserver )
User::Leave( KErrArgument );
CActiveScheduler::Add ( this );
ActivateRequest( KErrNone );
}
}
// --------------------------------------------------------------------------------------------------------
// Notifies callback the result for asynchronous request.
// --------------------------------------------------------------------------------------------------------
//
void CCalendarGetList::NotifyRequestResult( TInt aReason )
{
if ( iCallBack )
{
iAsyncRequestObserver->RequestComplete( iCallBack->iTransactionId );
if( iGetListOption == EGetListGUid )
{
TRAPD( err, iCallBack->NotifyResultL( aReason, ( TAny * )( & iEntryList )));
}
else if( iGetListOption == EGetListLocalUid )
{
TRAPD( err, iCallBack->NotifyResultL( aReason, ( TAny * )( & iEntryList )));
}
else
{
TRAPD( err, iCallBack->NotifyResultL( aReason, ( TAny * )( & iInstanceList )));
}
}
if ( aReason != KErrCancel )
delete this;
}
// ---------------------------------------------------------------------------
// Inherited from CActive class
// ---------------------------------------------------------------------------
//
void CCalendarGetList::DoCancel()
{
NotifyRequestResult( KErrCancel );
}
// ---------------------------------------------------------------------------
// Inherited from CActive class
// ---------------------------------------------------------------------------
//
void CCalendarGetList::RunL()
{
TInt err = iStatus.Int();
if ( err == KErrNone )
{
// Performs the actual delete depending on the parameters set
TRAP(err, StartFetchingL());
}
NotifyRequestResult( err );
}
// --------------------------------------------------------------------------------------------------------
// retrieves asynchronous request transactionid.
// --------------------------------------------------------------------------------------------------------
//
/*TInt32 CCalendarGetList::GetTransactionID()
{
return(iCallBack->GetTransactionID());
}*/
// ---------------------------------------------------------------------------
// retrieves Instances based on Time Range
// ---------------------------------------------------------------------------
//
void CCalendarGetList::GetTimeRangeL()
{
CalCommon::TCalTimeRange range = iFilter->TimeRange();
if( (range.EndTime().TimeLocalL()) < (range.StartTime().TimeLocalL()) )
User::Leave( KErrArgument );
if ( iFilter->FilterText().Length() )
{
// Search and return all instances which match filter text and time range
CCalInstanceView::TCalSearchParams searchParam( iFilter->FilterText(), CalCommon::EFoldedTextSearch );
iSessionInfo ->InstanceView()->FindInstanceL( iInstanceList,
iFilter->FilterType(),
iFilter->TimeRange(), searchParam ) ;
}
else
{
// Search and return all instances which match filter type and time range
iSessionInfo ->InstanceView()->FindInstanceL( iInstanceList,
iFilter->FilterType(),
iFilter->TimeRange() ) ;
}
}
// ---------------------------------------------------------------------------
// retrives Entries based in GlobalUid
// ---------------------------------------------------------------------------
//
void CCalendarGetList::GetGUidL()
{
TPtrC8 guid(iGuid->Des());
iSessionInfo ->EntryView()->FetchL( guid, iEntryList );
}
// ---------------------------------------------------------------------------
// retrives Entries based in LocalUid
// ---------------------------------------------------------------------------
//
void CCalendarGetList::GetLocalUidL()
{
CCalEntry* entry = iSessionInfo ->EntryView()->FetchL( iLocalUid/*(*iFilter->LocalUidList())[0], iEntryList*/ );
if( entry )
{
iEntryList.Append( entry );
}
}
// ---------------------------------------------------------------------------
// Call the appropriate getlist based in getlist option
// ---------------------------------------------------------------------------
//
void CCalendarGetList::StartFetchingL()
{
switch ( iGetListOption )
{
case EGetListGUid: // get guid - entries
GetGUidL();
break;
case EGetListLocalUid: // get localid - entries
GetLocalUidL();
break;
case EGetListTimeRange: // get time range - instances
GetTimeRangeL();
break;
default:
break;
}
}
// ---------------------------------------------------------------------------
// Initialises getlist option
// ---------------------------------------------------------------------------
//
void CCalendarGetList::InitializeGetListOption()
{
//Filter having only GUids
if ( iFilter->Filter() == EFilterGUid )
{
iGetListOption = EGetListGUid;
}
//Filter having only GUids
else if ( iFilter->Filter() == EFilterLUid )
{
iGetListOption = EGetListLocalUid;
}
//Filter having time range only (No GUid/LocalUid)
else
{
iGetListOption = EGetListTimeRange;
}
}
// ---------------------------------------------------------------------------
// Activates the asynchronous request
// ---------------------------------------------------------------------------
//
void CCalendarGetList::ActivateRequest( TInt aReason )
{
SetActive();
iStatus = KRequestPending;
TRequestStatus* temp = &iStatus;
User::RequestComplete( temp, aReason );
}