svgtviewer/SvgtViewerPlugin/AppSrc/SVGTViewerAppAppUi.cpp
author Dremov Kirill (Nokia-D-MSW/Tampere) <kirill.dremov@nokia.com>
Tue, 25 May 2010 12:28:38 +0300
branchRCL_3
changeset 14 1882882c7f9c
parent 0 632761c941a7
permissions -rw-r--r--
Revision: 201019 Kit: 2010121

/*
* Copyright (c) 2004,2005 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:  AppUI for SVGT Viewer App.
*
*/


#include <eikapp.h>
#include <avkon.hrh>
#include <aknnotewrappers.h>
#include <w32std.h>                                        // RWsSession 
#include <e32std.h> 
#include <ctsydomainpskeys.h>                              // For call handling
#include <e32property.h>
#include <StringLoader.h>
#include <coeutils.h>
#include <svgtviewerapp.rsg>
#include <SVGTAppObserverUtil.h>
#include "SVGTViewerAppDbgFlags.hrh"
#include "SVGTViewerAppAppUi.h"
#include "SVGTViewerAppDocument.h"
#include "SVGTViewerApp.pan"
#include "SVGTUIDialog.h"
#include "SVGTViewerApp.hrh"


#include "SvgtViewerAppView.h"

#ifdef RD_MULTIPLE_DRIVE    
#include <pathinfo.h>
#include <driveinfo.h>
#endif
// Constants

#ifdef SVGTVIEWERAPP_DBG_OPEN_HARDCODE_FILE
_LIT(KDummyTstFileName, "c:\\data\\images\\01-guide.svg");
#endif

// Constant for periodic timer
const TInt KOneMicroSec = 1;

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

// -----------------------------------------------------------------------------
// CSVGTViewerAppAppUi::CSVGTViewerAppAppUi
// Default Constructor for CSVGTViewerAppAppUi.
// -----------------------------------------------------------------------------
//
CSVGTViewerAppAppUi::CSVGTViewerAppAppUi()             
    {
    // No implementation required
    }

// -----------------------------------------------------------------------------
// CSVGTViewerAppAppUi::ConstructL
// Second Phase constructor for CSVGTViewerAppAppUi.
// -----------------------------------------------------------------------------
//
void CSVGTViewerAppAppUi::ConstructL()
    {
    BaseConstructL( EAknEnableSkin|EAknEnableMSK );    // Enable skin support and MSK label 
    												  // for this Application    												
                                   
    ResetEmbeddedAppRunning(); //By default, there are no embedded app started.    

    iContainer = new (ELeave) CSvgtViewerAppView;
    iContainer->ConstructL(ClientRect());
	// add container to stack; enables key event handling.
	AddToStackL(iContainer);
    
#ifndef SVGTVIEWERAPP_DBG_OPEN_HARDCODE_FILE    
    // Launch file only in non-hardcoded option.
    // Start an idle timer to start the dialog synchronously.
    iIdleTimer = CPeriodic::NewL(CActive::EPriorityIdle);
    // Using the periodic timer so that active object for
    // open file service gets a chance to execute
    iIdleTimer->Start(KOneMicroSec, KOneMicroSec, 
        TCallBack(CallBackFuncL,this));
#endif    
    }
    
// -----------------------------------------------------------------------------
// Destructor
// -----------------------------------------------------------------------------
CSVGTViewerAppAppUi::~CSVGTViewerAppAppUi()
    {
    iAppDialog = NULL; 
    iAppObserver = NULL;      
    if ( iIdleTimer )
        {
        delete iIdleTimer;
        iIdleTimer = NULL;
        }

	RemoveFromStack(iContainer);
    delete iContainer;
    }

// -----------------------------------------------------------------------------
// CSVGTViewerAppAppUi::HandleCommandL
// Reimplements CAknAppUi::HandleCommandL inorder to handle commands.
// -----------------------------------------------------------------------------
//
void CSVGTViewerAppAppUi::HandleCommandL( TInt aCommand )
    {
#ifdef SVGTVIEWERAPP_DBG_OPEN_HARDCODE_FILE        
    TFileName fileName;     
#endif    
    switch ( aCommand )
        {
        case EEikCmdExit:
        case EAknSoftkeyExit:
            Exit();
            break;
        case ESVGTViewerAppCommand1:
#ifdef _DEBUG
            iEikonEnv->InfoMsg( _L( "not implemented" ) );
#endif
#ifdef SVGTVIEWERAPP_DBG_OPEN_HARDCODE_FILE            
            fileName.Append( KDummyTstFileName );
            OpenFileL( fileName );
#endif        
            break;

        default:           
            break;
        }
    }





