/*

* Copyright (c) 2007-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:  Control for displaying remaining images/videos in Navi Pane

*

*  Copyright © 2007-2008 Nokia.  All rights reserved.

*  This material, including documentation and any related computer

*  programs, is protected by copyright controlled by Nokia.  All

*  rights are reserved.  Copying, including reproducing, storing,

*  adapting or translating, any or all of this material requires the

*  prior written consent of Nokia.  This material also contains

*  confidential information which may not be disclosed to others

*  without the prior written consent of Nokia.

*

*

*/

// INCLUDE FILES

#include <eiklabel.h>

#include <eikapp.h>   // For CEikApplication

#include <eikenv.h>

#include <AknsUtils.h>

#include <AknsDrawUtils.h>

#include <aknconsts.h>

#include <StringLoader.h> // StringLoader

#include <e32base.h>

#include <barsread.h>    // TResourceReader

#include <AknBidiTextUtils.h>

#include <cameraapp.mbg>

#include <AknLayoutFont.h>

#include <AknsFrameBackgroundControlContext.h>

#include <aknlayoutscalable_apps.cdl.h>

#include <aknnavide.h>

#include <layoutmetadata.cdl.h>

#include "CamNaviCounterModel.h"

#include "CamAppUi.h"

#include "CamUtility.h"

#include "CamSelfTimer.h"

#include <cameraapp.rsg>

#include <vgacamsettings.rsg>

#include "CamLogger.h"

#include "CamDecorator.h"

#include "camtextitem.h"

#include "CameraUiConfigManager.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "CamNaviCounterModelTraces.h"

#endif

// CONSTANTS

const TInt KMaxRemainingImagesShown = 9999; 

const TInt KCamDefaultCapturedImagesTextLen = 30;

_LIT( KNumberFormat, "%04d" );

_LIT( KTimeLapseImageFormat, "%04d/%04d" );

const TAknsItemID KNaviPaneMajorColour = KAknsIIDQsnComponentColors;

const TInt KNaviPaneMinorColour = EAknsCIQsnComponentColorsCG2;

// Sequence mode related constants that define the amount of pictures taken

// with sequence mode.

const TInt KShortBurstCount  = 18;   // number of images captured during burst

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

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

// CCamNaviCounterModel::NewL

// Factory construction function

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

//

CCamNaviCounterModel* 

CCamNaviCounterModel::NewL( CCamAppController& aController )

  {

  CCamNaviCounterModel* self = 

      new( ELeave ) CCamNaviCounterModel( aController );

  CleanupStack::PushL( self );

  self->ConstructL();

  CleanupStack::Pop( self );

  return self;

  }

// Destructor

CCamNaviCounterModel::~CCamNaviCounterModel()

  {

  iController.RemoveControllerObserver( this );

  delete iVideoTextItem;

  delete iPhotoTextItem;

  delete iSequenceImageTextItem;

  delete iSequenceCapturedTextItem;

  delete iTimeLapseCountdownTextItem;

  CCamNaviCounterModel::UnloadResourceData();

  delete iMpeg4Icon;

  delete iMpeg4IconMask;

  delete i3GPIcon;

  delete i3GPIconMask;

  CCamAppUi* appUi = static_cast<CCamAppUi*>( CEikonEnv::Static()->AppUi());

  if ( appUi )

    {

    if ( !iController.IsInShutdownMode() )

      {

      appUi->RemoveBurstModeObserver( this );

      }

    delete iSequenceIcon;

    delete iSequenceMask;

    }

  delete iSelfTimerIcon;

  delete iSelfTimerMask;

  // If not shutting down, deregister from SelfTimer observers.

  // If we try to deregister when shutting down, the object has already been 

  // deleted

  if ( !iController.IsInShutdownMode() && appUi )

    {

    // ...Remove self as an observer of the self timer.    

    CCamSelfTimer* selftimer = appUi->SelfTimer();

    if ( selftimer )

      {

      selftimer->RemoveObserver( this );

      }            

    }

#ifdef PRODUCT_SUPPORTS_NAVIPANE_GENERIC_SETUP_INDICATOR

  delete iGenericIcon;

  delete iGenericMask;    

#endif // PRODUCT_SUPPORTS_NAVIPANE_GENERIC_SETUP_INDICATOR

  delete iAudioMuteIcon;

  delete iAudioMuteMask;

#ifdef PRODUCT_SUPPORTS_NAVIPANE_MODE_SUBTITLE      

  delete iSubtitlePhotoIcon;

  delete iSubtitlePhotoMask;

  delete iSubtitleVideoIcon;

  delete iSubtitleVideoMask;

#endif // PRODUCT_SUPPORTS_NAVIPANE_MODE_SUBTITLE

  delete iTimeFormat;

  delete iCountDownText;

  delete iObserverHandler;

  }

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

