/*

* Copyright (c) 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:  Controller for managing the camera startup logo state

*

*/

#include "camstartuplogocontroller.h"

#include "camlogging.h"

// Maximum time the logo can be shown

const TInt KCamFailSafeTimeout = 5000000; // 5 seconds

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

// C++ constructor

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

//

CCamStartupLogoController::CCamStartupLogoController(TStartupLogoState aInitialState)

    : iState(aInitialState)

    {

    // No implementation required

    PRINT( _L("Camera <> CCamStartupLogoController::CCamStartupLogoController") );

    }

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

// Destructor

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

//

CCamStartupLogoController::~CCamStartupLogoController()

    {

    PRINT( _L("Camera <> CCamStartupLogoController::~CCamStartupLogoController") );

    delete iFailSafeTimer;

    }

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

// Two-phased constructor

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

//

CCamStartupLogoController* CCamStartupLogoController::NewLC(TStartupLogoState aInitialState)

    {

    CCamStartupLogoController* self =

            new (ELeave) CCamStartupLogoController(aInitialState);

    CleanupStack::PushL(self);

    self->ConstructL();

    return self;

    }

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

// Two-phased constructor

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

//

CCamStartupLogoController* CCamStartupLogoController::NewL(

    TStartupLogoState aInitialState)

    {

    CCamStartupLogoController* self = CCamStartupLogoController::NewLC(aInitialState);

    CleanupStack::Pop(self);

    return self;

    }

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

// 2nd phase constructor

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

//

void CCamStartupLogoController::ConstructL()

    {

    iFailSafeTimer = CPeriodic::NewL(0);

    }

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

// CCamStartupLogoController::AddObserver

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

//

TInt CCamStartupLogoController::AddObserver(

    MCamStartupLogoControllerObserver* aObserver)

    {

    return iObservers.Append(aObserver);

    }

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

// CCamStartupLogoController::RemoveObserver

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

//

void CCamStartupLogoController::RemoveObserver(

    MCamStartupLogoControllerObserver* aObserver)

    {

    TInt index = iObservers.Find(aObserver);

    if (index >= 0)

        {

        iObservers.Remove(index);

        }

    }

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

// CCamStartupLogoController::State

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

//

TStartupLogoState CCamStartupLogoController::State() const

    {

    return iState;

    }

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

// CCamStartupLogoController::ShowLogo

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

//

void CCamStartupLogoController::ShowLogo()

    {

    PRINT(_L("Camera <> CCamStartupLogoController::ShowLogo"));

    if (iFailSafeTimer)

        {

        iFailSafeTimer->Cancel();

        iFailSafeTimer->Start(TTimeIntervalMicroSeconds32(KCamFailSafeTimeout),

                TTimeIntervalMicroSeconds32(KCamFailSafeTimeout),

                TCallBack(FailSafeCallback, this));

        }

    SetState(EStartupLogoVisible);

    }

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

// CCamStartupLogoController::HideLogo

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

//

void CCamStartupLogoController::HideLogo()

    {

    PRINT(_L("Camera <> CCamStartupLogoController::HideLogo"));

    // Hide immediately

    SetState(EStartupLogoNotVisible);

    if (iFailSafeTimer)

        {

        iFailSafeTimer->Cancel();

        }

    }

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

// CCamStartupLogoController::SetState

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

//

void CCamStartupLogoController::SetState(TStartupLogoState aNewState)

    {

    PRINT1(_L("Camera => CCamStartupLogoController::SetState %d"), aNewState);

    if (iState != aNewState)

        {

        iState = aNewState;

        for (TInt i=0; i<iObservers.Count(); i++)

            {

            iObservers[i]->StartupLogoControllerStateChanged(aNewState);

            }

        }

    PRINT1(_L("Camera <= CCamStartupLogoController::SetState %d"), aNewState);

    }

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

// CCamStartupLogoController::FailSafeCallback

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

//

TInt CCamStartupLogoController::FailSafeCallback(TAny* ptr)

    {

    PRINT(_L("Camera <> CCamStartupLogoController::FailSafeCallback"));

    CCamStartupLogoController* self = static_cast<CCamStartupLogoController*>(ptr);

    if (self)

        {

        self->HideLogo();

        if (self->iFailSafeTimer)

            {

            self->iFailSafeTimer->Cancel();

            }

        }

    return 0;

    }