// -----------------------------------------------------------------------------
// CSVGTViewerAppAppUi::OpenFileL
// Reimplements CAknAppUi::OpenFileL inorder to provide for opening SVG 
// content through doc handler.
// -----------------------------------------------------------------------------
//
void CSVGTViewerAppAppUi::OpenFileL( 
    RFile& aFileHandle ) // File Handle to 
                         // SVGT content
    {
    // Display an info note if a video call is in progress.
    // SVG content cannot be displayed in this case.    
    if ( IsVideoCall() )
        {
        HBufC* text = StringLoader::LoadLC( 
                R_SVGT_VIEWER_INFO_VIDEO_CALL_ONGOING );
        CAknInformationNote* dlg = new (ELeave) CAknInformationNote( ETrue );
        dlg->ExecuteLD( text->Des() );
        CleanupStack::PopAndDestroy( text );  // text
        Exit();
        }
    
    TRAPD( err, iAppDialog = CSVGTUIDialog::NewL() );
    
    if ( err != KErrNone )
        {
        // Reset the pointer to dialog
        iAppDialog = NULL;
        iEikonEnv->HandleError( err );
        Exit();
        }

    // Get the File's fullpath, Handle and pass it to App Observer Util. 
    TFileName filename;
    CSVGTViewerAppDocument *appDocument = 
            static_cast< CSVGTViewerAppDocument* >(iDocument);

    if ( appDocument->IsFileFullPathAvailable() )
        {
        appDocument->GetFileFullPath(filename);
        }

    TRAP( err, iAppObserver = CSVGTAppObserverUtil::NewL( iAppDialog,
                                     &aFileHandle, 
                                     filename,
                                     appDocument->IsFileFullPathAvailable(),
                                     CanShowSave(),
                                     ShouldMoveContent()) );
    if ( err != KErrNone )
        {
        // Delete the dialog
        delete iAppDialog;
        // Reset the dialog pointer
        iAppDialog = NULL;
        // Reset the App Observer Pointer
        iAppObserver = NULL;
        iEikonEnv->HandleError( err );
        Exit();
        }
    
    if( iAppDialog )
        {
        TRAP( err, iAppDialog->ExecuteLD( aFileHandle, iAppObserver ) );
        if ( err != KErrNone )
            {
            if( err == KLeaveExit )
                {
            	delete iAppDialog;
            	delete iAppObserver;
            	
            	iAppObserver = NULL;
            	iAppDialog   = NULL;
            	
            	Exit();
                }
            // Reset the dialog pointer
            iAppDialog = NULL;
            // Delete the app observer 
            delete iAppObserver;
            iEikonEnv->HandleError( err );
            Exit();
            }
        }
    // Delete the app observer
    delete iAppObserver;
    
    // Reset the App Observer Pointer
    iAppObserver = NULL;
    
    // Dialog has destroyed itself, Reset the pointer
    iAppDialog = NULL;
    
    Exit();
    }

