/*

* 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 is the interface to all the settings.

*

*/

// INCLUDE FILES

#include <centralrepository.h> 

#include <usb.h>

#include <usbwatcher.h>

#include <UsbWatcherInternalCRKeys.h>

#include <USBClassChangeUIPlugin.rsg> // Resources

#include <coemain.h>

#include <usbpersonalityids.h>

#include <avkon.mbg>

#include <usbui.mbg>

#include <aknappui.h>

#include <AknIconArray.h>

#include <aknlists.h>

#include <featmgr.h>

#include "USBClassChangeUIPluginModel.h"

#include "USBClassChangeUIPluginDebug.h"

#include "USBClassChangeUIPlugin.h"

#include "USBClassChangeUIPluginView.h"

_LIT( KFirstTab, "%d\t" );

_LIT( KSecondTab, "\t" );

_LIT(KUSBUIEmptyString, "0\t \t "); 

#if defined(__WINS__) && !defined(__USB_EMULATION__)

    // There are two situations under emulator:

    // 1. Do not use UsbManager and UsbWatcher, which is the normal case, and

    // 2. Use UsbManagerDummy and UsbWatcherDummy, for UI testing.

    // Comment the define line for case 2. 

   #define NO_USBWATCHER_USBMANAGER  

#endif //__WINS__

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

//

CUSBClassChangeUIPluginModel::CUSBClassChangeUIPluginModel()

: CActive( EPriorityNormal ), iUsbWatcherConnected(EFalse)

    {

    CActiveScheduler::Add(this);

    }

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

// Destructor

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

//

CUSBClassChangeUIPluginModel::~CUSBClassChangeUIPluginModel()

    {

    FLOG(_L("[CUSBClassChangeUIPlugin]\t CUSBClassChangeUIPluginModel::Destructor"));

    Cancel();

    delete iCRPersonalityWatcher;

    delete iDeviceStateWatcher;

    delete iOtgHostStateWatcher;

    delete iRepository; 

    iUsbModeIndexes.Close(); 

#ifndef NO_USBWATCHER_USBMANAGER //UsbWatcher/UsbManager API N/A

    iUsbman.Close();

    iUsbWatcher.Close();  

    iDeviceIDs.Close();

#endif //NO_USBWATCHER_USBMANAGER

    FLOG(_L("[CUSBClassChangeUIPlugin]\t CUSBClassChangeUIPluginModel::Destructor complete"));

    }

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

// CUSBClassChangeUIPluginModel::ConstructL()

// Symbian 2nd phase constructor can leave.

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

//

void CUSBClassChangeUIPluginModel::ConstructL()

    {

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

    iCRPersonalityWatcher = CUSBClassChangeUIPluginCRWatcher::NewL( *this, 

        KUsbWatcherPersonality);

    iUsbModeIndexes = RArray<TInt>(KUSBClassChangeUISupportedModesGranularity);

    iRepository = CRepository::NewL( KCRUidUsbWatcher );

#ifndef NO_USBWATCHER_USBMANAGER //UsbWatcher/UsbManager API N/A

    User::LeaveIfError(iUsbman.Connect());

    FLOG(_L("[CUSBClassChangeUIPlugin]\t CUSBClassChangeUIPluginModel::ConstructL() iUsbman OK"));

    iDeviceStateWatcher = CUSBDeviceStateWatcher::NewL(*this, iUsbman);

    iOtgHostStateWatcher = CUSBOtgHostStateWatcher::NewL(*this, iUsbman);

    iDeviceIDs.ReserveL(1);

#endif //NO_USBWATCHER_USBMANAGER

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

    }

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

// CUSBClassChangeUIPluginModel::NewL

// Two-phased constructor.

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

//

CUSBClassChangeUIPluginModel* CUSBClassChangeUIPluginModel::NewL()

    {

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

    CUSBClassChangeUIPluginModel* self 

        = new (ELeave) CUSBClassChangeUIPluginModel();

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop( self ); 

    return self;

    }

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

// CUSBClassChangeUIPluginModel::SetUSBModeL

// Sets the Central Repository key to the parameter.

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

//

