/*

* Copyright (c) 2007-2008 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:  Post-capture view class for Camera application*

*/

// INCLUDE FILES

#include <sendnorm.rsg>

#include <sendui.h>

#include <SenduiMtmUids.h>

#ifndef __WINS__

//  #include <SFIUtilsAppInterface.h>

#endif

#include <eikbtgpc.h>

#include <avkon.rsg>

#include <cameraapp.rsg>

#include <vgacamsettings.rsg>

#include <aknradiobuttonsettingpage.h>

#include <akntextsettingpage.h>

#include <akntitle.h>  // CAknTitlePane

#include <CMessageData.h>

#include "MCamAddToAlbumObserver.h"

#include "CamCollectionManagerAo.h"

#include <glxmetadataviewutility.h>

#include <glxcollectionselectionpopup.h>

#include <akntoolbar.h>

#include <aknbutton.h>

#include <StringLoader.h>

#include "Cam.hrh"

#include "CamUtility.h"

#include "CamPostCaptureViewBase.h"

#include "CamAppController.h"

#include "CamAppUi.h"

#include "CamLogger.h"

#include "camactivepalettehandler.h"

#include "CamPostCaptureContainer.h"

#include "camoneclickuploadutility.h"

#include "CameraUiConfigManager.h"

//CONSTANTS

const TInt KCamSendUiBodySize = 0;

const TInt KCamSendUiMessageSize = 0;

const TUint KCamSendAsArrayGranularity = 1;

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

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

// CCamPostCaptureViewBase::~CCamPostCaptureViewBase

// Destructor

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

//

CCamPostCaptureViewBase::~CCamPostCaptureViewBase()

  {

  PRINT( _L("Camera => ~CCamPostCaptureViewBase") );

  delete iSendAppUi;    

  delete iSendMtmsToDim;

  if ( iAiwServiceHandler )

    {

    // unload service provider if any

    iAiwServiceHandler->Reset();

    delete iAiwServiceHandler;

    }

#ifndef __WINS__    

  iSFIUtils = NULL;       // Not owned

#endif // __WINS__

  if ( iCollectionManagerCallBack )

      {

      delete iCollectionManagerCallBack;

      iCollectionManagerCallBack = NULL;

      }

  delete iOneClickUploadUtility;

  PRINT( _L("Camera <= ~CCamPostCaptureViewBase") );

  }

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

// CCamPostCaptureViewBase::HandleCommandL

// Handle commands

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

//

