/*

* Copyright (c) 2002-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:   Support for Emergency Calls. Class Implementations.

*   Pressed keys are tracked in a buffer and CEmergencyNumberUtils

*   is used to find out if the buffer matches to emergency number.

*   Observers, if registered are called to notify them.

*

*

*/

// INCLUDES

#include <e32std.h>

#include "aknenv.h"

#include "aknappui.h"

#include "AknEcs.h"

#include <featmgr.h>

#include "AknDebug.h"

#include <CPhCltEmergencyCall.h>

#include <MPhCltEmergencyCallObserver.h>

#include <PhCltTypes.h>

#include <AvkonInternalCRKeys.h>

#include <PtiDefs.h>

#include <e32property.h>

#include <AiwCommon.hrh>

#include <aiwdialdata.h>

#include <AiwServiceHandler.h>

#include <centralrepository.h>

#include "akntrace.h"

const TInt KAknKeyScanCodeBegin = 33;

const TInt KAknKeyScanCodeEnd   = 126;

// CLASS DECLARATIONS

/** Class for getting emergency call events */

NONSHARABLE_CLASS(CPhCltEmergencyCallObserver) : public CBase,

                                                 public MPhCltEmergencyCallObserver

    {

    public:

        /** Constructor */

        CPhCltEmergencyCallObserver(CAknEcsDetector* aParent);

        /** Destructor */

        ~CPhCltEmergencyCallObserver( );

       /**

         * This method is called when client's dial request is completed.

         *

         * @param aStatus error code of the success of the operation.

         */       

        virtual void HandleEmergencyDialL( const TInt aStatus );

    private:

        /** Pointer to the parent object that really handles the events. */

        CAknEcsDetector* iParent;

    };

CPhCltEmergencyCallObserver::CPhCltEmergencyCallObserver(CAknEcsDetector* aParent)

    :iParent(aParent)

    {

    }

CPhCltEmergencyCallObserver::~CPhCltEmergencyCallObserver()

    {

    }

void CPhCltEmergencyCallObserver::HandleEmergencyDialL( const TInt /*aStatus*/ )

    {

#ifdef AVKON_RDEBUG_INFO

    _LIT(KDebugDialRequestCompleted, "Dial request is completed");

    RDebug::Print(KDebugDialRequestCompleted);

#endif

    iParent->CallAttemptedCallback( iParent );    

    }

/**

* Class to hold the queue of keys (TText characters) provided to the emergency call detector.

*

* Performs matching of an emergency number with the current queue.

*

* No memory is allocated after its complete construction

*

*/

NONSHARABLE_CLASS(CAknMatchingCharacterQueue) : public CBase

    {

    public:

        /**

        * These statuses are returned by MatchText

        */

        enum TStatus

            {

            ENoMatch,

            ECompleteMatch,

            EServiceNumMatch

            };

    public:

        /**

        * C++ constructor

        *

        * @param aPhCltEmergencyCall  Emergency call client

        * @param aServiceCallEnabled  Is service call feature enabled during device or key lock.

        */

        CAknMatchingCharacterQueue( CPhCltEmergencyCall* aPhCltEmergencyCall, TBool aServiceCallEnabled );

        /**

        * C++ destructor

        */

        ~CAknMatchingCharacterQueue( );

        /**

        * 2nd phase constructor

        */

        void ConstructL();

        /**

        * Method to reset the buffer by resetting the pointers.

        *

        */

        void Reset();

        /**

        * Adds the passed character code to the queue. All codes append to the queue;

        * none are ignored.

        *

        * @param aNewChar New char to the queue.

        */

        void AddChar( TText aNewChar );

        /**

        * Set the entire contents of the queue. If the new buffer is longer than

        * the queue, rest are stripped.

        *

        * @param aNewBuffer New content to the queue.

        */

        void SetBuffer( const TDesC& aNewBuffer );

        /**

        * The number of characters in the queue.  Resets to 0. Increases as characters are added

        * up to and equal to KAknEcsMaxMatchingLength

        *

        * @return   the number of characters queued and available for match.

        *

        */

        TInt Count() const;

        /**

        * Returns the status of the queue (which is automatically updated when AddChar and other non-const

        * API is called)

        * @return The status of the match. Nothing matching returns ENoMatch; 

        *         The whole sequence matching returns ECompleteMatch.

        */

        TStatus Status() const;

        /**

        * Returns a pointer to the current matching number. 

        *

        * @return A ptr descriptor into the currently matching text

        */

        TPtrC CurrentMatch() const;

        /**

        * Returns an index to the current character buffer where the emergency number

        * match begins.  This value is between 0 and KAknEcsMaxMatchingLength, even if

        * there have been a large number characters input to the FIFO. Thus, it does not

        * take account of characters that have fallen out of the FIFO.

        *

        * @return the index in the current buffer where the match starts

        */

        TInt IndexOfCurrentMatch() const;

        /**

        * Validates the service number.

        *

        * @param aNumber Service number to be validated from CenRep.

        *

        * @return Returns ETrue if aNumber is a service number, EFalse if not.

        */

        TBool ValidateServiceNumberL( const TDesC& aNumber );

    private:

        /**

        * Update the status of the queue

        */

        void UpdateStatus( TBool aBufferMode );

    private:

        // Emergency number buffer is as long as maximum sequence

        TBuf<KAknEcsMaxMatchingLength> iCharBuffer;

        /** Pointer to phone client interface of emergency call. Not owned */

        CPhCltEmergencyCall* iPhCltEmergencyCall; 

        TStatus iStatus;      // Holds the status;

        TInt iMatchPosition;  // Position in iCharBuffer from where the match starts.

        TBool iServiceCallFeature;  // True if service call feature is enabled.

        TAny* iSpare;

    };

