/*
* Copyright (c) 2007 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:  Device state watcher class.
 *
*/


// INCLUDE FILES
#include <e32base.h>
#include <e32property.h>
#include <UsbWatcherInternalPSKeys.h>

#include "usbotghoststatewatcher.h"
#include "USBClassChangeUIPluginDebug.h"

// --------------------------------------------------------------------------
// Two-phased constructor. Uses existing usb manager session.
// --------------------------------------------------------------------------
CUSBOtgHostStateWatcher* 
CUSBOtgHostStateWatcher::NewL(MUSBOtgHostStateObserver& aObserver, RUsb& aUsbMan)
    {
    FLOG(_L("[CUSBClassChangeUIPlugin]\t CUSBOtgHostStateWatcher:NewL"));
    
    CUSBOtgHostStateWatcher* self = new(ELeave)CUSBOtgHostStateWatcher(aObserver, aUsbMan);
    CleanupStack::PushL(self);
    self->ConstructL();
    CleanupStack::Pop(self);
    return self;
    }

// --------------------------------------------------------------------------
// C++ destructor
// --------------------------------------------------------------------------
CUSBOtgHostStateWatcher::~CUSBOtgHostStateWatcher()
    {
    FLOG(_L("[CUSBClassChangeUIPlugin]\t CUSBOtgHostStateWatcher:~CUSBOtgHostStateWatcher"));

    delete iOtgIdPinWatcher;
    delete iHostEventWatcher;
    iPeripheral.Close();
    }

// --------------------------------------------------------------------------
// Get Id pin state
// --------------------------------------------------------------------------
TInt CUSBOtgHostStateWatcher::IsIdPinOn(TBool& aIsIdPinOn)
    {
    return iOtgIdPinWatcher->IsIdPinOn(aIsIdPinOn);
    }

// --------------------------------------------------------------------------
// Check wheather a pheripheral device is connected or not. 
// --------------------------------------------------------------------------
TInt CUSBOtgHostStateWatcher::IsPeripheralConnected(TBool &aIsConnected)
    {
    aIsConnected = EFalse;

    TInt val(0);
    TInt err = iPeripheral.Get(val);

    if (KErrNone != err)
        {
        FTRACE(FPrint(_L("[CUSBClassChangeUIPlugin]\t CUSBOtgHostStateWatcher::IsPeripheralConnected - err=%d"), err));
        return err;
        }
    
    FTRACE(FPrint(_L("[CUSBClassChangeUIPlugin]\t CUSBOtgHostStateWatcher::IsPeripheralConnected - val=%d"), val));
    aIsConnected = (TBool)val;
    
    return KErrNone;
    }

// --------------------------------------------------------------------------
// C++ constructor
// --------------------------------------------------------------------------
CUSBOtgHostStateWatcher::CUSBOtgHostStateWatcher(
        MUSBOtgHostStateObserver& aObserver, RUsb& aUsbMan) 
    : iUsbMan(aUsbMan), iObserver(aObserver)
    {
    }

// --------------------------------------------------------------------------
// Symbian 2nd phase constructor. 
// --------------------------------------------------------------------------
void CUSBOtgHostStateWatcher::ConstructL()
    {
    iOtgIdPinWatcher = CUSBOtgIdPinStateWatcher::NewL(*this);
    iHostEventWatcher = CUSBHostEventNotifWatcher::NewL(*this);
    TInt ret = iPeripheral.Attach(KPSUidUsbWatcher, KUsbWatcherIsPeripheralConnected);
    if (ret != KErrNone)
        {
        FTRACE(FPrint(_L("[CUSBClassChangeUIPlugin]\t CUSBOtgHostStateWatcher::ConstructL - iPeripheral.Attach err=%d"), ret));
        User::Leave(ret);
        }    
    }


// --------------------------------------------------------------------------
// Two-phased constructor.
// --------------------------------------------------------------------------
CUSBOtgHostStateWatcher::CUSBOtgIdPinStateWatcher* 
CUSBOtgHostStateWatcher::CUSBOtgIdPinStateWatcher::NewL(CUSBOtgHostStateWatcher& aOtgHostStateWatcher)
    {
    FLOG(_L("[CUSBClassChangeUIPlugin]\t CUSBOtgIdPinStateWatcher::NewL"));

    CUSBOtgIdPinStateWatcher* self = new(ELeave)CUSBOtgIdPinStateWatcher(aOtgHostStateWatcher);
    CleanupStack::PushL(self);
    self->ConstructL();
    CleanupStack::Pop(self);
    return self;
    }

