/*
* 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
                if ( KUidCSCApp == embeddeeuid )
                    {
                    ret = ETrue;
                    gstask.EndTask();
                    }
                CleanupStack::PopAndDestroy( windowName1 );  // CS:0
                }
            }
        wgrp.Close();
        }
    
    return ret;
    }

// ---------------------------------------------------------------------------
// Handle view change messages (e.g. from MeCo)
// ---------------------------------------------------------------------------
//
MCoeMessageObserver::TMessageResponse CCSCAppUi::HandleMessageL(
    TUint32 /*aClientHandleOfTargetWindowGroup*/, TUid aMessageUid,
    const TDesC8& aMessageParameters )
    {
    CSCDEBUG( "CCSCAppUi::HandleMessageL - begin" ); 

    MCoeMessageObserver::TMessageResponse ret = EMessageNotHandled;

    if ( TUid::Uid( KUidApaMessageSwitchOpenFileValue ) == aMessageUid &&
        aMessageParameters.Length() &&
        aMessageParameters.Length() <= KMaxParamLength )
        {
        TBuf<KMaxParamLength> params;
        params.Copy( aMessageParameters );  
        iStartupHandler->SetStartupParametersL( params );
            
        iServiceView->InitializeWithStartupParametersL();
        iServiceView->ExecuteStartupActionsL( EFalse, EFalse );
        
        ret = EMessageHandled;
        }

    CSCDEBUG( "CCSCAppUi::HandleMessageL - end" ); 
    return ret;
    }