/*

* 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:  Main view for Sensor plug-in.

*

*/

// INCLUDE FILES

#include <aknsettingpage.h>

#include <hlplch.h>             // For HlpLauncher

#include <bautils.h>

#include <featmgr.h>

#include <StringLoader.h>

#include <AknQueryDialog.h>

#include <aknnotedialog.h>

#include <aknradiobuttonsettingpage.h>

#include <gssensorpluginrsc.rsg>

#include <gsprivatepluginproviderids.h>

#include <gsfwviewuids.h>

#include <gscommon.hrh>

#include "gssensorplugin.h"

#include "gssensorplugincontainer.h"

#include "gssensorplugin.hrh"

#include "gssensorpluginlocalviewids.h"

#include "gssensorpluginmodel.h"

#include "gssensorplugin_debug.h"

// Local views

#include "gssensensorsview.h"

#include "gssentappingctrlview.h"

#include "gssenturnctrlview.h"

#include "gssenorientationview.h"

// LOCAL CONSTANTS AND MACROS

_LIT( KGSSensorPluginResourceFileName, "z:gssensorpluginrsc.rsc" );

// Panic

_LIT( KGSDoActivateError, "DoActivateL" );

// Child plugin count

const TInt KGSSenPluginCount = 10;

#include <gssenplugin.mbg>

#ifdef __SCALABLE_ICONS

// bitmap

_LIT( KGSSenPluginIconFileName, "\\resource\\apps\\gssenplugin.mif");

#else //__SCALABLE_ICONS

// svg file

_LIT( KGSSenPluginIconFileName, "\\resource\\apps\\gssenplugin.mbm");

#endif //__SCALABLE_ICONS

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

// CGSSensorPlugin::CGSSensorPlugin

// Constructor

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

//

CGSSensorPlugin::CGSSensorPlugin()

  : iResourceLoader( *iCoeEnv )

    {

    TRACE_( "[GSSensorPlugin] CGSSensorPlugin::CGSSensorPlugin()" );

    }

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

// CGSSensorPlugin::NewL

// Symbian OS default constructor

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

CGSSensorPlugin* CGSSensorPlugin::NewL( TAny* /*aInitParams*/ )

    {

    TRACE_( "[GSSensorPlugin] CGSSensorPlugin::NewL()" );

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

    CleanupStack::PushL( self );

    self->ConstructL();        

    CleanupStack::Pop( self );

    TRACE_( "[GSSensorPlugin] CGSSensorPlugin::NewL() - return" );

    return self;

    }

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

// CGSSensorPlugin::ConstructL

// Symbian OS two-phased constructor

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

void CGSSensorPlugin::ConstructL()

    {

    TRACE_( "[GSSensorPlugin] CGSSensorPlugin::ConstructL()" );

    FeatureManager::InitializeLibL();

    // Initialize the Model

    iModel = CGSSensorPluginModel::NewL();

    // assign view pointers to point to NULL.

    iTappingCtrlView = NULL;

    iTurningCtrlView = NULL;

    // Find the resource file

    TParse parse;

    parse.Set( KGSSensorPluginResourceFileName, 

               &KDC_RESOURCE_FILES_DIR, NULL );

    TFileName fileName( parse.FullName() );

    // Get language of resource file

    BaflUtils::NearestLanguageFile( iCoeEnv->FsSession(), fileName );

    // Open resource file

    iResourceLoader.OpenL( fileName );

    // Load extended plugins if any

    iPluginArray = new  ( ELeave ) CArrayPtrFlat<CGSPluginInterface>( KGSSenPluginCount );

    iPluginLoader = CGSPluginLoader::NewL( iAppUi );

    iPluginLoader->SetObserver( this );

    iPluginLoader->LoadAsyncL( KGSPluginInterfaceUid, Id(), iPluginArray );

    BaseConstructL( R_GS_SEN_VIEW );

    TRACE_( "[GSSensorPlugin] CGSSensorPlugin::ConstructL() - return" );

    }

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

// CGSSensorPlugin::~CGSSensorPlugin 

// Destructor

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

