/*
* Copyright (c) 2008-2009 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:   Logging to chunk wrappe for MC Photos
*
*/



// CLASS HEADER
#include "glxlogchunk.h"

// EXTERNAL INCLUDES
#include <e32svr.h>

// LOCAL DECLARATIONS
namespace
	{
	// size for the chunks
	const TInt KLogChunkSize = 1000000; // 1 million bytes
	// name for chunk 1
	_LIT( KLogChunk1Name, "MC_Photos_Logchunk1" );
	// name for chunk 2
	_LIT( KLogChunk2Name, "MC_Photos_Logchunk2" );
	// extension for log file
	_LIT( KLogFileExtension, ".log" );
	// carriage return / line feed
	_LIT8( KLogCR, "\r" );
	_LIT8( KLogLF, "\n" );
	// constant for machine word alignment
	const TInt KBytesInAWord = sizeof( TInt32 );
	}
	
inline void Panic(TInt aReason)
    {
	_LIT(applicationName,"Glx Logging");
    User::Panic(applicationName, aReason);
    }

// -----------------------------------------------------------------------------
// RGlxLogUtility::Open
// -----------------------------------------------------------------------------
TInt RGlxLogUtility::Open( const TDesC& aName, TBool aReadOnly )
	{
	// open the chunk
	return iChunk.OpenGlobal( aName, aReadOnly );
	}

// -----------------------------------------------------------------------------
// RGlxLogUtility::CreateL
// -----------------------------------------------------------------------------
void RGlxLogUtility::CreateL( const TDesC& aName )
    {
	// create the chunk, leave if error
	TInt error = iChunk.CreateGlobal( aName, KLogChunkSize, KLogChunkSize  );
	// dont treate already exists as an error
	if( KErrAlreadyExists == error )
		{
		// open in read-write
		User::LeaveIfError( iChunk.OpenGlobal( aName, EFalse ) );
		}
	else
		{
		User::LeaveIfError( error );
		}

    // initialise the iChunk to all zeros.
    Mem::FillZ( iChunk.Base(), iChunk.Size() );
    // initialise current address to base
    SetCurrentAddress( BaseAddress() );
    // initialise last logged address to base
    SetLastLoggedAddress( BaseAddress() );
    }

// -----------------------------------------------------------------------------
// RGlxLogUtility::Close
// -----------------------------------------------------------------------------
void RGlxLogUtility::Close()
	{
	iChunk.Close();
	}

// -----------------------------------------------------------------------------
// RGlxLogUtility::ChunkSize
// -----------------------------------------------------------------------------
TInt RGlxLogUtility::ChunkSize()
	{
	return iChunk.Size();
	}
    
// -----------------------------------------------------------------------------
// RGlxLogUtility::Id
// -----------------------------------------------------------------------------
TObjectId RGlxLogUtility::Id()
	{
	// take chunk base address
	TUint8* ptr_in_chunk = iChunk.Base();
	// cast that to TObjectId*
	TObjectId* ptr_as_tobjectid = reinterpret_cast< TObjectId* >( ptr_in_chunk );
	// return the id
	return *ptr_as_tobjectid;
	}

// -----------------------------------------------------------------------------
// RGlxLogUtility::SetId
// -----------------------------------------------------------------------------
void RGlxLogUtility::SetId( TObjectId aId )
	{
	// take chunk base address
	TUint8* ptr_in_chunk = iChunk.Base();
	// cast that to TObjectId*
	TObjectId* ptr_as_tobjectid = reinterpret_cast< TObjectId* >( ptr_in_chunk );
	// assign the id in place
	*ptr_as_tobjectid = aId;
	}

// -----------------------------------------------------------------------------
// RGlxLogUtility::CurrentAddress
// -----------------------------------------------------------------------------
TUint8* RGlxLogUtility::CurrentAddress()
	{
	// take chunk base address plus object id
	TUint8* ptr_in_chunk = iChunk.Base() + sizeof( TObjectId );
	// cast that to TInt*
	TUint32* ptr_as_tint = reinterpret_cast< TUint32* >( ptr_in_chunk );
	// dereference that pointer to read the 32 bits that are the address
	TUint32 value_of_pointer = *ptr_as_tint;
	// then return the value as TUint8*
	return reinterpret_cast< TUint8* >( value_of_pointer );
	}

// -----------------------------------------------------------------------------
// RGlxLogUtility::SetCurrentAddress
// -----------------------------------------------------------------------------
void RGlxLogUtility::SetCurrentAddress( TUint8* aValue )
	{
	// take chunk base address plus object id
	TUint8* ptr_in_chunk = iChunk.Base() + sizeof( TObjectId );
	// cast that to TInt*
	TUint32* ptr_as_tint = reinterpret_cast< TUint32* >( ptr_in_chunk );
	// assign the addres to TInt
	TUint32 new_value = reinterpret_cast< TUint32 >( aValue );
	// ensure we're byte aligned - ARM requires 32 bit alignment to machine word
	// boundary!!
	TInt remainder = new_value % KBytesInAWord;
	if ( remainder > 0 )
	    {
	    new_value += ( KBytesInAWord - remainder );
	    }
	// set the new value to the chunk
	*ptr_as_tint = new_value;
	}