// CLASS IMPLEMENTATIONS

/**

 * Local Panic Function and Panic Codes

 */

enum TAknEcsPanicCodes

    {

    EAknEcsPanicDialLLeft = 1,

    EAknEcsPanicBadState

    };

GLDEF_C void Panic(TAknEcsPanicCodes aPanic)

    {

    _LIT(KPanicCat,"AknEcs");

    User::Panic(KPanicCat, aPanic);

    }

//

// Queue used for storing and matching the keys used in emergency number detection

//

//

CAknMatchingCharacterQueue::CAknMatchingCharacterQueue( CPhCltEmergencyCall* aPhCltEmergencyCall, TBool aServiceCallEnabled )

        : iPhCltEmergencyCall( aPhCltEmergencyCall ), iServiceCallFeature( aServiceCallEnabled )

    {

    _AKNTRACE_FUNC_ENTER;

    Reset();

    _AKNTRACE_FUNC_EXIT;

    }

CAknMatchingCharacterQueue::~CAknMatchingCharacterQueue( )

    {

    }

void CAknMatchingCharacterQueue::ConstructL()

    {

    }

void CAknMatchingCharacterQueue::Reset()

    {

    _AKNTRACE_FUNC_ENTER;

    iMatchPosition = 0;

    iCharBuffer.Zero();

    _AKNTRACE_FUNC_EXIT;

    }

void CAknMatchingCharacterQueue::AddChar( TText aNewChar )

    {    

    _AKNTRACE_FUNC_ENTER;

    _AKNTRACE( "[%s][%s] aNewChar: %s", "CAknMatchingCharacterQueue", 

        		__FUNCTION__,&aNewChar);

    TInt length = iCharBuffer.Length();

    TInt maxLenght = iCharBuffer.MaxLength();

    if (length >= maxLenght)

        {

        iCharBuffer = iCharBuffer.Right(length - 1);

        }

    iCharBuffer.Append( aNewChar );

    UpdateStatus( EFalse );

    _AKNTRACE_FUNC_EXIT;

    }

void CAknMatchingCharacterQueue::SetBuffer( const TDesC& aNewBuffer )

    {    

    _AKNTRACE_FUNC_ENTER;

    _AKNTRACE( "[%s][%s] aNewBuffer: %s", "CAknMatchingCharacterQueue", 

            		__FUNCTION__,&aNewBuffer);

    TInt maxLenght = iCharBuffer.MaxLength();

    TInt length = aNewBuffer.Length();

    if ( length > maxLenght )

        {

        length = maxLenght;

        }

    iCharBuffer = aNewBuffer.Left( length );

    UpdateStatus( ETrue );

    _AKNTRACE_FUNC_EXIT;

    }