// --------------------------------------------------------------------------
// C++ destructor
// --------------------------------------------------------------------------
CUSBOtgHostStateWatcher::CUSBOtgIdPinStateWatcher::~CUSBOtgIdPinStateWatcher()
    {
    FLOG(_L("[CUSBClassChangeUIPlugin]\t CUSBOtgIdPinStateWatcher::~CUSBOtgIdPinStateWatcher"));

    Cancel();    
    iIdPin.Close();
    }

// --------------------------------------------------------------------------
// Get Id pin state
// --------------------------------------------------------------------------
TInt CUSBOtgHostStateWatcher::CUSBOtgIdPinStateWatcher::IsIdPinOn(TBool& aIsIdPinOn)
    {
    FLOG(_L("[CUSBClassChangeUIPlugin]\t CUSBOtgIdPinStateWatcher::IsIdPinOn" ));

    TInt val(0);
    TInt err = iIdPin.Get(val);

    if (KErrNone != err)
        {
        FTRACE(FPrint(_L("[CUSBClassChangeUIPlugin]\t CUSBOtgIdPinStateWatcher::IsIdPinOn - err=%d"), err));
        return err;
        }

    FTRACE(FPrint(_L( "[CUSBClassChangeUIPlugin]\t CUSBOtgIdPinStateWatcher::IsIdPinOn=%d" ), val ));

    // not found in docs clear definition of this property. Verification is needed   
    aIsIdPinOn = (0 == val ? EFalse : ETrue);
    
    return KErrNone;
    }

// --------------------------------------------------------------------------
// The Id pin state has changed.
// --------------------------------------------------------------------------
void CUSBOtgHostStateWatcher::CUSBOtgIdPinStateWatcher::RunL()
    {
    FLOG(_L("[CUSBClassChangeUIPlugin]\t CUSBOtgIdPinStateWatcher::RunL"));

    if (iStatus.Int() != KErrNone)
        {
        FTRACE(FPrint(_L("[CUSBClassChangeUIPlugin]\t CUSBOtgIdPinStateWatcher::RunL - iStatus=%d"), iStatus.Int()));
        User::Leave(iStatus.Int());
        }    

    // re-issue request first
    iIdPin.Subscribe(iStatus);
    SetActive();

    TBool isIdPinOn;
    TInt ret = IsIdPinOn(isIdPinOn);
    if (ret != KErrNone)
        {
        FTRACE(FPrint(_L("[CUSBClassChangeUIPlugin]\t CUSBOtgIdPinStateWatcher::RunL - IsIdPinOn=%d"), ret));
        User::Leave(ret);
        }    

    if (isIdPinOn)
        {
        FLOG(_L("[CUSBClassChangeUIPlugin]\t CUSBOtgIdPinStateWatcher::RunL IdPin ON"));

        iOtgHostStateWatcher.iObserver.OtgHostIdPinStateChanged(ETrue);
        }
    else
        {
        FLOG(_L("[CUSBClassChangeUIPlugin]\t CUSBOtgIdPinStateWatcher::RunL IdPin OFF"));

        iOtgHostStateWatcher.iObserver.OtgHostIdPinStateChanged(EFalse);
        }
    }
 
// ----------------------------------------------------------------------------
// Standard active object error function.
// ----------------------------------------------------------------------------
TInt CUSBOtgHostStateWatcher::CUSBOtgIdPinStateWatcher::RunError(TInt aError)
    {
    FTRACE(FPrint(_L("[CUSBClassChangeUIPlugin]\t CUSBOtgIdPinStateWatcher::RunL"), aError));

    // Currently no leaving functions called in RunL, thus nothing should cause
    // this to be called -> return.
    return KErrNone;
    }

// ----------------------------------------------------------------------------
// Standard active object cancellation function.
// ----------------------------------------------------------------------------
void CUSBOtgHostStateWatcher::CUSBOtgIdPinStateWatcher::DoCancel()
    {
    FLOG(_L("[CUSBClassChangeUIPlugin]\t CUSBOtgIdPinStateWatcher::DoCancel"));
    
    iIdPin.Cancel();
    }

// ----------------------------------------------------------------------------
// C++ constructor
// ----------------------------------------------------------------------------
CUSBOtgHostStateWatcher::CUSBOtgIdPinStateWatcher::CUSBOtgIdPinStateWatcher(
        CUSBOtgHostStateWatcher& aOtgHostStateWatcher)
    : CActive(EPriorityStandard), iOtgHostStateWatcher(aOtgHostStateWatcher)
    {
    CActiveScheduler::Add(this);
    }

