/*
* 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:  Class responsible for application exit.
*
*/


#ifndef C_VTUIAPPSHUTTER_H
#define C_VTUIAPPSHUTTER_H

#include <babitflags.h>

#include 	<MPhCltEmergencyCallObserver.h>
#include    <CPhCltEmergencyCall.h>
#include    <RPhCltServer.h>

class CAsyncCallBack;
class MVtUiShutterObserver;
class MVtUiStateContext;

/**
* Shutdown service for the application. This is singleton
* which deletes itself when shutdown is complete.
*
* @since S60 v3.2
*/                       
class CVtUiAppShutter : public CBase
    {
public:          

    /**
    * Returns the instance of application shutter.
    *
    * @param aComms for sending call ending related commands to Phone.
    * @param aObserver observer informed when shutdown is completed.
    * @return the application shutter
    */
    static CVtUiAppShutter* InstanceL( 
        MVtUiShutterObserver& aObserver );

    /**
    *  Starts shutdown.
    */
    void StartShutdown();

    /**
    * Starts shutdown because emergency call was requested by the user.
    * If supplied number is detected other than emergency number this method
    * leaves KErrArgument.
    * @param aStateContext for accessing emergency number and local
    * variation.
    */
    void ShutdownWithEmergencyCallL( MVtUiStateContext& aStateContext );
                               
    /**
    * Callback from emergency caller.
    */
    void EmergencyCallDoneL();
                                   
private:

    /**
    * Exits the application if no pending shutdown preparation
    * is ongoing. Deletes itself as last action.
    */
    void ShutdownIfReadyAndDestroy();

    
    /**
    * Enques async callback.
    */
    void EnqueCallbackL( TCallBack& aCallback );

    /**
    * Asynch callback handling response to emergency call creation.
    */
    static TInt EmergencyResponseCallback( TAny* aAny );

    /** C++ constructor */
    CVtUiAppShutter( MVtUiShutterObserver& aObserver );

    /** destructor */
    ~CVtUiAppShutter();

private: // for making shutdown with emergency call
    class CEmergencyCaller : public CBase, private MPhCltEmergencyCallObserver
        {
        public:         
            /**
            * Dials emergency call. Object destroys itself when
            * response is received.
            */
            static CEmergencyCaller* DialEmergencyL(
                CVtUiAppShutter& aObserver,
                MVtUiStateContext& aStateContext );
            
            // Destructor
            ~CEmergencyCaller();
            
        private: // C++ constructor
            
            CEmergencyCaller( 
                CVtUiAppShutter& aObserver, 
                MVtUiStateContext& aStateContext );
            
            /**
            * 2nd phase constructor
            */
            void ConstructL();
            
        private: // from MPhCltEmergencyCallObserver       
            /**
            * @see  MPhCltEmergencyCallObserver::HandleEmergencyDialL
            */
            virtual void HandleEmergencyDialL( const TInt aStatus );

        private: // Data

            // Emergency number
            TPhCltTelephoneNumber iNumber;             
            
            // Phone Server session
            RPhCltServer          iServer;
            
            // Emergency call handler
            CPhCltEmergencyCall*  iEmergency;
            
            // Observer for callback
            CVtUiAppShutter&      iObserver;

            // State context for gettin entered numbers and local variation
            MVtUiStateContext&    iStateContext;
        };
private: // Data

    /**
    * Guard flags for completing shutdown.
    * All must be cleared before shutdown
    * can be completed.
    */
    enum TShutterFlags 
        {                               
        /** Waiting for call on StartShutdown() */
        EShutterWaitingStart,
        /** Waiting for callback on emegency call request */
        EShutterWaitingEmergencyCallback,
        };
    
    // Asynch callback
    CAsyncCallBack* iCallback;
    
    // guard flags          
    TBitFlags8 iPendingStateFlags;
     
    // Observer to notify when application exit
    // is allowed.
    MVtUiShutterObserver& iObserver;

    // Handles emergency call dialling    
    CEmergencyCaller* iEmergencyCaller;

    };

#endif // C_VTUIAPPSHUTTER_H