/*
* Copyright (c) 2009-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:  Application UI implementation.
*
*/


// INCLUDES
#include <EIKDOC.H>
#include <stringloader.h>
#include <AknQueryDialog.h>
#include <VoIPProvisioningApp.rsg>
#include <aknnotewrappers.h>
#include <apgcli.h> // RApaLsSession
#include <bautils.h>
#include <xspviewservices.h>
#include <BrowserUiSDKCRKeys.h>
#include <pathinfo.h>
#include <DriveInfo.h>
#include <zipfile.h>
#include <zipfilememberinputstream.h>
#include <aknwaitdialog.h>

#include "voipxmlparser.h"
#include "VoIPProvisioningAppUi.h"
#include "VoIPProvisioningApp.h"
#include "VoIPProvisioningDocument.h"

const TInt KOneSecond( 1000000 );
const TUid KMecoServiceTabUid = {0x20012423};
const TInt KFiveTimes( 5 );
_LIT( KDownloadFileName, "tempbranddatapackage.zip" );
_LIT( KBrandMifPath,     ":\\private\\102828DD\\import\\" );
_LIT( KBrandInstallPath, ":\\private\\102828DD\\import\\install\\" );
_LIT( KBrandXmlPath,     ":\\private\\102828E1\\import\\" );
_LIT( KXmlExtension,     ".xml" );
_LIT( KMifExtension,     ".mif" );
_LIT( KInstallExtension, ".install" );
_LIT8( KZipExtension,    ".zip" );

// ----------------------------------------------------------------------------
// CVoIPProvisioningAppUi::CVoIPProvisioningAppUi
// ----------------------------------------------------------------------------
//
CVoIPProvisioningAppUi::CVoIPProvisioningAppUi()
    {
    }

// ----------------------------------------------------------------------------
// CVoIPProvisioningAppUi::ConstructL
// ----------------------------------------------------------------------------

void CVoIPProvisioningAppUi::ConstructL()
    {
    // Call base classes ConstructL method.
    BaseConstructL( ENoScreenFurniture | EAknEnableMSK );

    StatusPane()->MakeVisible( EFalse );
    HideApplicationFromFSW( ETrue );

    iBrandPackageName.Copy( PathInfo::PhoneMemoryRootPath() );
    iBrandPackageName.Append( PathInfo::OthersPath() );
    iBrandPackageName.Append( KDownloadFileName );
    }

// ----------------------------------------------------------------------------
// CVoIPProvisioningAppUi::~CVoIPProvisioningAppUi
// ----------------------------------------------------------------------------
//
CVoIPProvisioningAppUi::~CVoIPProvisioningAppUi()
    {
    iDownloadMgr.Close();
    if ( iWaitDialog )
        {
        TRAP_IGNORE( iWaitDialog->ProcessFinishedL() );
        iWaitDialog = NULL;
        }
    }

// ----------------------------------------------------------------------------
// CVoIPProvisioningAppUi::ProcessCommandParametersL
// ----------------------------------------------------------------------------
//
TBool CVoIPProvisioningAppUi::ProcessCommandParametersL(
    TApaCommand /*aCommand*/, TFileName& /*aDocumentName*/,
    const TDesC8& /*aTail*/ )
    {
    // Always return ETrue to make CVoIPProvisioningDocument's
    // OpenFileL to be called.
    return ETrue;
    }