void CUSBClassChangeUIPluginModel::SetUSBModeL(TInt aMode)

    {

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

    // Only change the value if necessary

    TInt usbMode = USBMode();

    if (usbMode != aMode)

        {

#ifndef NO_USBWATCHER_USBMANAGER //UsbWatcher/UsbManager API N/A

        // Change the personality asynchrously, result checked in RunL()

        if( IsActive() ) 

            {

            Cancel();

            }

        if ( (!iUsbWatcherConnected) && (iUsbWatcher.Connect() == KErrNone) )

            {

            iUsbWatcherConnected = ETrue;

            FLOG(_L("[CUSBClassChangeUIPlugin]\t CUSBClassChangeUIPluginModel::SetUSBModeL iUsbWatcher connected"));

            }

        if (iUsbWatcherConnected)

            {

            FLOG(_L("[CUSBClassChangeUIPlugin]\t CUSBClassChangeUIPluginModel::SetUSBModeL setting personality"));

            iUsbWatcher.SetPersonality(iStatus, aMode);

            SetActive();

            }

#endif //NO_USBWATCHER_USBMANAGER

        }

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

    }

void CUSBClassChangeUIPluginModel::RunL()

    {

    FLOG(_L("[CUSBClassChangeUIPlugin]\t CUSBClassChangeUIPluginModel::RunL()"));

    //Check the return value of SetPersonality()

    //Leave if KErrDiskFull

    if( iStatus == KErrDiskFull ) // Other errors not leave

        {

        User::Leave( KErrDiskFull );    

        }

    FLOG(_L("[CUSBClassChangeUIPlugin]\t CUSBClassChangeUIPluginModel::RunL complete"));

    }

void CUSBClassChangeUIPluginModel::DoCancel()

    {

    FLOG(_L("[CUSBClassChangeUIPlugin]\t CUSBClassChangeUIPluginModel::DoCancel()"));

    if (iUsbWatcherConnected)

        {

        iUsbWatcher.CancelSetPersonality();

        }

    FLOG(_L("[CUSBClassChangeUIPlugin]\t CUSBClassChangeUIPluginModel::DoCancel complete()"));

    }

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

// CUSBClassChangeUIPluginModel::USBMode

// Returns the value in Central Repository.

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

//

TInt CUSBClassChangeUIPluginModel::USBMode()

    {

    FLOG(_L("[CUSBClassChangeUIPlugin]\t CUSBClassChangeUIPluginModel::USBMode()"));

    TInt mode = 0;

    iRepository->Get(KUsbWatcherPersonality, mode);

    FLOG(_L("[CUSBClassChangeUIPlugin]\t CUSBClassChangeUIPluginModel::USBMode complete"));

    return mode;

    }

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

// CUSBClassChangeUIPluginModel::GetDeviceState

// Gets the current device state

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

//

TInt CUSBClassChangeUIPluginModel::GetDeviceState(TUsbDeviceState& aState)

    {

#ifdef NO_USBWATCHER_USBMANAGER //UsbWatcher/UsbManager API N/A

        aState = EUsbDeviceStateUndefined;

        return KErrNone;

#else

        return iUsbman.GetDeviceState(aState);

#endif

    }

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

// CUSBClassChangeUIPluginModel::GetDescription

// Gets description for the specified USB mode (personality ID)

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

//

TInt CUSBClassChangeUIPluginModel::GetDescription(TInt aMode, HBufC*& aDescription)

    {

        return iUsbman.GetDescription(aMode, aDescription);

    }

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

// CUSBClassChangeUIPluginModel::UpdateMainContainerReference

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

//

void CUSBClassChangeUIPluginModel::SetSettingsObserver(MUSBUIObserver* aObserver)

    {

    FLOG(_L("[CUSBClassChangeUIPlugin]\t CUSBClassChangeUIPluginModel::SetSettingsObserver()"));

    iObserver = aObserver;

    FLOG(_L("[CUSBClassChangeUIPlugin]\t CUSBClassChangeUIPluginModel::SetSettingsObserver complete"));

    }

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

// CUSBClassChangeUIPluginModel::GetSupportedUSBModesL

// Reads the supported USB Modes from USBManager

// The lists received as parameters are updated. 

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

//