// -----------------------------------------------------------------------------
// RGlxLogUtility::LastLoggedAddress
// -----------------------------------------------------------------------------
TUint8* RGlxLogUtility::LastLoggedAddress()
	{
	// take chunk base address plus object id plus one pointer
	TUint8* ptr_in_chunk = 
		iChunk.Base() + sizeof( TObjectId ) + sizeof( TUint8* );
	// cast that to TInt*
	TUint32* ptr_as_tint = reinterpret_cast< TUint32* >( ptr_in_chunk );
	// dereference that pointer to read the 32 bits that are the address
	TUint32 value_of_pointer = *ptr_as_tint;
	// then return the value as TUint8*
	return reinterpret_cast< TUint8* >( value_of_pointer );
	}

// -----------------------------------------------------------------------------
// RGlxLogUtility::SetLastLoggedAddress
// -----------------------------------------------------------------------------
void RGlxLogUtility::SetLastLoggedAddress( TUint8* aValue )
	{
	// take chunk base address plus object id plus one pointer
	TUint8* ptr_in_chunk = 
		iChunk.Base() + sizeof( TObjectId ) + sizeof( TUint8* );
	// cast that to TInt*
	TUint32* ptr_as_tint = reinterpret_cast< TUint32* >( ptr_in_chunk );
	// assign the addres to TInt
	TUint32 new_value = reinterpret_cast< TUint32 >( aValue );
	// ensure we're byte aligned - ARM requires 32 bit alignment to machine word
	// boundary!!
    TInt remainder = new_value % KBytesInAWord;
	if ( remainder > 0 )
	    {
	    new_value += ( KBytesInAWord - remainder );
	    }	
	// set the new value to the chunk
	*ptr_as_tint = new_value;
	}

// -----------------------------------------------------------------------------
// RGlxLogUtility::BaseAddress
// -----------------------------------------------------------------------------
TUint8* RGlxLogUtility::BaseAddress()
	{
	// take chunks base address
	TUint8* base = iChunk.Base();
	// calculate the topmost write address, our header is 
	// TObjectId and two TUint8*
	return base + sizeof( TObjectId ) + sizeof( TUint8* ) * 2;
	}

// -----------------------------------------------------------------------------
// RGlxLogUtility::LastAddress
// -----------------------------------------------------------------------------
TUint8* RGlxLogUtility::LastAddress()
	{
	// return chunks base address plus its size
	return iChunk.Base() + iChunk.Size();
	}

// -----------------------------------------------------------------------------
// RGlxLogClient::Open
// -----------------------------------------------------------------------------
EXPORT_C TInt RGlxLogClient::Open( TObjectId aId )
    {
    // try to open first log chunk, in read-write mode
    TInt err = iLogUtility.Open( KLogChunk1Name(), EFalse );
    if ( err != KErrNone )
        {
        return err;
        }
    // check id
    TObjectId id = iLogUtility.Id();
    if ( id  == TObjectId( 0 ) )
        {
        // no id set, so reserve this for us and use this chunk
        iLogUtility.SetId( aId );
        }
    // check if our id was there?
    else if( id != aId )
        {
        // not our chunk, try second chunk in read-write mode
        err = iLogUtility.Open( KLogChunk2Name(), EFalse );
        if ( err != KErrNone )
            {
            return err;
            }
        // check id
        id = iLogUtility.Id();
        if ( id  == TObjectId( 0 ) )
            {
            // no id, reserve this for us and use this chunk
            iLogUtility.SetId( aId );
            }
        else if ( id != aId )
            {
            // both chunks already reserved, return error
            return KErrNotFound;
            }
       	}
    return KErrNone;
    }

// -----------------------------------------------------------------------------
// RGlxLogClient::Close
// -----------------------------------------------------------------------------
EXPORT_C void RGlxLogClient::Close()
	{
    iLogUtility.Close();
	}

// -----------------------------------------------------------------------------
// RGlxLogClient::Write
// -----------------------------------------------------------------------------
EXPORT_C void RGlxLogClient::Write( const TDesC8& aLogEntry )
    {
    // get the size of log entry (in bytes)
    TInt num_bytes = aLogEntry.Size();
    // take current address and chunk size to ensure log entry fits
    TUint8* current_address = iLogUtility.CurrentAddress();
    // calculate the new current address, we write the size and the data
    TUint8* after_write = current_address + num_bytes + sizeof( TInt );
    // chck that we fit
    if( after_write >= iLogUtility.LastAddress() )
    	{
    	// we dont fit in the end
    	// need to mark the old current_address so that
    	// manager knows we jumped to the start
	    TInt* last_indicator_ptr = 
	    	reinterpret_cast< TInt* >( current_address );
	   	// assign KErrNotFound there
		*last_indicator_ptr = KErrNotFound;
    	// write this entry to the base address
    	current_address = iLogUtility.BaseAddress();
    	}
    // we need to store the size in the chunk first so take a TInt*
    TInt* size_ptr = reinterpret_cast< TInt* >( current_address );
    // assign new value in place
    *size_ptr = num_bytes;
    // increase address
    current_address += sizeof( TInt );
    // copy the data, first target, then source and last number of bytes
    Mem::Copy( current_address, aLogEntry.Ptr(), num_bytes );
    // and set the new current address
    iLogUtility.SetCurrentAddress( current_address + num_bytes );
    }