CGSSensorPlugin::~CGSSensorPlugin()

    {

    TRACE_( "[GSSensorPlugin] CGSSensorPlugin::~CGSSensorPlugin()" );

    FeatureManager::UnInitializeLib();

    // close resource loader

    iResourceLoader.Close();

    // delete Model

    if ( iModel )

        {

        delete iModel;

        }

    // Delete plugin loader

    if ( iPluginLoader )

        {

        delete iPluginLoader;

        }

    // Delete possible plugins

    if ( iPluginArray )

        {

        // Since the plugins are actually avkon views, avkon is responsible

        // for owning the plugins. This means we do not reset and destroy

        // the contents of the array in which the plugins reside. We have to

        // leave it up to avkon to tidy up.

        delete iPluginArray;

        }

    TRACE_( "[GSSensorPlugin] CGSSensorPlugin::~CGSSensorPlugin() - return" );

    }

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

// TUid CGSSensorPlugin::Id

// Returns plug-in's ID.

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

TUid CGSSensorPlugin::Id() const

    {

    TRACE_1( "[GSSensorPlugin] CGSSensorPlugin::Id() - ID: %i", KGSSensorPluginUid );

    return KGSSensorPluginUid;

    }

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

// CGSSensorPlugin::HandleCommandL 

// Handles commands directed to this class.

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

void CGSSensorPlugin::HandleCommandL( TInt aCommand )

    {

    TRACE_1( "[GSSensorPlugin] CGSSensorPlugin::HandleCommandL() - command: %i", aCommand );

    switch ( aCommand )

        {

        case EGSSenMskGeneral:  // MSK, this is either 'Change' or 'Open'

        case EGSSenMenuOpen:    // 'Open' from options menu

            {

            SelectLocalViewL();

            break;

            }

        case EGSSenMenuChange:  // 'Change' from options menu

            {

            TInt current = iModel->SensorActiveStatusL();

            CDesCArrayFlat* items =

				iCoeEnv->ReadDesC16ArrayResourceL( R_GS_SENSOR_ACTIVE_STATUS );

			CleanupStack::PushL( items );

			CAknRadioButtonSettingPage* dlg =

				new ( ELeave ) CAknRadioButtonSettingPage(

					R_GS_SENSOR_ACTIVE_STATUS_SETTING_PAGE,

					current,

					items );

			if ( dlg->ExecuteLD( CAknSettingPage::EUpdateWhenChanged ) )

				{

				iModel->SetSensorActiveStatusL( current );

				UpdateListBoxL( EGSSensorsListItemId );

				}

		    CleanupStack::PopAndDestroy( items );

            break;

            }

        case EAknSoftkeyBack:

            // remove views

            RemoveLocalViews();

            // check exit status

            CheckExitStatusL();

            // Activate parent plugin

            iAppUi->ActivateLocalViewL( KGSGenPluginUid );

            break;

        case EAknCmdHelp:

            {

            if ( FeatureManager::FeatureSupported( KFeatureIdHelp ) )

                {

                HlpLauncher::LaunchHelpApplicationL(

                    iEikonEnv->WsSession(), iAppUi->AppHelpContextL() );

                }

            break;

            }

        case EGSSenMenuExit:

            {

            CheckExitStatusL();

            }

        default:

            iAppUi->HandleCommandL( aCommand );

            break;

        }

    TRACE_( "[GSSensorPlugin] CGSSensorPlugin::HandleCommandL() - return" );

    }

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

// CGSSensorPlugin::CheckExitStatusL

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

//

void CGSSensorPlugin::CheckExitStatusL()

    {

    TRACE_( "[GSSensorPlugin] CGSSensorPlugin::CheckExitStatusL()" );

    // Check were there changes

    if ( iModel->ChangesMade() )

        {

        const TBool sensorStatus( iModel->SensorActiveStatusL() );

        const TBool settingsExists( iModel->SettingsExistsL() );

        // Check should we show dialog, note or neither

        if ( !sensorStatus && settingsExists )

            {

            // Query to turn sensors on

            CAknQueryDialog* dialog = CAknQueryDialog::NewL();

            dialog->PrepareLC( R_GS_SEN_CONFIRM_YES_NO_QUERY );

            TInt ret = dialog->RunLD();

            if ( ret == EAknSoftkeyYes )

                {

                // Set sensor status to active

                iModel->SetSensorActiveStatusL( ETrue );

                }

            }

        else if ( sensorStatus && !settingsExists )

            {

            // Set sensors off, as there are no sensor settings...

            iModel->SetSensorActiveStatusL( EFalse );

            // ...and inform user

            CAknNoteDialog* note = new ( ELeave ) CAknNoteDialog(

                REINTERPRET_CAST( CEikDialog**, &note ),

                CAknNoteDialog::ENoTone,

                CAknNoteDialog::ELongTimeout );

            note->PrepareLC( R_GS_SEN_INFORMATION_NOTE );

            note->RunLD(); // note will delete itself

            }

        else

            {

            // Everyting is OK, no need for actions

            }

        }

    TRACE_( "[GSSensorPlugin] CGSSensorPlugin::CheckExitStatusL() - return" );

    }

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

