/*

* 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: Implementation of CSsmLocaleObserverSup class.

*

*/

#include <bacntf.h>

#include <bautils.h>

#include <connect/sbdefs.h>

#include <s32file.h>

#include "ssmmapperutilitystatic.h"

#include "ssmlocaleobserversup.h"

#include "trace.h"

/**

* Directory to store user-specific locale data files.

* Private directory of SSM Utility Server.

*/

_LIT( KLocaleDataDir, "\\private\\2000d766\\localedata\\" );

/** Name is LocaleData.Dnn or CommonData.D00 */

_LIT( KFileName, "LocaleData.D" );

_LIT( KCommonFileName, "CommonData.D" );

/**

* Version number from 1..255 to indicate data

* format of the file. To make dynamic data format fixes possible we need

* version ID.

*/

const TInt KCurrentVersionNumber = 2; // For fixing TChar r/w

// ======== LOCAL FUNCTIONS ========

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

// EnvChangeNotifierCallbackL

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

//

static TInt EnvChangeNotifierCallback( TAny* aThis )

    {

    CSsmLocaleObserverSup* self = static_cast<CSsmLocaleObserverSup*>( aThis );

    ASSERT_TRACE( self );

    TRAPD( err, self->EnvChangeOccurredL() );

    ERROR( err, "Failed to handle environment change" );

    return err;

    }

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

// MakeFileNameL

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

//

static HBufC* MakeFileNameL( const TDesC& aPath, const TDesC& aName, const TInt aCode )

    {

    FUNC_LOG;

    INFO_3( "Locale data dir: %S, file name base: %S, lang code: %d", &aPath, &aName, aCode );

    TInt length = aPath.Length();

    // Reserve spave for language code also

    HBufC* buffer = HBufC::NewL( length + aName.Length() + 10 );

    TPtr ptr = buffer->Des();

    ptr.Append( aPath );

    if ( length > 0 && aPath[ length - 1 ] != KPathDelimiter )

        {

        ptr.Append( KPathDelimiter );

        }

    ptr.Append( aName );

    if ( aCode < 10 )

        {

        ptr.AppendNum( 0 ); // add leading zero to the extention

        }

    ptr.AppendNum( aCode );

    INFO_1( "Locale data file: %S", buffer );

    return buffer;

    }

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

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

// CSsmLocaleObserverSup::NewL

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

//

EXPORT_C MSsmUtility* CSsmLocaleObserverSup::NewL()

    {

    CSsmLocaleObserverSup* self = new ( ELeave ) CSsmLocaleObserverSup;

    return self;

    }

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

// CSsmLocaleObserverSup::~CSsmLocaleObserverSup

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

//

CSsmLocaleObserverSup::~CSsmLocaleObserverSup()

    {

    FUNC_LOG;

    Cancel();

    delete iEnvChangeNotifier;

    iFs.Close();

    iProperty.Close();

    }

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

// CSsmLocaleObserverSup::EnvChangeOccurredL

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

//

void CSsmLocaleObserverSup::EnvChangeOccurredL()

    {

    FUNC_LOG;

    const TInt changes( iEnvChangeNotifier->Change() );

    INFO_2( "Env data changed: 0x%08x, restore active: %d",

        changes, iRestoreActive );

    if ( !iRestoreActive && ( changes & EChangesLocale ) )

        {

        TParsePtrC parse( KLocaleDataDir );

        SaveLocaleL( parse.FullName() );

        }

    if( changes & EChangesSystemTime )

        {

        INFO( "Persisting HAL settings" );

        // Changes by writing to HAL

        TInt err = BaflUtils::PersistHAL();

        ERROR( err, "BaflUtils::PersistHAL failed" );

        }

    }

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

// CSsmLocaleObserverSup::RunL

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

//

void CSsmLocaleObserverSup::RunL()

    {

    FUNC_LOG;

    TInt err = iStatus.Int();

    ERROR( err, "RSsmStateAdaptation::NotifyCoopSysEvent completed with error" );

    if ( err != KErrServerTerminated )

        {

        Activate();

        }

    if ( err == KErrNone )

        {

        TInt status( 0 );

        err = iProperty.Get( status );

        ERROR( err, "Failed to get backup status from P&S" );

        if ( err == KErrNone )

            {

            TInt type = status & conn::KBURPartTypeMask;

            if ( type == conn::EBURRestoreFull ||

                 type == conn::EBURRestorePartial )

                {

                INFO( "Restore started" );

                iRestoreActive = ETrue;

                }

            else if ( type == conn::EBURNormal && iRestoreActive )

                {

                INFO( "Restore finished" );

                iRestoreActive = EFalse;

                TParsePtrC parse( KLocaleDataDir );

                TRAP( err, LoadLocaleL( parse.FullName() ) );

                ERROR( err, "Failed to load locale" );

                // Can not do anything about the error - just continue.

                }

            }

        }

    }

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

