diff -r 5b6f26637ad3 -r f4a778e096c2 logsui/EngineSrc/CLogsClearNewMissed.cpp --- /dev/null Thu Jan 01 00:00:00 1970 +0000 +++ b/logsui/EngineSrc/CLogsClearNewMissed.cpp Wed Sep 01 12:29:52 2010 +0100 @@ -0,0 +1,369 @@ +/* +* Copyright (c) 2002 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: +* Class for setting a missed calls event and its duplicates read. This is needed only for +* clearing the new missed icon and duplicate counters for one missed call event if a call or +* message is initiated. +* +* +*/ + + +// INCLUDE FILES +#include +#include +#ifndef SYMBIAN_ENABLE_SPLIT_HEADERS +#include +#else +#include +#include +#endif +#include "CLogsClearNewMissed.h" +#include "MLogsObserver.h" +#include "LogsUID.h" +#include "LogsEngConsts.h" + + + + +// ---------------------------------------------------------------------------- +// CLogsClearNewMissed::NewL +// ---------------------------------------------------------------------------- +// +CLogsClearNewMissed* CLogsClearNewMissed::NewL( + RFs& aFsSession) + { + CLogsClearNewMissed* self = new (ELeave) CLogsClearNewMissed( aFsSession ); + CleanupStack::PushL( self ); + self->ConstructL(); + CleanupStack::Pop(); + return self; + } + +// ---------------------------------------------------------------------------- +// CLogsClearNewMissed::CLogsClearNewMissed +// ---------------------------------------------------------------------------- +// +CLogsClearNewMissed::CLogsClearNewMissed( + RFs& aFsSession ) : + CActive( EPriorityStandard ), + iFsSession( aFsSession ), + iPhase( EUnInitilized ) + { + } + +// ---------------------------------------------------------------------------- +// CLogsClearNewMissed::ConstructL +// ---------------------------------------------------------------------------- +// +void CLogsClearNewMissed::ConstructL() + { + iLogClient = CLogClient::NewL( iFsSession ); + iPhase = EUnInitilized; + + CActiveScheduler::Add( this ); + } + +// ---------------------------------------------------------------------------- +// CLogsClearNewMissed::~CLogsClearNewMissed +// ---------------------------------------------------------------------------- +// +CLogsClearNewMissed::~CLogsClearNewMissed() + { + Cancel(); + delete iLogViewRecent; + delete iRecentFilter; + delete iLogViewDuplicates; + delete iDuplicateFilter; + delete iLogClient; + delete iLogEvent; + } + +// ---------------------------------------------------------------------------- +// CLogsClearNewMissed::DoCancel +// ---------------------------------------------------------------------------- +// +void CLogsClearNewMissed::DoCancel() + { + if (iLogViewDuplicates) + { + iLogViewDuplicates->Cancel(); + } + + if (iLogViewRecent) + { + iLogViewRecent->Cancel(); + } + + if( iLogClient ) + { + iLogClient->Cancel(); + } + } + +// ---------------------------------------------------------------------------- +// CLogsClearNewMissed::SetNewMissedCallRead +// ---------------------------------------------------------------------------- +// +void CLogsClearNewMissed::SetNewMissedCallRead(TLogId aLogId, TInt aDuplicates) + { + iDuplicates = aDuplicates; + + // First we must read the event from the log db + if ( !IsActive() && (iPhase == EFinished || iPhase == EUnInitilized ) ) + { + TRAPD(err, GetEventL(aLogId)); + if (err) + { + // If there was a leave, just let this fail. Nothing to do. + } + } + else + { + // If still active, we don't do anything. The UI should prevent this from being possible + } + } + +// ---------------------------------------------------------------------------- +// CLogsClearNewMissed::GetEventL +// ---------------------------------------------------------------------------- +// +void CLogsClearNewMissed::GetEventL(TLogId aLogId) + { + delete iLogEvent; + iLogEvent = NULL; + iLogEvent = CLogEvent::NewL(); + + // When this asynchronous call finishes, the log event will contain all the event data + // corresponding to the event id. + iLogEvent->SetId(aLogId); + iLogClient->GetEvent( *iLogEvent, iStatus ); + + iPhase = EGetEvent; + SetActive(); + } + +// ---------------------------------------------------------------------------- +// CLogsClearNewMissed::RunL +// ---------------------------------------------------------------------------- +// +void CLogsClearNewMissed::RunL() + { + if (iStatus != KErrNone) + { + iPhase = EFinished; + } + else + { + switch(iPhase) + { + // 1.st phase: event data fetched from db. + case EGetEvent: + { + // If event has duplicates continue to setting the CLogViewRecent if possible + if ( TrySetRecentViewL() ) + { + iPhase = ESetRecentView; + SetActive(); + } + // Otherwise just set this event read. + else + { + iLogEvent->SetFlags( iLogEvent->Flags() | KLogEventRead ); + iLogClient->ChangeEvent( *iLogEvent, iStatus ); + + iPhase = EChangeEvent; + SetActive(); + } + break; + } + + case EChangeEvent: // If event has duplicates this state is skipped. + { + // Nothing to do anymore + iPhase = EFinished; + break; + } + + // Recent view set, set the duplicate view + case ESetRecentView: + { + if ( TrySetDuplicatesViewL() ) + { + iPhase = ESetDuplicatesView; + SetActive(); + } + else + { + // if there are no duplicates after all, just set the KLogEventRead flag + // for the recent view + SetReadFlagsL(); + iPhase = EFinished; + } + break; + } + + // Duplicate view set, set KLogEventRead flag for the views + case ESetDuplicatesView: + { + SetReadFlagsL(); + iPhase = EFinished; + break; + } + + default: + { + break; + } + } + } + } + +// ---------------------------------------------------------------------------- +// CLogsClearNewMissed::TrySetDuplicatesViewL +// ---------------------------------------------------------------------------- +// +TBool CLogsClearNewMissed::TrySetDuplicatesViewL() + { + if( !iLogViewDuplicates ) + { + iLogViewDuplicates = CLogViewDuplicate::NewL( *iLogClient ); + } + + // Duplicates filter is always the same, no need to recreate + // or "reset" after it has once been set + if( !iDuplicateFilter) + { + iDuplicateFilter = CLogFilter::NewL(); + iDuplicateFilter->SetFlags( KLogEventRead ); + iDuplicateFilter->SetNullFields( ELogFlagsField ); + } + + //DuplicatesL refreshes duplicate event view with the duplicates of the current + //event in the recent event list view. Is an asynchronous request. + //rc = False, if there are no events in the view. + TBool rc; + rc = iLogViewRecent->DuplicatesL( *iLogViewDuplicates, + *iDuplicateFilter, iStatus ); + if (rc) + { + // Duplicates view set and contains events + return ETrue; + } + else + { + // If no duplicates after all revert back to recent view. + return EFalse; + } + } + +// ---------------------------------------------------------------------------- +// CLogsClearNewMissed::TrySetRecentViewL +// ---------------------------------------------------------------------------- +// +TBool CLogsClearNewMissed::TrySetRecentViewL() + { + // If there are no duplicates or event has neither Number or Remoteparty + // set, then stop now and revert to just setting the latest event read + if ( iDuplicates == 0 || + ( iLogEvent->Number().Length() == 0 && + iLogEvent->RemoteParty().Length() == 0 ) ) + { + return EFalse; + } + + // Otherwise continue to settin the recent view, which is needed to get the duplicates view + // of the recent event. + // + if( !iLogViewRecent ) + { + iLogViewRecent = CLogViewRecent::NewL( *iLogClient ); + } + // + SetRecentFilterL(); + + + TInt rc; + rc = iLogViewRecent->SetRecentListL( ( TInt8 )ELogsMissedModel, *iRecentFilter, iStatus ); //asynch request + + if( rc == 1 ) + { + // If just one event in the list, like it should, continue to getting the duplicates view. + return ETrue; + } + else + { + // No events in the view after all or multiple events found, return EFalse + // will revert to just setting the latest event read + return EFalse; + } + + } + +// ---------------------------------------------------------------------------- +// CLogsClearNewMissed::SetRecentFilterL +// ---------------------------------------------------------------------------- +// +void CLogsClearNewMissed::SetRecentFilterL() + { + // Always start fresh with the filter, so delete the old one and create new. + delete iRecentFilter; + iRecentFilter = NULL; + iRecentFilter = CLogFilter::NewL(); + + if (iLogEvent->Number().Length() != 0) + { + iRecentFilter->SetNumber(iLogEvent->Number()); + } + + if (iLogEvent->RemoteParty().Length() != 0 ) + { + iRecentFilter->SetRemoteParty(iLogEvent->RemoteParty()); + } + + } + + +// ---------------------------------------------------------------------------- +// CLogsClearNewMissed::SetReadFlagsL +// ---------------------------------------------------------------------------- +// +void CLogsClearNewMissed::SetReadFlagsL() + { + iLogViewRecent->SetFlagsL( iLogEvent->Flags() | KLogEventRead ); + + // By setting the duplicates view to read, the duplicates counter is also reseted + // incase there will be new missed calls from the same number after SetReadFlagsL + // (and CLogsClearDuplicates has not been run). + if (iLogViewDuplicates && iPhase == ESetDuplicatesView) + { + iLogViewDuplicates->SetFlagsL( iLogEvent->Flags() | KLogEventRead ); + } + } + +// ---------------------------------------------------------------------------- +// CLogsClearNewMissed::RunError +// ---------------------------------------------------------------------------- +// +TInt CLogsClearNewMissed::RunError(TInt aError) + { + if( aError == KErrAccessDenied ) + { + return KErrNone; + } + else + { + return aError; + } + }