/*
* Copyright (c) 2007-2010 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:   This module contains the implementation of IAUpdateTools functions
*
*/






#include <s32mem.h>
#include <iaupdateparameters.h>

#include "iaupdatetools.h"
#include "iaupdatedebug.h"

// -----------------------------------------------------------------------------
// IAUpdateTools::ExternalizeParametersL
// 
// -----------------------------------------------------------------------------
// 
void IAUpdateTools::ExternalizeParametersL( HBufC8*& aTarget,
                                            const CIAUpdateParameters& aSource )
    {
    IAUPDATE_TRACE("[IAUPDATE] IAUpdateTools::ExternalizeParametersL begin");
    // Notice!
    // If you make changes here. Also, remember to make corresponding
    // changes to the InternalizeParametersL

    // The size of the buffer will contain:
    // - 1 TInt for UIDs,
    // - 1 TBool for ShowProgress boolean
    // - 1 TUint for importance
    // - 1 TUint for type
    // - 1 TBool for Refresh boolean
    
    // - 3 TInt for descriptor lengths
    // --> bytes for 5 + 3 = 8 TInt values are needed 
    //     (sizeof( TInt ) * KNumberOfTInts)
    // - 3 descriptor TDesC texts
    const TInt KNumberOfTInts( 8 );

    // Notice, that because descriptor texts that are included
    // here are TDesC, their Size-information has to be used
    // instead of Length.
    HBufC8* tmp = 
        HBufC8::NewLC( sizeof( TInt ) * KNumberOfTInts
                       + aSource.SearchCriteria().Size()
                       + aSource.CommandLineExecutable().Size()
                       + aSource.CommandLineArguments().Size() );

    // Create stream that uses the buffer created above.
    // By using the stream, the values are easier to insert into the buffer.
    TPtr8 ptr( tmp->Des() );    
    RDesWriteStream stream( ptr );
    CleanupClosePushL( stream );

    // These are integers for uids
    IAUPDATE_TRACE_1("[IAUPDATE] uid: %x", aSource.Uid().iUid );
    stream.WriteInt32L( aSource.Uid().iUid );

    // These are length and data pairs for descriptors
    IAUPDATE_TRACE_1("[IAUPDATE] search criteria: %S", &aSource.SearchCriteria() );
    ExternalizeDesL( aSource.SearchCriteria(), stream );
    IAUPDATE_TRACE_1("[IAUPDATE] command line executable: %S", &aSource.CommandLineExecutable() );
    ExternalizeDesL( aSource.CommandLineExecutable(), stream );
#ifdef _DEBUG
    HBufC* temp = HBufC::NewL( aSource.CommandLineArguments().Length() );
    temp->Des().Copy( aSource.CommandLineArguments()) ;
    IAUPDATE_TRACE_1("[IAUPDATE] command line arguments: %S", temp );
    delete temp;
#endif //_DEBUG
    ExternalizeDes8L( aSource.CommandLineArguments(), stream );
    
    // Boolean for ShowProgress
    stream.WriteInt32L( aSource.ShowProgress() );
    
    // TUint for importance
    stream.WriteInt32L( aSource.Importance() );
    
    // TUint for type
    stream.WriteInt32L( aSource.Type() );
    
    // Boolean for Refresh
    stream.WriteInt32L( aSource.Refresh() );

    // Stream is not needed anymore
    CleanupStack::PopAndDestroy( &stream );

    // Remove tmp from the stack but do not delete it because it will be
    // assigned to the aTarget below.
    CleanupStack::Pop( tmp );
    
    // Replace aTarget with new value
    delete aTarget;
    aTarget = tmp;
    IAUPDATE_TRACE("[IAUPDATE] IAUpdateTools::ExternalizeParametersL end");
    }

// -----------------------------------------------------------------------------
// IAUpdateTools::InternalizeParametersL
// 
// -----------------------------------------------------------------------------
// 
void IAUpdateTools::InternalizeParametersL( CIAUpdateParameters& aTarget, 
                                            const TDesC8& aSource )
    {
    IAUPDATE_TRACE("[IAUPDATE] IAUpdateTools::InternalizeParametersL begin");
    // Notice!
    // If you make changes here. Also, remember to make corresponding
    // changes to the ExternalizeParametersL

    // InternalizeDesL function will set values into this tmp descriptor.
    HBufC* tmp( NULL );
    
    // Create stream that uses the given buffer.
    RDesReadStream stream( aSource );
    CleanupClosePushL( stream );

    aTarget.SetUid( TUid::Uid( stream.ReadInt32L() ) );
    IAUPDATE_TRACE_1("[IAUPDATE] uid: %x", aTarget.Uid().iUid );
    
    InternalizeDesL( tmp, stream );
    CleanupStack::PushL( tmp );
    aTarget.SetSearchCriteriaL( *tmp );
    IAUPDATE_TRACE_1("[IAUPDATE] search criteria: %S", tmp );
    CleanupStack::PopAndDestroy( tmp );
    tmp = NULL;
        
    InternalizeDesL( tmp, stream );
    CleanupStack::PushL( tmp );
    aTarget.SetCommandLineExecutableL( *tmp );
    IAUPDATE_TRACE_1("[IAUPDATE] command line executable: %S", tmp );
    CleanupStack::PopAndDestroy( tmp );
    tmp = NULL;

    HBufC8* tmp8( NULL );        
    InternalizeDes8L( tmp8, stream );
    CleanupStack::PushL( tmp8 );
    aTarget.SetCommandLineArgumentsL( *tmp8 );
#ifdef _DEBUG
    tmp = HBufC::NewL( tmp8->Length() );
    tmp->Des().Copy( *tmp8 ) ;
    IAUPDATE_TRACE_1("[IAUPDATE] command line arguments: %S", tmp );
    delete tmp;
    tmp = NULL;
#endif //_DEBUG
    CleanupStack::PopAndDestroy( tmp8 );
    tmp8 = NULL;
    
    aTarget.SetShowProgress( stream.ReadInt32L() );

    // new parameters (in phase 2 IAD) do not always exist. Parameters may have written by old IAD in selfupdate case.
    TRAPD( err, aTarget.SetImportance( stream.ReadInt32L() ) );
    if ( err != KErrEof )
        {
        User::LeaveIfError( err );
        aTarget.SetType( stream.ReadInt32L() );
        aTarget.SetRefresh( stream.ReadInt32L() );
        }
     
    IAUPDATE_TRACE_1("[IAUPDATE] show progress: %d", aTarget.ShowProgress() );
    CleanupStack::PopAndDestroy( &stream );   
    IAUPDATE_TRACE("[IAUPDATE] IAUpdateTools::InternalizeParametersL end");
    }


// -----------------------------------------------------------------------------
// IAUpdateTools::ExternalizeDesL
// 
// -----------------------------------------------------------------------------
// 
void IAUpdateTools::ExternalizeDesL( const TDesC& aDes, 
                                     RWriteStream& aStream )
    {
    aStream.WriteInt32L( aDes.Length() );
    aStream.WriteL( aDes );
    }

// -----------------------------------------------------------------------------
// IAUpdateTools::InternalizeDesL
// 
// -----------------------------------------------------------------------------
// 
TInt IAUpdateTools::InternalizeDesL( HBufC*& aDes, 
                                     RReadStream& aStream )
    {
    TInt length = aStream.ReadInt32L();
    if ( length > 0 ) 
        {
        HBufC* target = HBufC::NewLC( length );
        TPtr ptr( target->Des() );        
        aStream.ReadL( ptr, length );
        delete aDes;
        aDes = target;
        CleanupStack::Pop( target );
        }
    else
        {
        delete aDes;
        aDes = KNullDesC().AllocL();
        }
    return length;
    }

// -----------------------------------------------------------------------------
// IAUpdateTools::ExternalizeDes8L
// 
// -----------------------------------------------------------------------------
// 
void IAUpdateTools::ExternalizeDes8L( const TDesC8& aDes, RWriteStream& aStream )
    {
    aStream.WriteInt32L( aDes.Length() );
    aStream.WriteL( aDes );
    }

// -----------------------------------------------------------------------------
// IAUpdateTools::InternalizeDes8L
// 
// -----------------------------------------------------------------------------
// 
TInt IAUpdateTools::InternalizeDes8L( HBufC8*& aDes, RReadStream& aStream )
    {
    TInt length = aStream.ReadInt32L();
    if ( length > 0 ) 
        {
        HBufC8* target = HBufC8::NewLC( length );
        TPtr8 ptr( target->Des() );        
        aStream.ReadL( ptr, length );
        delete aDes;
        aDes = target;
        CleanupStack::Pop( target );
        }
    else
        {
        delete aDes;
        aDes = KNullDesC8().AllocL();
        }
    return length;
    }