/*

 * Copyright (c) 2008 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 "cusbstatehosthandle.h"

#include "cusbstatehostdelayhandle.h"

#include "cusbstatehostdelayattachedhandle.h"

#include "cusbstatehostdelaynotattachedhandle.h"

#include "cusbstatehosthandledropping.h"

#include "cusbstatehostundefined.h"

#include "cusbwarningnotifier.h"

#ifndef STIF

#include "cusbnotifmanager.h"

#else

#include "mockcusbnotifmanager.h"

#endif

#include "errors.h"

#include "debug.h"

#include "panic.h"

#ifndef STIF

_LIT_SECURITY_POLICY_PASS( KAlwaysPassPolicy );

_LIT_SECURITY_POLICY_C1( KLocalServicesPolicy, ECapabilityLocalServices );

#endif

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

// 

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

//

CUsbOtgWatcher::CUsbOtgWatcher(RUsb& aUsbMan) :

    iUsb(aUsbMan), iPersonalityId(KUsbPersonalityIdMTP), iUsbServiceRequest(

            CUsbServiceControl::ERequestUndefined)

    {

    LOG_FUNC

    }

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

// 

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

//

void CUsbOtgWatcher::ConstructL()

    {

    LOG_FUNC

#ifdef _DEBUG

    SelfTestL();

#endif

#ifndef STIF

    LEAVEIFERROR(RProperty::Define(KPSUidUsbWatcher,

                    KUsbWatcherIsPeripheralConnected, RProperty::EInt,

                    KAlwaysPassPolicy, KLocalServicesPolicy));

    LEAVEIFERROR(RProperty::Set(KPSUidUsbWatcher,

                    KUsbWatcherIsPeripheralConnected,

                    KUsbWatcherPeripheralIsNotConnected));

#endif

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

    LEAVEIFERROR(iStates.Append(CUsbStateHostUndefined::NewL(*this)));

    LEAVEIFERROR(iStates.Append(CUsbStateHostAInitiate::NewL(*this)));

    LEAVEIFERROR(iStates.Append(CUsbStateHostAHost::NewL(*this)));

    LEAVEIFERROR(iStates.Append(CUsbStateHostAPeripheral::NewL(*this)));

    LEAVEIFERROR(iStates.Append(CUsbStateHostDelayAttachedHandle::NewL(

                            *this)));

    LEAVEIFERROR(iStates.Append(

                    CUsbStateHostDelayNotAttachedHandle::NewL(*this)));

    LEAVEIFERROR(iStates.Append(

                    CUsbStateHostHandleDropping::NewL(*this)));

    iIdPinObserver = CUsbIdPinObserver::NewL();

    iVBusObserver = CUsbVBusObserver::NewL();

    iOtgStateObserver = CUsbOtgStateObserver::NewL();

    iBusActivityObserver = CUsbBusActivityObserver::NewL();

    iHostEventNotificationObserver = CUsbHostEventNotificationObserver::NewL(

            &iUsb);

    iMessageNotificationObserver = CUsbMessageNotificationObserver::NewL(

            &iUsb);

    iHostState = iStates[EUsbStateHostUndefined];

    // Notif manager must be created at least after VBus observer and iHostState initialization

    // to allow USb indicator subscribe to its notifications at construction and check their's current states

    iNotifManager = CUsbNotifManager::NewL(*this);

    iVBusObserver->SubscribeL(*this);

    iOtgStateObserver->SubscribeL(*this);

    iBusActivityObserver->SubscribeL(*this);

    iHostEventNotificationObserver->SubscribeL(*this);

    iMessageNotificationObserver->SubscribeL(*this);

    iIdPinObserver->SubscribeL(*this);

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

        {

        StartSessionL();

        }

    }

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

// 

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

//

EXPORT_C TBool CUsbOtgWatcher::IsDeviceA()

    {

    ASSERT_PANIC(iIdPinObserver != NULL, EIdPinObserverNULLPointer);

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

                                                                   ? ETrue

                                                                      : EFalse);

    }

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

// 

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

//

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

    {

    LOG_FUNC

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

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

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

// 

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

//

    {

    LOG_FUNC

#ifndef STIF

    RProperty::Delete(KPSUidUsbWatcher, KUsbWatcherIsPeripheralConnected);

#endif

    // delete Notif manager before VBus observer, due to USB indicator observes VBus

    delete iNotifManager;

    if (iIdPinObserver)

        {

        TRAP_IGNORE(iIdPinObserver->UnsubscribeL(*this));

        }

    if (iVBusObserver)

        {

        TRAP_IGNORE(iVBusObserver->UnsubscribeL(*this));

        }

    if (iOtgStateObserver)

        {

        TRAP_IGNORE(iOtgStateObserver->UnsubscribeL(*this));

        }

    if (iBusActivityObserver)

        {

        TRAP_IGNORE(iBusActivityObserver->UnsubscribeL(*this));

        }

    if (iHostEventNotificationObserver)

        {

        TRAP_IGNORE(iHostEventNotificationObserver->UnsubscribeL(*this));

        }

    if (iMessageNotificationObserver)

        {

        TRAP_IGNORE(iMessageNotificationObserver->UnsubscribeL(*this));

        }

    delete iIdPinObserver;

    delete iVBusObserver;

    delete iOtgStateObserver;

    delete iBusActivityObserver;

    delete iHostEventNotificationObserver;

    delete iMessageNotificationObserver;

    iOtgStateObservers.Close();

    // Destroy states

    iStates.ResetAndDestroy();

    iStates.Close();

    delete iUsbServiceControl;

    iUsb.Close();

    }

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

// 

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

//

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

        TInt aPersonality)

    {

    LOG_FUNC

    LOG1( "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()

    {

    LOG_FUNC

    iState->CancelSetPersonalityL();

    }

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

// 

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

//

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

    {

    LOG_FUNC

    // maybe more complex processing needed here

    iState->SetPreviousPersonalityL();

    }

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

// 

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

//

void CUsbOtgWatcher::SetPreviousPersonalityL()

    {

    LOG_FUNC

    iState->SetPreviousPersonalityL();

    }

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

// 

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

//

void CUsbOtgWatcher::CancelSetPreviousPersonalityL()

    {

    LOG_FUNC

    iState->CancelSetPreviousPersonalityL();

    }

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

// 

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

//

void CUsbOtgWatcher::SetPreviousPreviousPersonalityOnDisconnectL()

    {

    LOG_FUNC

    }

// From IdPin observer

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

// 

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

//

void CUsbOtgWatcher::StartSessionL()

    {

    LOG_FUNC

    if (!CanStartSessionL())

        {

        HandleHostProblemL(EUsbWatcherCanNotStartSession,

                EUsbStateHostHandleDropping);

        return;

        }

    iUsbServiceRequest = CUsbServiceControl::EStartUsbService;

    TInt err = iUsbServiceControl->StartL(iPersonalityId);

    if (KErrNone != err)

        {

        LOG1( "Can not start usb services. err = %d" , err);

        HandleHostProblemL(EUsbWatcherCanNotStartUsbServices,

                EUsbStateHostHandleDropping);

        return;

        }

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

    // so, continue there if everything is OK

    }

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

// 

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

//

void CUsbOtgWatcher::HandleHostProblemL(TInt aWhatKindOf,

        TUsbStateIds aInState)

    {

    LOG_FUNC

    HostHandle(aInState)->SetWhat(aWhatKindOf);

    ChangeHostStateL(aInState);

    }

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

// 

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

//

void CUsbOtgWatcher::IdPinOnL()

    {

    LOG_FUNC

    StartSessionL();

    }

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

// 

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

//

void CUsbOtgWatcher::IdPinOffL()

    {

    LOG_FUNC

    ChangeHostStateL(EUsbStateHostUndefined);

    iNotifManager->CloseAllNotifiers();

    Usb().DisableFunctionDriverLoading();

    iUsbServiceRequest = CUsbServiceControl::EStopUsbService;

    TInt err = iUsbServiceControl->StopL();

    LOG1( "iUsbServiceControl->Stop() err = %d", err );

    if (KErrNone != err)

        {

        LOG( "ErrorStoppingUsbServices" );

        PANIC(ECanNotStopUsbServices);

        }

    }

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

// 

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

//

    {

    ASSERT_PANIC(iHostState != NULL, EBadHostState);

    HandleHostProblemL(EUsbWatcherIdPinError, EUsbStateHostHandleDropping);

    }

// From VBus observer

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

// 

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

//

void CUsbOtgWatcher::VBusDownL()

    {

    ASSERT_PANIC(iHostState != NULL, EBadHostState);

    iHostState->VBusDownL();

    }

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

// 

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

//

void CUsbOtgWatcher::VBusUpL()

    {

    ASSERT_PANIC(iHostState != NULL, EBadHostState);

    iHostState->VBusUpL();

    }

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

// 

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

//

    {

    ASSERT_PANIC(iHostState != NULL, EBadHostState);

    HandleHostProblemL(EUsbWatcherVBusObserverError,

            EUsbStateHostHandleDropping);

    }

// From OTG state observer

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

// 

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

//

void CUsbOtgWatcher::AIdleL()

    {

    ASSERT_PANIC(iHostState != NULL, EBadHostState);

    iHostState->AIdleL();

    }

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

// 

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

//

void CUsbOtgWatcher::AHostL()

    {

    ASSERT_PANIC(iHostState != NULL, EBadHostState);

    iHostState->AHostL();

    }

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

// 

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

//

void CUsbOtgWatcher::APeripheralL()

    {

    ASSERT_PANIC(iHostState != NULL, EBadHostState);

    iHostState->APeripheralL();

    }

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

// 

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

//

void CUsbOtgWatcher::AVBusErrorL()

    {

    ASSERT_PANIC(iHostState != NULL, EBadHostState);

    iHostState->AVBusErrorL();

    }

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

// 

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

//

void CUsbOtgWatcher::BIdleL()

    {

    ASSERT_PANIC(iHostState != NULL, EBadHostState);

    iHostState->BIdleL();

    }

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

// 

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

//

void CUsbOtgWatcher::BPeripheralL()

    {

    ASSERT_PANIC(iHostState != NULL, EBadHostState);

    iHostState->BPeripheralL();

    }

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

// 

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

//

void CUsbOtgWatcher::BHostL()

    {

    ASSERT_PANIC(iHostState != NULL, EBadHostState);

    iHostState->BHostL();

    }

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

// 

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

//

    {

    ASSERT_PANIC(iHostState != NULL, EBadHostState);

    HandleHostProblemL(EUsbWatcherOtgStateError, EUsbStateHostHandleDropping);

    }

// From bus activity observer

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

// 

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

//

void CUsbOtgWatcher::BusIdleL()

    {

    ASSERT_PANIC(iHostState != NULL, EBadHostState);

    iHostState->BusIdleL();

    }

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

// 

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

//

void CUsbOtgWatcher::BusActiveL()

    {

    ASSERT_PANIC(iHostState != NULL, EBadHostState);

    iHostState->BusActiveL();

    }