// ----------------------------------------------------------------------------
// CVoIPProvisioningAppUi::HandleFileL
// ----------------------------------------------------------------------------
//
void CVoIPProvisioningAppUi::HandleFileL( RFile& aFile )
    {
    RFile file;
    User::LeaveIfError( file.Duplicate( aFile ) );
    CVoipXmlParser* parser = CVoipXmlParser::NewLC(); // CS:1
    TBuf8<KMaxFileName> brandUrl( KNullDesC8 );
    HBufC* queryText = parser->ReadDescriptionLC( aFile, brandUrl ); // CS:2
    if ( !queryText->Des().Length() )
        {
        CleanupStack::PopAndDestroy( queryText );
        queryText = NULL;
        queryText = StringLoader::LoadLC( R_VOIP_DEFAULT_SAVE_QUERY );
        }
    CAknQueryDialog* query = CAknQueryDialog::NewL();
    CleanupStack::PushL( query ); // CS:3
    query->SetPromptL( queryText->Des() );
    TBool launchTab( EFalse );
    TUint32 serviceTabId;
    if ( query->ExecuteLD( R_VOIP_PROVISIONING_QUERY_INSTALL_SERVICE ) )
        {
        iWaitDialog = new( ELeave ) CAknWaitDialog( 
            REINTERPRET_CAST( CEikDialog**, &iWaitDialog ) );
        iWaitDialog->SetTone( CAknNoteDialog::ENoTone );
        iWaitDialog->ExecuteLD( R_WAITNOTE_CONFIGURE );

        FetchBrandingDataL( brandUrl );

        // Start phonebook into backgound.
        RxSPViewServices viewServices;
        CleanupClosePushL( viewServices ); // CS:4
        TInt viewSrvErr = viewServices.Open();
        if ( KErrServerTerminated == viewSrvErr || KErrNotFound == viewSrvErr )
            {
            viewServices.Close();
            viewSrvErr = viewServices.Open();
            }
        if ( KErrNone == viewSrvErr )
            {
            viewServices.Close();
            }

        // Ownership of file is trasferred.
        TInt error = parser->ImportDocument( file, serviceTabId );
        if ( KErrNone == error )
            {
            iWaitDialog->ProcessFinishedL();
            iWaitDialog = NULL;
            ShowDoneNoteL();
            launchTab = ETrue;
            }
        else
            {
            iWaitDialog->ProcessFinishedL();
            iWaitDialog = NULL;
            ShowFailNoteL();
            }
        CleanupStack::PopAndDestroy( &viewServices ); // CS:3
        }
    CleanupStack::Pop( query ); // CS:2
    // queryText, parser
    CleanupStack::PopAndDestroy( 2, parser ); // CS:0

    // Launch service tab.
    if ( launchTab )
        {
        TInt err = KErrNotFound;
        TInt counter( 0 );
        RxSPViewServices viewServices;
        CleanupClosePushL( viewServices ); // CS:1
        while ( KErrNone != err && KFiveTimes > counter )
            {
            err = viewServices.Activate( 
                KMecoServiceTabUid.iUid, (TInt32)serviceTabId );
            if ( KErrServerTerminated == err || KErrNotFound == err )
                {
                err = viewServices.Activate( 
                    KMecoServiceTabUid.iUid, (TInt32)serviceTabId );
                }
            // Wait...
            User::After( KOneSecond );
            counter++;
            }

        CleanupStack::PopAndDestroy( &viewServices ); // CS:0
        TApaTaskList taskList( CEikonEnv::Static()->WsSession() );
        TApaTask browserTask = taskList.FindApp( KCRUidBrowser );
        if ( browserTask.Exists() )
            {
            browserTask.EndTask();
            }
        }

    if ( iWaitDialog )
        {
        iWaitDialog->ProcessFinishedL();
        iWaitDialog = NULL;
        }

    iDownloadMgr.Close();
#ifndef __EUNIT_TESTING
    User::Exit( KErrNone );
#endif
    }

// ----------------------------------------------------------------------------
// CVoIPProvisioningAppUi::ShowFailNoteL
// ----------------------------------------------------------------------------
//
void CVoIPProvisioningAppUi::ShowFailNoteL() const
    {
    HBufC* text = StringLoader::LoadLC( R_VOIP_INVALID_DATA );
    CAknErrorNote* note = new (ELeave) CAknErrorNote( R_AKN_ERROR_NOTE );
    note->ExecuteLD( *text );
    CleanupStack::PopAndDestroy( text );
    }

// ----------------------------------------------------------------------------
// CVoIPProvisioningAppUi::ShowDoneNoteL
// ----------------------------------------------------------------------------
//
void CVoIPProvisioningAppUi::ShowDoneNoteL() const
    {
    HBufC* text = StringLoader::LoadLC( R_VOIP_INSTALLED );
    CAknInformationNote* note =
        new (ELeave) CAknInformationNote( R_AKN_INFORMATION_NOTE );
    note->ExecuteLD( *text );
    CleanupStack::PopAndDestroy( text );
    }