// CGSSensorPlugin::DynInitMenuPaneL

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

//

void CGSSensorPlugin::DynInitMenuPaneL( TInt aResourceId, CEikMenuPane* aMenuPane )

    {

    TRACE_( "[GSSensorPlugin] CGSSensorPlugin::Container()" );

    // Check resource

    if ( R_GS_SEN_MENU_ITEM_OPEN == aResourceId )

        {

        // First, resolve current item in listbox

        const TInt currentItem = Container()->CurrentFeatureId();

        if ( EGSSensorsListItemId == currentItem )

            {

            // Hide menu item 'Open'

            aMenuPane->SetItemDimmed( EGSSenMenuOpen, ETrue );

            aMenuPane->SetItemDimmed( EGSSenMenuChange, EFalse );

            }

        else

            {

            // Hide menu item 'Change'

            aMenuPane->SetItemDimmed( EGSSenMenuChange, ETrue );

            aMenuPane->SetItemDimmed( EGSSenMenuOpen, EFalse );

            }

        }

    // Forward to base class

    CGSBaseView::DynInitMenuPaneL( aResourceId, aMenuPane );

    TRACE_( "[GSSensorPlugin] CGSSensorPlugin::Container() - return" );

    }

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

// CGSSensorPlugin::UpdateListBoxL

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

//

void CGSSensorPlugin::UpdateListBoxL( TInt aItemId )

    {

    TRACE_1( "[GSSensorPlugin] CGSSensorPlugin::UpdateListBoxL() - item: %i", aItemId );

    Container()->UpdateListBoxL( aItemId );

    TRACE_( "[GSSensorPlugin] CGSSensorPlugin::UpdateListBoxL() - return" );

    }

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

// CGSSensorPlugin::Container

// Return handle to container class.

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

//

CGSSensorPluginContainer* CGSSensorPlugin::Container()

    {

    TRACE_( "[GSSensorPlugin] CGSSensorPlugin::Container()" );

    return static_cast<CGSSensorPluginContainer*>( iContainer );

    }

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

// CGSSensorPlugin::NewContainerL

// Creates new iContainer.

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

//

void CGSSensorPlugin::NewContainerL()

    {

    TRACE_( "[GSSensorPlugin] CGSSensorPlugin::NewContainerL()" );

    // container takes a CGSSensorPluginModel pointer

    iContainer = new( ELeave ) CGSSensorPluginContainer( iModel, *this );

    TRACE_( "[GSSensorPlugin] CGSSensorPlugin::NewContainerL() - return" );

    }

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

// CGSSensorPlugin::DoActivateL

// First method called by the Avkon framwork to invoke a view.

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

//

void CGSSensorPlugin::DoActivateL( const TVwsViewId& aPrevViewId,

                                    TUid aCustomMessageId,

                                    const TDesC8& aCustomMessage )

    {

    TRACE_( "[GSSensorPlugin] CGSSensorPlugin::DoActivateL()" );

    CGSBaseView::DoActivateL( aPrevViewId, aCustomMessageId, aCustomMessage );

    // Update MSK label

    CheckMiddleSoftkeyLabelL();

    TRACE_( "[GSSensorPlugin] CGSSensorPlugin::DoActivateL() - return" );

    }

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

// CGSSensorPlugin::DoDeactivate

// Called by the Avkon view framework when closing.

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

//

void CGSSensorPlugin::DoDeactivate()

    {

    TRACE_( "[GSSensorPlugin] CGSSensorPlugin::DoDeactivateL()" );

    // Deactivate view

    CGSBaseView::DoDeactivate();

    TRACE_( "[GSSensorPlugin] CGSSensorPlugin::DoDeactivateL() - return" );

    }

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

// CGSSensorPlugin::HandleListBoxSelectionL

// Handles events raised through a rocker key

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

void CGSSensorPlugin::HandleListBoxSelectionL()

    {

    TRACE_( "[GSSensorPlugin] CGSSensorPlugin::HandleListBoxSelectionL()" );

    SelectLocalViewL();

    TRACE_( "[GSSensorPlugin] CGSSensorPlugin::HandleListBoxSelectionL() - return" );

    }

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

