/*

* Copyright (c) 2007 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:  Document class for Camera Application*

*/

#include "camlogging.h"

#include "CamLogger.h"

#ifdef _DEBUG

#include <e32debug.h>

//#define _AO_TRACKING

#ifdef _AO_TRACKING

static void ReplaceCurrentASL();

static void RestoreCurrentAS();

class CFilterScheduler;

class CFilterInfo : public CBase

    {

    friend class CFilterScheduler;

public:

    static CFilterInfo* NewL();

protected:

    struct CFilterStruct

        {

        CFilterStruct(CActive* aActiveAddPointer, char* aActiveLogInfo,

                CFilterStruct* aLink);

        CActive *iActiveAddPointer;

        char *iActiveLogInfo;

        CFilterStruct *iLink;

        };

protected:

    CFilterInfo();

    void ConstructL();

    void AddInfoL(CActive* aActiveAddPointer, char* aActiveLogInfo,

            CFilterStruct * &aLink);

    char* FindInfo(CActive *);

    ~CFilterInfo();

protected:

    struct CFilterStruct *iFiSHead;

    };

class CFilterScheduler : public CActiveScheduler

    {

    friend void ReplaceCurrentASL();

    friend void RestoreCurrentAS();

public:

    static CFilterScheduler* NewL();

private:

    static CActiveScheduler* iSavedFS;

public:

    using CActiveScheduler::Start;

    // It is used as a hook, which makes possible to collect meaningful

    // information about every active object

    virtual TInt Extension_(TUint aUid, TAny*& a0, TAny* a1);

protected:

    void ConstructL();

    CFilterScheduler();

    ~CFilterScheduler();

    void DebugPrint();

    char* FindInfo(CActive *);

    // it has to default to CActiveScheduler implementations  

    virtual void WaitForAnyRequest();

    // it has to default to CActiveScheduler implementations

    virtual void Error(TInt aError) const;

    // It has to be implemented since this is a concrete class

    virtual void OnStarting()

        {

        }

    virtual void OnStopping()

        {

        }

    virtual void Reserved_1()

        {

        }

    virtual void Reserved_2()

        {

        }

private:

    CFilterInfo *iFilterInfo;

    };

CActiveScheduler* CFilterScheduler::iSavedFS= NULL;

