/*

* Copyright (c) 2005-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:  Application UI class implementation. 

*

*/

// INCLUDE FILES

#include <eikenv.h>

#include <coemain.h>

#include <coehelp.h>

#include <bacntf.h>

#include <starterclient.h>

#include <telinternalpskeys.h>

#include <activeidle2domainpskeys.h>

#include <telremotepartyinformationpskeys.h>

#include <telinformationpskeys.h>

#include <UikonInternalPSKeys.h>

#include <startupdomainpskeys.h>

#include <apgtask.h>

#include <apgwgnam.h>

#include <barsread.h>

#include <coemain.h>

#include <AknsConstants.h>   // KAknsMessageSkinChange

#include <bautils.h>

#include <StringLoader.h>

#include <aknnotewrappers.h> // for Notification for startup...

#include <eikbtgpc.h>

#include <eiksoftkeyimage.h> // EikSoftkeyImage

#include <featmgr.h>         // Feature Manager

#include <bldvariant.hrh>    // System variant definition

#include <phoneui.rsg>

#include "phoneui.pan"

#include "cphoneappui.h"

#include "cphoneapplication.h"

#include "cphonedocument.h"

#include "cphonekeys.h"

#include "cphoneview.h" // from PhoneUIView

#include "cphoneviewcontroller.h"

#include "cphoneuicontroller.h"

#include "cphonepubsubproxy.h"

#include "phonelogger.h"

#include "phoneconstants.h"

#include "cphoneclearblacklist.h"

#include "cphonestatuspane.h"

#include "tphonecmdparaminteger.h"

#ifndef __WINS__

#include <f32file.h>

#endif

// ================= MEMBER FUNCTIONS =======================

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

// CPhoneAppUI::CPhoneAppUI()

// Default constructor

// (other items were commented in a header).

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

//

CPhoneAppUI::CPhoneAppUI() : 

    iAppsReady( EPhoneStartupInitial )

    {            

    }

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

// CPhoneAppUI::~CPhoneAppUI()

// Destructor

// (other items were commented in a header).

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

//

CPhoneAppUI::~CPhoneAppUI()

    {

    __LOGMETHODSTARTEND(EPhoneControl, "CPhoneAppUI::~CPhoneAppUI() ");

    if ( iPhoneViewController )

        {

        RemoveFromStack( iPhoneViewController->PhoneView() );

        delete iPhoneViewController;

        }

    delete iPhoneUIController;

    CPhoneRecoverySystem::Remove( iStartupSignalRecoveryId );

    delete iEnvChangeNotifier;

    iEnvChangeNotifier = NULL;

    }

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

// CPhoneAppUI::ConstructL

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

//