// CCamNaviCounterModel::LoadResourceDataL()

// Reads in all information needed from resources

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

//

void CCamNaviCounterModel::LoadResourceDataL()

    {

OstTrace0( CAMERAAPP_PERFORMANCE_DETAIL, CCAMNAVICOUNTERMODEL_LOADRESOURCEDATAL, "e_CCamNaviCounterModel_LoadResourceDataL 1" );

    PRINT( _L("Camera => CCamNaviCounterModel::LoadResourceDataL") );

    // Read the time format resource

    PRINT( _L("Camera <> construct timeformat..") );

    delete iTimeFormat;

    iTimeFormat = NULL;

    if ( !Layout_Meta_Data::IsLandscapeOrientation() ) 

        {

        iTimeFormat = CEikonEnv::Static()->AllocReadResourceL( R_QTN_TIME_DURAT_MIN_SEC_WITH_ZERO );

        }

    else 

        {

        iTimeFormat = CEikonEnv::Static()->AllocReadResourceL( R_QTN_TIME_DURAT_LONG );

        }    

    CCamAppUi* appUi = static_cast<CCamAppUi*>( CEikonEnv::Static()->AppUi() );

    delete iPhotoTextItem;

    iPhotoTextItem = NULL;

    iPhotoTextItem = CCamTextItem::NewL();

    delete iVideoTextItem;

    iVideoTextItem = NULL;

    iVideoTextItem = CCamTextItem::NewL();

    delete iSequenceImageTextItem;

    iSequenceImageTextItem = NULL;   

    iSequenceImageTextItem = CCamTextItem::NewL();

    delete iTimeLapseCountdownTextItem;

    iTimeLapseCountdownTextItem = NULL;

    iTimeLapseCountdownTextItem = CCamTextItem::NewL();

    delete iSequenceCapturedTextItem;

    iSequenceCapturedTextItem = NULL;

    iSequenceCapturedTextItem = CCamTextItem::NewL();   

    iCamOrientation = appUi->CamOrientation();

    if ( Layout_Meta_Data::IsLandscapeOrientation() || CamUtility::IsNhdDevice() )

        {

        TSize screenSize;

        AknLayoutUtils::LayoutMetricsSize( AknLayoutUtils::EScreen, screenSize ); 

        iExtent = TRect( TPoint(), screenSize );

        }

    else

        {

        TRect screenRect;

        AknLayoutUtils::LayoutMetricsRect( AknLayoutUtils::EMainPane, screenRect );

        iExtent = screenRect;

        }

    if ( CamUtility::IsNhdDevice() )

        {

        TouchLayoutL();

        }

    else

        {

        if ( !Layout_Meta_Data::IsLandscapeOrientation() )

            {

            NonTouchLayoutSecondaryL();

            }

        else

            {

            NonTouchLayoutL();

            }

        }

    iVidPostStorageIconRect = iVidPreStorageIconRect;

    if ( iController.UiConfigManagerPtr() && 

         iController.UiConfigManagerPtr()->IsLocationSupported() )

        {

        iLocationIconVisible = (/*TCamLocationId::ECamLocationOn*/1 == iController.IntegerSettingValue( ECamSettingItemRecLocation ));

        // If location setting is on, then the decoration should be wider to fit the location icon

        if ( iLocationIconVisible )

            {

            iPhotoPrecapDecorator = CCamDecorator::NewL( iController, R_CAM_STILL_PRECAP_NAVICOUNTER_DECORATIONS_CAMCORDER_LOCATION );

            }

        else

            {

            iPhotoPrecapDecorator = CCamDecorator::NewL( iController, R_CAM_STILL_PRECAP_NAVICOUNTER_DECORATIONS_CAMCORDER );

            }

        }

    else

        {

        iPhotoPrecapDecorator = CCamDecorator::NewL( iController, R_CAM_STILL_PRECAP_NAVICOUNTER_DECORATIONS_CAMCORDER );

        }

    iVideoPrecapDecorator = CCamDecorator::NewL( iController, R_CAM_VIDEO_PRECAP_NAVICOUNTER_DECORATIONS_CAMCORDER );

    iPhotoPostcapDecorator = CCamDecorator::NewL( iController, R_CAM_STILL_POSTCAP_NAVICOUNTER_DECORATIONS_CAMCORDER );

    iVideoPostcapDecorator = CCamDecorator::NewL( iController, R_CAM_VIDEO_POSTCAP_NAVICOUNTER_DECORATIONS_CAMCORDER );

    iSequenceInCaptureDecorator = CCamDecorator::NewL( iController, R_CAM_TIMELAPSE_IN_CAPTURE_NAVICOUNTER_DECORATIONS );

    iTimeLapsePostCaptureDecorator = CCamDecorator::NewL( iController, R_CAM_TIMELAPSE_POST_CAPTURE_NAVICOUNTER_DECORATIONS );

    TFileName resFileName;

    CamUtility::ResourceFileName( resFileName );

    TPtrC resname = resFileName;

    // Create component bitmaps 

    TSize size = iVidPostStorageIconRect.Rect().Size();

    TCamOrientation orientation = appUi->CamOrientation();

    AknIconUtils::CreateIconL( iPhoneIcon, 

                               iPhoneIconMask, 

                               resname, 

                               EMbmCameraappQgn_indi_cam4_memory_phone,

                               EMbmCameraappQgn_indi_cam4_memory_phone_mask );

    AknIconUtils::SetSize( iPhoneIcon, size );

    AknIconUtils::CreateIconL( iMMCIcon, 

                               iMMCIconMask, 

                               resname, 

                               EMbmCameraappQgn_indi_cam4_memory_mmc, 

                               EMbmCameraappQgn_indi_cam4_memory_mmc_mask );

    AknIconUtils::SetSize( iMMCIcon, size );

    if ( orientation != ECamOrientationCamcorder && orientation != ECamOrientationCamcorderLeft )

        {

        AknIconUtils::CreateIconL( iMassStorageIcon, 

                                   iMassStorageIconMask, 

                                   resname, 

                               EMbmCameraappQgn_indi_cam4_memory_mass,  

                               EMbmCameraappQgn_indi_cam4_memory_mass_mask );

        }

    else

        {

        AknIconUtils::CreateIconL( iMassStorageIcon, 

                                   iMassStorageIconMask, 

                                   resname, 

                               EMbmCameraappQgn_indi_cam4_memory_mass,  

                               EMbmCameraappQgn_indi_cam4_memory_mass_mask );

        }

     AknIconUtils::SetSize( iMassStorageIcon, size );

	PRINT( _L("Camera <= CCamNaviCounterModel::LoadResourceDataL") );	

OstTrace0( CAMERAAPP_PERFORMANCE_DETAIL, DUP1_CCAMNAVICOUNTERMODEL_LOADRESOURCEDATAL, "e_CCamNaviCounterModel_LoadResourceDataL 0" );

    }

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

