/*
* Copyright (c) 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:  The implementation for presentation elements.
*
*/


#include <s32strm.h>

#include "irdebug.h"
#include "irreportsettings.h"
#include "irnmslogger.h"

//const TInt KMaxUrlLength = 256

// ============================== Function declaration =======================

// ---------------------------------------------------------------------------
// Function: NewL
// Two phase constructor returns the instance of CIRNmsLogger
// ---------------------------------------------------------------------------
//
CIRNmsLogger* CIRNmsLogger::NewL()
    {
    IRLOG_DEBUG( "CIRNmsLogger::NewL" );
    CIRNmsLogger* self = CIRNmsLogger::NewLC();
    CleanupStack::Pop( self );
    IRLOG_DEBUG( "CIRNmsLogger::NewL - Exiting." );
    return self;
    }

// ---------------------------------------------------------------------------
// Function: NewLC
// Two phase constructor creates the instance of CIRNmsLogger
// ---------------------------------------------------------------------------
//
CIRNmsLogger* CIRNmsLogger::NewLC()
    {
    IRLOG_DEBUG( "CIRNmsLogger::NewLC" );
    CIRNmsLogger* self = new ( ELeave ) CIRNmsLogger;
    CleanupStack::PushL( self );
    self->ConstructL();
    IRLOG_DEBUG( "CIRNmsLogger::NewLC - Exiting." );
    return self;
    }    

// ---------------------------------------------------------------------------
// Function: ~CIRNmsLogger
// default destructor
// ---------------------------------------------------------------------------
//
CIRNmsLogger::~CIRNmsLogger()    
    {
    }

// ---------------------------------------------------------------------------
// Function: ConstructL
// Two phase constructor
// ---------------------------------------------------------------------------
//
void CIRNmsLogger::ConstructL()        
    {
    //No implementation
    //return;
    }

// ---------------------------------------------------------------------------
// Function: CIRNmsLogger
// default constructor
// ---------------------------------------------------------------------------
//
CIRNmsLogger::CIRNmsLogger()    
    {
    //No implementation
    }

    
// ---------------------------------------------------------------------------
// Function: ResetResource
// reset data from channel server
// ---------------------------------------------------------------------------
//    
void CIRNmsLogger::ResetResource()
    {
    IRLOG_DEBUG( "CIRNmsLogger::ResetResource" );
    //reseting of resource
    }


    
// ---------------------------------------------------------------------------
// Function: UpdateChannelID
// updates the channel id
// ---------------------------------------------------------------------------
//    
void CIRNmsLogger::UpdateChannelID( TInt aChanneldID )
    {
    IRLOG_DEBUG( "CIRNmsLogger::UpdateChannelID" );
    iChannelId = aChanneldID;    
    }

// ---------------------------------------------------------------------------
// Function: UpdateCurrentNetwork
// updates the current network
// ---------------------------------------------------------------------------
//
void CIRNmsLogger::UpdateCurrentNetwork( TInt aCurrentNetwork )
    {
    IRLOG_DEBUG( "CIRNmsLogger::UpdateCurrentNetwork" );
    iNmsCurrentNetwork = aCurrentNetwork;
    }

// ---------------------------------------------------------------------------
// Function: UpdateHomeOperator
// updates the home network
// ---------------------------------------------------------------------------
//
void CIRNmsLogger::UpdateHomeOperator( TInt aHomeOperator )
    {
    IRLOG_DEBUG( "CIRNmsLogger::UpdateHomeOperator" );
    iHomeOperator = aHomeOperator;
    }

// ---------------------------------------------------------------------------
// Function : UpdateNmsStartGMTTime
// function updates Nms start time with current GMT time
// ---------------------------------------------------------------------------
//
void CIRNmsLogger::UpdateNmsStartGMTTime()
    {
    iStartNmsTime.UniversalTime();    
    }
// ---------------------------------------------------------------------------
// CIRNmsLogger: UpdateNmsType
// updates the Nms type
// ---------------------------------------------------------------------------
//
void CIRNmsLogger::UpdateNmsType( const TDesC& aNmsType )
    {
    IRLOG_DEBUG( "CIRNmsLogger::UpdateNmsType" );
    iNmsType.Copy( aNmsType );
    }

// ---------------------------------------------------------------------------
// Function: ChannelID
// returns the channel id
// ---------------------------------------------------------------------------
//    
TInt CIRNmsLogger::ChannelID() const
    {
    IRLOG_DEBUG( "CIRNmsLogger::ChannelID" );
    return iChannelId;
    }

