/*

* Copyright (c) 2005-2009 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:  This the implementation of the view class

*

*/

// INCLUDE FILES

#include <aknradiobuttonsettingpage.h>

#include <akntitle.h>

#include <bautils.h>         // BAFL utils (for language file)

#include <StringLoader.h> 

#include <usbui.mbg>

#include <featmgr.h>

#include <hlplch.h>         // Help launcher

#include <usbpersonalityids.h>

#include <USBClassChangeUIPlugin.rsg> // Resources

#include "USBClassChangeUIPluginView.h"

#include "USBClassChangeUIPluginDebug.h"

#include "USBClassChangeUIPlugin.h"

#include "USBClassChangeUIPluginContainer.h"

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

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

// CUSBClassChangeUIPluginView::NewPluginL

// Entry point for CGSPluginInterface.

// Used by General Settings Application

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

//

CUSBClassChangeUIPluginView* CUSBClassChangeUIPluginView::NewPluginL()

    {

    FLOG(_L("[CUSBClassChangeUIPlugin]\t CUSBClassChangeUIPluginView::NewPluginL()"));

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

    self->iLoadAsGSPlugin = ETrue;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    FLOG(_L("[CUSBClassChangeUIPlugin]\t CUSBClassChangeUIPluginView::NewPluginL() completed"));

    return self;

    }

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

// CUSBClassChangeUIPluginView::NewL

// Entry point for CGSPluginInterface.

// Used by USBClassChangeUIPluginAppUI.

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

//

CUSBClassChangeUIPluginView* CUSBClassChangeUIPluginView::NewL()

    {

    FLOG(_L("[CUSBClassChangeUIPlugin]\t CUSBClassChangeUIPluginView::NewL()"));

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

    self->iLoadAsGSPlugin = EFalse;

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self );

    FLOG(_L("[CUSBClassChangeUIPlugin]\t CUSBClassChangeUIPluginView::NewL() completed"));

    return self;

    }    

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

// CUSBClassChangeUIPluginView::ConstructL

// Symbian 2nd phase constructor can leave.

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

//

void CUSBClassChangeUIPluginView::ConstructL()

    {

    FLOG(_L("[CUSBClassChangeUIPlugin]\t CUSBClassChangeUIPluginView::ConstructL()"));

    iEikEnv = CEikonEnv::Static();

    TFileName filename;

    filename += KFileDrive;

    filename += KDC_RESOURCE_FILES_DIR; 

    filename += KResourceFileName;

    BaflUtils::NearestLanguageFile(iEikEnv->FsSession(),filename);

    iResourceFileFlag = iEikEnv->AddResourceFileL(filename);

    //"Back" or "Exit" right-softkey resource

    BaseConstructL( iLoadAsGSPlugin ? 

        R_USBUI_MAIN_VIEW_GS_PLUGIN : R_USBUI_MAIN_VIEW );

    iAppUIRef = AppUi();

    iModelRef = CUSBClassChangeUIPluginModel::NewL();

    iModelRef->SetSettingsObserver(this);

    FeatureManager::InitializeLibL();

    iHelpSupported = FeatureManager::FeatureSupported( KFeatureIdHelp );

    FeatureManager::UnInitializeLib(); 

    FLOG(_L("[CUSBClassChangeUIPlugin]\t CUSBClassChangeUIPluginView::ConstructL() completed"));

    }

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

// Destructor.

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

//

CUSBClassChangeUIPluginView::~CUSBClassChangeUIPluginView()

    {

    FLOG(_L("[CUSBClassChangeUIPlugin]\t CUSBClassChangeUIPluginView::~CUSBClassChangeUIPluginView()"));

    if ( iContainer )

        {

        if ( iAppUIRef )

            {

            iAppUIRef->RemoveFromViewStack( *this, iContainer );

            }

        delete iContainer;

            }

    if ( iEikEnv )

        {

        iEikEnv->DeleteResourceFile ( iResourceFileFlag );

        }

    if ( iModelRef )

        {

        delete iModelRef;    

        }

    if ( !iLoadAsGSPlugin )

        {

        SignalDestruction();

        }

    FLOG(_L("[CUSBClassChangeUIPlugin]\t CUSBClassChangeUIPluginView::~CUSBClassChangeUIPluginView() completed"));

    }

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

// TUid CUSBClassChangeUIPluginView::Id

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

//

