/*

* 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 Service View´s Container

*

*/

#include <fbs.h>

#include <csc.mbg>

#include <csc.rsg>

#include <e32std.h>

#include <aknapp.h>

#include <gulicon.h>

#include <eikclbd.h>

#include <aknlists.h>

#include <pathinfo.h>

#include <coecntrl.h>

#include <AknsUtils.h>

#include <cchclient.h>

#include <csc.hlp.hrh>

#include <akncontext.h>

#include <AknIconArray.h>

#include <StringLoader.h>

#include <aknViewAppUi.h>

#include <AiwServiceHandler.h>

#include <mspnotifychangeobserver.h>

#include <data_caging_path_literals.hrh>

#include <cscengsettingscleanupplugininterface.h>

#include "mcscservicecontainerobserver.h"

#include "csclogger.h"

#include "cscdialog.h"

#include "cscconstants.h"

#include "cscapplication.h"

#include "cscnoteutilities.h"

#include "cscengcchhandler.h"

#include "cscservicecontainer.h"

#include "cscengservicehandler.h"

#include "cscengbrandinghandler.h"

#include "cscengservicepluginhandler.h"

#include "cscenguiextensionpluginhandler.h"

const TUint KServiceListItemTextMaxLength = 64;

const TUint KMaxUiExetnsionNameLength = 64;

// Format of the list item string.

_LIT( KServiceListItemTextFormat, "%d\t%S\t" );

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

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

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

//

CCSCServiceContainer::CCSCServiceContainer( 

    MCSCServiceContainerObserver& aContainerObserver,

    CCSCEngServicePluginHandler& aServicePluginHandler,

    CCSCEngUiExtensionPluginHandler& aUiExtensionPluginHandler,

    CCSCEngServiceHandler& aServiceHandler,

    CCSCEngBrandingHandler& aBrandingHandler,

    CCSCEngCCHHandler& aCCHHandler ):

    iContainerObserver( aContainerObserver ),

    iServicePluginHandler( aServicePluginHandler ),

    iUiExtensionPluginHandler( aUiExtensionPluginHandler ),

    iServiceHandler( aServiceHandler ),

    iBrandingHandler( aBrandingHandler ),

    iCCHHandler( aCCHHandler )

    {

    }

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

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

//

void CCSCServiceContainer::ConstructL( const TRect& aRect )

    {

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

    CreateWindowL(); 

    iDialog = CCSCDialog::NewL();

    iListBox = new (ELeave) CAknDouble2LargeStyleListBox;

    iListBox->SetContainerWindowL( *this );

    iListBox->ConstructL( this, EAknGenericListBoxFlags );

    iListBox->HideSecondRow( ETrue );

    iListBox->Model()->SetOwnershipType( ELbmOwnsItemArray );

    HBufC* emptyTxt = StringLoader::LoadLC( R_QTN_CSC_NO_SERVICES_INSTALLED );

    iListBox->View()->SetListEmptyTextL( *emptyTxt );

    CleanupStack::PopAndDestroy( emptyTxt );

    iListBox->CreateScrollBarFrameL( ETrue );

    iListBox->ScrollBarFrame()->SetScrollBarVisibilityL(

                                                 CEikScrollBarFrame::EOff,

                                                 CEikScrollBarFrame::EAuto );

    CTextListBoxModel* model = iListBox->Model();

    MDesCArray* textArray = model->ItemTextArray();

    iListBoxItems = static_cast<CDesCArray*>( textArray );

    iEikMenuBar = new ( ELeave ) CEikMenuBar();

    iEikMenuBar->ConstructL( this, NULL, R_CSC_SERVICEVIEW_MENUBAR );

    SetRect( aRect );

    UpdateServiceViewL();

    ActivateL();

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

    }

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

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

//