// CCamNaviCounterModel::UnloadResourceData()

// Frees all dynamic resources allocated in LoadResourceDataL

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

//

void CCamNaviCounterModel::UnloadResourceData()

    {

#ifdef PRODUCT_SUPPORTS_NAVIPANE_MODE_SUBTITLE

    delete iSubtitleVideoText;

    iSubtitleVideoText = NULL;

    delete iSubtitlePhotoText;

    iSubtitlePhotoText = NULL;

#endif // PRODUCT_SUPPORTS_NAVIPANE_MODE_SUBTITLE

    delete iPhotoPrecapDecorator;

    iPhotoPrecapDecorator = NULL;

    delete iVideoPrecapDecorator;

    iVideoPrecapDecorator = NULL;

    delete iPhotoPostcapDecorator;

    iPhotoPostcapDecorator = NULL;

    delete iVideoPostcapDecorator;

    iVideoPostcapDecorator = NULL;

    delete iSequenceInCaptureDecorator;

    iSequenceInCaptureDecorator = NULL;

    delete iTimeLapsePostCaptureDecorator;

    iTimeLapsePostCaptureDecorator = NULL;

    delete iPhoneIcon;

    iPhoneIcon = NULL;

    delete iPhoneIconMask;

    iPhoneIconMask = NULL;

    delete iMMCIcon;

    iMMCIcon = NULL;

    delete iMMCIconMask;

    iMMCIconMask = NULL;

    delete iMassStorageIcon;

    iMassStorageIcon = NULL;

    delete iMassStorageIconMask;

    iMassStorageIconMask = NULL;

    }

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

