/*
* 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:  Simulator for flash recharging
*
*/



// ===========================================================================
// Includes
#include <ECam.h>            // TECAMEvent
#include <ecamadvsettings.h> // ECam event ids

#include "camlogging.h"
#include "camcameracontroller.h"
#include "camflashsimulator.h"


// ===========================================================================
// Local constants
static const TUint KEventInterest = ECamCameraEventClassNone
                                  | ECamCameraEventClassImage;


// ===========================================================================
// Methods

// ---------------------------------------------------------------------------
// CCamFlashSimulator::CCamFlashSimulator
// ---------------------------------------------------------------------------
//
CCamFlashSimulator::CCamFlashSimulator( CCamCameraController& aController )
  : iController   ( aController ),
    iError        ( KErrNone    ),
    iFlashRequired( EFalse      ),
    iFlashReady   ( ETrue       )
  {
  }

// ---------------------------------------------------------------------------
// CCamFlashSimulator::~CCamFlashSimulator
// ---------------------------------------------------------------------------
//    
CCamFlashSimulator::~CCamFlashSimulator()
  {
  iController.DetachObserver( this );

  if( iRechargeTimer )
    {
    iRechargeTimer->Cancel();
    delete iRechargeTimer;
    }
  // DeleteProperty();
  }
    

// ---------------------------------------------------------------------------
// CCamFlashSimulator::NewL
// ---------------------------------------------------------------------------
// 
CCamFlashSimulator*
CCamFlashSimulator::NewL( CCamCameraController& aController )
  {
  CCamFlashSimulator* self = 
      new (ELeave) CCamFlashSimulator( aController );
  CleanupStack::PushL( self );
  self->ConstructL();
  CleanupStack::Pop(); // self
  return self;
  }

// ---------------------------------------------------------------------------
// CCamFlashSimulator::ConstructL
// ---------------------------------------------------------------------------
//
void
CCamFlashSimulator::ConstructL()
  {
  iRechargeTimer = CPeriodic::NewL( EPriorityNormal );

  iController.AttachObserverL( this, KEventInterest );
  }
    

// ---------------------------------------------------------------------------
// HandleCameraEventL <<virtual>>
// ---------------------------------------------------------------------------
//
void 
CCamFlashSimulator::HandleCameraEventL( TInt              aStatus, 
                                        TCamCameraEventId aEventId, 
                                        TAny*             aEventData /*=NULL*/ )
  {
  switch( aEventId )
    {
    case ECamCameraEventImageInit :
      {
      StartRecharging();
      break;
      }
    
    default :
      {
      break;
      }
    }
  }


// ---------------------------------------------------------------------------
// CCamFlashSimulator::SetFlashRequired
// ---------------------------------------------------------------------------
//
void
CCamFlashSimulator::SetFlashRequired( TBool aFlashRequired )
  {
  iFlashRequired = aFlashRequired;
  }

// ---------------------------------------------------------------------------
// CCamFlashSimulator::SetFlashError
// ---------------------------------------------------------------------------
//    
void
CCamFlashSimulator::SetFlashError( TBool aFlashError )
  {
  iError = aFlashError;
  }
    

// ---------------------------------------------------------------------------
// CCamFlashSimulator::StartRecharging
// ---------------------------------------------------------------------------
//    
void
CCamFlashSimulator::StartRecharging( TBool aError )
  {
  if( iRechargeTimer )
    {
    // Empty the flash, and publish the property value
    iFlashReady = EFalse;  
    
    // The possible error shall be published when the recharging is done
    iError = aError;
    
    // Start recharging timer
    iRechargeTimer->Cancel();
    iRechargeTimer->Start( KSimulatedChargingTime,
                           KMaxTInt32,
                           TCallBack( RechargeTimerCallback, this ) );    

    // Send "flash not ready" event to Camera Controller
    NotifyController();
    }
  }


// ---------------------------------------------------------------------------
// NotifyController
// ---------------------------------------------------------------------------
//
void 
CCamFlashSimulator::NotifyController()
  {
  PRINT2( _L("Camera => CCamFlashSimulator::NotifyController, flash ready:%d, status:%d"), iFlashReady, iError )

  const TUid eventId( iFlashReady 
                    ? KUidECamEventFlashReady 
                    : KUidECamEventFlashNotReady );   
  const TECAMEvent event( eventId, iError );

  iController.HandleEvent( event );

  PRINT ( _L("Camera <= CCamFlashSimulator::NotifyController") );
  }

// ---------------------------------------------------------------------------
// CCamFlashSimulator::RechargeTimerCallback
// ---------------------------------------------------------------------------
//
TInt
CCamFlashSimulator::RechargeTimerCallback( TAny* aSelf )
  {
  CCamFlashSimulator* self = static_cast<CCamFlashSimulator*>( aSelf );
  if( self )
    {
    self->iRechargeTimer->Cancel();
    // Set the flash to ready state and publish value
    self->iFlashReady = ETrue;

    // Send "flash ready" event to Camera Controller
    self->NotifyController();
    }
  return KErrNone;    
  }