// --------------------------------------------------------------------------
// Symbian 2nd phase constructor. 
// --------------------------------------------------------------------------
void CUSBOtgHostStateWatcher::CUSBOtgIdPinStateWatcher::ConstructL()
    {
    TInt ret = iIdPin.Attach(KUidUsbManCategory, KUsbOtgIdPinPresentProperty);
    if (ret != KErrNone)
        {
        FTRACE(FPrint(_L("[CUSBClassChangeUIPlugin]\t CUSBOtgIdPinStateWatcher::ConstructL - iIdPin.Attach error:%d"), ret));
        User::Leave(ret);
        }
    
    // Issue request first
    iIdPin.Subscribe(iStatus);
    SetActive();
    }

// --------------------------------------------------------------------------
// Two-phased constructor.
// --------------------------------------------------------------------------
CUSBOtgHostStateWatcher::CUSBHostEventNotifWatcher* 
CUSBOtgHostStateWatcher::CUSBHostEventNotifWatcher::NewL(CUSBOtgHostStateWatcher& aOtgHostStateWatcher)
    {
    FLOG(_L("[CUSBClassChangeUIPlugin]\t CUSBHostEventNotifWatcher::NewL"));

    CUSBHostEventNotifWatcher* self = new(ELeave)CUSBHostEventNotifWatcher(aOtgHostStateWatcher);
    CleanupStack::PushL(self);
    self->ConstructL();
    CleanupStack::Pop(self);
    return self;
    }

// --------------------------------------------------------------------------
// C++ destructor
// --------------------------------------------------------------------------
CUSBOtgHostStateWatcher::CUSBHostEventNotifWatcher::~CUSBHostEventNotifWatcher()
    {
    FLOG(_L("[CUSBClassChangeUIPlugin]\t CUSBHostEventNotifWatcher::~CUSBHostEventNotifWatcher"));

    Cancel();    
    }

// --------------------------------------------------------------------------
// The Id pin state has changed.
// --------------------------------------------------------------------------
void CUSBOtgHostStateWatcher::CUSBHostEventNotifWatcher::RunL()
    {
    FLOG(_L("[CUSBClassChangeUIPlugin]\t CUSBHostEventNotifWatcher::RunL"));

    if (iStatus.Int() != KErrNone)
        {
        FTRACE(FPrint(_L("[CUSBClassChangeUIPlugin]\t CUSBHostEventNotifWatcher::RunL - iStatus=%d"), iStatus.Int()));
        User::Leave(iStatus.Int());
        }    

    // Save current event
    TDeviceEventInformation dei = iEventInfo;

    // Re-issue request first
    iOtgHostStateWatcher.iUsbMan.HostEventNotification(iStatus, iEventInfo);
    SetActive();
   
    iOtgHostStateWatcher.iObserver.HostEventNotify(dei);    
    }
 
// ----------------------------------------------------------------------------
// Standard active object error function.
// ----------------------------------------------------------------------------
TInt CUSBOtgHostStateWatcher::CUSBHostEventNotifWatcher::RunError(TInt aError)
    {
    FTRACE(FPrint(_L("[CUSBClassChangeUIPlugin]\t CUSBHostEventNotifWatcher::RunL"), aError));

    // Currently no leaving functions called in RunL, thus nothing should cause
    // this to be called -> return.
    return KErrNone;
    }

// ----------------------------------------------------------------------------
// Standard active object cancellation function.
// ----------------------------------------------------------------------------
void CUSBOtgHostStateWatcher::CUSBHostEventNotifWatcher::DoCancel()
    {
    FLOG(_L("[CUSBClassChangeUIPlugin]\t CUSBHostEventNotifWatcher::DoCancel"));
    
    iOtgHostStateWatcher.iUsbMan.HostEventNotificationCancel();
    }

// ----------------------------------------------------------------------------
// C++ constructor
// ----------------------------------------------------------------------------
CUSBOtgHostStateWatcher::CUSBHostEventNotifWatcher::CUSBHostEventNotifWatcher(
        CUSBOtgHostStateWatcher& aOtgHostStateWatcher)
    : CActive(EPriorityStandard), iOtgHostStateWatcher(aOtgHostStateWatcher)
    {
    CActiveScheduler::Add(this);
    }

// --------------------------------------------------------------------------
// Symbian 2nd phase constructor. 
// --------------------------------------------------------------------------
void CUSBOtgHostStateWatcher::CUSBHostEventNotifWatcher::ConstructL()
    {
    iOtgHostStateWatcher.iUsbMan.HostEventNotification(iStatus, iEventInfo);
    SetActive();
    }