/*

* 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 <SWInstDefs.h>

#include <zipfile.h>

#include <SWInstTaskManager.h>

#include <SWInstTask.h>

#include <SWInstLogTaskParam.h>

#include "WidgetUIOperationsWatcher.h"

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

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

// CONSTANTS

_LIT( KInfoPlist,"Info.plist" );

_LIT( KIconFile, "Icon.png" );

_LIT( KMBMExt, ".mbm");

_LIT( KLprojExt, ".lproj" );

_LIT( KInfoPlistStrings, "InfoPlist.strings" );

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

_LIT( KCookieFile, "c:\\private\\101f8530\\cookies.dat" );

const TUint KMaxDescLength = 0x0fffffffu;

// Note about filenames: All file name matching is case insensitive

// the EDriveName is stored as "c:" (withou a trailing backslash) all

// filenames are kept as complete pathnames (drive + path + filename)

// except when working with the widget bundle where the bundle

// contains relative paths

// TODO

// filenames are kept as drive relative pathnames (path + filename but

// not drive).  The widget bundle must contain relative paths.  The

// drive letter is separated because support for multiple drives and

// removable memory cards means that drive letters may change.

using namespace SwiUI;

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

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

// CWidgetUIOperationsWatcher::NewL()

// two-phase constructor

//

// @since 3.1

// @return pointer to CWidgetUIOperationsWatcher

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

//

CWidgetUIOperationsWatcher* CWidgetUIOperationsWatcher::NewL()

    {

    CWidgetUIOperationsWatcher* self

        = new (ELeave) CWidgetUIOperationsWatcher();

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    return self;

    }

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

// CWidgetUIOperationsWatcher::CWidgetUIOperationsWatcher()

// C++ constructor

//

// @since 3.1

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

//

CWidgetUIOperationsWatcher::CWidgetUIOperationsWatcher()

    : CActive( CActive::EPriorityStandard ),

      iPropertyValues( EWidgetPropertyIdCount )

    {

    CActiveScheduler::Add( this );

    }

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

// CWidgetUIOperationsWatcher::ConstructL()

// Symbian second phase constructor

//

// @since 3.1

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

//

void CWidgetUIOperationsWatcher::ConstructL()

    {

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

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

    iFileMgr = CFileMan::NewL( iRfs );

    iAppManager = CWidgetRegistrationManager::NewL( iRfs );

    iWidgetConfigHandler = CWidgetUIConfigHandler::NewL();

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

    iServerConnected = ETrue;

    TInt i = 0;

    // empty values

    for ( ; i < EWidgetPropertyIdCount; ++i )

        {

        CWidgetPropertyValue* value = CWidgetPropertyValue::NewL();

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

        }

    *(iPropertyValues[EWidgetPropertyListVersion]) = WIDGETPROPERTYLISTVERSION;

    iTaskManager = CTaskManager::NewL();

    }

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

// CWidgetUIOperationsWatcher::~CWidgetUIOperationsWatcher()

// destructor

//

// @since 3.1

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

//

CWidgetUIOperationsWatcher::~CWidgetUIOperationsWatcher()

    {

    CActive::Cancel();

    TInt i = 0;

    for ( ; i < EWidgetPropertyIdCount; ++i )

        {

        delete iPropertyValues[i];

        }

    iPropertyValues.Close();

    delete iMembers;

    delete iZipFile;

    delete iFileMgr;

    iRfs.Close();

    delete iUIHandler;

    delete iWidgetConfigHandler;

    delete iAppManager;

    delete iIconConverter;

    if ( iServerConnected )

        {

        iRegistry.Disconnect();

        }

    delete iTaskManager;

    }

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

// CWidgetUIOperationsWatcher::SilentInstallL()

// Handle silent install request.

//

// @since 3.1

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

//

void CWidgetUIOperationsWatcher::SilentInstallL(

    RFile& aFile,

    const TDesC8& aMIME,

    TRequestStatus& aRequestStatus )

    {

    iSilent = ETrue;

    InstallL( aFile, aMIME, aRequestStatus );

    }

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

// CWidgetUIOperationsWatcher::InstallSubfunctionL()

// Breaks out some install work inside trap macro because trap macro

// intereferes with some debuggers.

//

// @since 5.0

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

//

void CWidgetUIOperationsWatcher::InstallSubfunctionL(

    RFile& aFile,

    TBool& userCancel,

    TRequestStatus& aRequestStatus )

    {

    iZipFile = CZipFile::NewL( iRfs, aFile );

    // 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();

    if ( PromptUserForInstallL( replaceExisting )

         && PromptUserForUntrustedWidgetL( ) )

        {

        // reinitialize

        delete iMembers;

        iMembers = NULL;

        iMembers = iZipFile->GetMembersL();

        // now that install location is known, update MainHTML

        const TDesC& base = *(iPropertyValues[EBasePath]);

        const TDesC& main = *(iPropertyValues[EMainHTML]);

        if ( KMaxFileName < (base.Length() + main.Length()) )

            {

            User::Leave( KErrCorrupt );

            }

        TFileName tempFile;

        tempFile.Copy( base );

        tempFile.Append( main );

        *(iPropertyValues[EMainHTML]) = tempFile;

        // diplay explanation: 1. The progress display only comes up

        // if the total size is over 1 kilobyte (this

        // conditionalization is in UIHandler). 2. The displays stack

        // on top of each other so if progress display comes up it

        // will hide the finalize and then when progesss is removed,

        // the finalize will be revealed.  3. Also, finalize failed to

        // come up when triggered at the end of RunL() on a tiny

        // widget file with no icon.  Why, I'm not sure but probably

        // had to do with this active object blocking display

        // processing.  So here is a good place to put up the displays

        // (before RunL() is invoked) which lets other objects run.

        iUIHandler->DisplayFinalizeDialogL(); // a dialog without a cancel option

        iUIHandler->DisplayProgressDialogL(); // progress bar

        if ( replaceExisting )

            {

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

            // backup will gaurantee that install dir is empty

            // now don't execute any leaving code before starting RunL

            }

        else

            {

            // new widget, allocate a UID for this widget

            const TDesC& drive = *(iPropertyValues[EDriveName]);

            *(iPropertyValues[EUid]) = iRegistry.GetAvailableUidL(drive[0]).iUid;

            // check that install location is empty and remove what is

            // there if it isn't

            TUint attributes = 0;

            TInt e = iRfs.Att( base, attributes );

            if ( (KErrNotFound != e)

                 && (KErrPathNotFound != e) )

                {

                (void)iFileMgr->RmDir( base );

                }

            }

        }

    else

        {

        userCancel = ETrue;

        iUIHandler->DisplayCancelL();

        TRequestStatus* status = &aRequestStatus;

        User::RequestComplete( status, KErrNone );

        }

    }

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

// CWidgetUIOperationsWatcher::InstallL()

// NORMAL INSTALL STEPS:

// 1. open zip file

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

// 3. prompt user to install (or replace identically named existing widget)

// 4. prompt user for install location (built-in mem or mem card)

//    and do free space check

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

//    to backup for possible restore on install error

// 6. continue install in an active object runl to make install

//    cancellable also do icon processing in a separate active object

//   (the icon processing active object is a questionable design because

//    it doesn't follow the conventional CActive request/response pattern

//    and might as well be done here in the RunL)

//

// @since 3.1

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

//

void CWidgetUIOperationsWatcher::InstallL(

    RFile& aFile,

    const TDesC8& /*aMIME*/,

    TRequestStatus& aRequestStatus )

    {

    // Wrapper CWidgetInstallerUI::InstallL() guards against

    // a second install request while currently installing.

    iCancelled = EFalse;

    // These three bools will be flase until doing something that

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

    iUnzipping = EFalse;

    iOverwriting = EFalse;

    iProcessingIcon = EFalse;

    iIconSearchFinished = EFalse;

    iIconError = KErrNone;

    // outside trap because without a UI we can't display an error message

    iUIHandler =

        CWidgetUIHandler::NewL( CWidgetUIHandler::EModeInstall, this );

    TBool userCancel = EFalse;

    TRAPD( error, InstallSubfunctionL( aFile, userCancel, aRequestStatus ) );

    if ( KErrNone != error )

        {

        iUIHandler->DisplayErrorL( error );

        User::Leave( error );

        }

    else if ( userCancel )

        {

        return; // can't do return inside trap

        }

    // start putting bundle files in install area, registy won't be

    // changed until done unzipping and processing icon (if present)

    iUnzipping = ETrue;

    // set client request to pending state

    iRequestStatus = &aRequestStatus;

    *iRequestStatus = KRequestPending;

    // start RunL

    TRequestStatus* status = &iStatus;

    User::RequestComplete( status, KErrNone );

    SetActive();

    }

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