void CPhoneAppUI::ConstructL()

    {

    __LOGMETHODSTARTEND(EPhoneControl, "CPhoneAppUI::ConstructL() ");

    // Requires the availability of CBA and Menubar resources

    BaseConstructL( EAknEnableSkin | EAknEnableMSK | EAknSingleClickCompatible );

    SetKeyEventFlags( CAknAppUiBase::EDisableSendKeyShort | CAknAppUiBase::EDisableSendKeyLong );

    // Item specific soft key IS DISABLED in order to make SK1 visible with easy dialing.

    CEikCba* cba = static_cast<CEikCba*>( CEikButtonGroupContainer::Current()->ButtonGroup() );

    cba->EnableItemSpecificSoftkey( EFalse );

    SetAliasKeyCodeResolverL( this );

    // Set phone application to be system application so it can't be closed

    iEikonEnv->SetSystem( ETrue );

    // Disable priority changes of window server and set

    // process priority (phone app might be on the background

    // and so it's priority might be low).

    iEikonEnv->WsSession().ComputeMode( 

        RWsSession::EPriorityControlDisabled ); 

    RThread().SetProcessPriority( EPriorityHigh  );

    // System enviroment change notifier.

    iEnvChangeNotifier = CEnvironmentChangeNotifier::NewL( 

        CActive::EPriorityStandard, TCallBack( HandleCallBackL, this ) );

    iEnvChangeNotifier->Start();

    iPhoneViewController = CPhoneViewController::NewL( ClientRect() );

    iPhoneUIController = CPhoneUIController::NewL( *iPhoneViewController );

    // Blacklist singleton is initialized here

    // return value is ignored since we do not require its services in this class

    CPhoneClearBlacklist::CreateL( 

        iEikonEnv->WsSession(), 

        *iPhoneViewController->PhoneView()->DrawableWindow() );

    RegisterViewL( *iPhoneViewController->PhoneView() );

    AddToStackL( iPhoneViewController->PhoneView(), ECoeStackPriorityDefault );

    const_cast<CEikAppUi*>( 

        iEikonEnv->EikAppUi() )->AddViewActivationObserverL( this );

    // Eikon server window group

    iEikonServerWgId = 

        iEikonEnv->WsSession().FindWindowGroupIdentifier( 0, KPhoneEikonServer );

    __ASSERT_ALWAYS( iEikonServerWgId != KErrNotFound, Panic( EPhoneUiNoWindowGroup ) );

    iEikonEnv->RootWin().EnableFocusChangeEvents(); 

    iEikonEnv->RootWin().EnableGroupChangeEvents();

    // CLI Name.

    TInt err = RProperty::Define( 

        KPSUidTelRemotePartyInformation,

        KTelCLIName,

        RProperty::EText,

        KPhoneReadPolicy,

        KPhoneWritePolicy );

    __PHONELOG1( 

        EBasic, 

        EPhonePhoneapp, 

        "CPhoneAppUI::ConstructL() - Define CLIName property (status=%d)", 

        err );

    // CLI Number.

    err = RProperty::Define( 

        KPSUidTelRemotePartyInformation,

        KTelCLINumber,

        RProperty::EText,

        KPhoneReadPolicy,

        KPhoneWritePolicy );

    __PHONELOG1( 

        EBasic, 

        EPhonePhoneapp, 

        "CPhoneAppUI::ConstructL() - Define CLINumber property (status=%d)", 

        err );

    // Define the top application system property

    err = RProperty::Define( 

        KPSUidUikon,

        KUikVideoCallTopApp,

        RProperty::EInt,

        KPhoneReadPolicy,

        KPhoneWritePolicy );

    __PHONELOG1( 

        EBasic, 

        EPhonePhoneapp, 

        "CPhoneAppUI::ConstructL() Define top application property (status=%d)", 

        err );

    // Startup event signalling

    // Define the telephony application system property 

     err = RProperty::Define( 

        KPSUidTelInformation,

        KTelPhoneUid,

        RProperty::EInt,

        KPhoneReadPolicy,

        KPhoneWritePolicy );  

// DefineNewPSKeys:

    // UID: KPSUidTelInternalInformation:

    err = RProperty::Define( 

        KPSUidTelInternalInformation,

        KTelRemotePartyContactInfo,

        RProperty::EByteArray,

        KPhoneReadPolicy,

        KPhoneWritePolicy );    

    // VT UID.

    err = RProperty::Define( 

        KPSUidTelInternalInformation,

        KTelVideoCallUid,

        RProperty::EInt,

        KPhoneReadPolicy,

        KPhoneWritePolicy );

    // TELINTERNALPSKEY CHANGE 

    // Move to AudioHandling

    // UID: KPSUidTelAudioPreference

    // Call Audio Routing

    err = RProperty::Define( 

        KPSUidTelAudioPreference, 

        KTelAudioOutput, 

        RProperty::EInt,

        KPhoneReadPolicyAlwaysPass,

        KPhoneWritePolicy );

    // UID: KPSUidNEInformation

    err = RProperty::Define( 

        KPSUidNEInformation, 

        KTelNumberEntryInfo, 

        RProperty::EInt,

        KPhoneReadPolicyAlwaysPass,

        KPhoneWritePolicy );

    __PHONELOG1( 

        EBasic, 

        EPhonePhoneapp, 

        "CPhoneAppUI::ConstructL() Define phone property (status=%d)", 

        err );

    // Add DoStartupSignalL to the recovery system 

    iStartupSignalRecoveryId = 

        CPhoneRecoverySystem::Instance()->AddL( 

            TCallBack( DoStartupSignalL, this ),

            CTeleRecoverySystem::EPhonePriorityHigh,

            CTeleRecoverySystem::EPhoneStateIdle );

    // Call DoStartupSignalL within recovery system

    const TInt startupState = CPhonePubSubProxy::Instance()->Value(

        KPSUidStartup,

        KPSGlobalSystemState );

    __PHONELOG1( 

        EBasic, 

        EPhonePhoneapp, 

        "CPhoneAppUI::ConstructL() StartupState value", 

        startupState );

    if ( startupState == ESwStateCriticalPhaseOK ||

        startupState == ESwStateEmergencyCallsOnly ||

        startupState == ESwStateNormalRfOn ||

        startupState == ESwStateNormalRfOff ||

        startupState == ESwStateNormalBTSap )

        {

        __PHONELOG( 

            EBasic, 

            EPhonePhoneapp, 

            "CPhoneAppUI::ConstructL() Notify Starter that phone is ready..." );

        CPhoneRecoverySystem::Instance()->RecoverNow(

            iStartupSignalRecoveryId, 

            CTeleRecoverySystem::EPhonePriorityHigh );

        }

    else

        {        

        __PHONELOG( 

            EBasic, 

            EPhonePhoneapp, 

            "CPhoneAppUI::ConstructL() Startup not ready yet. Start listening..." );            

        CPhonePubSubProxy::Instance()->NotifyChangeL(

            KPSUidStartup,

            KPSGlobalSystemState,

            this );

        }

    // THE VERY LAST STEP: DROP PRIORITY.

    RThread().SetPriority( EPriorityNormal );

    if ( err == KErrNone || err == KErrAlreadyExists )

        {

        // Indicate to the system that the Phone has been started

        CPhonePubSubProxy::Instance()->ChangePropertyValue(

            KPSUidTelInformation,

            KTelPhoneUid,

            KUidPhoneApplication.iUid );

        }

    // Update the Apps ready flag

    iAppsReady += EPhoneStartedUp;

    if ( FeatureManager::FeatureSupported( KFeatureIdOnScreenDialer ) )     

        {

        iOnScreenDialer = ETrue;   

        }

    __PHONELOG( EBasic, EPhonePhoneapp, "CPhoneAppUI::ConstructL() Phone started..." );

    __PHONELOG( EBasic, EPhonePhoneapp, "CPhoneAppUI::ConstructL() done..." );

    }

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