CCSCServiceContainer* CCSCServiceContainer::NewL( 

    const TRect& aRect,

    MCSCServiceContainerObserver& aContainerObserver,

    CCSCEngServicePluginHandler& aServicePluginHandler,

    CCSCEngUiExtensionPluginHandler& aUiExtensionPluginHandler,

    CCSCEngServiceHandler& aServiceHandler,

    CCSCEngBrandingHandler& aBrandingHandler,

    CCSCEngCCHHandler& aCCHHandler )

    {

    CCSCServiceContainer* self = 

        new ( ELeave ) CCSCServiceContainer( 

            aContainerObserver,

            aServicePluginHandler, 

            aUiExtensionPluginHandler,

            aServiceHandler,

            aBrandingHandler,

            aCCHHandler );

    CleanupStack::PushL( self );

    self->ConstructL( aRect );

    CleanupStack::Pop( self );

    return self;

    }

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

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

//

CCSCServiceContainer::~CCSCServiceContainer()

    {

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

    delete iDialog;        

    delete iArray;   

    delete iListBox;    

    delete iEikMenuBar;

    iListBoxItemArray.Reset();

    iListBoxItemArray.Close();

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

    }

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

// Updates services to listbox.

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

//

void CCSCServiceContainer::UpdateServiceViewL()

    {

    CSCDEBUG( "CCSCServiceContainer::UpdateServiceViewL - begin" );

    TInt currentItemIndex = CurrentItemIndex();

    // Reset listbox items and item array

    iListBoxItems->Reset();

    iListBoxItemArray.Reset();

    // Find and add Ui Extension Plug-ins

    iUiExtensionCount = iUiExtensionPluginHandler.PluginCount();

    // Create icon array or cleanup iconarray if it already exists

    CArrayPtr<CGulIcon>* iconArray =  

        iListBox->ItemDrawer()->ColumnData()->IconArray();

    if ( !iconArray )

        {

        iconArray = new( ELeave ) CAknIconArray( 1 );

         // Set icon array for ListBox.

        iListBox->ItemDrawer()->ColumnData()->SetIconArray( iconArray );

        }

    else

        {

        iconArray->ResetAndDestroy();

        }

    // move add new service plugin to top

    RArray<TUiExtensionPluginInfo> uiPlugins;

    CleanupClosePushL( uiPlugins );

    for( TInt i = 0; i < iUiExtensionCount; i++ )

        {

        TUiExtensionPluginInfo uiExtension = 

            iUiExtensionPluginHandler.ItemFromPluginInfoArray( i );

        if ( KAccountCreationPluginUID == uiExtension.iPluginsUid )

            {

            uiPlugins.InsertL( uiExtension, 0 );

            }

        else

            {

            uiPlugins.AppendL( uiExtension );

            }

        }

    const TInt itemHeight( iListBox->ItemHeight() );

    TInt iconSize( KIconSizeQvgaPortrait ); // Default icon size (QVGA portrait).

    if ( KItemHeightQvgaLandscape == itemHeight ) // QVGA landscape

        {

        iconSize = KIconSizeQvgaLandscape;

        }

    for ( TUint i( 0 ) ; i < iUiExtensionCount ; i++ )

        {

        TUiExtensionPluginInfo uiExtension = uiPlugins[i];

        if ( 0 == uiExtension.iPlace )

            {                        

            TBuf<KMaxUiExetnsionNameLength> extensionName;

            extensionName.Copy( uiExtension.iUiExtensionName );

            // To keep track which kind of listbox items we have

            TListBoxItem listBoxItem;

            listBoxItem.iItemType = TListBoxItem::EUiExtension;

            listBoxItem.iPluginUid = uiExtension.iPluginsUid;

            iListBoxItemArray.Append( listBoxItem );

            // Set icon for ui extension

            SetIconL( listBoxItem, iconArray, iconSize );

            TBuf<KServiceListItemTextMaxLength> listBoxItemText;          

            listBoxItemText.Format(

                KServiceListItemTextFormat,

                iconArray->Count() - 1,

                &extensionName );

            iListBoxItems->AppendL( listBoxItemText );

            }

        }

    CleanupStack::PopAndDestroy( &uiPlugins );

    // Get services  

    RArray<TUint> serviceIds;

    CleanupClosePushL( serviceIds );

    TRAPD( err, iServiceHandler.GetAllServiceIdsL( serviceIds ) );

    for ( TInt i(0) ; i < serviceIds.Count() && !err ; i++ )

        {                

        // Check service validity from cch before adding to listbox

        if ( iCCHHandler.IsServiceValidL( serviceIds[ i ] ) )

            {

            TBuf<KServiceListItemTextMaxLength> listBoxItemText;          

            HBufC* serviceString = NULL;

            serviceString = StringLoader::LoadLC( 

                R_QTN_CSC_SERVICE_LISTBOX_ITEM, 

                iServiceHandler.ServiceNameL( serviceIds[ i ] ) );

            // To keep track which kind of listbox items we have

            TListBoxItem listBoxItem;

            listBoxItem.iServiceId = serviceIds[ i ];

            // Set icon for service

            SetIconL( listBoxItem, iconArray, iconSize );

            listBoxItemText.Format(

                KServiceListItemTextFormat,

                iconArray->Count() - 1,

                serviceString );

            iListBoxItems->AppendL( listBoxItemText );    

            TInt32 servicePluginId( 0 );

            TInt err2( KErrNone );

            // Find service plug-in id if service has one

            TRAP( 

                err2, servicePluginId = 

                iServiceHandler.ServiceSetupPluginIdL( serviceIds[ i ] ) );

            if ( !err2 && servicePluginId )

                {            

                listBoxItem.iItemType = TListBoxItem::EServicePlugin;

                listBoxItem.iPluginUid.iUid = servicePluginId;

                }

            else if ( KErrNotFound == err2 )

                {

                listBoxItem.iItemType = TListBoxItem::EGeneralService;

                }

            iListBoxItemArray.Append( listBoxItem );    

            CleanupStack::PopAndDestroy( serviceString );   

            }

        }

    CleanupStack::PopAndDestroy( &serviceIds );  

    UpdateListboxL();

    if( iListBoxItemArray.Count() > 0 )

    	{

        if ( 0 <= currentItemIndex && 

           ( iListBoxItemArray.Count() > currentItemIndex  ) )

            {

            iListBox->SetCurrentItemIndexAndDraw( currentItemIndex );

            }

        else

            {

            iListBox->SetCurrentItemIndexAndDraw( 0 );

            }

    	}

    CSCDEBUG( "CCSCServiceContainer::UpdateSerUpdateServiceViewL - end" );

    }

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