// -----------------------------------------------------------------------------
// RGlxLogManager::CreateL
// -----------------------------------------------------------------------------
EXPORT_C void RGlxLogManager::CreateL()
    {
    // connect to the file server
    User::LeaveIfError( iFs.Connect() );
    
    // create two log chunks
    iLogUtility1.CreateL( KLogChunk1Name );
    iLogUtility2.CreateL( KLogChunk2Name );
    }

// -----------------------------------------------------------------------------
// RGlxLogManager::Release
// -----------------------------------------------------------------------------
EXPORT_C void RGlxLogManager::Release()
    {
    // close file server handle
    iFs.Close();
    
    // release both log chunks
    iLogUtility1.Close();
    iLogUtility2.Close();
    }

// -----------------------------------------------------------------------------
// RGlxLogManager::CommitToFileL
// -----------------------------------------------------------------------------
EXPORT_C void RGlxLogManager::CommitToFileL( const TDesC& aFolder )
	{
	// open the file
	RFile file;
	CleanupClosePushL( file );
	
	// chunk1
	// create the file name
	TFileName fileName;
	fileName = aFolder;
	fileName.Append( KLogChunk1Name );
	fileName.Append( KLogFileExtension );
	// try to open the file	
	TInt err = file.Open( iFs, fileName, EFileWrite );
	if ( err == KErrNotFound )
	    {
	    // file doesn't exist so create it
	    err = file.Create( iFs, fileName, EFileWrite );
	    }
	User::LeaveIfError( err );
	// write the first chunk to file
	CommitToFileL( iLogUtility1, file );
	// close the file
	file.Close();
	
	// chunk2
	// reset the file name
	fileName.Zero();
	// create the file name
	fileName = aFolder;
	fileName.Append( KLogChunk2Name );
	fileName.Append( KLogFileExtension );
	// try to open the file
	err = file.Open( iFs, fileName, EFileWrite );
	if ( err == KErrNotFound )
	    {
	    // file doesn't exist so create it
	    err = file.Create( iFs, fileName, EFileWrite );
	    }
	User::LeaveIfError( err );
	// write the second chunk to file
	CommitToFileL( iLogUtility2, file );

	CleanupStack::PopAndDestroy( &file );
	}

// -----------------------------------------------------------------------------
// RGlxLogManager::CommitToFileL
// -----------------------------------------------------------------------------    
void RGlxLogManager::CommitToFileL( RGlxLogUtility& aUtility, RFile& aFile )
    {
    // Need to explicitly move to the end of the file as it's not done
    // automatically on call to Write
    TInt pos = 0;
    TInt err = aFile.Seek( ESeekEnd, pos );
    User::LeaveIfError( err );
    TPtr8 logEntryPtr( 0, 0 );
    TInt logEntrySize = 0;
    
    // what's previously been logged to the file?
    TUint8* lastLoggedAddress = aUtility.LastLoggedAddress();
    
    // how much more has been added to the chunk?
    TUint8* currentAddress = aUtility.CurrentAddress();
    
    // write each of the chunk's logged entries to the file 
    TInt32* sizePtr = NULL;
    while ( currentAddress != lastLoggedAddress && err == KErrNone )
        {
        // get the logEntry's size
        sizePtr = reinterpret_cast< TInt32* >( lastLoggedAddress );
        logEntrySize = *sizePtr;
        if ( logEntrySize == KErrNotFound )
            {
            // logged entries have wrapped around the end of the chunk
            // so start from the beginning
            lastLoggedAddress = aUtility.BaseAddress();
            sizePtr = reinterpret_cast< TInt32* >( lastLoggedAddress );
            logEntrySize = *sizePtr;
            }
        // set an error - this will be reset to KErrNone if we succeed
        // with finding and writing a log entry
        err = KErrNotFound;
        if ( logEntrySize > 0 )
            {
            // move the current address to the data
            lastLoggedAddress += sizeof( TInt32 );
            // extract the log entry's data 
            logEntryPtr.Set( lastLoggedAddress, logEntrySize, logEntrySize );
            // write the log entry to the file
            err = aFile.Write( logEntryPtr );
            // append carriage return and line feed to the entry
            err = aFile.Write( KLogCR );
            err = aFile.Write( KLogLF );
            // ensure we align to a multiple of a 4-byte boundary
            TInt remainder = logEntrySize % KBytesInAWord;
            if ( remainder > 0 )
                {
                // not aligned so add some padding
                logEntrySize += ( KBytesInAWord - remainder );
                }
 
            // update the last logged address
            lastLoggedAddress += logEntrySize;
            }
        }
    // update the last logged address
    aUtility.SetLastLoggedAddress( lastLoggedAddress );
	// 
	// commit the data
	err = aFile.Flush();
	User::LeaveIfError( err );
    }