// CSsmLocaleObserverSup::DoCancel()

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

//

void CSsmLocaleObserverSup::DoCancel()

    {

    FUNC_LOG;

    iProperty.Cancel();

    }

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

// CSsmLocaleObserverSup::InitializeL()

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

//

void CSsmLocaleObserverSup::InitializeL()

    {

    FUNC_LOG;

    TInt err = iFs.Connect();

    ERROR( err, "Failed to connect to file server" );

    User::LeaveIfError( err );

    TRAP( err, iEnvChangeNotifier = CEnvironmentChangeNotifier::NewL(

        CActive::EPriorityStandard,

        TCallBack( EnvChangeNotifierCallback, this ) ) );

    ERROR( err, "Failed to create environment change notifier" );

    User::LeaveIfError( err );

    }

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

// CSsmLocaleObserverSup::StartL()

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

//

void CSsmLocaleObserverSup::StartL()

    {

    FUNC_LOG;

    TParsePtrC parse( KLocaleDataDir );

    TRAPD_ERR( err, LoadLocaleL( parse.FullName() ) );

    ERROR( err, "Failed to load locale data the first time" );

    if ( iEnvChangeNotifier )

        {

        iEnvChangeNotifier->Start();

        }

    TInt err1 = iProperty.Attach( SsmMapperUtility::PsUid( KUidSystemCategory ), conn::KUidBackupRestoreKey );

    ERROR( err1, "Failed to attach to KUidBackupRestoreKey" );

    Activate();

    }

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

// CSsmLocaleObserverSup::Release()

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

//

void CSsmLocaleObserverSup::Release()

    {

    FUNC_LOG;

    delete this;

    }

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

// CSsmLocaleObserverSup::CSsmLocaleObserverSup

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

//

CSsmLocaleObserverSup::CSsmLocaleObserverSup()

  : CActive( EPriorityNormal ),

    iRestoreActive( EFalse )

    {

    FUNC_LOG;

    CActiveScheduler::Add( this );

    }

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

// CSsmLocaleObserverSup::Activate

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

//

void CSsmLocaleObserverSup::Activate()

    {

    FUNC_LOG;

    ASSERT_TRACE( !IsActive() );

    iProperty.Subscribe( iStatus );

    SetActive();

    }

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

// CSsmLocaleObserverSup::SaveLocaleL

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

//