// Update listbox. Handle item addition and drawing.

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

//

void CCSCServiceContainer::UpdateListboxL()

    {

    CSCDEBUG( "CCSCServiceContainer::UpdateListboxL - begin" );

    iListBox->HandleItemAdditionL(); 

    CSCDEBUG( "CCSCServiceContainer::UpdateListboxL - end" );

    }

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

// Returns current item index of listbox.

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

//

TInt CCSCServiceContainer::CurrentItemIndex() const

    {

    CSCDEBUG2( 

    "CCSCServiceContainer::CurrentItemIndex:%d",iListBox->CurrentItemIndex());

    return iListBox->CurrentItemIndex();

    }

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

// Returns currently selected list box item.

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

//

TListBoxItem CCSCServiceContainer::ListBoxItem()

    {    

    return iListBoxItemArray[ CurrentItemIndex() ];

    }

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

// Returns reference to listbox.

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

//

CAknDouble2LargeStyleListBox& CCSCServiceContainer::ListBox()

    {    

    return *iListBox;

    }

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

// Returns pen down point.

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

//

TPoint CCSCServiceContainer::PenDownPoint()

    {

    return iPenDownPoint;

    }

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

// Returns service count.

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

//

TInt CCSCServiceContainer::ServiceCount()

    {

    TUint serviceCount( 0 );

    for ( TInt i ( 0 ) ; i < iListBoxItemArray.Count() ; i++ )

        {

        //Add count if list box item type is general service or service plugin

        if ( 

            TListBoxItem::EGeneralService == iListBoxItemArray[i].iItemType ||

            TListBoxItem::EServicePlugin == iListBoxItemArray[i].iItemType )

            {

            serviceCount++;

            }

        }

    return serviceCount;

    }

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