void CCamPostCaptureViewBase::HandleCommandL( TInt aCommand )

    {

    PRINT1( _L("Camera => CCamPostCaptureViewBase::HandleCommandL (%d)"), aCommand )

    CCamAppUi* appUi = static_cast<CCamAppUi*>( AppUi() );

    switch ( aCommand )

        {

        case ECamCmdOneClickUpload:

            {

            iOneClickUploadUtility->UploadL(

                    iController.CurrentFullFileName() );

            break;

            }

        case ECamCmdToggleActiveToolbar:

            {

       		// If in the Landscape mode, MSK event is mapped 

      	  	// like a normal selection key so that AP items

       	  	// are selected and respective setting pages are launched´

       	  	// refer to @ProcessCommandL, since we get here only from there

       	    TKeyEvent aKeyEvent;

    		aKeyEvent.iCode =  aKeyEvent.iRepeats = aKeyEvent.iModifiers = 0;

   			aKeyEvent.iScanCode = EStdKeyDevice3;

   			static_cast<CCamContainerBase*>

       				( Container() )->OfferKeyEventL( aKeyEvent, EEventKey );	

            break;

            }

        case EAknSoftkeyBack:

            {

            iController.DeepSleepTimerCancel();

            appUi->HandleCommandL( aCommand );

            }

            break;

        case ECamCmdSend:

        case ECamCmdSendToCallerMultimedia:    

        case ECamCmdQuickSend:

            {

/*            TBool inCall = EFalse;

#if !defined(__WINS__) && !defined(__WINSCW__)

            inCall = iSFIUtils->IsCLIValidL();

#endif	            */

            //use both inCall and InCallOrRinging() conditions to make sure if it is in call state

            if ( /*inCall &&*/ iController.InCallOrRinging() )

                {

#ifndef __WINS__

                DoInCallSendL();

#endif

                }

            else

                {

                DoSendAsL();                    	

                }    

            }

            break;

        case ECamCmdExitStandby:

        	{

        	// leave standby mode

        	ExitStandbyModeL();

        	}

        	break;

        case ECamCmdToggleCourtesyUI:

            {

            /*

            * EFalse --> We just hide the AP tool bar

            * ETrue  --> We show the AP tool bar

            * In this case, we dont toggle the UI between Show/Hide icons so

            * we send EFalse as a parameter to SetAlwaysDrawPostCaptureCourtesyUI method

            */

            if ( appUi )

                {

                appUi->SetAlwaysDrawPostCaptureCourtesyUI( EFalse );

                }

            break;

            }

		case ECamCmdProperties:

            {

            // Passing the name of the current file

            // Asking the MetadataViewUtility to lauch an view for us

            CEikStatusPane* sp = StatusPane();

            CAknTitlePane* title = 

                static_cast<CAknTitlePane*>( sp->ControlL( 

                        TUid::Uid( EEikStatusPaneUidTitle ) ) );

            title->SetTextL( KNullDesC );

            sp->MakeVisible( ETrue );

            title->MakeVisible( ETrue );

            iContainer->SetRect( AppUi()->ClientRect() );

            GlxMetadataViewUtility::ActivateViewL( iController.CurrentFullFileName() );

            static_cast<CCamContainerBase*>(iContainer)->CheckForFileName( ETrue );

            title->MakeVisible( EFalse );

            sp->MakeVisible( EFalse );

            iContainer->SetRect( AppUi()->ApplicationRect() );                

			break;

            }

        // Add Photo/Video to the album

        case ECamCmdAddToAlbum:

            {

                /*

                * Status = 0 ( User confirms add to album operation )

                * Status = 1 ( User cancels add to album operation )

                */

                /*TInt status = ShowAddToAlbumConfirmationQueryL();

                if ( status == 0 )

                    {

                    StartAddToAlbumOperationL();

                    }

                else

                    { // Lint warnings

                    }*/

            StartAddToAlbumOperationL();

            }

            break;

        default:

            {

            CCamViewBase::HandleCommandL( aCommand );

            }

        }

    PRINT1( _L("Camera <= CCamPostCaptureViewBase::HandleCommandL (%d)"), aCommand )

    }

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

// CCamPostCaptureViewBase::HandleControllerEventL

// Handle user menu selections

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

//

void 

