/*

* Copyright (c) 2006-2010 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 implements CUsbWatcher class.

*

*/

#include <ecom/ecom.h>

#include <utf.h>

#include <coreapplicationuisdomainpskeys.h>

//CleanupResetAndDestroyPushL

#include <mmf/common/mmfcontrollerpluginresolver.h>

#include <UsbWatcherInternalCRKeys.h>

#include <cusbpersonalitynotifier.h>

#include <UsbWatcherInternalPSKeys.h>

#include <e32property.h>

#include <startupdomainpskeys.h> //for global system state

#include "cusbwatcher.h"

#include "cusbactivestate.h"

#include "cusbactivepersonalityhandler.h"

#include "cusbwatchersession.h"

#include "cusbdevicelock.h"

#include "cusbdevconstarter.h"

#include "cusbglobalsystemstateobserver.h"

#include "cusbotgwatcher.h"

_LIT_SECURITY_POLICY_PASS( KAlwaysPassPolicy );

_LIT_SECURITY_POLICY_C1( KLocalServicesPolicy, ECapabilityLocalServices );

const TUint32 KUsbWatcherUseSerialNumber = 0x80000000;

const TUint32 KUsbWatcherPersonalityIdMask = 0x0000FFFF;

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

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

// C++ default constructor can NOT contain any code, that might leave.

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

//

CUsbWatcher::CUsbWatcher()

    : CActive( EPriorityStandard )

    {

    LOG_FUNC

    CActiveScheduler::Add( this );

    }

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

// Symbian 2nd phase constructor can leave.

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

//

void CUsbWatcher::ConstructL()

    {

    LOG_FUNC

    LEAVEIFERROR( RProperty::Define( KPSUidUsbWatcher,

            KUsbWatcherSelectedPersonality, RProperty::EInt, KAlwaysPassPolicy,

            KLocalServicesPolicy ) );

    LEAVEIFERROR( RProperty::Set( KPSUidUsbWatcher,

            KUsbWatcherSelectedPersonality,

            KUsbWatcherSelectedPersonalityNone ) );

    iPersonalityRepository = CRepository::NewL( KCRUidUsbWatcher );

    LEAVEIFERROR( iPersonalityRepository->Get( KUsbWatcherPersonality,

            iPersonalityId ) );

    LOG1( "iPersonalityId from CenRep = %d", iPersonalityId );

    iPrevPersonalityId = iPersonalityId;

    iOldPrevPersonalityId = iPersonalityId;

    LEAVEIFERROR( iUsbMan.Connect() );

    TInt ret = iUsbMan.SetCtlSessionMode( ETrue );

    if( KErrNone == ret )

        {

        LOG( "Creating CUsbOtgWatcher..."  );

        iOtgWatcher = CUsbOtgWatcher::NewL( iUsbMan );

        }

    else if( KErrNotSupported == ret )

        {

        LOG( "Non-OTG configuration detected!"  );

        }

    else

        {

        LOG( "ERROR: is there another USB Control process? LEAVE" );

        LEAVE( ret );

        }

    iPersonalityHandler

        = CUsbActivePersonalityHandler::NewL( iUsbMan, *this );

    GetPersonalityPluginsL();

    iUsbDeviceLock = CUsbDeviceLock::NewL( *this );

    iUsbDeviceLock->Subscribe();

    iGlobalStateObserver = CUsbGlobalSystemStateObserver::NewL( *this );

    iUsbDevConStarter = CUsbDevConStarter::NewL();

    iActiveState = CUsbActiveState::NewL( iUsbMan, *this );

    }

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

// Two-phased constructor.

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

//

CUsbWatcher* CUsbWatcher::NewL()

    {

    LOG_FUNC

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

    CleanupStack::PushL( self );

    self->ConstructL();

    CleanupStack::Pop(); // pop self

    return self;

    }

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

// Destructor.

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

//

CUsbWatcher::~CUsbWatcher()

    {

    LOG_FUNC

    RProperty::Delete( KPSUidUsbWatcher, KUsbWatcherSelectedPersonality );

    iUsbMan.Close();

    iObservers.Reset();

    if( iUsbDeviceLock )

        {

        iUsbDeviceLock->Cancel();

        }

    delete iActiveState;

    delete iUsbDevConStarter;

    delete iPersonalityHandler;

    delete iPersonalityRepository;

    delete iOtgWatcher;

    delete iUsbDeviceLock;

    delete iGlobalStateObserver;

    iSupportedPersonalities.Close();

    }

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

// Get personality plugins. Note that this is done only in normal mode.

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