void CSsmLocaleObserverSup::SaveLocaleL( const TDesC& aPath )

    {

    FUNC_LOG;

    INFO( "Saving locale data" );

    HBufC* fName = MakeFileNameL( aPath, KFileName, User::Language() );

    CleanupStack::PushL( fName );

    RFileWriteStream fStream;

    CleanupClosePushL( fStream );

    // According to documentation RFileWriteStream

    // keeps written data in RAM until CommitL has been

    // called.

    TInt err = iFs.MkDirAll( *fName ); // Ignore errors

    err = fStream.Create( iFs, *fName, EFileWrite );

    if ( err == KErrAlreadyExists )

        {

        // Override

        err = fStream.Open( iFs, *fName, EFileWrite );

        ERROR_1( err, "Failed to open stream %S", fName );

        }

    User::LeaveIfError( err );

    // Write first the version number to enable

    // support for file format changes.

    fStream.WriteInt8L( KCurrentVersionNumber );

    TLocale locale; // copy current values

    fStream.WriteInt16L( locale.CountryCode() );

    fStream.WriteInt16L( 0 ); // reserved

    fStream.WriteInt8L( locale.DateFormat() );

    fStream.WriteInt8L( locale.TimeFormat() );

    fStream.WriteInt8L( locale.CurrencySymbolPosition() );

    fStream.WriteInt8L( locale.CurrencySpaceBetween() );

    fStream.WriteInt8L( locale.CurrencyDecimalPlaces() );

    fStream.WriteInt8L( locale.CurrencyNegativeInBrackets() );

    fStream.WriteInt8L( locale.CurrencyTriadsAllowed() );

    fStream.WriteUint32L( locale.ThousandsSeparator() );

    fStream.WriteUint32L( locale.DecimalSeparator() );

    fStream.WriteInt8L( KMaxDateSeparators ); // restoring this constant. It might chance.

    TInt counter( 0 );

    for ( counter = 0; counter < KMaxDateSeparators; counter++ )

        {

        fStream.WriteUint32L( locale.DateSeparator( counter ) );

        }

    fStream.WriteInt8L( KMaxTimeSeparators ); // restoring this constant. It might chance.

    for ( counter = 0; counter < KMaxTimeSeparators; counter++ )

        {

        fStream.WriteUint32L( locale.TimeSeparator( counter ) );

        }

    fStream.WriteInt8L( locale.AmPmSpaceBetween() );

    fStream.WriteInt8L( locale.AmPmSymbolPosition() );

    // DaylightSaving and HomeDaylightSavingZone are not part of TLocale

    // any more, zeros are written to LocaleData.Dxx to keep file structure

    // as it was.

    fStream.WriteInt32L( 0 );

    fStream.WriteUint32L( 0 );

    fStream.WriteUint8L( locale.WorkDays() );

    fStream.WriteInt8L( locale.StartOfWeek() );

    fStream.WriteInt8L( locale.ClockFormat() );

    fStream.WriteInt8L( locale.UnitsGeneral() );

    fStream.WriteInt8L( locale.UnitsDistanceShort() );

    fStream.WriteInt8L( locale.UnitsDistanceLong() );

    fStream.WriteInt8L( locale.NegativeCurrencyFormat() );

    fStream.WriteInt8L( locale.NegativeLoseSpace() );

    fStream.WriteInt8L( locale.NegativeCurrencySymbolOpposite() );

    fStream.WriteInt16L( locale.DigitType() );

    // Then save display language independent data

    SaveIndependentDataL( locale, aPath );

    // If CommitL leaves it means probably full disk.

    // It is here assumed that data has not been changed if this leaves.

    fStream.CommitL();

    CleanupStack::PopAndDestroy( &fStream );

    CleanupStack::PopAndDestroy( fName );

    }

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

// CSsmLocaleObserverSup::LoadLocaleL

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

//

