/*

* Copyright (c) 2006, 2008 Nokia Corporation and/or its subsidiary(-ies).

* All rights reserved.

* This component and the accompanying materials are made available

* under the terms of the License "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 header file of the CMidletUI class.

*

*                This class implements the ECom SWInstUIPluginAPI interface

*                for midlet installation.

*

*

*/

#include <f32file.h>

#include <bautils.h>

#include <e32cmn.h>

#include <libxml2_globals.h>

#include <libc/stdlib.h>

#include <libxml2_parser.h>

#include <libxml2_tree.h>

#include "browser_platform_variant.hrh"

#ifdef BRDO_SYMBIAN_LIBXML_FF

#include <xmlengxestd.h>

#endif

#include "WidgetInstaller.h"

#include "WidgetConfigHandler.h" // info.plist parser

#include "WidgetRegistrationManager.h" // interface to "shell"

#include "IconConverter.h"

#include "WidgetBackupRegistryXml.h" 

// CONSTANTS

_LIT( KInfoPList,"Info.plist" );

_LIT( KIconFile, "Icon.png" );

_LIT( KMBMExt, ".mbm");

_LIT( KLprojExt, ".lproj" );

_LIT( KInfoPlistStrings, "InfoPlist.strings" );

_LIT( KWidgetPropFile, "\\private\\10282822\\WidgetEntryStore.xml" );

// For parsing backedup registration file 

_LIT8( KWidgetRegistry, "widgetregistry" );

_LIT8( KEntry, "entry" );

_LIT8( KXmlPropTag, "prop" );

_LIT8( KXmlValTag, "val" );

_LIT8( KXmlTypeTag, "type" );

_LIT( KXmlDataTypeBool, "bool" );

_LIT( KXmlDataTypeInt, "int" );

_LIT( KXmlDataTypeString, "string" );

_LIT( KXmlDataTypeUid, "uid" );

// TODO MW has a hard dependency to APP domain. Not very good...

// TODO Hard-coded UID.

_LIT( KWidgetAppDir, "\\private\\10282822\\" );

_LIT( KBackSlash, "\\" );

// todo: other keystring.dat for preference

_LIT(KWidgetPref, "prefs.dat*");

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

// ============================================================================

// CWidgetInstaller::NewL()

// two-phase constructor

//

// @since 3.1

// @return pointer to CWidgetInstaller

// ============================================================================

//