// Set current item index.

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

//

void CCSCServiceContainer::SetCurrentIndex( TInt aIndex )

    {

    CSCDEBUG2( "CCSCServiceContainer::SetCurrentIndex: aIndex=%d", aIndex );

    if( ( aIndex < iListBoxItemArray.Count() ) && ( aIndex >= 0 ) )

        {

        iListBox->SetCurrentItemIndex( aIndex );

        }

    else

        {

        iListBox->SetCurrentItemIndex( 0 );

        }

    }

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

// Deletes service.

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

//

void CCSCServiceContainer::DeleteServiceL()

    {

    CSCDEBUG( "CCSCServiceContainer::DeleteServiceL - begin" );

    if (  iListBoxItemArray.Count() )

        {

        TListBoxItem item = ListBoxItem();

        TBool  disabled = iCCHHandler.IsServiceDisabled( item.iServiceId );

        // if enabled -> show unable to delete note

        if ( !disabled )

            {

            CCSCNoteUtilities::ShowInformationNoteL( 

                CCSCNoteUtilities::ECSCUnableToDeleteNote,

                    iServiceHandler.ServiceNameL( item.iServiceId ) );

            return;

            }

        // Show confirmation query for service deletion                        

        if ( CCSCNoteUtilities::ShowCommonQueryL( 

            CCSCNoteUtilities::ECSCDeleteServiceQuery, 

            iServiceHandler.ServiceNameL( item.iServiceId ) ) )

            {

            // First check if there is a service plugin UID.

            TInt count = iServicePluginHandler.PluginCount( 

                CCSCEngServicePluginHandler::EInitialized );

            TBool setupPlugin( EFalse );

            for ( TInt i = 0; i < count && !setupPlugin; i++ )

                 {

                 TServicePluginInfo pluginInfo = 

                     iServicePluginHandler.ItemFromPluginInfoArray( i );

                 if ( pluginInfo.iPluginsUid == item.iPluginUid )

                     {

                     CSCDEBUG2( "   DeleteServiceL - plugin UID match found: %d",

                         item.iPluginUid );

                     setupPlugin = ETrue;

                     }

                 }

            if ( setupPlugin )

                {

                HandleServicePluginRemovationL( item.iPluginUid );

                }

            else

                {

                TRAPD( err, LaunchCleanupPluginL( item.iServiceId ) );

                if ( KErrNone != err )

                    {

                    iServiceHandler.DeleteServiceL( item.iServiceId );

                    }

                }

            }

        }

    CSCDEBUG( "CCSCServiceContainer::DeleteServiceL - end" );

    }

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

// Handles service plugin removation.

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

//

void CCSCServiceContainer::HandleServicePluginRemovationL( const TUid& aUid )

    {

    CSCDEBUG( 

         "CCSCServiceContainer::HandleServicePluginRemovationL - begin" );  

    TUint serviceId( 0 );   

    ResolveServiceIdL( aUid, serviceId );

    if ( !serviceId )

        {

        User::Leave( KErrNotFound );

        }

    TBool disabled = iCCHHandler.IsServiceDisabled( serviceId );

    // If service is not disabled, try to disable it

    if ( !disabled )

        {

        iDialog->LaunchWaitNoteL( R_QTN_CSC_REMOVING_SERVICE );

        User::LeaveIfError( iCCHHandler.DisableService( serviceId ) );

        return;

        } 

    // Remove service plugin

    TInt error( KErrNone );

    TRAP( error, iServicePluginHandler.DoRemovationL( aUid, EFalse ) );

    // If error, remove remainging setting by cleanupplugin

    if ( error )

        {

        error = KErrNone;

        TRAP( error, LaunchCleanupPluginL( serviceId ) );