void CUSBClassChangeUIPluginModel::SupportedUSBModeArraysL( 

        CDesCArrayFlat& aListBox,CDesCArrayFlat& aListBoxDefault,

        CDesCArrayFlat& aListBoxActive, CDesCArrayFlat& aPopUpItems,

        CArrayPtrFlat<CGulIcon>& aIconArray)

    {

    FLOG(_L("[CUSBClassChangeUIPlugin]\t CUSBClassChangeUIPluginModel::SupportedUSBModeArraysL()"));  

    RArray<TInt> personalityIds;

    CleanupClosePushL( personalityIds );

    HBufC* usbModeListBox = NULL;

    HBufC* usbModeListBoxActive = NULL;

    // Allocate memory for descriptors to hold texts for listbox 

    usbModeListBox = HBufC::NewLC( KUsbStringDescStringMaxSize );

    TPtr usbModeListBoxPtr = usbModeListBox->Des();

    usbModeListBoxActive = HBufC::NewLC( KUsbStringDescStringMaxSize );

    TPtr usbModeListBoxActivePtr = usbModeListBoxActive->Des();

    HBufC* usbDefaultText = NULL;

    usbDefaultText = CCoeEnv::Static()->AllocReadResourceLC( R_USB_MODE_DEFAULT );

    HBufC* usbActiveText = NULL;

    usbActiveText = CCoeEnv::Static()->AllocReadResourceLC( R_USB_MODE_ACTIVE );

    //Check phone as modem is supported or not

    FeatureManager::InitializeLibL();

    TBool phoneAsModemSupported = FeatureManager::FeatureSupported(

        KFeatureIdUsbModem );

    FeatureManager::UnInitializeLib();

    // Get personality ids

     iPersonalityCount = 0;

#ifndef NO_USBWATCHER_USBMANAGER //UsbWatcher/UsbManager API N/A

    if (iUsbman.GetPersonalityIds(personalityIds) == KErrNone)

        {

        FLOG(_L("CUSBClassChangeUIPluginModel::SupportedUSBModeArraysL(): Personality Ids got"));              

        for (TInt i = 0; i < personalityIds.Count(); i++)

            {  

            FTRACE(FPrint(_L("[CUSBClassChangeUIPlugin]\t i= %d "), i));

            if (personalityIds[i] == KUsbPersonalityIdModemInst)

                {

                if (!phoneAsModemSupported)

                    {

                    FLOG(_L("Phone as modem is not supported!"));    

                    continue;

                    }

                }

			TUint32 property;

			TInt ret  =  iUsbman.GetPersonalityProperty(personalityIds[i], property);

			if (ret == KErrNone)

				{

				FTRACE(FPrint(_L("[CUSBClassChangeUIPlugin] property\t i= 0x%x "), property));

				if (property & KUsbPersonalityPropertyHidden)

					{

					FLOG(_L("CUSBClassChangeUIPluginModel::SupportedUSBModeArraysL(): The Personality is hidden"));

					continue;

					}

				}

			else

				{

				FTRACE(FPrint(_L("[CUSBClassChangeUIPlugin] Error to get the property\t i= %d "), ret));

				}

            HBufC* description = NULL;

            HBufC* detailDescription = NULL;

            if (iUsbman.GetDescription(personalityIds[i], description) == KErrNone)

                {

                CleanupStack::PushL(description);

                FLOG(_L("CUSBClassChangeUIPluginModel::SupportedUSBModeArraysL(): Description read"));

                //mode strings for setting page

                TPtr descriptionPtr = description->Des();                                        

                iUsbModeIndexes.Append(personalityIds[i]);

                //modes with labels for list box

                usbModeListBoxPtr.Zero();

                usbModeListBoxActivePtr.Zero();

                usbModeListBoxPtr.Format(KFirstTab, iPersonalityCount);

                usbModeListBoxPtr.Append(descriptionPtr);

                usbModeListBoxPtr.Append(KSecondTab);

                usbModeListBoxActivePtr.Copy(usbModeListBoxPtr);

                aListBox.AppendL(usbModeListBoxPtr);

                usbModeListBoxPtr.Append(*usbDefaultText);

                usbModeListBoxActivePtr.Append(*usbActiveText);

                aListBoxDefault.AppendL(usbModeListBoxPtr);

                aListBoxActive.AppendL(usbModeListBoxActivePtr);

                CleanupStack::PopAndDestroy(description); 

                //creating the icon list

                AddIconL (personalityIds[i], aIconArray);

                if (iUsbman.GetDetailedDescription(personalityIds[i], detailDescription) == KErrNone)

                	{

                	CleanupStack::PushL(detailDescription);

                	aPopUpItems.AppendL(detailDescription->Des());

                	CleanupStack::PopAndDestroy(detailDescription); 

               		}

                else

                	{ 

                	aPopUpItems.AppendL(KNullDesC);

                	}

                iPersonalityCount++;

                }

            }

        }

#endif // NO_USBWATCHER_USBMANAGER

    if (iPersonalityCount == 0)

        {

        // Add empty value

        AddIconL (iPersonalityCount, aIconArray);

        iUsbModeIndexes.AppendL(0);

        aPopUpItems.AppendL(KNullDesC);

        aListBox.AppendL(KUSBUIEmptyString);

        aListBoxDefault.AppendL(KUSBUIEmptyString);

        aListBoxActive.AppendL(KUSBUIEmptyString);

        }

    CleanupStack::PopAndDestroy( usbActiveText ); 

    CleanupStack::PopAndDestroy( usbDefaultText ); 

    CleanupStack::PopAndDestroy( usbModeListBoxActive ); 

    CleanupStack::PopAndDestroy( usbModeListBox ); 

    CleanupStack::PopAndDestroy( &personalityIds ); 

    FLOG(_L("[CUSBClassChangeUIPlugin]\t CUSBClassChangeUIPluginModel::SupportedUSBModeArraysL() complete"));  

    }

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