// ---------------------------------------------------------------------------
// From base class MHttpDownloadMgrObserver.
// Handles download manager events.
// ---------------------------------------------------------------------------
//
void CVoIPProvisioningAppUi::HandleDMgrEventL( RHttpDownload& aDownload,
    THttpDownloadEvent aEvent )
    {
    if ( EHttpDlPaused == aEvent.iDownloadState && 
        EHttpContentTypeReceived == aEvent.iProgressState )
        {
        TInt32 length;
        TInt err = aDownload.GetIntAttribute( EDlAttrLength, length );
        if ( KDefaultContentLength != length && 0 < length )
            {
            // Continue.
            aDownload.Start();
            }
        else
            {
            CActiveScheduler::Stop();
            aDownload.Delete();
            }
        }
    else if ( EHttpDlCompleted == aEvent.iDownloadState )
        {
        CActiveScheduler::Stop();
        // We don't need the leave code; un-branded service is OK.
        TRAP_IGNORE( UncompressFilesL() );
        aDownload.Delete();
        }
    else if ( EHttpDlFailed == aEvent.iDownloadState )
        {
        CActiveScheduler::Stop();
        aDownload.Delete();
        }
    else if ( EHttpDlInprogress == aEvent.iDownloadState && 
        EHttpProgDisconnected == aEvent.iProgressState )
        {
        CActiveScheduler::Stop();
        aDownload.Delete();
        }
    }

// ---------------------------------------------------------------------------
// Starts branding data download.
// ---------------------------------------------------------------------------
//
TInt CVoIPProvisioningAppUi::FetchBrandingDataL( const TDesC8& aUrl )
    {
    if ( !aUrl.Length() || KErrNotFound == aUrl.Find( KZipExtension ) )
        {
        return KErrNotFound;
        }
    iDownloadMgr.ConnectL( KUidVoIPProvisioningAppUid, *this, EFalse );
    RHttpDownload& download = iDownloadMgr.CreateDownloadL( aUrl );
    download.SetStringAttribute( EDlAttrDestFilename, iBrandPackageName );
    TInt err = download.Start();
    CActiveScheduler::Start();
    return err;
    }

// ---------------------------------------------------------------------------
// Uncompresses files from a zip file.
// ---------------------------------------------------------------------------
//
void CVoIPProvisioningAppUi::UncompressFilesL()
    {
    RFs fs;
    User::LeaveIfError( fs.Connect() );
    CleanupClosePushL( fs ); // CS:1
    CZipFile* zipfile = CZipFile::NewL( fs, iBrandPackageName );
    CleanupStack::PushL( zipfile ); // CS:2
    CZipFileMemberIterator* iterator = zipfile->GetMembersL();
    CleanupStack::PushL( iterator ); // CS:3
    CZipFileMember* fileMember = iterator->NextL();
    TChar drive;
    DriveInfo::GetDefaultDrive( DriveInfo::EDefaultPhoneMemory, drive );

    RFile output;
    CleanupClosePushL( output ); // CS:4

    while ( fileMember )
        {
        TFileName memberFileName = *fileMember->Name();
        TFileName outputPath;
        outputPath.Append( drive );
        if ( KErrNotFound != memberFileName.Find( KXmlExtension ) )
            {
            outputPath.Append( KBrandXmlPath );
            outputPath.Append( memberFileName );
            }
        else if ( KErrNotFound != memberFileName.Find( KInstallExtension ))
            {
            outputPath.Append( KBrandInstallPath );
            outputPath.Append( memberFileName );
            }
        else if ( KErrNotFound != memberFileName.Find( KMifExtension ))
            {
            outputPath.Append( KBrandMifPath );
            outputPath.Append( memberFileName );
            }
        else
            {
            // Ignore this file and get next file from zip.
            fileMember = iterator->NextL();
            break;
            }

        TInt err = fs.MkDirAll( outputPath );
        err = output.Replace( fs, outputPath, EFileShareAny|EFileWrite );

        TUint32 size = fileMember->UncompressedSize();
        RBuf8 outputData;
        outputData.CreateL( size );
        CleanupClosePushL( outputData ); // CS:5
        RZipFileMemberReaderStream* stream;
        zipfile->GetInputStreamL( fileMember, stream );
        CleanupStack::PushL( stream ); // CS:6

        err = stream->Read( outputData, size );
        err = output.Write( outputData );

        output.Flush();

        // stream, &outputData
        CleanupStack::PopAndDestroy( 2, &outputData ); // CS:4

        fileMember = iterator->NextL();
        }
    // &output, iterator, zipfile, &fs
    CleanupStack::PopAndDestroy( 3, zipfile ); // CS:1

    // Finally, delete temp zip file.
    fs.Delete( iBrandPackageName );    
    CleanupStack::PopAndDestroy( &fs ); // CS:0
    }

// End of file.