/*

* Copyright (c) 2007-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:  CSC Applicationīs AppUi

*

*/

#include <apgcli.h>

#include <AknDoc.h>

#include <eikclb.h>

#include <aknview.h>

#include <eikappui.h>

#include <cchclient.h>

#include <cmmanagerext.h>

#include <AknIconUtils.h>

#include <AknsConstants.h>

#include <cscsettingsui.h>

#include <xSPViewServices.h>

#include <AiwServiceHandler.h>

#include <mspnotifychangeobserver.h>

#include <gsfwviewuids.h>

#include <apgwgnam.h>

#include "cscappui.h"

#include "csclogger.h"

#include "cscdocument.h"

#include "cscconstants.h"

#include "cscserviceview.h"

#include "cscengcchhandler.h"

#include "cscengstartuphandler.h"

#include "cscengservicehandler.h"

#include "cscengbrandinghandler.h"

#include "cscengconnectionhandler.h"

#include "cscengservicepluginhandler.h"

#include "cscengdestinationshandler.h"

#include "cscenguiextensionpluginhandler.h"

const TInt KMaxParamLength = 255;

const TInt KGSChildAppWindowGroupNameLength = 100;

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

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

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

//

CCSCAppUi::CCSCAppUi()                         

    {

    }

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

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

//

void CCSCAppUi::ConstructL()

    {

    CSCDEBUG( "CCSCAppUi::ConstructL - begin" );

    BaseConstructL( 

        EAknEnableSkin | EAknEnableMSK | EAknSingleClickCompatible );

    iStartupHandler = CCSCEngStartupHandler::NewL();

    iServiceHandler = CCSCEngServiceHandler::NewL( this );

    iBrandingHandler = CCSCEngBrandingHandler::NewL();

    iCCHHandler = CCSCEngCCHHandler::NewL( *this );

    iConnectionHandler = CCSCEngConnectionHandler::NewL( *this );

    CCSCEngServicePluginHandler* servicePluginHandler = 

        CCSCEngServicePluginHandler::NewL( 

            *iEikonEnv, *this, *iServiceHandler );

    CleanupStack::PushL( servicePluginHandler );

    CCSCEngUiExtensionPluginHandler* uiExtensionPluginHandler = 

        CCSCEngUiExtensionPluginHandler::NewL( 

            *iEikonEnv, *this, *iStartupHandler );

    CleanupStack::Pop( servicePluginHandler );

    // Responsibility or Plugin Handlers are transferred to document,

    // because UI framework might make calls to ECom plugin after the

    // application UI is deleted. Case exists when Exit() is 

    // called from plugin.

    CCSCDocument* doc = static_cast< CCSCDocument* >( Document() );

    doc->SetOwnershipOfPluginHandlers( 

        servicePluginHandler, uiExtensionPluginHandler );

    TRAP_IGNORE(   

        servicePluginHandler->InitializePluginsL();

        uiExtensionPluginHandler->InitializePluginsL();

        );

    iServiceView = CCSCServiceView::NewL( 

        *servicePluginHandler, 

        *uiExtensionPluginHandler,

        *iStartupHandler,

        *iServiceHandler,

        *iBrandingHandler,

        *iCCHHandler );

    AddViewL( iServiceView );

    CSCDEBUG( "CCSCAppUi::ConstructL - end" );

    }

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

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

//

CCSCAppUi::~CCSCAppUi()

    {

    CSCDEBUG( "CCSCAppUi::~CCSCAppUi - begin" );

    delete iStartupHandler;

    delete iServiceHandler;

    delete iBrandingHandler;

    delete iCCHHandler;

    delete iConnectionHandler;

    CSCDEBUG( "CCSCAppUi::~CCSCAppUi - end" );

    }

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

// From class CEikAppUi

// For giving startup parameters to CSC application

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

//

TBool CCSCAppUi::ProcessCommandParametersL(

    TApaCommand /*aCommand*/,

    TFileName& aDocumentName,

    const TDesC8& /*aTail*/)

    {

    CSCDEBUG( "CCSCAppUi::ProcessCommandParametersL - begin" );

    if ( aDocumentName.Length() )

        {

        iStartupHandler->SetStartupParametersL( aDocumentName );

        if ( CCSCEngStartupHandler::EOpenSettingsUi == 

            iStartupHandler->GetParamAction() )

            {

            iServiceView->InitializeWithStartupParametersL();

            }

        }

    CSCDEBUG( "CCSCAppUi::ProcessCommandParametersL - end" );

    return EFalse;

    }

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

// From class CEikAppUi

// For giving startup parameters to CSC application

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

//

void CCSCAppUi::ProcessMessageL( TUid /* aUid */, const TDesC8 &aParams )

	{

	CSCDEBUG( "CCSCAppUi::ProcessMessageL - begin" );

	if ( aParams.Length() && ( aParams.Length() <= KMaxParamLength ) )

	    {

        TBuf<KMaxParamLength> params;

	    params.Copy( aParams );  

	    iStartupHandler->SetStartupParametersL( params );

	    iServiceView->InitializeWithStartupParametersL();

	    iServiceView->ExecuteStartupActionsL( EFalse, EFalse );

	    }

	CSCDEBUG( "CCSCAppUi::ProcessMessageL - end" );

	}

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