// CUSBClassChangeUIPluginModel::AddIconL()

// creates the icon list 

// 

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

//

void CUSBClassChangeUIPluginModel::AddIconL (TInt aMode, CArrayPtrFlat<CGulIcon>& aIconArray )

    {

    FLOG( _L("[CUSBClassChangeUIPlugin]\t CUSBClassChangeUIPluginModel::AddIconL()"));

    TFileName usbUiIconFilename( KFileDrive );

    usbUiIconFilename += KDC_APP_BITMAP_DIR;

    usbUiIconFilename += KUSBUIconFileName;

    switch (aMode)

        {

        case KUsbPersonalityIdPCSuite:

        case KUsbPersonalityIdPCSuiteMTP:

            CreateAndAppendIconL( KAknsIIDQgnPropUsbPcsuite,

                    usbUiIconFilename,

                    EMbmUsbuiQgn_prop_usb_pcsuite,

                    EMbmUsbuiQgn_prop_usb_pcsuite_mask,

                    aIconArray);

            break;

        case KUsbPersonalityIdMS:

            CreateAndAppendIconL( KAknsIIDQgnPropUsbMemcLarge,

                    usbUiIconFilename,

                    EMbmUsbuiQgn_prop_usb_memc_large,

                    EMbmUsbuiQgn_prop_usb_memc_large_mask,

                    aIconArray);

            break;

        case KUsbPersonalityIdPTP:

            CreateAndAppendIconL( KAknsIIDQgnPropUsbPrint,

                    usbUiIconFilename,

                    EMbmUsbuiQgn_prop_usb_print,

                    EMbmUsbuiQgn_prop_usb_print_mask,

                    aIconArray);

            break;

        case KUsbPersonalityIdMTP:

            CreateAndAppendIconL( KAknsIIDQgnPropUsbMtp,

                    usbUiIconFilename,

                    EMbmUsbuiQgn_prop_usb_mtp,

                    EMbmUsbuiQgn_prop_usb_mtp_mask,

                    aIconArray);

            break;

        case KUsbPersonalityIdModemInst:

            CreateAndAppendIconL( KAknsIIDQgnPropUsbModem,

                    usbUiIconFilename,

                    EMbmUsbuiQgn_prop_usb_modem,

                    EMbmUsbuiQgn_prop_usb_modem_mask,

                    aIconArray);

            break;

        default:

            CreateAndAppendIconL( KAknsIIDQgnPropSetAppsUsb, 

                    usbUiIconFilename, 

                    EMbmUsbuiQgn_prop_set_apps_usb,

                    EMbmUsbuiQgn_prop_set_apps_usb_mask,

                    aIconArray);

           break;

       }

    FLOG( _L("[CUSBClassChangeUIPlugin]\t CUSBClassChangeUIPluginModel::AddIconL() completed"));

    }

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