// CPhoneAppUI::DoStartupSignalL

//

// Callback function.

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

//

TInt CPhoneAppUI::DoStartupSignalL( TAny* aAny )

    {

    CPhoneAppUI* appUi =

        static_cast< CPhoneAppUI* >( aAny );

    return

        !appUi->iLightIdleReached ?

            appUi->DoStartupSignalIdleL() :

            appUi->DoStartupSignalSecurityL();

    }

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

// CPhoneAppUI::DoStartupSignalIdleL

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

//

TInt CPhoneAppUI::DoStartupSignalIdleL()

    {

    TBool idleReached = EFalse;

    // Check if Idle application has been started.

    const TInt idleUid = CPhonePubSubProxy::Instance()->Value(

            KPSUidAiInformation,

            KActiveIdleUid );

    if ( idleUid != 0 && idleUid != KErrNotFound )

        {

        // Idle application has already started

        if ( !( iAppsReady & EPhoneIdleStartedUp ) )

            {

            __PHONELOG1( EBasic, EPhonePhoneapp, "CPhoneAppUI::ConstructL() Idle App started (uid=%d)!", idleUid );

            iAppsReady += EPhoneIdleStartedUp;

            // Remove Phone application from Fast Swap Window.

            iPhoneViewController->SetHiddenL( ETrue );

            // Set Idle's UID to PubSub.

            CPhonePubSubProxy::Instance()->ChangePropertyValue(

                KPSUidUikon,

                KUikVideoCallTopApp,

                idleUid );

            }

        }

    else

        {

        CPhonePubSubProxy::Instance()->NotifyChangeL(

            KPSUidAiInformation,

            KActiveIdleUid,

            this );   

        }

    const TInt current = CPhonePubSubProxy::Instance()->Value(

        KPSUidStartup,

        KPSGlobalSystemState );

    __PHONELOG1( EBasic, EPhonePhoneapp, "CPhoneAppUI::DoStartupSignalIdleL() System state=%d", current );

    if ( current == ESwStateSelfTestOK ||

        current == ESwStateCriticalPhaseOK )

        {                       

        // Check that both the Phone and Idle applications are ready

        idleReached = ( iAppsReady & EPhoneStartedUp ) &&

             ( iAppsReady & EPhoneIdleStartedUp );

        if ( idleReached )

            {

            __PHONELOG( EBasic, EPhonePhoneapp, "CPhoneAppUI::DoStartupSignalIdleL() Phone and Idle apps have both been started" );

            CPhonePubSubProxy::Instance()->ChangePropertyValue(

                KPSUidStartup,

                KPSPhonePhase1Ok,

                EPhonePhase1Ok );

            }

        }

    else 

        {

        idleReached = ( iAppsReady & EPhoneIdleStartedUp ) && 

            ( current == ESwStateEmergencyCallsOnly ||

            current == ESwStateNormalRfOn ||

            current == ESwStateNormalRfOff ||

            current == ESwStateNormalBTSap );

        __PHONELOG1( EBasic, EPhonePhoneapp, "CPhoneAppUI::DoStartupSignalIdleL() System state is not at SelfTestOk. Idle reached anyway?=%d", idleReached );

        }

    if ( idleReached )

        {

        __PHONELOG( EBasic, EPhonePhoneapp, "CPhoneAppUI::DoStartupSignalIdleL() Idle reached!" );

        // Now err == KErrNone and it means that

        // we have succeeded in signalling.

        CPhoneRecoverySystem::Instance()->EnablePreconditionL();

        // Update the Phone light idle flag

        iLightIdleReached = ETrue;

        // Notify the UI controller that the phone is ready

        iPhoneUIController->HandlePhoneStartupL();

        }

    else 

        {

        __PHONELOG( EBasic, EPhonePhoneapp, "CPhoneAppUI::DoStartupSignalIdleL() Idle is not reached yet!" );

        // Idle has not been reached yet. Indicate to the recovery

        // system that this iteration has failed so that it will

        // try again at a later time.

        User::Leave( KErrNotReady );

        }

    return KErrNone;

    }

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