TInt CAknMatchingCharacterQueue::Count() const

    {

    return iCharBuffer.Length();

    }

CAknMatchingCharacterQueue::TStatus CAknMatchingCharacterQueue::Status() const

    {

    return iStatus;

    }

TPtrC CAknMatchingCharacterQueue::CurrentMatch() const

    {

    return TPtrC(iCharBuffer.Right(iCharBuffer.Length() - iMatchPosition));

    }

TInt CAknMatchingCharacterQueue::IndexOfCurrentMatch() const

    {

    return iMatchPosition;

    }

void CAknMatchingCharacterQueue::UpdateStatus( TBool aBufferMode )

    {

    _AKNTRACE_FUNC_ENTER;

    TBool isEmergency = EFalse;

    TInt err = KErrNone;

    TPhCltTelephoneNumber buffer = iCharBuffer;

    if (iPhCltEmergencyCall)

        {

        //err = iPhCltEmergencyCall->FindEmergencyPhoneNumber(buffer, isEmergency);        

        }

    if ( err != KErrNone )

        {

        isEmergency = EFalse;

        }

    TInt cbLength = iCharBuffer.Length();

    TInt bLength = buffer.Length();

    if ( aBufferMode && isEmergency && ( cbLength != bLength ) )

        {

        isEmergency = EFalse;

        }

    if ( isEmergency )

        {

        iMatchPosition = cbLength - bLength;

        iStatus = ECompleteMatch;

        }

    else if ( iServiceCallFeature && cbLength >= KAknServiceCallMinLength )

        {

        // Check if this is a service call

        TBool isServiceNum = EFalse;

        TRAP_IGNORE( isServiceNum = ValidateServiceNumberL( iCharBuffer ) );

        if ( isServiceNum )

            {

            iMatchPosition = 0;

            iStatus = EServiceNumMatch;

            }

        else

            {

            iMatchPosition = cbLength;

            iStatus = ENoMatch;

            }

        }

    else

        {

        iMatchPosition = cbLength;

        iStatus = ENoMatch;

        }

    _AKNTRACE( "[%s][%s] iStatus: %d", "CAknMatchingCharacterQueue", 

                		__FUNCTION__,iStatus );

    _AKNTRACE_FUNC_EXIT;

    }

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

// CAknMatchingCharacterQueue::ValidateServiceNumber

// 

// Validates the service phone number.

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

//

TBool CAknMatchingCharacterQueue::ValidateServiceNumberL( const TDesC& aNumber )

    {

    _AKNTRACE_FUNC_ENTER;

	TBool isServiceNum = EFalse;

    HBufC* serviceNum = HBufC::NewLC( KAknEcsMaxMatchingLength );

    CRepository* cenRep = CRepository::NewLC( KCRUidAvkon );

    TPtr bufPtr = serviceNum->Des();

    if( cenRep->Get( KAknServiceCallNumber, bufPtr ) != KErrNone )

        {

        CleanupStack::PopAndDestroy( cenRep );

        CleanupStack::PopAndDestroy( serviceNum );

        return EFalse;

        }

    // Check if aNumber matches serviceNum

    if ( aNumber.Compare( *serviceNum ) == 0 )

        {

        isServiceNum = ETrue;

		}

    CleanupStack::PopAndDestroy( cenRep );

    CleanupStack::PopAndDestroy( serviceNum );

    _AKNTRACE_FUNC_EXIT;

    return isServiceNum;

    }

//

//

// Implementation of CAknEcsDetector

//  (Emergency Call Support Detector)

//

//

EXPORT_C CAknEcsDetector::CAknEcsDetector()

    {

    _AKNTRACE_FUNC_ENTER;

    iCoeEnv = CCoeEnv::Static();

    iState = ENotFullyConstructed;

    _AKNTRACE_FUNC_EXIT;

    }