// CGSSensorPlugin::SelectLocalViewL

// Selects a particular local view

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

void CGSSensorPlugin:: SelectLocalViewL()

    {

    TRACE_( "[GSSensorPlugin] CGSSensorPlugin::SelectLocalViewL()" );

    const TInt currentFeatureId = Container()->CurrentFeatureId();

    switch ( currentFeatureId )

        {

        case EGSSensorsListItemId:

            ChangeSensorActiveSettingL();

            break;

        case EGSTapCtrlListItemId:

            CreateLocalViewL( KSenTapCtrlViewId );

            break;

        case EGSTurnCtrlListItemId:

            CreateLocalViewL( KSenTurnCtrlViewId );

            break;

        default:

            {

            // Not local view, try plugins

            CGSPluginInterface* selectedPlugin( Container()->SelectedPluginL() );

            switch( selectedPlugin->ItemType() )

                {

                // In these cases the plugin is a view:

                case EGSItemTypeSingleLarge:

                case EGSItemTypeSetting:

                case EGSItemTypeSettingIcon:

                    {

                    CleanupStack::PushL( selectedPlugin );

                    iAppUi->ActivateLocalViewL( selectedPlugin->Id() );

                    CleanupStack::Pop( selectedPlugin );

                    break;

                    }

                // In these cases the plugin is a dialog:

                case EGSItemTypeSettingDialog:

                case EGSItemTypeSingleLargeDialog:

                     selectedPlugin->HandleSelection( EGSSelectionByMenu );

                     break;

                default:

                    break;

                }

            break;

            }

        }

    TRACE_( "[GSSensorPlugin] CGSSensorPlugin::SelectLocalViewL() - return" );

    }

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

// CGSSensorPlugin::ProcessCommandL

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

void CGSSensorPlugin::ProcessCommandL( TInt aCommand )

    {

    TRACE_1( "[GSSensorPlugin] CGSSensorPlugin::ProcessCommandL() - command: %i", aCommand );

    // Call base class

    CAknView::ProcessCommandL( aCommand );

    TRACE_( "[GSSensorPlugin] CGSSensorPlugin::ProcessCommandL() - return" );

    }

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

// CGSSensorPlugin::RemoveLocalViews

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

//

void CGSSensorPlugin::RemoveLocalViews()

    {

    TRACE_( "[GSSensorPlugin] CGSSensorPlugin::RemoveLocalViews()" );

    // Remove view from iAppUi -> View is deleted by iAppUi automatically.

    if ( iTappingCtrlView )

        {

        // Also deletes view.

        iAppUi->RemoveView( KSenTapCtrlViewId );

        iTappingCtrlView = NULL;

        }

    if ( iTurningCtrlView )

        {

        // Also deletes view.

        iAppUi->RemoveView( KSenTurnCtrlViewId );

        iTurningCtrlView = NULL;

        }

    TRACE_( "[GSSensorPlugin] CGSSensorPlugin::RemoveLocalViews() - return" );

    }

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

// CGSSensorPlugin::CreateLocalViewL

// Initializes local views within this plug-in based on the view ID.

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

void CGSSensorPlugin::CreateLocalViewL( TUid aLocalViewId )

    {

    TRACE_1( "[GSSensorPlugin] CGSSensorPlugin::CreateLocalViewL() - view: %i", aLocalViewId );

    // Check if the view exists. If view does not exist:

    // 1. Create the view

    // 2. Add view to iAppUi -> iAppUi takes the view ownership.

    //

    if ( aLocalViewId == KSenTapCtrlViewId && !iTappingCtrlView )

        {

        iTappingCtrlView = CGSSenTappingCtrlView::NewL( iModel );

        iAppUi->AddViewL( iTappingCtrlView );

        }

    else if ( aLocalViewId == KSenTurnCtrlViewId && !iTurningCtrlView )

        {

        iTurningCtrlView = CGSSenTurnCtrlView::NewL( iModel );

        iAppUi->AddViewL( iTurningCtrlView );

        }

    else

        {

        // View is already created

        TRACE_( "[GSSensorPlugin] CGSSensorPlugin::CreateLocalViewL() - View already exists" );

        }

    iAppUi->ActivateLocalViewL( aLocalViewId );

    TRACE_( "[GSSensorPlugin] CGSSensorPlugin::CreateLocalViewL() - return" );

    }

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

// CGSSensorPlugin::GetCaption

// Return application/view caption.

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

//