// CCamNaviCounterModel::ReloadResourceDataL()

// Refreshes all resource-based information stored in the class

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

//

void CCamNaviCounterModel::ReloadResourceDataL()

    {

    OstTrace0( CAMERAAPP_PERFORMANCE_DETAIL, CCAMNAVICOUNTERMODEL_RELOADRESOURCEDATAL, "e_CCamNaviCounterModel_ReloadResourceDataL 1" );

    UnloadResourceData();

    LoadResourceDataL();

    OstTrace0( CAMERAAPP_PERFORMANCE_DETAIL, DUP1_CCAMNAVICOUNTERMODEL_RELOADRESOURCEDATAL, "e_CCamNaviCounterModel_ReloadResourceDataL 0" );

    }

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

// CCamNaviCounterModel::UpdateCounter

// Update counter 

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

//

void CCamNaviCounterModel::UpdateCounter()

  {

  PRINT( _L("Camera => CCamNaviCounterModel::UpdateCounter") );

  const TInt imagesLeft = Min( 

      iController.ImagesRemaining( ECamMediaStorageCurrent, iBurstActive ), 

      KMaxRemainingImagesShown );

  iCounterText.Format( KNumberFormat, imagesLeft );

  if ( iPhotoTextItem )

      {

      TRAP_IGNORE( iPhotoTextItem->SetTextL( iCounterText ) );

      }

  PRINT( _L("Camera <= CCamNaviCounterModel::UpdateCounter") );

  }

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

// CCamNaviCounterModel::UpdateTimeLapseCountdownL

// Update the counter for remaining time until the next capture

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

//

void CCamNaviCounterModel::UpdateTimeLapseCountdownL()

    {

    // Get the actual remaining time till next capture

    TTime time ( iController.TimeLapseCountdown().Int64() );

    // The format function always rounds down to the next whole number of seconds

    // so add on 0.5 secs to force round up if closer to the next higher whole number of seconds

    // This gives a countdown from max to 1, to get a countdown from max-1 to 0 remove this

    const TTimeIntervalMicroSeconds KHalfSecInMicroSecs = TInt64( 500000 );

    time += KHalfSecInMicroSecs; 

    TBuf<15> timebuf;

	// use 00:00 format as normal in secondary cam

	// but long format for primary cam. 2nd cam uses sharing quality. With primary cam sharing 

	// we just use the same layout for sharing and other qualities.

	HBufC* timeFormat;

    if ( ECamActiveCameraSecondary == iController.ActiveCamera() ) 

    	{

    	timeFormat = CEikonEnv::Static()->AllocReadResourceLC( R_QTN_TIME_DURAT_MIN_SEC_WITH_ZERO );

    	}

    else 

    	{

    	timeFormat = CEikonEnv::Static()->AllocReadResourceLC( R_QTN_TIME_DURAT_LONG );

    	}

    time.FormatL( timebuf, *timeFormat );

    CleanupStack::PopAndDestroy( timeFormat );

    delete iCountDownText;

    iCountDownText = NULL;

    iCountDownText = StringLoader::LoadL( R_CAM_TIMELAPSE_COUNTDOWN_TIME, timebuf ); 

    }  

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