CCamPostCaptureViewBase::HandleControllerEventL( TCamControllerEvent aEvent, 

                                                 TInt               /*aError*/ )

  {

  PRINT( _L("Camera => CCamPostCaptureViewBase::HandleControllerEventL") );

  switch( aEvent )

    {

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

    case ECamEventCallStateChanged:

      {

      PRINT( _L("Camera <> case ECamEventCallStateChanged") );

      CCamAppUiBase* appUi = static_cast<CCamAppUiBase*>( AppUi() );      

      // Reset the Send and Send to caller items in the active toolbar  

      if ( !iEmbedded )

        {

		CCamActivePaletteHandler* apHandler = appUi->APHandler();    

		// Hide Send or Send to caller

        ResetSendAvailabilityL( apHandler );

		if ( iController.IsTouchScreenSupported() )

			{

			UpdateToolbarIconsL();

			}

		else

			{

			UpdateActivePaletteItemsL();

			}

        }

      break;

      }

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

    case ECamEventSaveComplete:

    case ECamEventSnapshotReady:

      {

      if ( ECamEventSaveComplete == aEvent &&

           iWaitForImageSave &&

           !iController.IsTouchScreenSupported() )

        {

        UpdateActivePaletteItemsL();

        }

      static_cast<CCamContainerBase*>(iContainer)->CheckForFileName( EFalse );

      // Check that the file that has just completed is the one just taken

      if ( iController.SavedCurrentImage()

        && iController.IsAppUiAvailable()            

         )//&& iWaitForImageSave )

        {

        CCamAppUi* appUi = static_cast<CCamAppUi*>( AppUi() );

        // check whether embedded or not

        if ( iEmbedded )

          {

          //Do not show postcapture softkeys if we are still capturing or

          //saving image

          if ( iController.CurrentOperation() != ECamCapturing && 

                  iController.CurrentOperation() != ECamCompleting )

              {

              if ( !appUi->IsSecondCameraEnabled() || appUi->IsQwerty2ndCamera() )  

                  {

                  SetSoftKeysL( R_CAM_SOFTKEYS_SELECT_DELETE__SELECT );

                  }

              else

                  {

                  SetSoftKeysL( R_CAM_SOFTKEYS_SELECT_DELETE__SELECT_SECONDARY );

                  }

              }

          else

              {

              SetSoftKeysL( R_CAM_SOFTKEYS_BLANK );

              }

          }

        else

          {

          appUi->RaisePostCaptureCourtesyUI();

          if ( appUi->IsSecondCameraEnabled() && !appUi->IsQwerty2ndCamera() )

              {

              SetSoftKeysL( R_CAM_SOFTKEYS_OPTIONS_BACK_TOGGLETOOLBAR_PORTRAIT );

              }

          else if ( ECamViewStateBurstThumbnail == appUi ->CurrentViewState() )

              {

              SetSoftKeysL( R_CAM_SOFTKEYS_OPTIONS_BACK_TOGGLETOOLBAR_BURST );

              }

          else

              {

              SetSoftKeysL( R_CAM_SOFTKEYS_OPTIONS_BACK_TOGGLETOOLBAR );

              }

          // image processing complete, enable gallery button

          if( !iEmbedded )        

              {

              // fixed toolbar is used only with touch devices

              if ( iController.IsTouchScreenSupported() )

                  {

                  CAknToolbar* fixedToolbar = Toolbar();

                  if ( fixedToolbar )

                      {

                      fixedToolbar->SetItemDimmed( ECamCmdPhotos, EFalse, ETrue );

                      fixedToolbar->SetItemDimmed( ECamCmdDelete, EFalse, ETrue );

                      fixedToolbar->SetItemDimmed( ECamCmdOneClickUpload, EFalse, ETrue );

                      fixedToolbar->SetItemDimmed( ECamCmdSend, EFalse, ETrue );

                      }

                  }

              }

          }

        iWaitForImageSave = EFalse;

        }

      break;

      }

    case ECamEventSliderClosed:

      {

      // if embedded and the slider is closed, close the menu

      if( iEmbedded )

        {

        PRINT( _L("Camera => CCamPostCaptureViewBase -> ECamEventSliderClosed") );

        StopDisplayingMenuBar();

        }

      }

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

    default:

      break;

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

    } // switch

  PRINT( _L("Camera <= CCamPostCaptureViewBase::HandleControllerEventL") );        

  }

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

// CCamPostCaptureViewBase::HandleForegroundEventL

// Handle foreground event

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

//

void 