// From class CAknViewAppUi

// For command handling.

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

//

void CCSCAppUi::HandleCommandL( TInt aCommand ) 

    {

    CSCDEBUG( "CCSCAppUi::HandleCommandL - begin" );

    switch ( aCommand )

        {

        case EAknSoftkeyBack:

            {

            Exit();

            break;

            }

        case EEikCmdExit:

        case EAknSoftkeyExit:

        case EAknCmdExit:

            {

            ExitGSIfParentL();

            Exit();

            break;

            }

        default:

            break;

        }

    CSCDEBUG( "CCSCAppUi::HandleCommandL - end" );

    }

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

// From class CAknViewAppUi

// Handling changing of the skin and layout.

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

//

void CCSCAppUi::HandleResourceChangeL( TInt aType )

    {

    CSCDEBUG( "CCSCAppUi::HandleResourceChangeL" );

    CAknViewAppUi::HandleResourceChangeL( aType );

    }

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

// From class MCSCProvisioningObserver

// Notifies service plug-in event

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

//

void CCSCAppUi::NotifyServicePluginResponse( 

    const CCSCEngServicePluginHandler::TServicePluginResponse& aResponse, 

    const TInt aIndex, 

    const TUid& aPluginUid )

    {

    CSCDEBUG( "CCSCAppUi::NotifyServicePluginResponse - begin" );

    CCSCEngStartupHandler::TAction action = iStartupHandler->GetParamAction();

    TUid pluginUid = iStartupHandler->GetParamPluginUid();

    switch ( aResponse )

        {

        case CCSCEngServicePluginHandler::EPluginInitialized:

            {           

            // Run service configuration procedure, if new plugin is added

            // after service setup plugins has been initialized and plugin 

            // is set to be configured in startup parameters.

            if ( CCSCEngStartupHandler::EAddSetupPluginService == action &&

                aPluginUid == pluginUid )

                {       

                TRAP_IGNORE( 

                    TBool canceled ( EFalse );

                    canceled = iServiceView->HandleServiceConfigurationL( 

                                aPluginUid );

                    if ( canceled )

                        {

                        iServiceView->ExecuteStartupActionsL();

                        }

                    );

                } 

            else if ( iStartupHandler->StartedFromHomescreen() )

                {

                TRAP_IGNORE( iServiceView->HandleServiceConfigurationL( KNullUid ) );

                }

            break;

            }

        case CCSCEngServicePluginHandler::EPluginProvisioned:

            {

            CSCDEBUG( "CCSCAppUi::NotifyServicePluginResponse - plugin provisioned" );

            // shutdown csc (provisioned service plugin should open phonebook tab).

            RunAppShutter();

            break;

            }

        case CCSCEngServicePluginHandler::EPluginRemoved:

            {

            // Service removed. If application is started with statup

            // parameters, close application and retuns to application

            // installer. Otherwise dismiss wait note from the screen.

            if ( CCSCEngStartupHandler::ERemoveSetupPluginService == action &&

                KNullUid != pluginUid )

                {

                iServiceView->HideDialogWaitNote();

                RunAppShutter();

                }

            else

                {

                CCSCDocument* doc = 

                    static_cast< CCSCDocument* >( Document() );

                CCSCEngServicePluginHandler& handler = 

                    doc->ServicePluginHandler();

                TServicePluginInfo pluginInfo = 

                    handler.ItemFromPluginInfoArray( aIndex );

                CAknView* view = View( pluginInfo.iViewId );

                if( !view )

                    {

                    RemoveView( pluginInfo.iViewId );

                    }

                else

                    {

                    // nothing to do

                    }

                iServiceView->HideDialogWaitNote();

                }

            break;

            }

        case CCSCEngServicePluginHandler::EPluginError:

            {

            TRAP_IGNORE( iServiceView->ServiceConfiguringFailedL( aIndex ) );

            break;

            }

        case CCSCEngServicePluginHandler::EPluginModified:

        default:

             break;

        }

    CSCDEBUG( "CCSCAppUi::NotifyServicePluginResponse - end" );

    }

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

// From class MCSCUiExtensionObserver

// Notifies when configuring of service plug-in is done.

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

//

void CCSCAppUi::NotifyUiExtensionPluginResponse( 

    const CCSCEngUiExtensionPluginHandler::TUiExtensionPluginResponse& 

    aResponse, 

    const TInt /*aIndex*/, 

    const TUid& /*aPluginUid*/ )

    {

    CSCDEBUG( "CCSCAppUi::NotifyUiExtensionPluginResponse - begin" );

    switch ( aResponse )

        {

        case CCSCEngUiExtensionPluginHandler::EPluginExited:

            {

            TRAP_IGNORE( iServiceView->HandleUiExtensionExitL() );

            break;

            }

        case CCSCEngUiExtensionPluginHandler::EPluginError:

            {

            TRAP_IGNORE( ActivateLocalViewL( KCSCServiceViewId ) );

            break;

            }

        case CCSCEngUiExtensionPluginHandler::EPluginInitialized:

            // nothing to do

        default:

            break;

        }

    CSCDEBUG( "CCSCAppUi::NotifyUiExtensionPluginResponse - end" );

    }

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