EXPORT_C CAknEcsDetector::~CAknEcsDetector()

    {

    _AKNTRACE_FUNC_ENTER;

    // Must close this in order to remove any observers from the AppUi's monitor

    CloseEventSource();

    delete iPhCltEmergencyCall;

    delete iEmergencyCallObserver;

    delete iQueue;

    delete iIdler;

    delete iKeyTimeoutTimer;

    _AKNTRACE_FUNC_EXIT;

    }

EXPORT_C void CAknEcsDetector::ConstructL()

    {

    _AKNTRACE_FUNC_ENTER;

    iEmergencyCallObserver = new (ELeave) CPhCltEmergencyCallObserver( this );

    // Phone client interface

    //iPhCltEmergencyCall = CPhCltEmergencyCall::NewL( iEmergencyCallObserver );

    // Check if service call is allowed during device and key lock

    iServiceCallEnabled = 

        FeatureManager::FeatureSupported( KFeatureIdFfServiceCallWhilePhoneLocked );

    iQueue = new (ELeave) CAknMatchingCharacterQueue( iPhCltEmergencyCall, iServiceCallEnabled );

    iQueue->ConstructL();

    DetermineState();

    // Idler for delaying the change of state to Call Attempted

    iIdler = CIdle::NewL( CActive::EPriorityLow );

    // Timer for timing the timeout between keys

    iKeyTimeoutTimer = CPeriodic::NewL( CActive::EPriorityLow);

    _AKNTRACE_FUNC_EXIT;

    }

EXPORT_C CAknEcsDetector* CAknEcsDetector::NewL()

    { // static

    _AKNTRACE_FUNC_ENTER;

    CAknEcsDetector* self = new (ELeave) CAknEcsDetector();

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop(); //self

    _AKNTRACE_FUNC_EXIT;

    return self;

    }

EXPORT_C TBool CAknEcsDetector::ConnectToEventSource()

    {

    if ( iFlags.IsClear( EEventSourceConnected ) )

        {

        TRAPD( err, iAvkonAppUi->EventMonitor()->AddObserverL(this) );

        iFlags.Assign( EEventSourceConnected, ( err == KErrNone ) );

        return ( err == KErrNone );

        }

    else

        {

        return ETrue;

        }

    }

EXPORT_C void CAknEcsDetector::CloseEventSource()

    {

    if (iFlags.IsSet( EEventSourceConnected ) )

        {

        CAknWsEventMonitor* eventMonitor = iAvkonAppUi->EventMonitor();

        eventMonitor->RemoveObserver(this);

        iFlags.Clear( EEventSourceConnected );

        }

    }

EXPORT_C void CAknEcsDetector::HandleWsEventL(const TWsEvent& aEvent, CCoeControl* /* aDestination  */)

    {

    _AKNTRACE_FUNC_ENTER;

    _AKNTRACE( "[%s][%s] aEvent.type(): %d, aEvent.Key()->iScanCode :%d", "CAknEcsDetector", 

                            		__FUNCTION__,aEvent.Type(),aEvent.Key()->iScanCode );

    if ( aEvent.Type() == EEventKeyDown || 

        // EKeyPhoneEnd/EKeyNo doesn't send EEVentKeyDown events, so EEventKey is used instead

       ( ( aEvent.Key()->iScanCode == EStdKeyNo ) && ( aEvent.Type() == EEventKey ) ) )

        {

        AddChar( (TText)(aEvent.Key()->iScanCode ) ); // top 16 ( in Unicode build) bits removed

        }

    if ( iServiceCallEnabled )

        {

        // When Cancel is pressed we need to clear the queue

        if ( iState == EServiceNumMatch && aEvent.Type() == EEventPointer && 

        	   aEvent.Pointer()->iType == TPointerEvent::EButton1Down )

            {

            // Clear the queue, set state to EEmpty, and cancel any pending timeout

            Reset();

            iKeyTimeoutTimer->Cancel();

            }

        }

    _AKNTRACE_FUNC_EXIT;

    }

EXPORT_C void CAknEcsDetector::AddChar( TText aNewChar )

    {

    _AKNTRACE_FUNC_ENTER;

    _AKNTRACE( "[%s][%s] aNewChar: %s", "CAknEcsDetector", 

                                		__FUNCTION__, &aNewChar );

    if (aNewChar == EKeyQwertyOn || aNewChar == EKeyQwertyOff)