// CWidgetUIOperationsWatcher::PreprocessWidgetBundleL()

// Handles parsing and creating widget

//

// @since 3.1

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

//

TBool CWidgetUIOperationsWatcher::PreprocessWidgetBundleL()

    {

    TBool found = EFalse;

    TFileName tempFile;

    TFileName bundleRoot; // root dir in widget bundle (not install root)

    TUint32 zipfileUncompressedSize = 0;

    iMembers = iZipFile->GetMembersL();

    if ( NULL == iMembers )

        {

        User::Leave( KErrNotSupported );

        }

    // compute total installed (uncompressed) size for use in progress

    // meter (doesn't account for some derived things like scaled

    // icons and registry data)

    CZipFileMember* member = iMembers->NextL();

    for ( ; member ; member = iMembers->NextL() )

        {

        zipfileUncompressedSize += member->UncompressedSize();

        delete member;

        }

    if ( 0 == zipfileUncompressedSize )

        {

        User::Leave( KErrNotSupported );

        }

    *(iPropertyValues[EFileSize]) = zipfileUncompressedSize;

    // find the top-level directory under which to get metadata

    // TODO this isn't robust, check cases where there are multiple

    // top-level dirs and no top-level dirs.

    delete iMembers;

    iMembers = NULL;

    iMembers = iZipFile->GetMembersL();

    member = iMembers->NextL();

    TPtrC fName( *member->Name() );

    TInt pos = fName.Locate( KPathDelimiter );

    if ( (KErrNotFound == pos) || (KMaxFileName < pos) )

        {

        User::Leave( KErrNotSupported );

        }

    bundleRoot.Copy( fName.Left( pos ) );

    delete member;

    delete iMembers;

    iMembers = NULL;

    // metadata file: "WeatherBug.wdgt\Info.plist"

    if ( KMaxFileName

         < (bundleRoot.Length() + 1 /* slash */ + KInfoPlist().Length()) )

        {

        User::Leave( KErrCorrupt );

        }

    tempFile.Copy( bundleRoot );

    tempFile.Append( KPathDelimiter );

    tempFile.Append( KInfoPlist );

    CZipFileMember* infoFileMember =

        iZipFile->CaseInsensitiveMemberL( tempFile );

    if ( NULL == infoFileMember )

        {

        // missing metadata file

        User::Leave( KErrNotSupported );

        }

    CleanupStack::PushL( infoFileMember );

    // we will use descriptors to handle the Info.plist contents so

    // the file may not be larger than a descriptor can handle

    if ( KMaxDescLength < infoFileMember->UncompressedSize() )

        {

        User::Leave( KErrCorrupt );

        }

    // extract Info.plist from zip into a buffer

    RZipFileMemberReaderStream* stream;

    iZipFile->GetInputStreamL( infoFileMember, stream );

    CleanupStack::PushL( stream );

    HBufC8* buffer = HBufC8::NewLC( infoFileMember->UncompressedSize() );

    TPtr8 bufferPtr( buffer->Des() );

    User::LeaveIfError(

        stream->Read( bufferPtr, infoFileMember->UncompressedSize() ) );

    // METADATA PARSE

    iWidgetConfigHandler->ParseValidateBundleMetadataL(

        bufferPtr, iPropertyValues, iRfs );

    CleanupStack::PopAndDestroy( 3 ); // infoFileMember, stream, buffer

    // EXISTING WIDGET?

    if( iRegistry.WidgetExistsL( *(iPropertyValues[EBundleIdentifier]) ) )

        {

        // replacement for currently installed widget

        *(iPropertyValues[EUid]) = iRegistry.GetWidgetUidL(

            *(iPropertyValues[EBundleIdentifier]));

        found = ETrue;

        if ( iRegistry.IsWidgetRunning( 

                TUid::Uid( *(iPropertyValues[EUid]) )) )

            {

            iUIHandler->CloseProgressDialogL();

            User::Leave( KErrInUse );

            }

        // get original install dir from registry in case user

        // decides to "overrite" to another memory location

        iOriginalDir = *( iRegistry.GetWidgetPropertyValueL(

                              TUid::Uid( *(iPropertyValues[EUid]) ),

                              EBasePath ) );

        }

    // uid for a new widget will be gotten once install location (c: or

    // e:) is selected

    // see if main.html is in zip bundle

    const TDesC& main = *(iPropertyValues[EMainHTML]);

    if ( KMaxFileName

         < (bundleRoot.Length() + 1 /* slash */ + main.Length()) )

        {

        User::Leave( KErrCorrupt );

        }

    tempFile.Copy( bundleRoot );

    tempFile.Append( KPathDelimiter );

    tempFile.Append( main );

    CZipFileMember* mainFileMember

        = iZipFile->CaseInsensitiveMemberL( tempFile );

    if ( !mainFileMember )

        {

        // missing main html file

        User::Leave( KErrCorrupt );

        }

    delete mainFileMember;

    mainFileMember = NULL;

    // save MainHTML partial path to combine with base path when

    // install location is selected

    *(iPropertyValues[EMainHTML]) = tempFile;

    // see if there is an Icon.png in root and get partial path

    if ( KMaxFileName

         < (bundleRoot.Length() + 1 /* slash */ + KIconFile().Length()) )

        {

        User::Leave( KErrCorrupt );

        }

    tempFile.Copy( bundleRoot );

    tempFile.Append( KPathDelimiter );

    tempFile.Append( KIconFile );

    CZipFileMember* iconFileMember

        = iZipFile->CaseInsensitiveMemberL( tempFile );

    if ( iconFileMember )

        {

        // save this partial path to identify Icon.png during unzip

        *(iPropertyValues[EIconPath]) = tempFile;

        }

    else

        {

        iIconSearchFinished = ETrue;

        }

    // ex. infoLocFile pathname "WeatherBug.wdgt\en.lproj\InfoPlist.strings"

    TBuf<32> lproj;

    iRegistry.GetLprojName( lproj ); // e.g. "en", "fr", "zh_Hans" ...

    if ( KMaxFileName

         < (bundleRoot.Length() + 1 /* slash */ + lproj.Length()

            + KLprojExt().Length() + 1 /* slash */

            + KInfoPlistStrings().Length()) )

        {

        User::Leave( KErrCorrupt );

        }

    TFileName infoLocFile( bundleRoot );

    infoLocFile.Append( KPathDelimiter );

    infoLocFile.Append( lproj );

    infoLocFile.Append( KLprojExt );

    infoLocFile.Append( KPathDelimiter );

    infoLocFile.Append( KInfoPlistStrings );

    CZipFileMember* infoLocFileMember =

        iZipFile->CaseInsensitiveMemberL( infoLocFile );

    if ( infoLocFileMember )

        {

        CleanupStack::PushL( infoLocFileMember );

        RZipFileMemberReaderStream* stream;

        iZipFile->GetInputStreamL( infoLocFileMember, stream );

        CleanupStack::PushL( stream );

        // we will use descriptors to handle the l10n contents so

        // the file may not be larger than a descriptor can handle

        if ( KMaxDescLength < infoLocFileMember->UncompressedSize() )

            {