//

void CUsbWatcher::GetPersonalityPluginsL()

    {

    LOG_FUNC

    // Get personality plugins

    RImplInfoPtrArray implementations;

    CleanupResetAndDestroyPushL( implementations );

    const TEComResolverParams noResolverParams;

    REComSession::ListImplementationsL( KUidPersonalityPlugIns,

            noResolverParams, KRomOnlyResolverUid, implementations );

    TInt personalityNum = implementations.Count();

    LOG1( "Number of PersonalityPlugin(s): %d", personalityNum );

    if( personalityNum < 1 )

        {

        LOG( "No PersonalityPlugin available. LEAVE" );

        LEAVE( KErrGeneral );

        }

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

        {

        TUsbSupportedPersonalityInf inf;

        TLex8 lex;

        TUint32 confValue;

        // save implementation uid

        inf.iPersonalityUid = implementations[i]->ImplementationUid();

        lex.Assign( implementations[i]->DataType() );

        if( lex.Val( confValue, EHex ) != KErrNone )

            {

            CleanupStack::PopAndDestroy( &implementations );

            iSupportedPersonalities.Close();

            LEAVE( KErrGeneral );

            }

        // check whether personality requires serial number

        if( confValue & KUsbWatcherUseSerialNumber )

            {

            inf.iUseSerialNumber = ETrue;

            }

        else

            {

            inf.iUseSerialNumber = EFalse;

            }

        // save personality id

        inf.iPersonalityId = static_cast<TInt>( ( KUsbWatcherPersonalityIdMask

                & confValue ) );

        LOG1( "PersonalityId = %d" , inf.iPersonalityId );

        iSupportedPersonalities.AppendL( inf );

        }

    CleanupStack::PopAndDestroy( &implementations );

    }

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

// This method notifies CUsbWatcher class about USB state changes.

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

//

        TUsbDeviceState aStateNew )

    {

    LOG_FUNC

    // Handling USB indicator. This is valid for both A- and B-device cases.

    // Not show USB indicator in charging mode

    if ( iNormalStart ) 

        {

        }

    if ( IsDeviceA() ) // Will be handled by UsbOtgWatcher

        {

        LOG( "Device state change ignored by UsbWatcher in A-device state" );

        return;

        }

    LOG1( "WatcherState = %d", iState );

    // Notify personality handler first

    switch( aStateNew )

        {

        case EUsbDeviceStatePowered:

            // Case for Attached state missed 

            // NO break here;

        case EUsbDeviceStateAttached:

            {

            if( EUsbDeviceStateUndefined != aStateOld )

                {

                LOG1( "Not starting personality, previous state: %d", 

                    aStateOld);

                break;

                }

            LOG1( "Starting USB personality in device state: %d", aStateNew );

            iPersonalityHandler->StateChangeNotify( aStateOld, aStateNew );

            if( ( iState == EUsbIdle ) && !iPersonalityChangeOngoing )

                {

                Start();

                }

            else if( ( iState != EUsbStarted ) && !iPersonalityChangeOngoing )

                {

                Cancel();

                Start();

                }

            //start usbdevcon only in normal global state

            TInt globalState =

                    CUsbGlobalSystemStateObserver::GlobalSystemState();

            if( ( ESwStateNormalRfOn == globalState ) ||

                    ( ESwStateNormalRfOff == globalState ) ||

                    ( ESwStateNormalBTSap == globalState ) )

                {

                iUsbDevConStarter->Start();

                }

            }

            break;

        case EUsbDeviceStateUndefined:

            {

            iGlobalStateObserver->Cancel();

            // Notify clients currently loaded personality will be unloaded

            iPersonalityHandler->StateChangeNotify( aStateOld, aStateNew );

            iUsbDevConStarter->StopRestarting();

            // This must be done before Notify()

            if( iSetPreviousPersonalityOnDisconnect )

                {

                TInt temp = iPersonalityId;

                iPersonalityId = iPrevPersonalityId;

                iPrevPersonalityId = temp;

                WritePersonalityId( iPersonalityId );

                iSetPreviousPersonalityOnDisconnect = EFalse;

                }

            Notify( KErrCancel );

            if (iState == EUsbStarting)

                {

                LOG( "StartCancel USB" );

                Cancel();

                }

            else

                {

                LOG( "Stop USB" );

                if( EUsbConfirmStop == iState )

                    {

                    // We have request pending on personality handler

                    Cancel();

                    }

                    Stop();

                    }

            }

            break;

        default:

            if ( EUsbStarted == iState )

                {

                iPersonalityHandler->StateChangeNotify( aStateOld, aStateNew );

                }

            break;

        }

    }

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