// CCamNaviCounterModel::UpdateSequenceImageCount

// Update the counter of captured and remaining images for 

// timelapse and burst during capture

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

//

void CCamNaviCounterModel::UpdateSequenceImageCount()

  {

  PRINT( _L("Camera => CCamNaviCounterModel::UpdateSequenceImageCount" ) )

  TInt imagesLeft   = iController.ImagesRemaining( ECamMediaStorageCurrent, iBurstActive );

  TInt showLeft     = Min( imagesLeft, KMaxRemainingImagesShown );

  TInt showCaptured = 0;

  if ( ECamImageCaptureTimeLapse == iImageMode )

    {

    // Use the count of captured images

    showCaptured = iController.TimeLapseImageCount();

    }

  else if ( ECamImageCaptureBurst == iImageMode )       

    {

    // Use the count of burst capture moments

    showCaptured = iController.CurrentCapturedCount();

    // The images have not been saved yet so the remaining count does not account

    // for the ones already captured. Reduce the remaining count by the captured count.

    // Commented out - The burst images are saved immediately after capturing.

    // However, we cannot know if all the previous images have already been saved

    // so this number is not 100% accurate.

    // showLeft -= showCaptured; 

	if( ( iOriginalValueForEachBurst > 0 ) && ( iCounterNeedUpdate ) )

		{

	       iOriginalValueForEachBurst--; 

		}

    	if( ( iController.SequenceCaptureInProgress() ) )   

    		{

    		if( !iController.IsRemainingImageStored() )

    		    {

    	            iOriginalValueForEachBurst = showLeft;

		     iController.SetRemainingImageStored();

    		    }

            iCounterText.Format( KNumberFormat, iOriginalValueForEachBurst );

    		}

		else

       iCounterText.Format( KNumberFormat, iController.ImagesRemaining( ECamMediaStorageCurrent, iBurstActive ) );

	   showLeft = iOriginalValueForEachBurst;

    }

  else

    {

    // no action

    }

  // show only the KShortBurstCount value if there is enough space to take all

  // pictures, otherwise display the number of images that can be shown

  TInt showSequenceMax = Min( showLeft, KShortBurstCount );

  iSequenceImageText.Format( KTimeLapseImageFormat, showCaptured, showSequenceMax );

  }   

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

// CCamNaviCounterModel::UpdateRecordTimeAvailableL

// Update record time remaining 

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

//

void CCamNaviCounterModel::UpdateRecordTimeAvailableL()

    {

        PRINT( _L("Camera => CCamNaviCounterModel::UpdateRecordTimeAvailableL" ) )

    // Get the total remaining record time from the controller

    TTime time ( iController.RecordTimeRemaining().Int64() );

    HBufC* timeFormat;

    // Use 00:00 format in secondary cam

	if ( ECamActiveCameraSecondary == iController.ActiveCamera() ) 

        {

	   	timeFormat = CEikonEnv::Static()->AllocReadResourceLC( R_QTN_TIME_DURAT_MIN_SEC_WITH_ZERO );

        }

	// Use 0:00:00 format in primary cam

	else 

        {

	    timeFormat = CEikonEnv::Static()->AllocReadResourceLC( R_QTN_TIME_DURAT_LONG );

        }

    time.FormatL( iRemainingTimeText, *timeFormat );

    if ( iVideoTextItem )

        {

        iVideoTextItem->SetTextL( iRemainingTimeText );

        }

    CleanupStack::PopAndDestroy( timeFormat );

    PRINT( _L("Camera <= CCamNaviCounterModel::UpdateRecordTimeAvailableL" ) )

    }

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

// CCamNaviCounterModel::SetCaptureModeL

// Set capture mode (defines which counter to use)

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

//

void 

CCamNaviCounterModel::SetCaptureModeL( TCamCameraMode       aMode,

                                       TCamImageCaptureMode aImageMode )

  {

  iMode      = aMode;

  iImageMode = aImageMode;