// -----------------------------------------------------------------------------
// CSVGTViewerAppAppUi::OpenFileL
// Reimplements CAknAppUi::OpenFileL inorder to provide for opening SVG 
// content through doc handler.
// -----------------------------------------------------------------------------
//
void CSVGTViewerAppAppUi::OpenFileL( 
    const TDesC& aFileName) // File Name of SVGT content
    {
    // Display an info note if a video call is in progress.
    // SVG content cannot be displayed in this case.
    if ( IsVideoCall() )
        {
        HBufC* text = StringLoader::LoadLC( 
                R_SVGT_VIEWER_INFO_VIDEO_CALL_ONGOING );
        CAknInformationNote* dlg = new (ELeave) CAknInformationNote( ETrue );
        dlg->ExecuteLD( text->Des() );
        CleanupStack::PopAndDestroy( text );  // text
        Exit();
        }
    
    // Open File Handle for the file

    RFile fileHandle;
    TInt err = fileHandle.Open( iEikonEnv->FsSession(), 
                                aFileName, EFileShareAny );
    if ( err != KErrNone )
        {       
        iEikonEnv->HandleError( err );
        Exit();
        }


    TRAP( err, iAppDialog = CSVGTUIDialog::NewL() );
    if ( err != KErrNone )
        {
        // Reset the Dialog pointer
        iAppDialog = NULL;
        // Close the file handle
        fileHandle.Close();

        iEikonEnv->HandleError( err );
        Exit();
        }
    
    TRAP( err, 
        iAppObserver = CSVGTAppObserverUtil::NewL( iAppDialog, 
                                     &fileHandle, 
                                     aFileName,
                                     ETrue,
                                     CanShowSave(),
                                     ShouldMoveContent() ) );
    if ( err != KErrNone )
        {
        // Reset the AppObserver Pointer
        iAppObserver = NULL;
        // Reset the Dialog pointer
        iAppDialog = NULL;
        // Close the file handle
        fileHandle.Close();
        
        iEikonEnv->HandleError( err );
        Exit();
        }
        
    if( iAppDialog )
        {
        TRAP( err, iAppDialog->ExecuteLD( fileHandle, iAppObserver ) );

        if ( err != KErrNone )
            {
            if( err == KLeaveExit )
                {
                delete iAppDialog;
                delete iAppObserver;
            	
                iAppObserver = NULL;
                iAppDialog   = NULL;
            	
                Exit();
                }
            // Delete the AppObserver Pointer
            delete iAppObserver;
            // Reset the AppObserver Pointer
            iAppObserver = NULL;
            // Reset the Dialog pointer
            iAppDialog = NULL;
            // Close the file handle
            fileHandle.Close();
        
            iEikonEnv->HandleError( err );
            Exit();
            }
        }
    
    // Delete the App Observer
    delete iAppObserver;
   
    // Reset the App Observer pointer
    iAppObserver = NULL;

    // Dialog has destroyed itself, Reset the pointer
    iAppDialog = NULL;
    
    // Close the file handle and session
    fileHandle.Close();
    
    Exit();
    }

// -----------------------------------------------------------------------------
// CSVGTViewerAppAppUi::SetAllowMove
// -----------------------------------------------------------------------------
//
void CSVGTViewerAppAppUi::SetAllowMove(TInt32 aMoveAllowed)
    {
    iMoveAllowed = aMoveAllowed;
    }

// -----------------------------------------------------------------------------
// CSVGTViewerAppAppUi::ProcessCommandParametersL
// -----------------------------------------------------------------------------
//
TBool CSVGTViewerAppAppUi::ProcessCommandParametersL(
    TApaCommand /* aCommand */ ,
    TFileName& aDocumentName, 
    const TDesC8& /* aTail */ )
    {
    return ConeUtils::FileExists(aDocumentName);
    }    

// -----------------------------------------------------------------------------
// CSVGTViewerAppAppUi::HandleScreenDeviceChangedL
// Handle the screen size being changed
// -----------------------------------------------------------------------------
//
void CSVGTViewerAppAppUi::HandleScreenDeviceChangedL()
    {
    CAknAppUiBase::HandleScreenDeviceChangedL();  
    }
// -----------------------------------------------------------------------------
// CSVGTViewerAppAppUi::HandleResourceChangeL
// Handle the screen size being changed
// -----------------------------------------------------------------------------
//
void CSVGTViewerAppAppUi::HandleResourceChangeL( TInt aType )
    {
    CAknAppUi::HandleResourceChangeL( aType );
    }
// -----------------------------------------------------------------------------
// CSVGTViewerAppAppUi::HandleForegroundEventL
// App Framework calls this api to give background/foreground events to the
// application. Param: aForeground : ETrue: Foreground. EFalse: Background.
// -----------------------------------------------------------------------------
//

void CSVGTViewerAppAppUi::HandleForegroundEventL( TBool aForeground )
    {   
    // Pass the application foreground or goes to background,
    // give the events to the underlying dialog and the custom
    // control so that the animation is paused when app goes
    // to background and so on. But the app might have
    // opened another application embedded (Browser or another
    // viewer). So need to qualify these events with these
    // conditions. Whenever opening/closing another app 
    // embedded, need to pass background/foreground events to
    // dialog, and call Set/ResetEmbeddedAppRunning.

    // Passing the event to the base class
    CAknAppUi::HandleForegroundEventL( aForeground );
    
    if ( !IsEmbeddedAppRunning() )
        {
        if ( iAppDialog )
            {
            iAppDialog->HandleApplicationForegroundEvent(
                            aForeground );
            }

        }
    }

