logexengine.cpp

专业的用于查询手机通话记录的代码

/*
 * ============================================================================
 *  Name     : CLogExEngine from LogExEngine.h
 *  Part of  : LogExample
 *  Created  : 26.05.2005 by Forum Nokia  
 *  Implementation notes:
 *  Version  : 1.0
 *  Copyright: Nokia Corporation
 * ============================================================================*/

//INCLUDE FILES
#include <eikenv.h>
#include <logwrap.h>
#include <logwrap.hrh>

#include "e32math.h"	// Random()        

#include "LogExEngine.h"

//DEBUG
#include <e32cons.h>

// CONSTANTS
_LIT(KOwnEventDescription, "Bluetooth");
_LIT(KOwnEventDirection, "Bluetooth");
_LIT(KOwnEventNumber, "No number");
_LIT(KOwnEventSubject, "RandomLogEvent");
_LIT(KOwnEventRemoteParty, "OwnContact");
_LIT(KEngineRunPanicText,"Engine-RunL");
_LIT(KEngineAddRandomText,"Engine-AddRandom");
_LIT(KEngineAddOwnText, "Engine-AddOwn");
_LIT(KEngineDefaultSwitch, "Engine-CreateRandom");

const TUid KOwnEventTypeUid =
    {
    0x10005570
    };

// ====================== PUBLIC ============================

// ----------------------------------------------------------
// CLogExEngine::CLogExEngine():CActive(EPriorityStandard)
// Defines priority for object
// ----------------------------------------------------------
//	
CLogExEngine::CLogExEngine() :
    CActive(EPriorityStandard)
    {
    }

// ----------------------------------------------------
// CLogExEngine::~CLogExEngine()
// Destructor
// Frees reserved resources
// ----------------------------------------------------
//
CLogExEngine::~CLogExEngine()
    {
    Cancel();

    delete iLogViewEvent;
    delete iLogViewRecent;
    delete iLogEventType;
    delete iLogClient;
    delete iLogEvent;
    delete iLogFilter;
    delete iEmptyLogFilter;

    iFs.Close();
    }

// ----------------------------------------------------
// CLogExEngine::NewL()
// Symbian 2-phase constructor
// ----------------------------------------------------
//
CLogExEngine* CLogExEngine::NewL()
    {
    CLogExEngine* self = CLogExEngine::NewLC();
    CleanupStack::Pop(self);
    return self;
    }

// ----------------------------------------------------
// CLogExEngine::NewLC()
// Symbian 2-phase constructor
// ----------------------------------------------------
//
CLogExEngine* CLogExEngine::NewLC()
    {
    CLogExEngine* self = new (ELeave) CLogExEngine();
    CleanupStack::PushL(self);
    self->ConstructL();
    return self;
    }

// ================= PRIVATE ======================= 

// ----------------------------------------------------
// CLogExEngine::ConstructL()
// Symbian 2-phase constructor
// ----------------------------------------------------
//
void CLogExEngine::ConstructL()
    {
    User::LeaveIfError(iFs.Connect());

    // Establish connection to log engine
    iLogClient = CLogClient::NewL(iFs);

    // Log view and view for recent events events with standard priority
    iLogViewEvent = CLogViewEvent::NewL(*iLogClient);
    iLogViewRecent = CLogViewRecent::NewL(*iLogClient);

    // Filter for events
    iLogFilter = CLogFilter::NewL();
    iEmptyLogFilter = CLogFilter::NewL();

    iOwnEvenTypeRegistered = EFalse;

    iObserver = NULL;

    iTask = ESleep; // Default task for RunL

    CActiveScheduler::Add(this);
    }

// ----------------------------------------------------
// CLogExEngine::RunL()
// RunL
// ----------------------------------------------------
//
void CLogExEngine::RunL()
    {
    switch (iTask)
        {
        case EGetEvent:
            {
            // Notify observer about change if it has been set
            if (iObserver)
                {
                iObserver->NotifyEventReadL(iLogViewEvent->Event());
                }
            else
                {
                iTask = ESleep;
                break; // No observer, no need to do anything	
                }

            // if there are more events in the log engine database...
            if (iLogViewEvent->NextL(iStatus))
                {
                // ... set active to get the next one
                SetActive();
                }
            else // no more events
                {
                iTask = ESleep;
                }
            break;
            }

        case EGetRecent:
            {
            // Notify observer about change if it has been set
            // Event in the view is sent as a parameter
            if (iRecentObserver)
                {
                iRecentObserver->NotifyEventReadL(iLogViewRecent->Event());
                }

            // if there are more events in the log engine database...
            if (iLogViewRecent->NextL(iStatus))
                {
                // ... set active to get the next one with the 
                // next asynchronous call
                SetActive();
                }
            else // no more events
                {
                iTask = ESleep;
                }
            break;
            }

        case EAddEvent: // add event to the log engine database
            {
            // Event added to log engine database 
            // Notify of change
            __ASSERT_ALWAYS( (iLogEvent != 0), User::Panic(KEngineRunPanicText,1) );
            if (iObserver)
                {
                iObserver->NotifyEventAddedL(*iLogEvent);
                }

            delete iLogEvent;
            iLogEvent = NULL;

            iTask = ESleep;
            break;
            }

        case EAddEventType:
            {
            if (iStatus == KErrAlreadyExists)
                {
                iOwnEvenTypeRegistered = ETrue;
                }

            AddOwnEventL();
            break;
            }

        case EDeleteEvent:
            {
            // Inform observers about deleted event if necessary
            if (iObserver)
                {
                iObserver->NotifyEventDeletedL();
                }

            iTask = ESleep;
            break;
            }

        case ESleep:
        default:
            {
            break;
            }
        }
    }

// ----------------------------------------------------
// CLogExEngine::RunError()
// RunL can leave so we need to implement RunError method
// ----------------------------------------------------
//
TInt CLogExEngine::RunError(TInt anError)
    {
    return anError;
    }

// ----------------------------------------------------
// CLogExEngine::DoCancel()
// Method to cancel outstanding request
// ----------------------------------------------------
//
void CLogExEngine::DoCancel()
    {
    //Cancel appropriate request
    switch (iTask)
        {
        case EGetEvent:
            {
            iLogViewEvent->Cancel();
            break;
            }

        case EGetRecent:
            {
            iLogViewRecent->Cancel();
            break;
            }

        case EAddEvent:
            {
            iLogClient->Cancel();
            break;
            }

        case EAddEventType:
            {
            iLogClient->Cancel();
            break;
            }

        case EDeleteEvent:
            {
            iLogClient->Cancel();
            break;
            }

        case ESleep:
        default:
            break;
        }
    }

// ----------------------------------------------------
// CLogExEngine::DeleteEventL(TLogId& aLogId)
// Deletes event from the main event log - asynchronous call
// ----------------------------------------------------
//
void CLogExEngine::DeleteEventL(TLogId& aLogId)
    {
    Cancel();
    iLogClient->DeleteEvent(aLogId, iStatus);
    iTask = EDeleteEvent;
    SetActive();
    }

// ----------------------------------------------------
// CLogExEngine::SetObserver(MEventsObserver* aObserver)
// Sets events observer
// ----------------------------------------------------
//
void CLogExEngine::SetObserver(MEventsObserver* aObserver)
    {
    iObserver = aObserver;
    }

// ----------------------------------------------------
// CLogExEngine::RemoveObserver()
// Removes current events observer
// ----------------------------------------------------
//
void CLogExEngine::RemoveObserver()
    {
    iObserver = NULL;
    }

// ----------------------------------------------------
// CLogExEngine::SetRecentObserver(MEventsObserver* aObserver)