// CPhoneAppUI::DoStartupSignalSecurityL

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

//

TInt CPhoneAppUI::DoStartupSignalSecurityL()

    {

    TInt err = KErrNone;    

    return err;

    }

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

// CPhoneAppUI::HandlePropertyChangedL

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

//

void CPhoneAppUI::HandlePropertyChangedL( 

    const TUid& aCategory,

    const TUint aKey,

    const TInt aValue )

    {

    __LOGMETHODSTARTEND(EPhoneControl, "CPhoneAppUI::HandlePropertyChangedL( ) ");

    if ( aCategory == KPSUidAiInformation )

        {

        // Call state event

        if ( aKey == KActiveIdleUid )

            {

            __PHONELOG( EBasic, EPhonePhoneapp, "CPhoneAppUi::HandleChangeL() Idle event" );

            TInt idleUid = aValue;

            // If idle startup is ok.

            if ( idleUid != 0 )

                {

                // If idle startup is ok for the first time, then recover

                // the Start signal processing

                if ( !( iAppsReady & EPhoneIdleStartedUp ) )

                    {            

                    __PHONELOG( EBasic, EPhonePhoneapp, 

                        "CPhoneAppUI::HandlePropertyChangedL() Idle App started!" );

                    iAppsReady += EPhoneIdleStartedUp;

                    // Try to update the startup signal again

                    CPhoneRecoverySystem::Instance()->RecoverNow(

                        iStartupSignalRecoveryId, 

                        CTeleRecoverySystem::EPhonePriorityHigh );    

                    // Remove Phone application from Fast Swap Window.

                    iPhoneViewController->SetHiddenL( ETrue );

                    // Set Idle's UID to PubSub.

                    CPhonePubSubProxy::Instance()->ChangePropertyValue(

                        KPSUidUikon,

                        KUikVideoCallTopApp,

                        idleUid );

                    }

                }

            }

        }

    if ( aCategory == KPSUidStartup )

        {

        __PHONELOG( EBasic, EPhonePhoneapp, "CPhoneAppUi::HandleChangeL() Starter event" );

        const TInt startupState = CPhonePubSubProxy::Instance()->Value(

            KPSUidStartup,

            KPSGlobalSystemState );

        __PHONELOG1( EBasic, EPhonePhoneapp, "CPhoneAppUI::HandleChangeL() StartupState value", startupState );

        if ( startupState == ESwStateCriticalPhaseOK ||

            startupState == ESwStateEmergencyCallsOnly ||

            startupState == ESwStateNormalRfOn ||

            startupState == ESwStateNormalRfOff ||

            startupState == ESwStateNormalBTSap )

            {

            // Try to update the startup signal again

            CPhoneRecoverySystem::Instance()->RecoverNow(

                iStartupSignalRecoveryId, 

                CTeleRecoverySystem::EPhonePriorityHigh );    

            }

        }

    }

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

// CPhoneAppUI::HandleEnvironmentChangeL

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

//

void CPhoneAppUI::HandleEnvironmentChangeL( const TInt aChanges )

    {

    // Pass environment changes to the UI controller

    iPhoneUIController->HandleEnvironmentChangeL( aChanges );

    }

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

// CPhoneAppUI::HandleWsEventL

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

//

void CPhoneAppUI::HandleWsEventL( 

    const TWsEvent& aEvent,

    CCoeControl* aDestination )

    {

    __LOGMETHODSTARTEND( EPhoneControl, "CPhoneAppUI::HandleWsEventL" );

    // Only handle window server events if startup is finished