// -----------------------------------------------------------------------------
// CSVGTViewerAppAppUi::IsVideoCall()
// Used to find out if the videocall is going on. The
// viewer is not allowed to open if viedo call is 
// going on.
// -----------------------------------------------------------------------------
//
TBool CSVGTViewerAppAppUi::IsVideoCall() const
    {
    TBool lVideoCallConnected = EFalse;
    TInt lType = 0;  
    TInt error = RProperty::Get( KPSUidCtsyCallInformation, 
                                 KCTsyCallType, lType );
    
    // EPSTelephonyCallTypeH324Multimedia is used for 3G video calls
    if ( !error && lType == EPSCTsyCallTypeH324Multimedia )
        {
        // Call is of video call, check whether call is connected
        TInt lState = 0;         
        error = RProperty::Get( KPSUidCtsyCallInformation, 
                                KCTsyCallState, lState );
        if ( !error &&
         ( lState != EPSCTsyCallStateUninitialized &&
           lState != EPSCTsyCallStateNone &&
           lState != EPSCTsyCallStateDisconnecting ) )
            {
            lVideoCallConnected = ETrue;    
            }
        }
    return lVideoCallConnected;
    }

// -----------------------------------------------------------------------------
// CSVGTViewerAppAppUi::IsEmbeddedAppRunning()
// Used to find out if viewer application has in turn 
// started an embedded application.
// -----------------------------------------------------------------------------
//
TBool CSVGTViewerAppAppUi::IsEmbeddedAppRunning() const
    {
    return iEmbeddedAppRunning;
    }

// -----------------------------------------------------------------------------
// CSVGTViewerAppAppUi::SetEmbeddedAppRunning()
// Used to set state in Viewer application if it has in turn 
// started an embedded application.
// -----------------------------------------------------------------------------
//
void CSVGTViewerAppAppUi::SetEmbeddedAppRunning()
    {
    iEmbeddedAppRunning = ETrue;
    }

// -----------------------------------------------------------------------------
// CSVGTViewerAppAppUi::ResetEmbeddedAppRunning()
// Used to set state in viewer application if embedded
// application started by it is closed now.
// -----------------------------------------------------------------------------
//
void CSVGTViewerAppAppUi::ResetEmbeddedAppRunning()
    {
    iEmbeddedAppRunning = EFalse;
    }

// -----------------------------------------------------------------------------
// CSVGTViewerAppAppUi::CallBackFuncL()
// Used to callback by the idle timer in order to launch 
// the dialog
// -----------------------------------------------------------------------------
//
TInt CSVGTViewerAppAppUi::CallBackFuncL(TAny *aPtr)
    {
    CSVGTViewerAppAppUi* appUi = 
        static_cast< CSVGTViewerAppAppUi* >( aPtr );
    if ( appUi )    
        {
        return ( appUi->LaunchDialogL() );    
        }
        else
            {
            // To indicate that the timer is not
            // called again, return false to the timer
            // RunL
            return ( EFalse );
            }
    }
    
// -----------------------------------------------------------------------------
// CSVGTViewerAppAppUi::LaunchDialogL()
// This function accesses the document and launches the 
// content.
// -----------------------------------------------------------------------------
//
TBool CSVGTViewerAppAppUi::LaunchDialogL()
    {
    // Check if file-handle in document is valid
    if ( static_cast< CSVGTViewerAppDocument* >
        (iDocument)->IsFileHandleValid() )
        {
        // Obtain the file-handle
        RFile& fileHandle = 
        (static_cast< CSVGTViewerAppDocument* >
        (iDocument)->GetSvgtContentFileHandle());
        
        // Cancel the periodic timer
        if ( iIdleTimer->IsActive() )
            {
            iIdleTimer->Cancel();
            }
            
        // Launch the content
        OpenFileL( fileHandle );
 
        // Delete and reset the idle-timer
        delete iIdleTimer;
        iIdleTimer = NULL;  
 
        // Return False to indicate that 
        // timer need not callback further.
        return EFalse; 
        
        }
        else
            {
            // Return True to indicate that the 
            // timer needs to callback this function 
            // again, as the file-handle is not valid 
            // yet.
            return ETrue;           
            }
    }

// -----------------------------------------------------------------------------
// CSVGTViewerAppAppUi::WeAreEmbedded
// -----------------------------------------------------------------------------
//
TBool CSVGTViewerAppAppUi::WeAreEmbedded() const
{
   // SVGT-Viewer will be opened in embedded mode always
   return ETrue;       
}

// -----------------------------------------------------------------------------
// CSVGTViewerAppAppUi::CanShowSave
// -----------------------------------------------------------------------------
//
TBool CSVGTViewerAppAppUi::CanShowSave() const 
    {
    // By default dont show the save option
    TBool ret = EFalse;
    
    // Check if we are launched embedded
    if (WeAreEmbedded())
        {
        // If the file is not a local file then 
        // display the save option
        if ( !IsLocalFile() )
            {
            ret = ETrue;
            }
        }
    return ret;
    }

// -----------------------------------------------------------------------------
// CSVGTViewerAppAppUi::ShouldMoveContent
// -----------------------------------------------------------------------------
//
TBool CSVGTViewerAppAppUi::ShouldMoveContent() const
    {
    return iMoveAllowed;
    }

// -----------------------------------------------------------------------------
// CSVGTViewerAppAppUi::IsLocalFile
//  This function returns ETrue if file is local, EFalse otherwise
// -----------------------------------------------------------------------------
//
TBool CSVGTViewerAppAppUi::IsLocalFile() const 
    {
    // By default file is not local
    TBool isLocal = EFalse;
   
    // Obtain the file-handle
    RFile& fileHandle = (static_cast<CSVGTViewerAppDocument*>
                        (iDocument)->GetSvgtContentFileHandle());
    // Check whether local/remote  
    TRAP_IGNORE( isLocal = IsLocalFileL( fileHandle ) );
    
    return isLocal;
    }

// -----------------------------------------------------------------------------
// CSVGTViewerAppAppUi::IsLocalFileL
//  This function checks whether the filepath of the content opened is 
//  in the PHONE_MEMORY_IMAGES_PATH or MEMORYCARD_IMAGES_PATH
// -----------------------------------------------------------------------------
//
TBool CSVGTViewerAppAppUi::IsLocalFileL( RFile& aFileHandle ) const 
    {
    // By default file is not local
    TBool retVal = EFalse;

#ifdef RD_MULTIPLE_DRIVE    

    HBufC* fileNameBuf = HBufC::NewLC( KMaxFileName );
    TPtr fileNamePtr = fileNameBuf->Des();
    aFileHandle.FullName( fileNamePtr );

    RFs fsSession = iEikonEnv->FsSession();
    TName driveRootPath;
     
    TInt intDrive;
    DriveInfo::TDriveArray driveArray;
    User::LeaveIfError( DriveInfo::GetUserVisibleDrives( fsSession, driveArray ) );
    for(TInt i=0; i < driveArray.Count(); i++)
        {
        TChar driveLetter = driveArray.LetterAt(i);
        User::LeaveIfError( RFs::CharToDrive(driveLetter, intDrive) );
        User::LeaveIfError( PathInfo::GetRootPath(driveRootPath, intDrive) );

        // Check whether filepath consists of phone mem path or mmc path
        if ( driveRootPath.FindF( fileNamePtr.Left(driveRootPath.Length() ) ) != KErrNotFound )
            {
            // Path Found means file is local
            retVal = ETrue;
            break;
            }
        }

    CleanupStack::PopAndDestroy( fileNameBuf );    
#else
    // Get the phone memory path
    HBufC* phoneMemImgPath = iEikonEnv->AllocReadResourceLC( 
            R_SVGT_VIEWER_PHONE_MEMORY_IMAGES_PATH );

    // Get the Memory Card path
    HBufC* memCardImgPath = iEikonEnv->AllocReadResourceLC(
            R_SVGT_VIEWER_MEMORYCARD_IMAGES_PATH );
    
    // Get the content filename
    HBufC* fileNameBuf = HBufC::NewLC( KMaxFileName );
    TPtr fileNamePtr = fileNameBuf->Des();
    aFileHandle.FullName( fileNamePtr );

    // Check whether filepath consists of phone mem path or mmc path
    if ( phoneMemImgPath->FindF( fileNamePtr.Left( 
            phoneMemImgPath->Length() ) ) != KErrNotFound
         || memCardImgPath->FindF( fileNamePtr.Left( 
            memCardImgPath->Length() ) ) != KErrNotFound )
        {
        // Path Found means file is local
        retVal = ETrue;
        }

    // Perform Cleanup         
    CleanupStack::PopAndDestroy( fileNameBuf );
    CleanupStack::PopAndDestroy( memCardImgPath );
    CleanupStack::PopAndDestroy( phoneMemImgPath );
#endif    

    return retVal;
    }
//End of File