TUid CUSBClassChangeUIPluginView::Id() const

    {

    if ( iLoadAsGSPlugin )

    	{

	    return KGsUSBUIPluginUid; //same as ecom impl UID, required by GS interface.

    	}

    else

    	{

    	return KUSBUIMainViewId;  //view id

    	}

    }

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

// CUSBClassChangeUIPluginView::HandleCommandL

// Redirects commands to the appui class.

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

//

void CUSBClassChangeUIPluginView::HandleCommandL(TInt aCommand)

    {

    FLOG(_L("[CUSBClassChangeUIPlugin]\t CUSBClassChangeUIPluginView::HandleCommandL()"));

    switch ( aCommand )

        {

        case EAknSoftkeyExit:

        case EEikCmdExit:

            {

            iAppUIRef->Exit();

            break;

            }

        case EAknSoftkeyBack:

            /** 

            * UPDATE THIS if this view has a sub-view. 

            * In this case constant UID must be used instead of the

            * previous view - otherwise the "back" might return to the 

            * sub-view. See GSFWViewUIDs.h for constant UIDs.

            */

            iAppUIRef->ActivateLocalViewL( iPrevViewId.iViewUid );

            break; 

        case EUSBUICmdHelp:

        case EAknCmdHelp:

            {

            HlpLauncher::LaunchHelpApplicationL( 

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

            break;

            }

        case EUSBUICmdSelect:

        case EUSBUICmdMskSelect:

            {

             TInt CurrentIndex = iContainer->CurrentItemIndex() ;

             HandleCmdChangeUSBModeL(CurrentIndex);

             break;

            }

        default:

            {

            FLOG( _L("[CUSBClassChangeUIPlugin]\t CUSBClassChangeUIPluginAppUi::HandleCommandL default switch"));    

            break;

            }

        }

    }

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

// CUSBClassChangeUIPluginView::DoActivateL

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

//

void CUSBClassChangeUIPluginView::DoActivateL( const TVwsViewId& aPrevViewId,

                                 TUid /*aCustomMessageId*/,

                                 const TDesC8& /*aCustomMessage*/)

    {

    FLOG(_L("[CUSBClassChangeUIPlugin]\t CUSBClassChangeUIPluginView::DoActivateL()"));

    iPrevViewId = aPrevViewId;

    if( !iContainer )

        {

        iContainer = CUSBClassChangeUIPluginContainer::NewL(this, iModelRef);

        iContainer->SetMopParent( this ); // MObjectProvider

        // Setup the title

        //

        HBufC* usbTitleMain = iCoeEnv->AllocReadResourceLC( R_USB_TITLE );

        CEikStatusPane* statusPane = StatusPane();

        CAknTitlePane* titlePane;

        titlePane = ( CAknTitlePane* ) statusPane->ControlL(TUid::Uid( EEikStatusPaneUidTitle ));

        titlePane->SetTextL( *usbTitleMain );

        CleanupStack::PopAndDestroy(usbTitleMain);

        iAppUIRef->AddToStackL( *this, iContainer );

        }

    FLOG(_L("[CUSBClassChangeUIPlugin]\t CUSBClassChangeUIPluginView::DoActivateL() completed"));

    }

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

// CUSBClassChangeUIPluginView::DoDeactivate

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

//

void CUSBClassChangeUIPluginView::DoDeactivate()

    {

    FLOG(_L("[CUSBClassChangeUIPlugin]\t CUSBClassChangeUIPluginView::DoDeactivate()"));

    if ( iContainer )

        {

        iAppUIRef->RemoveFromStack( iContainer );

        delete iContainer;

        iContainer = NULL;

        }

    FLOG(_L("[CUSBClassChangeUIPlugin]\t CUSBClassChangeUIPluginView::DoDeactivate() completed"));

    }

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

// CUSBClassChangeUIPluginView::GetCaptionL

// Method for getting caption of this plugin.

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

//   

void CUSBClassChangeUIPluginView::GetCaptionL (TDes& aCaption) const

    {   

    FLOG(_L("[CUSBClassChangeUIPlugin]\t CUSBClassChangeUIPluginView::GetCaptionL()")); 

    // The resource file is already opened, see ConstructL()

    //

    HBufC* result = StringLoader::LoadL( R_GS_USBUI_VIEW_CAPTION );

    aCaption.Copy( *result );

    delete result;  

    FLOG(_L("[CUSBClassChangeUIPlugin]\t CUSBClassChangeUIPluginView::GetCaptionL() completed"));

    }

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

// CUSBClassChangeUIPluginView::GetValue

// Function for getting plugin's value for a certain key.

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

//   

void CUSBClassChangeUIPluginView::GetValue(const TGSPluginValueKeys aKey,

                                           TDes& aValue)

    {

    switch( aKey )

        {

        case EGSPluginKeySettingsItemValueString:

            {

            // Get Id pin state of UsbOtg-capable device

            TBool hasPeripheralEnabled = EFalse;

            // Ignore error code

            TInt ret = iModelRef->HasPeripheralEnabled(hasPeripheralEnabled);

            FTRACE(FPrint(_L("[CUSBClassChangeUIPlugin]\t CUSBClassChangeUIPluginView::GetValue - HasPeripheralEnabled=%d"), ret));

            TInt resId = 0;

            if (hasPeripheralEnabled)

                {

                resId = R_CP_DETAIL_USB_OTG_CONN;

                }

            else if (IsUSBDeviceConnected())

                {

                TInt mode = USBMode();

                switch (mode)

                    {

                    case KUsbPersonalityIdPCSuite:

                    case KUsbPersonalityIdPCSuiteMTP:

                        resId = R_CP_DETAIL_USB_CONN_PC_SUITE;

                        break;

                    case KUsbPersonalityIdMS:

                        resId = R_CP_DETAIL_USB_CONN_MASS_STORAGE;

                        break;

                    case KUsbPersonalityIdPTP:

                        resId = R_CP_DETAIL_USB_CONN_PICTURE_TRANSFER;

                        break;

                    case KUsbPersonalityIdMTP:

                        resId = R_CP_DETAIL_USB_CONN_MEDIA_TRANSFER;

                        break;

                    case KUsbPersonalityIdModemInst:

                        resId = R_CP_DETAIL_USB_CONN_MODEM_INST;

                        break;

					case KUsbPersonalityIdRNDIS:

                        resId = R_CP_DETAIL_USB_CONN_RNDIS;

                        break;

                    default:

                        // Leave value empty

                        break;

                    }

                }

            else

                {

                resId = R_CP_DETAIL_USB_NOT_CONNECTED;

                }

            if (resId)

                {

                    TRAP_IGNORE(

                        HBufC* text = StringLoader::LoadL(resId);

                        aValue.Append(*text);

                        delete text;

                    );

                }

            }

            break;

        default:

            CGSPluginInterface::GetValue(aKey, aValue);

            break;

        }

    }

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

// CUSBClassChangeUIPluginView::SettingChanged()

// A setting has been changed. 

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

//

void CUSBClassChangeUIPluginView::SettingChanged()

    {

        if (iContainer)

            {

                iContainer->SettingChanged();

            }

        // Personality changes only affect USB UI when USB device is connected

        if (IsUSBDeviceConnected())

            {

                UpdateParentView();

            }

    }

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

// CUSBClassChangeUIPluginView::DeviceStateChanged()

// USB device state has changed.

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

//

void CUSBClassChangeUIPluginView::DeviceStateChanged(TUsbDeviceState /*aPrevState*/,

                                                     TUsbDeviceState aState)

    {

		//Transitions to EUsbDeviceStateUndefined, EUsbDeviceStateConfigured 

		//and EUsbDeviceStateAttached states update UI view.

        if (aState == EUsbDeviceStateConfigured ||

            aState == EUsbDeviceStateUndefined ||

			aState == EUsbDeviceStateAttached)

            {

                UpdateParentView();

                if (iContainer)

                           {

                               iContainer->SettingChanged();

                           }

            }

    }

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

// CUSBClassChangeUIPluginView::OtgHostIdPinStateChanged

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

//

void CUSBClassChangeUIPluginView::OtgHostIdPinStateChanged(TBool aIsIdPinOn)

    {

    if (!aIsIdPinOn)

        {

        UpdateParentView();

        }

    // else, Ignore Id pin on event, host event to be checked further

    }

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

// From MUSBOtgHostStateObserver

// Handle host event notification

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

void CUSBClassChangeUIPluginView::HostEventNotify(TDeviceEventInformation /*aEventInfo*/)

    {

    UpdateParentView();

    }

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

// CUSBClassChangeUIPluginView::USBMode()

// Gets the current USB mode from model

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

//

TInt CUSBClassChangeUIPluginView::USBMode() const

    {

    return iModelRef->USBMode();

    }

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

// CUSBClassChangeUIPluginView::SetUSBModeL(TInt)

// Sets the current USB mode through model

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

//

void CUSBClassChangeUIPluginView::SetUSBModeL( TInt aMode )

    {

    FLOG( _L("[CUSBClassChangeUIPlugin]\t CUSBClassChangeUIPluginView::SetUSBModeL()"));

    iModelRef->SetUSBModeL( aMode );

    FLOG( _L("[CUSBClassChangeUIPlugin]\t CUSBClassChangeUIPluginView::SetUSBModeL complete"));

    }   

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

// CUSBClassChangeUIPluginView::CreateIconL()

// Creates icon for General Settings application

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

//  

CGulIcon* CUSBClassChangeUIPluginView::CreateIconL( const TUid aIconType )

{

    FTRACE(FPrint(_L("[CUSBClassChangeUIPlugin]\t CUSBClassChangeUIPluginView::CreateIconL() - aIconType=0x%x"), aIconType.iUid));

    CGulIcon* icon = NULL;

    if( aIconType == KGSIconTypeLbxItem )

        {

        TFileName usbUiIconFilename( KFileDrive );

        usbUiIconFilename += KDC_APP_BITMAP_DIR;

        usbUiIconFilename += KUSBUIconFileName;

        // Get peripheral connected state of UsbOtg-capable device

        TBool hasPeripheralEnabled = EFalse;

        TInt ret = iModelRef->HasPeripheralEnabled(hasPeripheralEnabled);

        // In case of failure of getting the status, hasPeripheralEnabled is EFalse.

        // So ignore the error code here.

        FTRACE(FPrint(_L("[CUSBClassChangeUIPlugin]\t CUSBClassChangeUIPluginView::CreateIconL - HasPeripheralEnabled=%d"), ret));

        if (hasPeripheralEnabled || IsUSBDeviceConnected())

            {

            icon = AknsUtils::CreateGulIconL( AknsUtils::SkinInstance(), 

                KAknsIIDQgnPropSetAppsUsb, usbUiIconFilename, 

                EMbmUsbuiQgn_prop_set_apps_usb, 

                EMbmUsbuiQgn_prop_set_apps_usb_mask );

            }

        else

            {

            icon = AknsUtils::CreateGulIconL( AknsUtils::SkinInstance(), 

                KAknsIIDQgnPropSetAppsUsbOff, usbUiIconFilename, 

                EMbmUsbuiQgn_prop_set_apps_usb_off, 

                EMbmUsbuiQgn_prop_set_apps_usb_off_mask );

            }

        }

    else 

        {

        icon = CGSPluginInterface::CreateIconL( aIconType );

        }

    FLOG( _L("[CUSBClassChangeUIPlugin]\t CUSBClassChangeUIPluginView::CreateIconL() completed"));

    return icon;

}

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

// CUSBClassChangeUIPluginView::HandleCmdChangeUSBModeL()

// sets the selected usb mode 

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

//

void CUSBClassChangeUIPluginView::HandleCmdChangeUSBModeL(TInt aMode)

    {

    FLOG( _L("[CUSBClassChangeUIPlugin]\t CUSBClassChangeUIPluginView::HandleCmdChangeUSBModeL()"));

    const RArray<TInt> usbIndexes = iModelRef->GetUsbIds(); 

    SetUSBModeL( usbIndexes[aMode] );

    FLOG( _L("[CUSBClassChangeUIPlugin]\t CUSBClassChangeUIPluginView::HandleCmdChangeUSBModeL() completed"));

    }

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

// Remove Help from options menu, if the feature is not supported. 

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

//

void CUSBClassChangeUIPluginView::DynInitMenuPaneL( TInt /*aResId*/, CEikMenuPane* aMenu )

    {

    FLOG(_L("[CUSBClassChangeUIPlugin]\t CUSBClassChangeUIPluginView::DynInitMenuPaneL()"));

	//dim help if it is not supported and it exists

	if (!iHelpSupported)

	    {

    	TInt tmp;

        if (  aMenu->MenuItemExists(EUSBUICmdHelp, tmp) )

            {			

            aMenu->SetItemDimmed(EUSBUICmdHelp, ETrue);

            }

        }

    FLOG( _L("[CUSBClassChangeUIPlugin]\t CUSBClassChangeUIPluginView::DynInitMenuPaneL() completed"));