CFilterInfo* CFilterInfo::NewL()

    {

    CFilterInfo* self = new( ELeave ) CFilterInfo();

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

void CFilterInfo::AddInfoL(CActive* aActiveAddPointer, char* aActiveLogInfo,

        CFilterInfo::CFilterStruct* &aLink)

    {

    PRINT( _L("Camera => CFilterInfo::AddInfoL") );

    CFilterStruct *pFiS = new( ELeave ) CFilterStruct( aActiveAddPointer,

            aActiveLogInfo, aLink );

    pFiS->iLink = aLink;

    aLink = pFiS;

    }

char* CFilterInfo::FindInfo(CActive *aActive)

    {

    char *pInfo = (char *)NULL;

    CFilterStruct *pFiS = iFiSHead;

    while (pFiS != NULL)

        {

        if (pFiS->iActiveAddPointer == aActive)

            {

            pInfo = pFiS->iActiveLogInfo;

            break;

            }

        pFiS = pFiS->iLink;

        }

    return pInfo;

    }

CFilterInfo::CFilterStruct::CFilterStruct(CActive* aActiveAddPointer,

        char* aActiveLogInfo, CFilterInfo::CFilterStruct* aLink)

    {

    iActiveAddPointer = aActiveAddPointer;

    iActiveLogInfo = aActiveLogInfo;

    iLink = aLink;

    }

void CFilterInfo::ConstructL()

    {

    }

CFilterInfo::CFilterInfo()

    {

    iFiSHead = NULL;

    }

CFilterInfo::~CFilterInfo()

    {

    }

CFilterScheduler* CFilterScheduler::NewL()

    {

    CFilterScheduler* self = new( ELeave ) CFilterScheduler();

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

void ReplaceCurrentASL()

    {

    CFilterScheduler *fSH = CFilterScheduler::NewL();

    //if (fSH != NULL)

    CFilterScheduler::iSavedFS = CActiveScheduler::Replace(fSH);

    }

void RestoreCurrentAS()

    {

    if (CFilterScheduler::iSavedFS != NULL)

        {

        CActiveScheduler *iFS =

                CActiveScheduler::Replace(CFilterScheduler::iSavedFS);

        delete iFS;

        }

    }

TInt CFilterScheduler::Extension_(TUint aUid, TAny*& a0, TAny* a1)

    {

    if (aUid == 0)

        {

        TRAPD( rr, iFilterInfo->AddInfoL( (CActive *)a0, (char *)a1,

                        iFilterInfo->iFiSHead ) );

        return rr;

        }

    return KErrExtensionNotSupported;;

    }

void CFilterScheduler::WaitForAnyRequest()

    {

    // Here is the printout at every wait

    DebugPrint();

    if (iSavedFS)

        iSavedFS->WaitForAnyRequest();

    else

        User::WaitForAnyRequest();

    }

void CFilterScheduler::Error(TInt aError) const

    {

    if (iSavedFS)

        iSavedFS->Error(aError);

    }

CFilterScheduler::CFilterScheduler()

    {

    }

CFilterScheduler::~CFilterScheduler()

    {

    iSavedFS = NULL;

    }

void CFilterScheduler::ConstructL()

    {

    /* iActive = CFilterActive::NewL( this ); */

    iFilterInfo = CFilterInfo::NewL();

    }

char* CFilterScheduler::FindInfo(CActive * aA)

    {

    char *pFI= NULL;

    if (iFilterInfo)

        pFI = iFilterInfo->FindInfo(aA);

    return pFI;

    }

void CFilterScheduler::DebugPrint()

    {

    RDebug::Print( _L( " Camera => CFilterScheduler::DebugPrint" ));

    TDblQueIter<CActive> q(iActiveQ);

    q.SetToFirst();

    while (q != NULL)

        {

        CActive *pR = q++;

        /* TInt pri = pR->iLink.iPriority; */

        TInt pri = pR->Priority();

        TInt stat = pR->iStatus.Int(); // TRequestStatus

        // find active objects identification string otherwise

        // print it's address

        char *pText = FindInfo(pR);

        if (pR->IsActive() )

            {

            if (stat == KRequestPending)

                {

                // active, pending

                if (pText)

                    RDebug::Printf(

                            "Camera: CFilterScheduler::DebugPrint: %s - active/pending - priority: %d - req status: %d",

                            pText, pri, stat);

                else

                    RDebug::Printf(

                            "Camera: CFilterScheduler::DebugPrint: %x - active/pending - priority: %d - req status: %d",

                            (TInt)pR, pri, stat);

                }

            else

                {

                // active, not pending

                if (pText)

                    RDebug::Printf(

                            "Camera: CFilterScheduler::DebugPrint: %s - active/not pending - priority: %d - req status: %d",

                            pText, pri, stat);

                else

                    RDebug::Printf(

                            "Camera: CFilterScheduler::DebugPrint: %x - active/not pending - priority: %d - req status: %d",

                            (TInt)pR, pri, stat);

                }

            }

        else

            {

            // not active

            if (pText)

                RDebug::Printf(

                        "Camera: CFilterScheduler::DebugPrint: %s - not active: priority: %d - req status: %x",

                        pText, pri, stat);

            else

                RDebug::Printf(

                        "Camera: CFilterScheduler::DebugPrint: %x - not active: priority: %d - req status: %x",

                        (TInt)pR, pri, stat);

            }

        }

    RDebug::Print( _L( "Camera <= CFilterScheduler::DebugPrint" ));

    }

#endif // _AO_TRACKING

#endif // _DEBUG

// INCLUDE FILES

#include "CamAppUi.h"

#include "CamDocument.h"

#include "CamPerformance.h"

#include "CamAppController.h"

#ifdef _DEBUG

// These are used for memory allocation tracing.

#undef _MEMORY_TRACKING

//#define _MEMORY_TRACKING

#ifdef _MEMORY_TRACKING

#include <e32panic.h>

// stores the last RDebug::Print or RDebug::Printf calls

// string from cameraapp code if SInUse was ETrue

static char *sLastHeapContext = NULL;

// controls the context taking if it is EFalse sLastHeapContext is not updated

// used also by RTraceAllocator::Alloc, Free, Realloc etc.

static TBool sInUse = EFalse;

// forward declaration for friend statements.

class PtrAssocArray;

class RTraceAllocator;

// class which stores heap context info

// per allocation

// every allocation will have one entry in the hash table

class AllocHeapContext

    {

    // added as friend for writing less set/get methods

    friend class PtrAssocArray;

public:

    AllocHeapContext(TAny* aPtr, TInt aSize, char* aText1,

            AllocHeapContext *aNext = NULL);

    ~AllocHeapContext();

protected:

    // stored pointer of the allocation  

    TAny* iPtr;

    // stored size of the allocation

    TInt iSize;

    // context string of the allocation, collected from

    // RDebug::Print, RDebug::Printf calls

    char* iText1;

    // link field to the next context if they are more with same hash value

    // in PtrAssocArray then they can be linked into a single linked list

    AllocHeapContext *iNext;

    };

// class which stores the hash table

class PtrAssocArray

    {

public:

    // constructor takes a Heap to use for allocations and deallocations done by

    // this class,

    // Note: For not perturbing normal allocation/deallocation a separate heap is

    // used for internal needs. 

    PtrAssocArray(RHeap *aHeap);

    ~PtrAssocArray();

    // insert an element into the list

    // return KErrArgument if aAHC == NULL

    // otherwise KErrNone

    TInt Insert(AllocHeapContext* aAHC);

    // find an element in the list

    // return NULL pointer if cannot find, this means

    // also the case if aPtr == NULL  

    AllocHeapContext *Find(TAny *aPtr);

    // removes an element from the list

    // if aPtr == NULL does nothing and returns KErrArgument.

    // Returns KErrNotFound and does nothnig if cannot find it.

    // In normal case return KErrNone.

    TInt Remove(TAny *aPtr);

    // Prints the elements in the list

    void PrintLeaks();

    // cleans the list. It could be used if implemented for restarting

    // leak search from a certain point onward.

    // Note: only the list elements are cleaned, for real deallocation purposes

    // it cannot be used as this system doesn't offers a reference counting of

    // the pointer. It still can be used even that idea for debugging.  

    void CleanTables();

protected:

    // the hash function itself,

    // simply takes the middle 2 bytes of a 4 byte unsigned,

    // to which the pointer is converted  

    TUint Hash(TAny *aPtr);

    // internal structures for has array entries

    // iInfo points

    struct AssocHashTbl

        {

        AllocHeapContext* iInfo;

        };

    // the hash array

    AssocHashTbl iAHT[65536];

    // pointer to iOwnHeap of

    RHeap *iHeap;

    };

// the allocator class

class RTraceAllocator : public RAllocator

    {

public:

    // return current heap, just utility  

    static RTraceAllocator* OwnAllocator()

        {

        RTraceAllocator& currentHeap = (RTraceAllocator &)User::Heap();

        return &currentHeap;

        }

    // Simple utility function for getting a size of a char*

    // User::StringLength looks similar,

    // but this return 0 if aStr == NULL.

    static TUint StrSize(char * aStr);

    // stores the current heap for calls forwarding to that ones

    // implementation

    RTraceAllocator(RHeap *aCurrentHeap);

    // destructor sets sInUse to EFalse as iOwnHeap is not available any

    // more

    ~RTraceAllocator()

        {

        iOwnHeap->Close();

        sInUse = EFalse;

        }

    // These virtuals needs to be overwritten

    // there functionality is documented by Symbian

    virtual TAny* Alloc(TInt aSize);

    virtual void Free(TAny* aPtr);

    virtual TAny* ReAlloc(TAny* aPtr, TInt aSize, TInt aMode = 0);

    virtual TInt AllocLen(const TAny* aCell) const;

    virtual TInt Compress();

    virtual void Reset();

    virtual TInt AllocSize(TInt& aTotalAllocSize) const;

    virtual TInt Available(TInt& aBiggestBlock) const;

    virtual TInt DebugFunction(TInt aFunc, TAny* a1=NULL, TAny* a2=NULL);

    // print entries in hash table, it is just a proxy method 

    void PrintLeaks()

        {

        iAHM->PrintLeaks();

        }

    // clean the tables it is just a proxy

    void CleanTables()

        {

        iAHM->CleanTables();

        }

    // frees memory from own heap

    void FreeOwn(TAny* aPtr)

        {

        iOwnHeap->Free(aPtr);

        }

    // allocates from own heap and fills with 0

    TAny* AllocZOwn(TInt aSize)

        {

        return iOwnHeap->AllocZ(aSize);

        }

    // returns the saved heap

    RHeap* SavedHeap()

        {

        return iHeap;

        }

protected:

    // the original heap of the application, which does the real

    // allocation. All allocations are deferred to it  

    RHeap* iHeap;

    // A heap for own allocations, different than the one used by

    // cameraapp process 

    RHeap* iOwnHeap;

    // pointer to the hash table

    PtrAssocArray* iAHM;

    };

#if defined( _UNICODE )

// just, because they are needed

class TestOverflowTruncate : public TDes16Overflow

    {

public:

    virtual void Overflow(TDes16& /* aDes */)

        {

        }

    ;

    };

#else

class TestOverflowTruncate : public TDes8Overflow

    {

public:

    virtual void Overflow(TDes8 &aDes)

        {};

    };

#endif

// just, because they are needed

class TestOverflowTruncate8 : public TDes8Overflow

    {

public:

    virtual void Overflow(TDes8& /*aDes*/)

        {

        }

    };

// RDebug::Print is overwritten, because it is used

EXPORT_C TInt RDebug::Print( TRefByValue<const TDesC> aFmt,... )

    {

    TestOverflowTruncate overflow;

    VA_LIST list;

    VA_START(list,aFmt);

    TBuf<0x100> buf;

    buf.AppendFormatList( aFmt, list, &overflow );

#ifdef _UNICODE

    TPtr8 p( buf.Collapse() );

    // remember it

    char *context = ( char *)p.Ptr();

    if( sInUse )

        {

        if( sLastHeapContext )

            {

            //free it  

            RTraceAllocator::OwnAllocator()->FreeOwn( sLastHeapContext );

            sLastHeapContext = NULL;

            }

        sLastHeapContext = (char *)RTraceAllocator::OwnAllocator()->AllocZOwn( 0x100 );

        memcpy( sLastHeapContext, context, 0x100 );

        }

    // instead of Exec::DebugPrint((TAny*)&p, 0);

    // RawPrint is used