/*

* Copyright (c) 2007 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:  Camera UI recording icon decoration*

*/

#include <AknIconUtils.h>

#include <fbs.h>

#include <cameraapp.mbg>

#include "CamRecordingIconDecoration.h"

#include "CamObserverHandler.h"

#include "Cam.hrh"

#include "CamUtility.h"

#include "CamAppController.h"

#include "CamPanic.h"

const TInt KCamVidPauseFlashInterval = 800000;

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

// CCamRecordingIconDecoration::CCamRecordingIconDecoration()

// Default constructor

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

//

CCamRecordingIconDecoration

::CCamRecordingIconDecoration( CCamAppController& aController )

  : iController( aController )

  {

  }

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

// CCamRecordingIconDecoration::NewL

// Factory method to safely create a new instance

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

//

CCamRecordingIconDecoration* 

CCamRecordingIconDecoration::NewL( const TRect& aPosition, 

                                   CCamAppController& aController)

  {

  CCamRecordingIconDecoration* me = 

      new (ELeave) CCamRecordingIconDecoration( aController );

  CleanupStack::PushL( me );

  me->ConstructL( aPosition );

  CleanupStack::Pop( me );

  return me;

  }

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

// CCamRecordingIconDecoration::ConstructL

// Initializes a new instance

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

//

void 

CCamRecordingIconDecoration::ConstructL( const TRect& aPosition )

  {

  iPosition = aPosition.iTl;

  iSize = TRect( TPoint(0,0), aPosition.Size() );

  iObserverHandler = CCamObserverHandler::NewL();

  iPauseFlashPeriodic = CPeriodic::NewL( CActive::EPriorityStandard );

  // Register as a controller observer    

  iController.AddControllerObserverL(this);

  // Load in the icons

  TFileName resFileName;

  CamUtility::ResourceFileName( resFileName );

  TPtrC resname = resFileName;

  AknIconUtils::CreateIconL( iRecBitmap, 

                             iRecBitmapMask, 

                             resname, 

                             EMbmCameraappQgn_indi_vid4_record, 

                             EMbmCameraappQgn_indi_vid4_record_mask );

  AknIconUtils::SetSize( iRecBitmap, aPosition.Size() );

  AknIconUtils::CreateIconL( iRecPauseBitmap, 

                             iRecPauseBitmapMask, 

                             resname, 

                             EMbmCameraappQgn_indi_vid4_pause, 

                             EMbmCameraappQgn_indi_vid4_pause_mask );

  AknIconUtils::SetSize( iRecPauseBitmap, aPosition.Size() );

  // Set iRecordState to the correct value

  switch( iController.CurrentVideoOperation() )

    {

    case ECamCapturing:

        iRecordState = ECamRecording;

        break;

    case ECamPaused:

        iRecordState = ECamRecordPaused;

        break;

    default:

        iRecordState = ECamNotRecording;

        break;

    }

  }

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

// CCamRecordingIconDecoration::~CCamRecordingIconDecoration()

// Destructor

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

//

CCamRecordingIconDecoration::~CCamRecordingIconDecoration()

  {

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

  iController.RemoveControllerObserver(this);

  delete iObserverHandler;

  if( iPauseFlashPeriodic )

    {

    iPauseFlashPeriodic->Cancel();

    }

  delete iPauseFlashPeriodic;

  delete iRecBitmap;

  delete iRecBitmapMask;

  delete iRecPauseBitmap;

  delete iRecPauseBitmapMask;

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

  }

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

// CCamRecordingIconDecoration::Draw()

// Draw the decoration

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

//

void CCamRecordingIconDecoration::Draw(CBitmapContext& aGc, const TRect& /*aDrawRect*/)

    {

    if ( iRecordState == ECamRecording )

        {

		aGc.BitBltMasked(iPosition, iRecBitmap, iSize, iRecBitmapMask, ETrue);

        }

    else if ( iRecordState == ECamRecordPaused )

        {

        if( iShowPaused )

            {

    		aGc.BitBltMasked(iPosition, iRecPauseBitmap, iSize, iRecPauseBitmapMask, ETrue);

            }

        }

    else

        {

        }

    }

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

// CCamRecordingIconDecoration::HandleControllerEventL

// Listens for controller events

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

//

void 

CCamRecordingIconDecoration

::HandleControllerEventL( TCamControllerEvent aEvent, TInt /*aError*/ )

  {

  if( aEvent == ECamEventOperationStateChanged )

    {

    TCamCaptureOperation operation = iController.CurrentOperation();

    // Update based on new controller state

    if( ECamCapturing == operation )

      {

      ChangeRecordState(ECamRecording);

      }

    else if( ECamPaused == operation )

      {

      ChangeRecordState(ECamRecordPaused);

      iShowPaused = ETrue;

      // Kick off the pause flash timer

      if( !iPauseFlashPeriodic->IsActive() )

        {

        TCallBack cb( PauseFlashCallBack, this );

        iPauseFlashPeriodic->Start( KCamVidPauseFlashInterval,

                                    KCamVidPauseFlashInterval,

                                    cb );

        }

      }

    else

      {

      ChangeRecordState( ECamNotRecording );

      }

    // Cancel the timer if need be

    if( iRecordState != ECamRecordPaused )         

      {

      if( iPauseFlashPeriodic->IsActive() )

        {

        iPauseFlashPeriodic->Cancel();

        }

      }

    }

  }

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

// CCamRecordingIconDecoration::ChangeRecordState

// Changes iRecordState, tells observers to update

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

//

void CCamRecordingIconDecoration::ChangeRecordState(TCamRecordState aNewState)

    {

    if ( iRecordState != aNewState )

        {

        BroadcastEvent(ECamObserverEventRecordingIconUpdated);

        }

    iRecordState = aNewState;

    }

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

// CCamRecordingIconDecoration::PauseFlashCallBack

// Callback function from periodic timer used to flash paused icon every 0.8 secs

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

//

TInt CCamRecordingIconDecoration::PauseFlashCallBack( TAny* aRecordingIconDecoration )

    {

    __ASSERT_DEBUG( aRecordingIconDecoration, CamPanic( ECamPanicNullPointer ) );

    static_cast <CCamRecordingIconDecoration*> ( aRecordingIconDecoration )->

                                                    TogglePauseIconFlash();

    return KErrNone;

    }

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

// CCamRecordingIconDecoration::TogglePauseIconFlash

// Updates paused icon state in response to periodic timer 

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

//

void CCamRecordingIconDecoration::TogglePauseIconFlash()

    {

    PRINT(_L("CCamRecordingIconDecoration::TogglePauseIconFlash: broadcasting ECamObserverEventRecordingIconUpdated"));

    iShowPaused = !iShowPaused;

    BroadcastEvent(ECamObserverEventRecordingIconUpdated);

    }

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

// CCamRecordingIconDecoration::RegisterObserverL

// Registers an observer

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

//

void CCamRecordingIconDecoration::RegisterObserverL(MCamObserver* aObserver)

    {

    iObserverHandler->RegisterObserverL(aObserver);

    }

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

// CCamRecordingIconDecoration::DeregisterObserver

// Deregisters an observer

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

//

void CCamRecordingIconDecoration::DeregisterObserver(MCamObserver* aObserver)

    {

    iObserverHandler->DeregisterObserver(aObserver);

    }

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

// CCamRecordingIconDecoration::BroadcastEvent

// Broadcasts an event code to all observers

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

//

void CCamRecordingIconDecoration::BroadcastEvent(TCamObserverEvent aEvent)

    {

    iObserverHandler->BroadcastEvent(aEvent);

    }