void CSsmLocaleObserverSup::LoadLocaleL( const TDesC& aPath )

    {

    FUNC_LOG;

    INFO( "Loading locale data" );

    HBufC* fName = MakeFileNameL( aPath, KFileName, User::Language() );

    CleanupStack::PushL( fName );

    TLocale locale; // copy current values

    RFileReadStream fStream;

    CleanupClosePushL( fStream );

    TInt err = fStream.Open( iFs, *fName, EFileRead );

    if ( err != KErrNotFound && err != KErrPathNotFound )

        {

        ERROR_1( err, "Failed to open stream %S", fName );

        // Data file is missing upon the first boot or when switching into a

        // language for the first time

        }

    if ( err == KErrNone  )

        {

        TInt version = fStream.ReadInt8L();

        INFO_1( "Locale file version: %d", version );

        locale.SetCountryCode( fStream.ReadInt16L() );

        fStream.ReadInt16L(); // obsolete

        locale.SetDateFormat( static_cast< TDateFormat >( fStream.ReadInt8L() ) );

        locale.SetTimeFormat( static_cast< TTimeFormat >( fStream.ReadInt8L() ) );

        locale.SetCurrencySymbolPosition( static_cast< TLocalePos >( fStream.ReadInt8L() ) );

        locale.SetCurrencySpaceBetween( fStream.ReadInt8L() );

        locale.SetCurrencyDecimalPlaces( fStream.ReadInt8L() );

        locale.SetCurrencyNegativeInBrackets( fStream.ReadInt8L() );

        locale.SetCurrencyTriadsAllowed( fStream.ReadInt8L() );

        locale.SetThousandsSeparator( fStream.ReadUint32L() );

        locale.SetDecimalSeparator( fStream.ReadUint32L() );

        TInt dateSeparators = fStream.ReadInt8L();

        TInt counter( 0 );

        for ( counter = 0; counter < dateSeparators ; counter++ )

            {

            locale.SetDateSeparator( fStream.ReadUint32L(), counter );

            }

        TInt timeSeparators = fStream.ReadInt8L();

        for ( counter = 0; counter < timeSeparators; counter++ )

            {

            locale.SetTimeSeparator( fStream.ReadUint32L(), counter );

            }

        locale.SetAmPmSpaceBetween( fStream.ReadInt8L() );

        locale.SetAmPmSymbolPosition( static_cast< TLocalePos >( fStream.ReadInt8L() ) );

        // DaylightSaving and HomeDaylightSavingZone are not part of TLocale

        // any more, zeros are written to LocaleData.Dxx to keep file structure

        // as it was.

        fStream.ReadUint32L();

        fStream.ReadUint32L();

        locale.SetWorkDays( fStream.ReadUint8L() );

        locale.SetStartOfWeek( static_cast< TDay >( fStream.ReadInt8L() ) );

        locale.SetClockFormat( static_cast< TClockFormat>( fStream.ReadInt8L() ) );

        locale.SetUnitsGeneral( static_cast< TUnitsFormat >( fStream.ReadInt8L() ) );

        locale.SetUnitsDistanceShort( static_cast< TUnitsFormat >( fStream.ReadInt8L() ) );

        locale.SetUnitsDistanceLong( static_cast< TUnitsFormat >( fStream.ReadInt8L() ) );

        locale.SetNegativeCurrencyFormat(

            static_cast< TLocale::TNegativeCurrencyFormat >( fStream.ReadInt8L() ) );

        locale.SetNegativeLoseSpace( fStream.ReadInt8L() );

        locale.SetNegativeCurrencySymbolOpposite( fStream.ReadInt8L() );

        locale.SetDigitType( static_cast< TDigitType >( fStream.ReadInt16L() ) );

        }

    // Then patch data with locale independent data (code 00)

    // No changes to locale if no independent data can be found (the very first boot)

    LoadIndependentDataL( locale, aPath );

    // Save changes to the system.

    locale.Set();

    CleanupStack::PopAndDestroy( &fStream );

    CleanupStack::PopAndDestroy( fName );

    }

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

// CSsmLocaleObserverSup::SaveIndependentDataL

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

//

void CSsmLocaleObserverSup::SaveIndependentDataL(

    const TLocale& aLocale,

    const TDesC& aPath )

    {

    FUNC_LOG;

    // Get old independent data, if any.

    TLocale savedLoc;

    TRAPD( err, LoadIndependentDataL( savedLoc, aPath ) );

    ERROR( err, "Failed to load locale independent data" );

    HBufC* fName = MakeFileNameL( aPath, KCommonFileName, 0 );

    CleanupStack::PushL( fName );

    RFileWriteStream fStream;

    CleanupClosePushL( fStream );

    err = iFs.MkDirAll( *fName ); // Ignore errors

    err = fStream.Create( iFs, *fName, EFileWrite );

    if ( err == KErrAlreadyExists )

        {

        // Override

        err = fStream.Open( iFs, *fName, EFileWrite );

        ERROR_1( err, "Failed to create stream %S", fName );

        }

    User::LeaveIfError( err );

    // Write first the version number to enable support for file format changes.

    fStream.WriteInt8L( KCurrentVersionNumber );

    fStream.WriteInt32L( 0 ); // Universal time offset is not part of TLocale

                              // any more. Write zero here to keep file structure.

    // Clock format is also common.

    fStream.WriteUint32L( aLocale.ClockFormat() );

    fStream.WriteUint32L( 0 );  // reserved 2

    fStream.WriteUint32L( 0 );  // reserved 3

    fStream.CommitL();

    CleanupStack::PopAndDestroy( &fStream );

    CleanupStack::PopAndDestroy( fName );

    }

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

// CSsmLocaleObserverSup::LoadIndependentDataL

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

//

void CSsmLocaleObserverSup::LoadIndependentDataL(

    TLocale& aLocale,

    const TDesC& aPath )

    {

    FUNC_LOG;

    HBufC* fName = MakeFileNameL( aPath, KCommonFileName, 0 );

    CleanupStack::PushL( fName );

    RFileReadStream fStream;

    CleanupClosePushL( fStream );

    TInt err = fStream.Open( iFs, *fName, EFileRead );

    if ( err != KErrNotFound && err != KErrPathNotFound )

        {