// From class CActive.

// This method cancels any outstanding request.

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

//

void CUsbWatcher::DoCancel()

    {

    LOG_FUNC

    LOG1( "WatcherState = %d", iState );

    if( ( EUsbStarting == iState ) || ( EUsbStopping == iState ) )

        {

        iPersonalityHandler->Cancel();

        RProperty::Set( KPSUidUsbWatcher,

                KUsbWatcherSelectedPersonality,

                KUsbWatcherSelectedPersonalityNone );

        LOG( "personality set to none" );

        iState = EUsbIdle;

        }

    else if( EUsbConfirmStop == iState )

        {

        iPersonalityHandler->Cancel();

        iState = EUsbStarted;

        }

    else

        {

        LOG( "Nothingh to cancel" );

        }

    }

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

// This method implements state machine for personality start and stop.

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

//

void CUsbWatcher::RunL()

    {

    LOG_FUNC

    LOG1( "WatcherState = %d", iState );

    TInt ret = iStatus.Int();

    if ( KErrNone != ret  )

        {

        LOG1( "ERROR: CUsbWatcher::RunL iStatus = %d", ret );

        }

    switch ( iState )

        {

        case EUsbStarting:

            LOG( "Personality started" );

            Notify( ret );

            if( iStopStartScenario )

                {

                iStopStartScenario = EFalse;

                }

            //check if StartPersonality() fails     

            LEAVEIFERROR( ret );

            iState = EUsbStarted;

            break;

        case EUsbStopping:

            LOG( "Personality stopped" );

            iState = EUsbIdle;

            if( iStopStartScenario )

                {

                Start();

                }

            else

                {

                RProperty::Set( KPSUidUsbWatcher,

                    KUsbWatcherSelectedPersonality,

                    KUsbWatcherSelectedPersonalityNone );

                }

            break;

        case EUsbStarted:

            if( iStopStartScenario )

                {

                break;

                }

            iPersonalityHandler->StopPersonality( iStatus );

            SetActive();

            iState = EUsbStopping;

            break;

        case EUsbIdle:

            if( iStopStartScenario )

                {

                Start();

                }

            break;

        case EUsbConfirmStop:

            if( iStatus == KErrNone )

                {

                iStopStartScenario = ETrue;

                iPersonalityHandler->StopPersonality( iStatus );

                SetActive();

                iState = EUsbStopping;

                }

            else

                {

                Notify( ret );

                iState = EUsbStarted;

                }

            break;

        default:

            LOG( "ERROR: unexpected state" );

            PANIC( KErrGeneral );

            break;

        }

    }

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

// This method is not called cause RunL() never leaves.

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

//

TInt CUsbWatcher::RunError(TInt aError)

    {

    LOG_FUNC

    LOG2("Returned error: %d, iState: %d", aError, iState);

    if ( iState == EUsbStarting )

        {

        RProperty::Set( KPSUidUsbWatcher,

                KUsbWatcherSelectedPersonality,

                KUsbWatcherSelectedPersonalityNone );

        LOG( "personality set to none" );

        iState = EUsbIdle;

        }

    return KErrNone;

    }

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

// Function is called when state of the device is locked.

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

//

void CUsbWatcher::Lock()

    {

    LOG_FUNC

    if( IsDeviceA() ) // Not applicable in case of A-device

        {

        LOG( "Lock ignored in A-device state" );

        return;

        }

    TUsbDeviceState state = iActiveState->CurrentState();

    LOG1( "USB device state after lock: %d", state );

    if( EUsbDeviceStateUndefined != state ) // Stop personality

        {

        LOG( "Stopping USB persoanlity on device remote-lock" );

        iPersonalityHandler->CancelCableConnectedNotifier();

        if( iState != EUsbStarted )

            {

            Cancel();

            }

        else

            {

            Stop();

            }

        }

    }

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

// Function is called when state of the device is unlocked.

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

//

void CUsbWatcher::Unlock()

    {

    LOG_FUNC

    if( IsDeviceA() ) // Not applicable in case of A-device

        {

        LOG( "Unlock ignored in A-device state" );

        return;

        }

    TUsbDeviceState state = iActiveState->CurrentState();

    LOG1( "USB device state after unlock: %d", state );

    if( EUsbDeviceStateAttached == state || EUsbDeviceStatePowered == state)

        {

        LOG( "Starting USB personality" );

        Start();

        }

    }

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

// This method is called when client wants to set new personality.