// From class MCSCEngServiceObserver

// Notifies when service(s) have changed.

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

//

void CCSCAppUi::NotifyServiceChange()

    {

    CSCDEBUG( "CCSCAppUi::NotifyServiceChange - begin" );

    TVwsViewId activeViewId;

    GetActiveViewId( activeViewId );

    if( iServiceView && KCSCServiceViewId == activeViewId.iViewUid )

        {

        TRAP_IGNORE( iServiceView->UpdateServiceViewL() );

        }

    CSCDEBUG( "CCSCAppUi::NotifyServiceChange - end" );  

    }

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

// From class MCSCEngCCHObserver

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

//

void CCSCAppUi::ServiceStatusChanged(

    TUint aServiceId, 

    TCCHSubserviceType /*aType*/, 

    const TCchServiceStatus& aServiceStatus )

    {

    CSCDEBUG2( 

       "CCSCAppUi::ServiceStatusChanged - STATE=%d", aServiceStatus.State() );

    if ( ECCHDisabled == aServiceStatus.State() )

        {        

        TVwsViewId activeViewId;

        GetActiveViewId( activeViewId );

        if( iServiceView && KCSCServiceViewId == activeViewId.iViewUid )

            {            

            TRAPD( err, SnapCheckL( aServiceId ) );  

            if ( KErrInUse == err )

                {

                iMonitoredService = aServiceId;

                }

            else

                {

                TRAP_IGNORE( iServiceView->DeleteServiceL( aServiceId ) );

                }

            }

        }

    CSCDEBUG( "CCSCAppUi::ServiceStatusChanged - end" );

    }

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

// From class MCSCEngConnectionObserver

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

//

void CCSCAppUi::NotifyConnectionEvent( 

    CCSCEngConnectionHandler::TConnectionEvent aConnectionEvent )

    {

    CSCDEBUG( "CCSCAppUi::NotifyConnectionEvent - begin" );

    TVwsViewId activeViewId;

    GetActiveViewId( activeViewId );

    if( ( iServiceView && KCSCServiceViewId == activeViewId.iViewUid ) &&

        ( CCSCEngConnectionHandler::EEventConnectionDown == aConnectionEvent || 

          CCSCEngConnectionHandler::EEventTimedOut == aConnectionEvent ) )

        {        

        iConnectionHandler->StopListeningConnectionEvents();

        TRAP_IGNORE( iServiceView->DeleteServiceL( iMonitoredService ) );

        }

    CSCDEBUG( "CCSCAppUi::NotifyConnectionEvent - end" );

    }

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

// For checking if SNAP is still in use.

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

//

void CCSCAppUi::SnapCheckL( TUint aServiceId ) const

    {

    CSCDEBUG( "CCSCAppUi::SnapCheckL - begin" );  

    CCSCEngDestinationsHandler* destHandler =

        CCSCEngDestinationsHandler::NewL();

    CleanupStack::PushL( destHandler );

    TInt snapId( 0 );

    snapId = iServiceHandler->SnapIdL( aServiceId );

    if ( destHandler->IsSnapInUseL( snapId ) )

        {

        iConnectionHandler->StartListeningConnectionEvents();

        User::Leave( KErrInUse );

        }

    CleanupStack::PopAndDestroy( destHandler );

    CSCDEBUG( "CCSCAppUi::SnapCheckL - end" );  

    }

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

// Check if GS has to be closed

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

//

TBool CCSCAppUi::ExitGSIfParentL()

    {

    TBool ret = EFalse;

    RWsSession ws  = CEikonEnv::Static()->WsSession();

    TApaTaskList taskList( ws );

    TApaTask gstask = taskList.FindApp( KUidGS  );

    if ( gstask.Exists() )

        {

        TInt gswgid = gstask.WgId();

        RArray<RWsSession::TWindowGroupChainInfo> wgrp;

        ws.WindowGroupList( &wgrp );

        TInt i = 0;

        // Loop window groups, find GS's child app

        for ( i=0; i < wgrp.Count() ; ++i )

            {

            TBuf< KGSChildAppWindowGroupNameLength > name;

            ws.GetWindowGroupNameFromIdentifier( wgrp[i].iId , name );

            RWsSession::TWindowGroupChainInfo wginfo = wgrp[i];

            if ( wginfo.iParentId == gswgid ) // Child of GS found

                {

                CApaWindowGroupName* windowName1 =

                    CApaWindowGroupName::NewLC( ws, wginfo.iId ); // CS:1

                TUid embeddeeuid;

                embeddeeuid = windowName1->AppUid();

                // Check if CSC is the child of GS

                    {

                    ret = ETrue;

                    gstask.EndTask();

                    }

                CleanupStack::PopAndDestroy( windowName1 );  // CS:0

                }

            }

        wgrp.Close();

        }

    return ret;

    }