calllogengine.cpp

来自「series60 应用程序开发的源代码 series60 应用程序开发的源代码」· C++ 代码 · 共 248 行

/**
* 
* @brief Definition of CCallLogEngine
*
* Copyright (c) EMCC Software Ltd 2003
* @version 1.0
*/

// INCLUDES

//  Class include
#include "CallLogEngine.h"

// System includes
#include <eikenv.h>            // CCoeEnv
#include <logview.h>        // CLogViewEvent
 
// User includes
#include "CallArray.h"        // CCallArray
#include "EngineObserver.h"    // MCallLogEngineObserver

#if defined(_DEBUG)
#include "debugentries.h"    // CAddEntries
#endif // (_DEBUG)

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

/**
* C++ Constructor
* @param aObserver log engine observer
* @param aCallArray the array to be filled with information from the log engine
*/
CCallLogEngine::CCallLogEngine(MCallLogEngineObserver& aObserver, CCallArray& aCallArray)
    :CActive(CActive::EPriorityStandard), iObserver(aObserver), iCallArray(aCallArray)
{
}

/** 
* Destructor.  Frees up memory 
*/
CCallLogEngine::~CCallLogEngine()
{
    Cancel();
    delete iLogView;
    delete iLogClient;
    delete iLogFilter;

#if defined(_DEBUG)
    delete iEntryAdd;
#endif // (_DEBUG)
}

/**
* Symbian OS 2 phase constructor.
* Constructs the CCallLogEngine using the NewLC method, popping
* the constructed object from the CleanupStack before returning it.
* 
* @param aObserver log engine observer
* @param aCallArray the array to be filled with information from the log engine
* @param aDirectionId what type of calls to filter from log i.e incoming
* @return The newly constructed CCallLogEngine
*/
CCallLogEngine* CCallLogEngine::NewL(MCallLogEngineObserver& aObserver, CCallArray& aCallArray, TInt aDirection)
{
    CCallLogEngine* self = CCallLogEngine::NewLC(aObserver, aCallArray, aDirection);
    CleanupStack::Pop(self);
    return self;
}

/**
* Symbian OS 2 phase constructor.
* Constructs the CCallLogEngine using the constructor and ConstructL 
* method, leaving the constructed object on the CleanupStack before returning it.
* 
* @param aObserver log engine observer
* @param aCallArray the array to be filled with information from the log engine
* @param aDirectionId what type of calls to filter from log i.e incoming
* @return The newly constructed CCallLogEngine
*/
CCallLogEngine* CCallLogEngine::NewLC(MCallLogEngineObserver& aObserver, CCallArray& aCallArray, TInt aDirection)
{
    CCallLogEngine* self = new (ELeave) CCallLogEngine(aObserver, aCallArray);
    CleanupStack::PushL(self);
    self->ConstructL(aDirection);
    return self;
}

/**
* Symbian OS 2nd phase constructor.  
* @param aDirectionId what type of calls to filter from log i.e incoming
*/ 
void CCallLogEngine::ConstructL(TInt aDirection)
{
    // Get the file server session owned by control environment
    RFs& fsSession = CCoeEnv::Static()->FsSession();

    // create the log engine, a view of the logengine, a filter
    iLogClient = CLogClient::NewL(fsSession);
    iLogView = CLogViewEvent::NewL(*iLogClient);
    iLogFilter = CLogFilter::NewL();

    // Find from the log engine, the string for the given direction resource
    TBuf<64> direction;
    iLogClient->GetString(direction, aDirection);

    // Set the direction to be filtered 
    iLogFilter->SetDirection(direction);
    iLogFilter->SetEventType(KLogCallEventTypeUid);

    // Add to the active scheduler
    CActiveScheduler::Add(this);

    // Add the log events to the array of call information
    // ** Note that this is only performed when the engine is created, so any 
    // ** changes to the call log while the application is running will be ignored.
    PopulateCallArrayL();
}

/** 
* Makes an asynchronous request to set the a filter on
* the current log view. If there are no events in the filtered
* view, calls the observer's  CallArrayEmpty() function. 
* In a debug build, the new entries are asynchronously added to the event log
*/ 
void CCallLogEngine::PopulateCallArrayL()
{
    // Filter the view by the requrements in iFilter, if there
    // are no events in the view, eventsInView is EFalse, and the 
    // asynchronous request is not issued.
    TBool eventsInView = iLogView->SetFilterL(*iLogFilter, iStatus);
    iEngineState = ECreatingView;

    if (eventsInView)
    {
        // if there are events in the filtered view
        // issue the asynchronous request
        SetActive();
    }
    else
    {
#if defined(_DEBUG)
        // if there are no events in the view
        // add some dummy events to the log engine
        // if this is a debug build

        // **** Note that the dummy events will only be added the first time this runs as the events
        // **** are saved permanently in the event log. To delete the event log, remove the file
        // **** C:\system\data\logdbu.dat or use the Log application to clear it on target.

        iEngineState = EDebugCreatingEventLog;
        iEntryAdd = CAddEntries::NewL(*iLogClient, iStatus);
        SetActive();
#else
        // In a non-debug build, inform the observer 
        // that there no events in the view
        iObserver.CallArrayEmptyL();
#endif // (_DEBUG)
    }
}


/**
* Called from CActive::Cancel(), allowing this object 
* to provide specific cleanup activity.
*
*/
void CCallLogEngine::DoCancel()
{
}

/**
* Called when the an asynchronous request completes. If there has been
* error the observer's CallLogErrorL is called. If the request completes
* successfully a state pattern is used to determine whether an oberver 
* function is called or an asynchronous request made.
* 
*/
void CCallLogEngine::RunL()
{
    if (iStatus != KErrNone)
    {
        // if there has been a problem inform the observer.
        iObserver.CallLogErrorL();
        return;
    }

    switch (iEngineState)
    {
        case ECreatingView:
        {
            // The filtered view has been successfully created
            // so issue a request to go to the first event
            iLogView->FirstL(iStatus);
            iEngineState = EAddingEntry;
            SetActive();
            break;
        }
        case EAddingEntry:
        {
            // Add the current event to the array of events
            const CLogEvent& event = iLogView->Event();
            iCallArray.AddEntryL(event);

            // Are there any more entries
            if (iLogView->NextL(iStatus))
            {
                // if there is another entry, issue the request
                // to move to the next entry.
                SetActive();
            }
            else
            {
                // if there aren't any more entries, inform the observer
                // that the array has been created.
                iObserver.CallArrayCreatedL();
            }
            break;
        }
#if defined(_DEBUG)
        case EDebugCreatingEventLog:
        {
            // If under a debug build, events have been added to 
            // the event log, create a filtered view of the added
            // events.
            iLogView->SetFilterL(*iLogFilter, iStatus);
            iEngineState = ECreatingView;
            SetActive();
        }
#endif // _DEBUG
        default:
            break;
    }
}

/**
* Called if RunL leaves
* 
* @param the error that RunL leaves with. 
* @return error code
*/    
TInt CCallLogEngine::RunError(TInt /*aError*/)
{
    return KErrNone;
}

// End of File