/*

* Copyright (c) 2008-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:  Implementation

 *

*/

#include <usbpersonalityids.h>

#include <usbuinotif.h>

#include <UsbWatcherInternalPSKeys.h>

#include "cusbotgwatcher.h"

#include "cusbstate.h"

#include "cusbstatehostainitiate.h"

#include "cusbstatehostahost.h"

#include "cusbstatehostaperipheral.h"

#include "cusbstatehostaidle.h"

#include "cusbstatehosthandle.h"

#include "cusbwarningnotifier.h"

#ifndef STIF

#include "cusbnotifmanager.h"

#else

#include "mockcusbnotifmanager.h"

#endif

#include "errors.h"

#include "debug.h"

#include "panic.h"

_LIT_SECURITY_POLICY_PASS( KAlwaysPassPolicy );

_LIT_SECURITY_POLICY_C1( KLocalServicesPolicy, ECapabilityLocalServices );

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

// 

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

//

CUsbOtgWatcher::CUsbOtgWatcher(RUsb& aUsbMan) :

    iUsb(aUsbMan), iPersonalityId(KUsbPersonalityIdMTP)

    {

        FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::CUsbOtgWatcher" ) );

    }

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

// 

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

//

void CUsbOtgWatcher::ConstructL()

    {

        FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::ConstructL" ) );

#ifdef _DEBUG

    SelfTestL();

#endif

#ifndef STIF

    User::LeaveIfError(RProperty::Define( KPSUidUsbWatcher,

            KUsbWatcherIsPeripheralConnected, RProperty::EInt, KAlwaysPassPolicy,

                KLocalServicesPolicy ) );

    User::LeaveIfError( RProperty::Set( KPSUidUsbWatcher,

            KUsbWatcherIsPeripheralConnected,

            KUsbWatcherPeripheralIsNotConnected ) );

#endif

    iNotifManager = CUsbNotifManager::NewL();

    iUsbServiceControl = CUsbServiceControl::NewL(this, iUsb);

    User::LeaveIfError(iStates.Append(CUsbStateHostAInitiate::NewL(this)));

    User::LeaveIfError(iStates.Append(CUsbStateHostAHost::NewL(this)));

    User::LeaveIfError(iStates.Append(CUsbStateHostAPeripheral::NewL(this)));

    User::LeaveIfError(iStates.Append(CUsbStateHostAIdle::NewL(this)));

    User::LeaveIfError(iStates.Append(CUsbStateHostHandle::NewL(this)));

    iIdPinObserver = CUsbIdPinObserver::NewL();

    iVBusObserver = CUsbVBusObserver::NewL();

    iOtgStateObserver = CUsbOtgStateObserver::NewL();

    iBusActivityObserver = CUsbBusActivityObserver::NewL();

    iHostEventNotificationObserver = CUsbHostEventNotificationObserver::NewL(

            &iUsb);

    iMessageNotificationObserver = CUsbMessageNotificationObserver::NewL(

            &iUsb);

    iIdPinObserver->SubscribeL(this);

    if (CUsbIdPinObserver::EIdPinOn == iIdPinObserver->IdPin())

        {

        StartSessionL();

        }

    }

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

// 

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

//

EXPORT_C TBool CUsbOtgWatcher::IsDeviceA()

    {

    __ASSERT_DEBUG(iIdPinObserver != NULL, Panic(EIdPinObserverNULLPointer));

    return (iIdPinObserver->IdPin() == CUsbIdPinObserver::EIdPinOn

                                                                   ? ETrue

                                                                      : EFalse);

    }

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

// 

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

//

