// Copyright (c) 2009 Nokia Corporation and/or its subsidiary(-ies).

// All rights reserved.

// This component and the accompanying materials are made available

// under the terms of the License "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:

//

#include <e32cmn.h>

#include <e32base.h>

#include <d32otgdi.h>

#include <e32property.h>

#include "cusbotg.h"

#include "cusbotgwatcher.h"

#include "rusbmspublisher.h"

#include "tmslog.h"

#include "debug.h"

_LIT(KOtgdiLddFileName, "otgdi");

ROtgStateChangeNotifier::ROtgStateChangeNotifier()

:   iRegistered(EFalse)

    {

    __MSFNSLOG

    }

ROtgStateChangeNotifier::~ROtgStateChangeNotifier()

    {

    __MSFNSLOG

    if (iRegistered)

        iMessage.Complete(KErrDisconnected);

    }

/**

Initialise notifier to enable media change notfications.

@param aMessage The message to commplete the notification

*/

void ROtgStateChangeNotifier::Register(const RMessage2& aMessage)

    {

    __MSFNLOG

	iRegistered = ETrue;

	iMessage = aMessage;

    }

void ROtgStateChangeNotifier::DoNotifyL()

    {

	__MSFNLOG

	CompleteNotifierL(KErrNone);

    }

void ROtgStateChangeNotifier::DoCancelL()

    {

	__MSFNLOG

	CompleteNotifierL(KErrCancel);

    }

void ROtgStateChangeNotifier::CompleteNotifierL(TInt aReason)

	{

    __MSFNLOG

	if (iRegistered)

        {

		TBool changed = ETrue;

        TPckgBuf<TBool> p(changed);

		iMessage.WriteL(0, p);

		iMessage.Complete(aReason);

		iRegistered = EFalse;

        }

	}

CUsbOtg* CUsbOtg::NewL()

	{

    __MSFNSLOG

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

	CleanupStack::PushL(self);

	self->ConstructL();

	CleanupStack::Pop(self);

	return self;

	}

void CUsbOtg::ConstructL()

	{

    __MSFNLOG

    TInt r = User::LoadLogicalDevice(KOtgdiLddFileName);

    if (r != KErrNone && r != KErrAlreadyExists)

        {

        __USBOTGPRINT1(_L("   LoadLogicalDevice(KOtgdiLddFileName) error = %d"), r);

        User::Leave(r);

        }

    r = iUsbOtgDriver.Open();

    if (r != KErrNone && r != KErrAlreadyExists)

        {

        __USBOTGPRINT1(_L("   otg.Open fails %d"), r);

        User::FreeLogicalDevice(RUsbOtgDriver::Name());

        User::Leave(r);

        }

    StartL();

    r = iUsbOtgDriver.StartStacks();

    if (r != KErrNone)

        {

        __USBOTGPRINT1(_L("   otg.StartStacks fails %d"), r);

        User::FreeLogicalDevice(RUsbOtgDriver::Name());

        User::Leave(r);

        }

    __USBOTGPRINT(_L("   otg stacks successfully started"));

	}

CUsbOtg::CUsbOtg()

:   iOtgState(KOtgStateStart)

    {

    __MSFNLOG

    }

CUsbOtg::~CUsbOtg()

	{

    __MSFNLOG

    Stop();

    TInt r = iUsbOtgDriver.BusDrop();

    // Unload OTGDI components if it was ever started

    if (iUsbOtgDriver.Handle())

        {

        iUsbOtgDriver.StopStacks();

        iUsbOtgDriver.Close();

        }

    TInt err = User::FreeLogicalDevice(RUsbOtgDriver::Name());

	}

void CUsbOtg::StartL()

    {

    __MSFNLOG

	// Request Otg notifications

    iOtgEventWatcher = CUsbOtgEventWatcher::NewL(iUsbOtgDriver, *this);

	iOtgEventWatcher->Start();

    iRequestSessionWatcher = CRequestSessionWatcher::NewL(*this);

    }

void CUsbOtg::Stop()

/**

 * Stop the USB OTG events watcher

 */

    {

    __MSFNLOG

    if (iOtgEventWatcher)

        {

        iOtgEventWatcher->Cancel();

        delete iOtgEventWatcher;

        iOtgEventWatcher = NULL;

        }

    if (iRequestSessionWatcher)

        {

        delete iRequestSessionWatcher;

        iRequestSessionWatcher = NULL;

        }

    }

void CUsbOtg::BusRequestL()

    {

    __MSFNLOG

    if (iOtgState == KOtgStateAPlugInserted)

        {

        TInt err = iUsbOtgDriver.BusRequest();

        if (err)

            {

            __USBOTGPRINT1(_L("OTG::BusRequest[%d] failed !"), err);

            }

        User::LeaveIfError(err);

        iOtgState = KOtgStateSessionOpen;

        }

    }

void CUsbOtg::HandleUsbOtgEvent(RUsbOtgDriver::TOtgEvent aEvent)

    {

    __MSFNLOG

    switch (aEvent)

        {

        case RUsbOtgDriver::EEventAPlugInserted:

            {

            __USBOTGPRINT(_L(">> UsbOtgEvent[EEventAPlugInserted]"));

            /*

            RUsbOtgEventPublisher eventPublisher;

            eventPublisher.PublishEvent(aEvent);

            */

            iNotifier.DoNotifyL();

            iOtgState = KOtgStateAPlugInserted;

            }

            break;

        case RUsbOtgDriver::EEventBusConnectionBusy:

            {

            RUsbManConnectionStatePublisher publisher;

            publisher.PublishEvent(ETrue);

            }

            break;

        case RUsbOtgDriver::EEventBusConnectionIdle:

            {

            RUsbManConnectionStatePublisher publisher;

            publisher.PublishEvent(EFalse);

            }

            break;

        default:

            __USBOTGPRINT1(_L(">> UsbOtgEvent[%x]"), aEvent);

            break;

        }

    }

TBool CUsbOtg::DeviceInserted()

    {

    __MSFNLOG

    return iOtgState == KOtgStateAPlugInserted ? ETrue : EFalse;

    }

void CUsbOtg::NotifyChange(const RMessage2& aMessage)

    {

    __MSFNLOG

    iNotifier.Register(aMessage);

    }

void CUsbOtg::NotifyChangeCancel()

    {

    __MSFNLOG

    iNotifier.DoCancelL();

    }

TInt CUsbOtg::BusDrop()

    {

    __MSFNLOG

    return iUsbOtgDriver.BusDrop();

    }