/*
* 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 <logcli.h>
#include <logview.h>
#ifndef SYMBIAN_ENABLE_SPLIT_HEADERS
#include <logwrap.hrh>
#else
#include <logwrap.hrh>
#include <logfilterandeventconstants.hrh>
#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;
		}
	}