EXPORT_C CUsbOtgWatcher* CUsbOtgWatcher::NewL(RUsb& aUsbMan)

    {

        FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::NewL" ) );

    CUsbOtgWatcher* self = new (ELeave) CUsbOtgWatcher(aUsbMan);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

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

// 

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

//

CUsbOtgWatcher::~CUsbOtgWatcher()

    {

		FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::~CUsbOtgWatcher" ) );

#ifndef STIF

    RProperty::Delete( KPSUidUsbWatcher, KUsbWatcherIsPeripheralConnected );

#endif

    delete iIdPinObserver;

    delete iVBusObserver;

    delete iOtgStateObserver;

    delete iBusActivityObserver;

    delete iHostEventNotificationObserver;

    delete iMessageNotificationObserver;

    // Destroy states

    iStates.ResetAndDestroy();

    iStates.Close();

    delete iNotifManager;

    delete iUsbServiceControl;

    iUsb.Close();

    }

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

// 

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

//

void CUsbOtgWatcher::SetPersonalityL(TRequestStatus& /*aStatus*/,

        TInt aPersonality)

    {

        FTRACE( FPrint(_L( "[USBOTGWATCHER]\tCUsbOtgWatcher::SetPersonalityL aPersonality = %d" ), aPersonality));

    // watcher keeps this value, no need to pass it to request object

    // state can read it from watcher when needed

    iPersonalityId = aPersonality;

    // more complex processing has to be here, remember aStatus, etc.

    // pass the request to device state machine

    iState->SetPersonalityL();

    // the request is not passed to host state machine due to host ignores SetPersonality

    }

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

// 

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

//

void CUsbOtgWatcher::CancelSetPersonalityL()

    {

        FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::CancelSetPersonalityL" ) );

    iState->CancelSetPersonalityL();

    }

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

// 

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

//

void CUsbOtgWatcher::SetPreviousPersonalityL(TRequestStatus& /*aStatus*/)

    {

        FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::SetPreviousPersonalityL" ) );

    // maybe more complex processing needed here

    iState->SetPreviousPersonalityL();

    }

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

// 

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

//

void CUsbOtgWatcher::SetPreviousPersonalityL()

    {

        FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::SetPreviousPersonalityL" ) );

    iState->SetPreviousPersonalityL();

    }

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

// 

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

//

void CUsbOtgWatcher::CancelSetPreviousPersonalityL()

    {

        FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::CancelSetPreviousPersonalityL" ) );

    iState->CancelSetPreviousPersonalityL();

    }

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

// 

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

//

void CUsbOtgWatcher::SetPreviousPreviousPersonalityOnDisconnectL()

    {

        FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::SetPreviousPreviousPersonalityOnDisconnectL" ) );

    }

// From IdPin observer

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

// 

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

//

void CUsbOtgWatcher::StartSessionL()

    {

        FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::StartSessionL" ) );

    if (!CanStartSessionL())

        {

        HandleHostProblemL(EUsbWatcherErrorInConnection);

        return;

        }

    TInt err = iUsbServiceControl->Start(iPersonalityId);

    if (KErrNone != err)

        {

            FTRACE( FPrint(_L( "[USBOTGWATCHER]\tCUsbOtgWatcher::StartSessionL Can not start usb services. reason = %d" ), err));

        HandleHostProblemL(EUsbWatcherCanNotStartUsbServices);

        return;

        }

    // call back from iUsbServiceControl->Start(iPersonalityId) call is UsbServiceControlReqCompletedL(TInt aError)

    // so, continue there if everything is OK

    }

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

// 

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

//

void CUsbOtgWatcher::HandleHostProblemL(TInt aWhatKindOf)

    {

        FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::HandleProblemL" ) );

    HostHandle()->SetWhat(aWhatKindOf);

    ChangeHostStateL(EUsbStateHostHandle);

    }

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

// 

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

//

void CUsbOtgWatcher::IdPinOnL()

    {

        FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::IdPinOnL" ) );

    StartSessionL();

    }

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

// 

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

//

void CUsbOtgWatcher::IdPinOffL()

    {

        FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::IdPinOffL" ) );

    // for example, USB failed to start    

    if(NULL == iHostState) return;

    iVBusObserver->UnsubscribeL(this);

    iOtgStateObserver->UnsubscribeL(this);

    iBusActivityObserver->UnsubscribeL(this);

    iHostEventNotificationObserver->UnsubscribeL(this);

    iMessageNotificationObserver->UnsubscribeL(this);

    iHostState->JustBeforeLeavingThisStateL();

    iHostState = NULL;

    iNotifManager->CloseAllNotifiers();

        FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::IdPinOffL Before DisableFunctionDriverLoad " ) );

    Usb().DisableFunctionDriverLoading();

        FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::IdPinOffL Before TryStop" ) );

    TInt err = iUsbServiceControl->Stop();

    if (KErrNone != err)

        {

            FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::IdPinOnL ErrorStoppingUsbServices" ) );

        Panic(ECanNotStopUsbServices);

        }

        FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::IdPinOffL iUsbServiceControl->Stop() OK" ) );

    }

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

// 

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

//

void CUsbOtgWatcher::IdPinErrorL(TInt aError)

    {

    FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::IdPinErrorL" ) );

    __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState));  

    HandleHostProblemL(EUsbWatcherIdPinError);

    }

