diff -r 25fce757be94 -r e02eb84a14d2 usbuis/usbui/USBClassChangeUIPlugin/src/USBClassChangeUIPluginModel.cpp
--- /dev/null	Thu Jan 01 00:00:00 1970 +0000
+++ b/usbuis/usbui/USBClassChangeUIPlugin/src/USBClassChangeUIPluginModel.cpp	Wed Sep 01 12:20:49 2010 +0100
@@ -0,0 +1,615 @@
+/*
+* 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:
+                {
+                TInt index = iDeviceIDs.Find(aEventInfo.iDeviceId);
+                if (index >= 0)
+                    {
+                     iDeviceIDs.Remove(index);
+                    }
+                iObserver->HostEventNotify(aEventInfo);
+                break;
+                }
+            case EDriverLoad:
+                {
+                switch (aEventInfo.iDriverLoadStatus)
+                    {
+                    case EDriverLoadSuccess:
+                    case EDriverLoadPartialSuccess:
+                        {
+                        // Drivers are loaded more or less successfully
+                        TInt ret = iDeviceIDs.Append(aEventInfo.iDeviceId);
+                        if (ret != KErrNone) 
+                            {
+                            FLOG( _L("[CUSBClassChangeUIPlugin]\t CUSBClassChangeUIPluginModel::HostEventNotify *** append error"));       
+                            }
+                        iObserver->HostEventNotify(aEventInfo);
+                        break;
+                        }
+                    }
+                break;
+                }
+            }
+        }
+    }
+
+// ----------------------------------------------------------------------------
+// Informs the observer that USB device state has changed.
+// ----------------------------------------------------------------------------
+void CUSBClassChangeUIPluginModel::DeviceStateChanged(
+    TUsbDeviceState aPreviousState, TUsbDeviceState aCurrentState)
+{
+    if (iObserver)
+        {
+            iObserver->DeviceStateChanged(aPreviousState, aCurrentState);
+        }
+}
+
+// ----------------------------------------------------------------------------
+// CUSBClassChangeUIPluginModel::GetUsbIds()
+// Return an RArray of the personality indexes
+// 
+// ----------------------------------------------------------------------------
+//
+RArray<TInt>& CUSBClassChangeUIPluginModel::GetUsbIds()
+    {
+    return iUsbModeIndexes; 
+    }
+// ----------------------------------------------------------------------------
+// Returns if it's A-device and the driver to the attached pheripheral 
+// is loaded successfully(or partially). 
+// ----------------------------------------------------------------------------
+//
+TInt CUSBClassChangeUIPluginModel::HasPeripheralEnabled(TBool& aHasPeripheralEnabled)
+    {
+    aHasPeripheralEnabled = EFalse;
+#ifdef NO_USBWATCHER_USBMANAGER     ////UsbWatcher/UsbManager API N/A 
+    return KErrNone;
+#else
+    TBool idPinOn;
+    TInt ret = iOtgHostStateWatcher->IsIdPinOn(idPinOn);
+    if (ret != KErrNone || !idPinOn)
+        {
+        return ret;
+        }
+    
+    //aHasPeripheralEnabled = (iDeviceIDs.Count() > 0 ? ETrue : EFalse);
+    ret = iOtgHostStateWatcher->IsPeripheralConnected(aHasPeripheralEnabled); 
+    if (ret != KErrNone)
+        {
+        return ret;
+        }
+    
+    FTRACE(FPrint(_L("[CUSBClassChangeUIPlugin]\t CUSBClassChangeUIPluginModel::HasPeripheralEnabled - aHasPeripheralEnabled=%d"), aHasPeripheralEnabled));
+    
+    return KErrNone;
+#endif
+    }
+
+// End of file