CCamPostCaptureViewBase::HandleForegroundEventL( TBool aForeground )

  {    

  PRINT( _L("Camera => CCamPostCaptureViewBase::HandleForegroundEventL") )

  CCamAppUi* appUi = static_cast<CCamAppUi*>( AppUi() );

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

  // Coming to foreground

  if ( aForeground)

    {

    PRINT( _L("Camera <> CCamPostCaptureViewBase::HandleForegroundEventL: to foreground") )

    if ( static_cast<CCamAppUiBase*>( AppUi() )->IsInPretendExit() )

      {

      PRINT( _L("Camera <> CCamPostCaptureViewBase::HandleForegroundEventL: app in pretend exit so not grabbing the engine") )

      // The view can get a foreground event while the application is

      // actually in a pretend exit situation. This occurs when the view switch

      // was called before the exit event, but didn't complete until after the

      // exit event. In this case the view should not register an interest in

      // the engine as the application is really in the background and the resources

      // need to be released

      return;

      }

    // set embedded flag here

    iEmbedded = appUi->IsEmbedded();

    // need to update cba according to whether we are embedded or not

    if ( iEmbedded )

      {

      PRINT( _L("Camera <> CCamPostCaptureViewBase::HandleForegroundEventL: embedded mode") );

      //Do not show postcapture softkeys if we are still capturing or

      //saving image

      if ( iController.CurrentOperation() != ECamCapturing && 

              iController.CurrentOperation() != ECamCompleting )

          {

          if ( !appUi->IsSecondCameraEnabled() || appUi->IsQwerty2ndCamera() )  

              {

              SetSoftKeysL( R_CAM_SOFTKEYS_SELECT_DELETE__SELECT );

              }

          else

              {

              SetSoftKeysL( R_CAM_SOFTKEYS_SELECT_DELETE__SELECT_SECONDARY );

              }

          }

      else

          {

          SetSoftKeysL( R_CAM_SOFTKEYS_BLANK );

          }

      }

    else

      {

      // ensure cba is reset if we're not embedded

      if ( !iWaitForImageSave )

        {

        if ( static_cast<CCamAppUiBase*>( AppUi() )->IsSecondCameraEnabled() && 

            !static_cast<CCamAppUiBase*>( AppUi() )->IsQwerty2ndCamera() )

            {

            SetSoftKeysL( R_CAM_SOFTKEYS_OPTIONS_BACK_TOGGLETOOLBAR_PORTRAIT );

            }

        else if ( ECamViewStateBurstThumbnail == appUi ->CurrentViewState() )

            {

            SetSoftKeysL( R_CAM_SOFTKEYS_OPTIONS_BACK_TOGGLETOOLBAR_BURST );

            }

        else

            {

            SetSoftKeysL( R_CAM_SOFTKEYS_OPTIONS_BACK_TOGGLETOOLBAR );

            }

        }

      else

        {

        // still image not yet saved

        // disable Options softkey and cancel post capture timer

        // softkey will be re-enabled when image has been saved

        if(appUi->IsSecondCameraEnabled() && !appUi->IsQwerty2ndCamera())

            {

            SetSoftKeysL( R_CAM_SOFTKEYS_BACK_SECONDARY );

            }

        else

            {

            SetSoftKeysL( R_CAM_SOFTKEYS_BACK );

            }

        // disable gallery button until image is processed

        if( !iEmbedded )        

            {

            // fixed toolbar is used only with touch devices

            if ( iController.IsTouchScreenSupported() )

                {

                CAknToolbar* fixedToolbar = Toolbar();

                if ( fixedToolbar )

                    {

                    fixedToolbar->SetItemDimmed( ECamCmdPhotos, ETrue, ETrue );

                    fixedToolbar->SetItemDimmed( ECamCmdDelete, ETrue, ETrue );

                    fixedToolbar->SetItemDimmed( ECamCmdOneClickUpload, ETrue, ETrue );

                    fixedToolbar->SetItemDimmed( ECamCmdSend, ETrue, ETrue );

                    }

                }

            }

        }

      }

    // Register that we still want to use the engine (to receive final snap image)

    IncrementCameraUsers();

    iController.DeepSleepTimerStart();

    CCamAppUi* appUi = static_cast<CCamAppUi*>( AppUi() );

    if ( appUi && !iSuppressAPUntilCameraReady )

      {

      if(!iPartialBackground)

          {

          }

      }

    else if ( iSuppressAPUntilCameraReady ) 

      {

      iSuppressAPUntilCameraReady = EFalse;

      }

    iPartialBackground = EFalse;

        {

        appUi->HandleCommandL( ECamCmdSwitchCamera );

        }

    }

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

  // Going to background

  else

    {

    if( iController.IsAppUiAvailable() ) 

        {

        iPartialBackground = ( (appUi->AppInBackground(ETrue) ) && (!appUi->AppInBackground(EFalse) ) );

        }

    else

        {

        iPartialBackground = EFalse;

        }

    PRINT( _L("Camera <> CCamPostCaptureViewBase::HandleForegroundEventL: to background") )

    iController.DeepSleepTimerCancel();

    // Register that we nolonger need the engine.

    // Checks if we incremented the count.

    DecrementCameraUsers();

    }

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

  PRINT( _L("Camera <= CCamPostCaptureViewBase::HandleForegroundEventL") )

  }

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

// CCamPostCaptureViewBase::DoActivateL

// Activate this view

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

//

void CCamPostCaptureViewBase::DoActivateL( const TVwsViewId& aPrevViewId, TUid aCustomMessageId,

                                                    const TDesC8& aCustomMessage )

    {    

    PRINT( _L( "Camera => CCamPostCaptureViewBase::DoActivateL" ) );    

    CCamAppUi* appui = static_cast<CCamAppUi*>( AppUi() );

    CCamViewBase::DoActivateL( aPrevViewId, aCustomMessageId, aCustomMessage );

    // fixed toolbar is used only with touch devices

    if ( iController.IsTouchScreenSupported() )

        {

        CAknToolbar* fixedToolbar = Toolbar();

        if ( fixedToolbar )