// From VBus observer

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

// 

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

//

void CUsbOtgWatcher::VBusDownL()

    {

        FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::VBusDownL" ) );

    __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState));

    iHostState->VBusDownL();

    }

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

// 

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

//

void CUsbOtgWatcher::VBusUpL()

    {

        FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::VBusUpL" ) );

    __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState));

    iHostState->VBusUpL();

    }

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

// 

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

//

void CUsbOtgWatcher::VBusObserverErrorL(TInt aError)

    {

        FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::VBusObserverErrorL" ) );

    __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState));

    HandleHostProblemL(EUsbWatcherVBusObserverError);

    }

// From OTG state observer

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

// 

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

//

void CUsbOtgWatcher::AIdleL()

    {

        FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::AIdleL" ) );

    __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState));

    iHostState->AIdleL();

    }

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

// 

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

//

void CUsbOtgWatcher::AHostL()

    {

        FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::AHostL" ) );

    __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState));

    iHostState->AHostL();

    }

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

// 

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

//

void CUsbOtgWatcher::APeripheralL()

    {

        FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::APeripheralL" ) );

    __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState));

    iHostState->APeripheralL();

    }

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

// 

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

//

void CUsbOtgWatcher::AVBusErrorL()

    {

        FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::AVBusErrorL" ) );

    __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState));

    iHostState->AVBusErrorL();

    }

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

// 

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

//

void CUsbOtgWatcher::BIdleL()

    {

        FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::BIdleL" ) );

    __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState));

    iHostState->BIdleL();

    }

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

// 

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

//

void CUsbOtgWatcher::BPeripheralL()

    {

        FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::BPeripheralL" ) );

    __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState));

    iHostState->BPeripheralL();

    }

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

// 

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

//

void CUsbOtgWatcher::BHostL()

    {

        FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::BHostL" ) );

    __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState));

    iHostState->BHostL();

    }

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

// 

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

//

void CUsbOtgWatcher::OtgStateErrorL(TInt aError)

    {

    FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::OtgStateErrorL" ) );

__ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState));  

HandleHostProblemL(EUsbWatcherOtgStateError);

    }

// From bus activity observer

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

// 

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

//

void CUsbOtgWatcher::BusIdleL()

    {

        FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::BusIdleL" ) );

    __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState));

    iHostState->BusIdleL();

    }

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

// 

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

//

void CUsbOtgWatcher::BusActiveL()

    {

        FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::BusActiveL" ) );

    __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState));

    iHostState->BusActiveL();

    }

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

// 

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

//

void CUsbOtgWatcher::BusActivityErrorL(TInt aError)

    {

    FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::BusActivityErrorL" ) );

    __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState));

    // no action, continue

    }

// From Host Event notification observer

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

// 

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

//

void CUsbOtgWatcher::DeviceAttachedL(TDeviceEventInformation aTdi)

    {

        FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::DeviceAttachedL" ) );

    __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState));

    iHostState->DeviceAttachedL(aTdi);

    }

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

// 

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

//

void CUsbOtgWatcher::DeviceDetachedL(TDeviceEventInformation aTdi)

    {

        FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::DeviceDetachedL" ) );

    __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState));

    iHostState->DeviceDetachedL(aTdi);

    }

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

// 

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

//

void CUsbOtgWatcher::DriverLoadSuccessL(TDeviceEventInformation aTdi)

    {

        FLOG( _L( "[USBOTGWATCHER]\tCUsbOtgWatcher::DriverLoadSuccessL" ) );

    __ASSERT_DEBUG(iHostState != NULL, Panic(EBadHostState));