EXPORT_C CWidgetInstaller* CWidgetInstaller::NewL()

    {

    CWidgetInstaller* self

        = new (ELeave) CWidgetInstaller();

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

// ============================================================================

// CWidgetInstaller::CWidgetInstaller()

// C++ constructor

//

// @since 3.1

// ============================================================================

//

CWidgetInstaller::CWidgetInstaller()

    : iPropertyValues( EWidgetPropertyIdCount )

    {

    }

// ============================================================================

// CWidgetInstaller::ConstructL()

// Symbian second phase constructor

//

// @since 3.1

// ============================================================================

//

void CWidgetInstaller::ConstructL()

    {

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

    User::LeaveIfError( iRfs.ShareProtected() );

    iFileMgr = CFileMan::NewL( iRfs );

    iAppManager = CWidgetRegistrationManager::NewL( iRfs );

    iWidgetConfigHandler = CWidgetConfigHandler::NewL();

    // delay registry connect because registry is a client and that

    // produces a circular dependency

    iServerConnected = EFalse;

    // empty values

    for ( TInt i( 0 ); i < EWidgetPropertyIdCount; ++i )

        {

        CWidgetPropertyValue* value = CWidgetPropertyValue::NewL();

        User::LeaveIfError( iPropertyValues.Insert( value, i ) );

        }

    *(iPropertyValues[EWidgetPropertyListVersion]) = KWidgetPropertyListVersion71;

#ifdef _DEBUG

    _LIT(KDir, "WidgetBUR");

    _LIT(KFile, "WidgetBURInstaller.log");

    TInt err( 0 );

    err = iFileLogger.Connect();

    if ( err == KErrNone )

        {

        iFileLogger.CreateLog( KDir(), KFile(), EFileLoggingModeOverwrite );

        iCanLog = ETrue;

        }

#endif

    }

// ============================================================================

// CWidgetInstaller::~CWidgetInstaller()

// destructor

//

// @since 3.1

// ============================================================================

//

CWidgetInstaller::~CWidgetInstaller()

    {

    TInt i = 0;

    for ( ; i < EWidgetPropertyIdCount; ++i )

        {

        delete iPropertyValues[i];

        }

    iPropertyValues.Close();

    delete iFileMgr;

    iRfs.Close();

    delete iWidgetConfigHandler;

    delete iAppManager;

    if ( iServerConnected )

        {

        iRegistry.Disconnect();

        }

#ifdef _DEBUG

    iFileLogger.Close();

#endif

    }

// ============================================================================

// CWidgetInstaller::InstallL()

// NORMAL INSTALL STEPS:

// 2. get metadata file (e.g. Info.plist) and parse it

// 3. if needed, replace identically named existing widget)

// 4. do free space check

// 5. if replacing existing widget then move currently installed files

//    to backup for possible restore on install error

//

// @since 3.1

// ============================================================================

//

EXPORT_C void CWidgetInstaller::InstallL(

    TDesC& aRestoreDir )

    {

    if ( EFalse == iServerConnected )

        {

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

        iServerConnected = ETrue;

        }

    // The bool will be flase until doing something that

    // needs to be cleaned up on error/cancel.

    iOverwriting = EFalse;

    TRAPD( error,

        {

        // do initial bundle processing (parse and validate, total size,

        // check if replacing existing widget with same bundle ID, etc.)

        //

        // this step doesn't do anything that would need to be undone

        TBool replaceExisting = PreprocessWidgetBundleL( aRestoreDir );

        SetDriveAndCheckSpaceL();

        if ( replaceExisting )

            {

            BackupL(); // nothing need be undone if backup leaves

            }

        }

        ); // TRAPD

    if ( error == KErrNone )

        {

        ProcessRestoreDirL( aRestoreDir );

        }

    else if ( error == KErrAlreadyExists )

        {

        // max number of uid reached, to avoid SBE undo previous widget restore, don't leave with error

        return;

        }

    else

        {

        User::Leave( error );

        }

    }

// ============================================================================

// CWidgetInstaller::SearchWidgetRootL

//

// @since 3.2

// ============================================================================

//

TInt CWidgetInstaller::SearchWidgetRootL( const TDesC& aDir, TFileName& aFoundName )

    {

    CDir* entryList = NULL;

    TBool found = EFalse;

    RFile rFile;

    // aDir = "\private\[WidgetBackupRestoreUid]\WidgetBURTemp\bundleID\"

    TInt err = iRfs.GetDir( aDir, KEntryAttMatchMask, EDirsFirst, entryList );

    if ( err == KErrNone )

        {

        CleanupStack::PushL(entryList);

        // check for directory entries

        TInt cnt = entryList->Count();

        for (TInt i=0; i<cnt; i++)

            {

            const TEntry& fileEntry = (*entryList)[i];

            TFileName tempFile( aDir );

            tempFile.Append( fileEntry.iName );

            tempFile.Append( KBackSlash );

            TInt64 dirSize = GetDirSizeL( tempFile );

            if ( 0 == dirSize )

                continue;

            tempFile.Append( KInfoPList );

            TInt error = rFile.Open( iRfs, tempFile, EFileRead );

            CleanupClosePushL( rFile );

            CleanupStack::PopAndDestroy();  // rFile

            if ( KErrNone == error )

                {

                aFoundName.Copy( fileEntry.iName );

                found = ETrue;

                break;

                }

            }  // end of for

            CleanupStack::PopAndDestroy();  // entryList

        }  // end of if  iRfs

    return found;

    }

// ============================================================================

// CWidgetInstaller::FixWidgetPropsL()

// Handles preprocessing of widget properties 

//

// @since 5.0

// ============================================================================

//

void CWidgetInstaller::FixWidgetPropsL()

    {

	TInt  backupBlanketPerm = -1; 

    CWidgetBackupRegistryXml* aXmlProcessor = CWidgetBackupRegistryXml::NewL();

    RPointerArray<CWidgetPropertyValue>  backupPropertyValues;

    TInt i = 0;

    // empty values

    for ( ; i < EWidgetPropertyIdCount; ++i )

        {

        CWidgetPropertyValue* value = CWidgetPropertyValue::NewL();

        CleanupStack::PushL( value );

        User::LeaveIfError( backupPropertyValues.Insert( value, i ) );

        CleanupStack::Pop( value );

        }

// Algorithm

// 1. Look for the entry 

// 2. Check if the EBundleIdentifier is what we are looking for

// 3. If so, looking for the value of EBlanketPermGranted

// 4. If exist, then we fix it 

    // hardcode the filename first

    RFile file;

    TFileName propFile( KWidgetPropFile );

    User::LeaveIfError( file.Open( iRfs, propFile, EFileRead )); 

    CleanupClosePushL( file ); 

    TInt size;

    User::LeaveIfError ( file.Size ( size )); 

    HBufC8* buf = HBufC8::NewLC ( size ); 

    TPtr8 bufPtr ( buf->Des() );

    User::LeaveIfError( file.Read( bufPtr ) );

    // initialize the parser and check compiled code matches lib version

    LIBXML_TEST_VERSION

    xmlDocPtr doc; 

    doc = xmlReadMemory( (const char *)bufPtr.Ptr(), bufPtr.Length(),

                         NULL, 

                         NULL, 

                         0); 

    if ( !doc )

        {

        User::Leave( KErrCorrupt );

        }

    xmlNode* rootElement = xmlDocGetRootElement( doc );

    TPtrC8 rootTag( rootElement->name );

    if ( 0 != rootTag.Compare( KWidgetRegistry() ) )

    {

        User::Leave( KErrCorrupt );

    }

    for ( xmlNode* m = rootElement->children;

          m;

          m = m->next )

        {

        if ( m->type == XML_ELEMENT_NODE )

            {

            TPtrC8 element( m->name );

            if ( 0 == element.Compare( KEntry() ) )

                {

                backupBlanketPerm = -1;  // reset this value for every entry 	

                if ( NULL == m->children )

                    {

                    // malformed? should we require entry to have

                    // some minimal info?

                    continue;

                    }

                // extract one entry

                xmlNode* n;

                n = m->children;  

                for ( ; 

                      n; 

                    )

                    { 

                    while ( n && ( n->type != XML_ELEMENT_NODE )) 

                        {

                        n = n->next; 

                        }

                    if ( NULL == n ) 

                        {

                        break; 

                        }

                TPtrC8 propTag( n->name );

                if ( 0 != propTag.Compare( KXmlPropTag() ) )

                    {

                    // unrecognized subtree?

                    break;

                    }

                // validate n->children != NULL and type XML_TEXT_NODE

                HBufC* name;

                aXmlProcessor->GetContentL( iRfs, doc, n->children, &name );

                // get value array index (TWidgetPropertyId) for name

                TPtr namePtr( name->Des() );

                TInt propId =

                    aXmlProcessor->GetPropertyId( namePtr );

                delete name;

                name = NULL;

                if ( EWidgetPropertyIdInvalid == propId )

                    {

                    User::Leave( KErrNoMemory );

                    }

                n = n->children->next; // down to val

                if ( NULL == n )

                {

                    User::Leave( KErrCorrupt );

                }

                TPtrC8 valTag( n->name );

                if ( 0 != valTag.Compare( KXmlValTag() ) )

                    {

                    User::Leave( KErrCorrupt );

                    }

                if (propId >= EWidgetPropertyIdCount) // unsupported property

                    {

                    HBufC* value = NULL;

                    if (n->children)

                        {

                        aXmlProcessor->GetTextContentAsStringL( iRfs, doc, n->children, &value );

                        }

                    else

                       {

                       value = KNullDesC().AllocL();

                       }

                n = (n->parent)->next; // up two and next sibling

                continue;

                }

                HBufC* value;

                aXmlProcessor->GetContentL( iRfs, doc, n->children, &value );

                CleanupStack::PushL( value );

                n = n->children->next; // down to type

                if ( NULL == n )

                {

                User::Leave( KErrCorrupt );

                }

                TPtrC8 typeTag( n->name );

                if ( 0 != typeTag.Compare( KXmlTypeTag() ) )

                {

                    User::Leave( KErrCorrupt );

                }

                // validate n->children != NULL and type XML_TEXT_NODE

                HBufC* type;

                aXmlProcessor->GetContentL( iRfs, doc, n->children, &type );

                CleanupStack::PushL( type );

                //

                // assume void/unknown is not put in XML format so anything

                // not recognized should be handled like other unrecognized

                // subtree

                TWidgetPropertyType typeEnum = EWidgetPropTypeUnknown;

                if ( 0 == type->Des().Compare( KXmlDataTypeBool() ) )

                    {

                    typeEnum = EWidgetPropTypeBool;

                    }

                else if ( 0 == type->Des().Compare( KXmlDataTypeInt() ) )

                    {

                    typeEnum = EWidgetPropTypeInt;

                    }

                else if ( 0 == type->Des().Compare( KXmlDataTypeString() ) )

                    {

                    typeEnum = EWidgetPropTypeString;

                    }

                else if ( 0 == type->Des().Compare( KXmlDataTypeUid() ) )

                    {

                    typeEnum = EWidgetPropTypeUid;

                    }

                CleanupStack::PopAndDestroy( type );

                // set prop according to type

                switch ( typeEnum )

                    {

                    case EWidgetPropTypeBool:

                    if ( 0 == value->Des().Compare( _L("0") ) )

                        {

                        *backupPropertyValues[propId] = 0;

                        }

                    else

                        {

                        *(backupPropertyValues[propId]) = 1;

                        }        

                    break;

                    case EWidgetPropTypeInt:

                        {

                        TLex toInt( value->Des() );

                        TInt k;

                        if ( KErrNone != toInt.Val( k ) )

                            {

                            User::Leave( KErrCorrupt );

                            }

                        if ( propId ==  EBlanketPermGranted )

                            backupBlanketPerm = k;

                        }

                    break;                    

					          case EWidgetPropTypeString:

                    *(backupPropertyValues[propId]) = *value; 

                    break;

                    case EWidgetPropTypeUid:

                        {

                        TLex toUid( value->Des() );

                        TInt u;

                        if ( KErrNone != toUid.Val( u ) )

                            {

                            User::Leave( KErrCorrupt );

                            }

                       *(backupPropertyValues[propId])  = TUid::Uid( u );

                       }

                    break;        

                    };

                   CleanupStack::Pop( value );

                   if ( EWidgetPropTypeString != typeEnum )

                       {

                       delete value;

                       }

                   n = ((n->parent)->parent)->next; // up two and next sibling