// CUSBClassChangeUIPluginContainer::CreateAndAppendIconL

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

void CUSBClassChangeUIPluginModel::CreateAndAppendIconL( 

    const TAknsItemID& aID,

    const TDesC& aFileName,

    const TInt aBitmapId,

    const TInt aMaskId,

    CArrayPtrFlat<CGulIcon>& aIconArray)

    {    

    FLOG( _L("[CUSBClassChangeUIPlugin]\t CUSBClassChangeUIPluginModel::CreateAndAppendIconL"));

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

                                    aID, aFileName, aBitmapId, aMaskId);

    CleanupStack::PushL(icon);    

    aIconArray.AppendL(icon);

    CleanupStack::Pop(icon);

    FLOG( _L("[CUSBClassChangeUIPlugin]\t CUSBClassChangeUIPluginModel::CreateAndAppendIconL completed"));

    }

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

// CUSBClassChangeUIPluginModel::GetPersonalityCount()

// Informs the container, that a setting has changed. 

// 

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

//

TInt CUSBClassChangeUIPluginModel::PersonalityCount()

    {

    FTRACE(FPrint(_L("[CUSBClassChangeUIPlugin]\t PersonalityCount= %d "), iPersonalityCount));

       return iPersonalityCount;

    }  

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

// CUSBClassChangeUIPluginModel::SettingChangedL()

// Informs the container, that a setting has changed. 

// 

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

//

void CUSBClassChangeUIPluginModel::SettingChangedL( TUint32 /*aKey*/ )

    {

    FLOG( _L("[CUSBClassChangeUIPlugin]\t CUSBClassChangeUIPluginModel::SettingChangedL()"));

    if ( iObserver )

        {

        iObserver->SettingChanged();  

        }

    FLOG( _L("[CUSBClassChangeUIPlugin]\t CUSBClassChangeUIPluginModel::SettingChangedL() completed"));

    }

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

// From MUSBOtgHostStateObserver

// Handle Otg Id pin on/off notification

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

void CUSBClassChangeUIPluginModel::OtgHostIdPinStateChanged(TBool aIsIdPinOn)

    {

    iDeviceIDs.Reset();

    if (iObserver)

        {

        iObserver->OtgHostIdPinStateChanged(aIsIdPinOn);

        }

    }

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

// From MUSBOtgHostStateObserver

// Handle host event notification

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

void CUSBClassChangeUIPluginModel::HostEventNotify(TDeviceEventInformation aEventInfo)

    {

    if (iObserver)

        {

        FLOG( _L("[CUSBClassChangeUIPlugin]\t CUSBClassChangeUIPluginModel::HostEventNotify"));        

        FTRACE( FPrint(_L( "[CUSBClassChangeUIPlugin]\t iEventInfo.iDeviceId         = %d" ), aEventInfo.iDeviceId));

        FTRACE( FPrint(_L( "[CUSBClassChangeUIPlugin]\t iEventInfo.iEventType        = %d" ), aEventInfo.iEventType));

        FTRACE( FPrint(_L( "[CUSBClassChangeUIPlugin]\t iEventInfo.iError            = %d" ), aEventInfo.iError));

        FTRACE( FPrint(_L( "[CUSBClassChangeUIPlugin]\t iEventInfo.iDriverLoadStatus = %d" ), aEventInfo.iDriverLoadStatus));

        FTRACE( FPrint(_L( "[CUSBClassChangeUIPlugin]\t iEventInfo.iVid              = %d" ), aEventInfo.iVid));

        FTRACE( FPrint(_L( "[CUSBClassChangeUIPlugin]\t iEventInfo.iPid              = %d" ), aEventInfo.iPid));

        switch (aEventInfo.iEventType)

            {

            case EDeviceAttachment:

                {

                iObserver->HostEventNotify(aEventInfo);

                break;

                }

            case EDeviceDetachment: