/*

* Copyright (c) 2002-2004 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 file contains the implementation of CSisxUIStartupFile

*                class member functions.

*

*/

// INCLUDE FILES

#include <s32file.h>

#include <barsc.h>

#include <barsread.h>

#include <data_caging_path_literals.hrh>

#include <pathinfo.h>

#include <SWInstStartupTaskParam.h>

#include "SisxUIStartupFile.h"

using namespace SwiUI;

_LIT( KNewFileFormat, "%S.rsc" );

_LIT( KNewFileMatch, "[*].rsc" );

_LIT( KPrivateFileDir, "startup\\" );

_LIT( KPrivateFileFormat, "%S.dat" );

_LIT( KImportDir, "Import\\" );

// ============================ MEMBER FUNCTIONS ===============================

// -----------------------------------------------------------------------------

// CSisxUIStartupFile::CSisxUIStartupFile

// C++ default constructor can NOT contain any code, that

// might leave.

// -----------------------------------------------------------------------------

//

CSisxUIStartupFile::CSisxUIStartupFile()

    {

    }

// -----------------------------------------------------------------------------

// CSisxUIStartupFile::ConstructL

// Symbian 2nd phase constructor can leave.

// -----------------------------------------------------------------------------

//

void CSisxUIStartupFile::ConstructL( const TUid& aUid )

    {

    User::LeaveIfError( iFileSession.Connect() );

    TUidName uidStr = aUid.Name();

    TFileName tmp;

    iFileSession.PrivatePath( tmp );    

    tmp.Insert( 0, TParsePtrC( PathInfo::PhoneMemoryRootPath() ).Drive() );

    tmp.Append( KImportDir );      

    tmp.AppendFormat( KNewFileFormat, &uidStr ); 

    iNewFile = tmp.AllocL();

    tmp.Zero();

    iFileSession.PrivatePath( tmp );

    tmp.Insert( 0, TParsePtrC( PathInfo::PhoneMemoryRootPath() ).Drive() );

    tmp.Append( KPrivateFileDir );    

    iFileSession.MkDir( tmp );    

    tmp.AppendFormat( KPrivateFileFormat, &uidStr );

    iPrivateFile = tmp.AllocL();

    }

// -----------------------------------------------------------------------------

// CSisxUIStartupFile::NewL

// Two-phased constructor.

// -----------------------------------------------------------------------------

//

CSisxUIStartupFile* CSisxUIStartupFile::NewL( const TUid& aUid )

    {

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

    CleanupStack::PushL( self );

    self->ConstructL( aUid );

    CleanupStack::Pop( self );

    return self;    

    }

// Destructor

CSisxUIStartupFile::~CSisxUIStartupFile()

    {

    iFileSession.Close();

    delete iPrivateFile;

    delete iNewFile;   

    }

// -----------------------------------------------------------------------------

// CSisxUIStartupFile::NewFileExists

// Checks if new startup file exists in the import directory.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

TBool CSisxUIStartupFile::NewFileExists()

    {

    TBool result ( EFalse );

    // See if the file exists

    TUint dummy;

    if ( iFileSession.Att( *iNewFile, dummy ) == KErrNone )

        {

        result = ETrue;

        }

    return result;

    }

// -----------------------------------------------------------------------------

// CSisxUIStartupFile::PrivateFileExists

// Checks if old, processed startup file exists in the private directory.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

TBool CSisxUIStartupFile::PrivateFileExists()

    {

    TBool result ( EFalse );

    // See if the file exists

    TUint dummy;

    if ( iFileSession.Att( *iPrivateFile, dummy) == KErrNone )

        {

        result = ETrue;

        }

    return result;

    }

// -----------------------------------------------------------------------------

// CSisxUIStartupFile::ProcessNewFile

// Moves the new startup file from import directory to private directory and

// returns all startup items in that file.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

TInt CSisxUIStartupFile::ProcessNewFile( RArray<TStartupTaskParam>& aStartupItems,

                                         const RPointerArray<HBufC>& aFiles )

    {

    TInt result( KErrNone );

    // should check if old file is already there

    TRAP( result, ReadNewStartupItemsL( aStartupItems, aFiles ) );

    if ( result == KErrNone )

        { 

        TRAP( result, WritePrivateStartupItemsL( aStartupItems ) );

        }    

    if ( result != KErrNone )

        {        

        // Do some cleanup

        aStartupItems.Close();

        if ( PrivateFileExists() )

            {

            iFileSession.Delete( *iPrivateFile );

            }

        }    

    return result;

    }

// -----------------------------------------------------------------------------

// CSisxUIStartupFile::RemovePrivateFile

// Deletes the old startup file from private directory and returns all startup 

// items in that file.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

TInt CSisxUIStartupFile::RemovePrivateFile( RArray<TStartupTaskParam>& aStartupItems )

    {

    TInt result( KErrNone );

    TRAP( result, ReadPrivateStartupItemsL( aStartupItems ) );

    if ( result == KErrNone )

        {

        iFileSession.Delete( *iPrivateFile );

        } 

    else

        {

        // Do some cleanup

        aStartupItems.Close();        

        }    

    return result;

    }

// -----------------------------------------------------------------------------

// CSisxUIStartupFile::ClearAllNewFiles

// Deletes all resource files from import directory.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

TInt CSisxUIStartupFile::ClearAllNewFiles()

    {

    TInt result( KErrNone );

    RFs fileSess;

    CFileMan* fileMan = NULL;

    result = fileSess.Connect();

    if ( result == KErrNone )

        {

        TRAP( result, fileMan = CFileMan::NewL( fileSess ) );

        }

    if ( result == KErrNone )

        {  

        TFileName resFile;

        fileSess.PrivatePath( resFile );

        resFile.Insert( 0, TParsePtrC( PathInfo::PhoneMemoryRootPath() ).Drive() );

        resFile.Append( KImportDir );      

        resFile.Append( KNewFileMatch ); 

        fileMan->Delete( resFile );

        }

    delete fileMan;    

    fileSess.Close();

    return result;

    }

// -----------------------------------------------------------------------------

// CSisxUIStartupFile::ReadStartupItemsL

// Get all startup items from the given resource file.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

void CSisxUIStartupFile::ReadNewStartupItemsL( RArray<TStartupTaskParam>& aStartupItems,

                                               const RPointerArray<HBufC>& aFiles )

    {

    RResourceFile resource;

    CleanupClosePushL( resource );

    resource.OpenL( iFileSession, *iNewFile );

    TInt index( 0 );    

    // Read resources

    for ( index = 1; resource.OwnsResourceId( index ); index++ )

        {

        // Create the reader

        HBufC8* resBuffer = resource.AllocReadLC( index );

        TResourceReader reader;

        reader.SetBuffer( resBuffer );

        // Read version byte

        TInt version = reader.ReadUint8();        

        // Read actual parameters

        TStartupTaskParam item;

        item.iFileName.Copy( reader.ReadTPtrC() );        

        item.iRecoveryPolicy = (TStartupExceptionPolicy) reader.ReadUint16();

        aStartupItems.Append( item );

        CleanupStack::PopAndDestroy( resBuffer );

        }   

    // Validate the array. Each and every executable to be added to the 

    // startup list must also be installed by this package.

    for ( index = 0; index < aStartupItems.Count(); index++ ) 

        {

        // Sanity check

        if ( !aStartupItems[index].iFileName.Length() )

            {

            continue;

            }        

        TBool entryFound( EFalse );        

        TInt j( 0 );        

        iTemp = aStartupItems[index].iFileName;

        iTemp.Delete( 0, 1 );        

        iTemp.Fold();        

        for ( j = 0; j < aFiles.Count(); j++ )

            {            

            if ( aFiles[j]->FindF( iTemp ) >= 0 )

                {

                entryFound = ETrue;

                // Replace the possible ! with correct drive

                if ( aStartupItems[index].iFileName[0] == '!' )

                    {

                    TBuf<1> temp;

                    temp.Append( (*aFiles[j])[0] );                    

                    aStartupItems[index].iFileName.Replace(0, 1, temp );                    

                    }

                break;                

                }            

            }

        if ( !entryFound )

            {

            aStartupItems.Remove( index );

            index--;            

            }        

        }    

    CleanupStack::PopAndDestroy(); // resource

    }

// -----------------------------------------------------------------------------

// CSisxUIStartupFile::ReadPrivateStartupItemsL

// Read startup items from private file.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

void CSisxUIStartupFile::ReadPrivateStartupItemsL( RArray<TStartupTaskParam>& aStartupItems )

    {

    RFileReadStream reader;

    reader.PushL();

    User::LeaveIfError( reader.Open( iFileSession, *iPrivateFile, EFileRead ) );

    // Read the number of entries

    TInt count = reader.ReadInt32L();

     // Read file names from the file

    while ( count-- )

        {

        TStartupTaskParam item;

        HBufC* fileName = HBufC::NewLC( reader, KMaxFileName );

        item.iFileName.Copy( *fileName );        

        CleanupStack::PopAndDestroy( fileName);       

        aStartupItems.Append( item );

        }

    CleanupStack::PopAndDestroy(); // reader

    }

// -----------------------------------------------------------------------------

// CSisxUIStartupFile::WritePrivateStartupItemsL

// Write startup items into private file.

// (other items were commented in a header).

// -----------------------------------------------------------------------------

//

void CSisxUIStartupFile::WritePrivateStartupItemsL( RArray<TStartupTaskParam>& aStartupItems )

    {

    if ( PrivateFileExists() )

        {

        iFileSession.Delete( *iPrivateFile );

        }

    if ( aStartupItems.Count() > 0 )

        {

        RFileWriteStream writer;

        writer.PushL();    

        User::LeaveIfError( writer.Create( iFileSession, *iPrivateFile, EFileWrite ) );

        // Write the number of entries to the file

        writer.WriteInt32L( aStartupItems.Count() );

        // Write file names to the file

        for ( TInt index = 0; index < aStartupItems.Count(); index++ )

            {

            if ( iFileSession.IsValidName( aStartupItems[index].iFileName ) )

                {            

                writer << aStartupItems[index].iFileName;

                }

            else

                {

                User::Leave( KErrArgument );            

                }               

            }

        writer.CommitL();    

        CleanupStack::PopAndDestroy(); // writer

        }    

    }

//  End of File