// ---------------------------------------------------------------------------
// Function: CurrentNetwork
// returns the Current Network
// ---------------------------------------------------------------------------
//    
TInt CIRNmsLogger::CurrentNetwork() const
    {
    IRLOG_DEBUG( "CIRNmsLogger::CurrentNetwork" );
    return iNmsCurrentNetwork;
    }

// ---------------------------------------------------------------------------
// Function: HomeOperator
// returns the home network
// ---------------------------------------------------------------------------
//
TInt CIRNmsLogger::HomeOperator() const
    {
    IRLOG_DEBUG( "CIRNmsLogger::HomeOperator" );
    return iHomeOperator;
    }


// ---------------------------------------------------------------------------
// Function: StartTime
// returns the start time
// ---------------------------------------------------------------------------
//    
TDes& CIRNmsLogger::StartTime()
    {
    IRLOG_DEBUG( "CIRNmsLogger::StartTime" );
    return iStartTime;    
    }
// ---------------------------------------------------------------------------
// Function: NmsLogId
// returns the NmsLog id
// ---------------------------------------------------------------------------
//    
TInt CIRNmsLogger::NmsLogId() const
    {
    IRLOG_DEBUG( "CIRSessionLogger::NmsLogId" );
    return iNmsLogId;
    }
// ---------------------------------------------------------------------------
// Function: NmsType
// returns the Nms type
// ---------------------------------------------------------------------------
//    
TDesC& CIRNmsLogger::NmsType()
    {
    IRLOG_DEBUG( "CIRNmsLogger::ConnectionType" );
    return iNmsType;
    }

// ---------------------------------------------------------------------------
// Function: FileName
// returns file name
// ---------------------------------------------------------------------------
//
TFileName CIRNmsLogger::FileName()
    {
    IRLOG_DEBUG( "CIRNmsLogger::FileName" );
    return iFilePath;    
    }

// ---------------------------------------------------------------------------
// Function: DateTime
// returns Nms start time
// ---------------------------------------------------------------------------
//
TTime CIRNmsLogger::DateTime()
    {
    return iStartNmsTime;    
    }
    

    
// ---------------------------------------------------------------------------
// Function: GetBackedUp
// Back up the Nms log of a Nms
// ---------------------------------------------------------------------------
//    
void CIRNmsLogger::GetBackedUp( CIRNmsLogger& aNms )
    {
    //Nms start time
    iStartNmsTime = aNms.DateTime();
    //start time 
    iStartTime.Copy( aNms.StartTime() );
    //channel id
    iChannelId = aNms.ChannelID();
    //home operator
    iHomeOperator = aNms.HomeOperator();
    //current network
    iNmsCurrentNetwork = aNms.CurrentNetwork();
    // Newly added    
    ResetResource();
    }
            
// ---------------------------------------------------------------------------
// Function: ExternalizeL
// externialize the stream to the given stream
// ---------------------------------------------------------------------------
//
void CIRNmsLogger::ExternalizeL( RWriteStream& aWriteStream )
    {
    IRLOG_DEBUG( "CIRNmsLogger::ExternalizeL" );
    TInt length;
    //start time
    length = iStartTime.Length();
    aWriteStream.WriteInt32L( length );
    aWriteStream.WriteL( iStartTime, length );
    
    //channel id
    aWriteStream.WriteInt32L( iChannelId );

    //Type
    length = iNmsType.Length();
    aWriteStream.WriteInt32L( length );
    aWriteStream.WriteL( iNmsType, length );
    
    //current network
    aWriteStream.WriteInt32L( iNmsCurrentNetwork );
    
    //home operator
    aWriteStream.WriteInt32L( iHomeOperator );

    IRLOG_DEBUG( "CIRNmsLogger::ExternalizeL - Exiting." );
    }
    
// ---------------------------------------------------------------------------
// Function: InternalizeL
// gets the data from the stream
// ---------------------------------------------------------------------------
//
void CIRNmsLogger::InternalizeL( RReadStream& aReadStream )
    {
    IRLOG_DEBUG( "CIRNmsLogger::InternalizeL" );
    TInt length;
    
    //Start Time
    length = aReadStream.ReadInt32L();
    aReadStream.ReadL( iStartTime, length );
    
    
    //Channel Id
    iChannelId = aReadStream.ReadInt32L();

    //Nms Type
    length = aReadStream.ReadInt32L();
    aReadStream.ReadL( iNmsType, length );

    //Nms Current Network
    iNmsCurrentNetwork = aReadStream.ReadInt32L();
    
    //Home Operator
    iHomeOperator = aReadStream.ReadInt32L();
            
    IRLOG_DEBUG( "CIRNmsLogger::InternalizeL - Exiting." );
    }