/*

* Copyright (c) 2006 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:  Monitors for USB events

*

*/

#include <e32base.h>

#include <f32file.h>

#include <e32property.h>

#ifdef RD_MULTIPLE_DRIVE

#include <driveinfo.h>

#endif //RD_MULTIPLE_DRIVE

#include <mpxpskeywatcher.h>

#include <coreapplicationuisdomainpskeys.h>

#include <UsbWatcherInternalPSKeys.h>

#include <usbpersonalityids.h>

#include <mtpprivatepskeys.h>

#include <mpxlog.h>

#include "mpxconnectioneventhandler.h"

// CONSTANTS

const TUint KUsbAllStates = 0xFFFFFFFF;

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

// Default Constructor

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

//

CMPXConnectionEventHandler::CMPXConnectionEventHandler( MMPXSystemEventObserver& aObserver ) :

                                          CActive( EPriorityStandard ),

                                          iObserver( aObserver ),

                                          iState ( EMPXConnectionNone ),

                                          iUsbManConnected( EFalse )

    {

    CActiveScheduler::Add( this );

    }

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

// 2nd Phase Constructor

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

//

void CMPXConnectionEventHandler::ConstructL()

    {

    MPX_DEBUG1(_L("CMPXConnectionEventHandler::ConstructL <---"));

    iUSBKeyWatcher = CMPXPSKeyWatcher::NewL( KPSUidUsbWatcher,

                                            KUsbWatcherSelectedPersonality,

                                            this );

    //for checking MTP status key whether a client has started

    iMTPKeyWatcher = CMPXPSKeyWatcher::NewL( KMtpPSUid, 

                                             KMtpPSStatus,

                                             this );

    // Connect to usbman

    ConnectUsbMan();

    MPX_DEBUG1(_L("CMPXConnectionEventHandler::ConstructL --->"));

    }

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

// Two Phased Constructor

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

//

CMPXConnectionEventHandler* CMPXConnectionEventHandler::NewL

                                        ( MMPXSystemEventObserver& aObserver )

    {

    CMPXConnectionEventHandler* self = CMPXConnectionEventHandler::NewLC( aObserver );

    CleanupStack::Pop( self );

    return self;

    }

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

// Two Phased Constructor

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

//

CMPXConnectionEventHandler* CMPXConnectionEventHandler::NewLC

                                        ( MMPXSystemEventObserver& aObserver )

    {

    CMPXConnectionEventHandler* self = new( ELeave ) CMPXConnectionEventHandler( aObserver);

    CleanupStack::PushL( self );

    self->ConstructL();

    return self;

    }

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

// Destructor

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

//

CMPXConnectionEventHandler::~CMPXConnectionEventHandler()

    {

    Cancel();

    if ( iUsbManConnected )

        {

        iUsbMan.Close();

        }

    delete iUSBKeyWatcher;

    delete iMTPKeyWatcher;

    }

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

// Poll for any ongoing USB / MTP event

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

//

void CMPXConnectionEventHandler::PollStatus()

    {

    // only call back on connection state != EMPXConnectionNone

    if (iState == EMPXConnectionMassStorage)

        {

        TRAP_IGNORE( DoMSStartEventL() );

        }

    else if (iState == EMPXConnectionMTPActive)

        {

        TRAP_IGNORE( DoMTPStartEventL() );

        }

    else if (iState == EMPXConnectionMTPIdle)

        {

        TRAP_IGNORE( DoMTPNotActiveEventL() );

        }

    }

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

// Handle the PS key event

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

//

void CMPXConnectionEventHandler::HandlePSEvent( TUid aUid, TInt aKey )

    {

    TRAP_IGNORE( DoHandlePSEventL(aUid,aKey) );

    }

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

// Handle the PS key event

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

//

void CMPXConnectionEventHandler::DoHandlePSEventL( TUid /*aUid*/, TInt /*aKey*/ )

    {

    MPX_FUNC("CMPXConnectionEventHandler::DoHandlePSEvent()");

    if ( !iUsbManConnected )

        {

        ConnectUsbMan();

        }

    // Handle the Key event

    TInt usbStatus;

    iUSBKeyWatcher->GetValue( usbStatus );

    TInt mtpStatus;

    TInt err = iMTPKeyWatcher->GetValue(mtpStatus);

    MPX_DEBUG3("CMPXConnectionEventHandler::DoHandlePSEventL, usbStatus = %d, mtpStatus = %d", usbStatus, mtpStatus);

    MPX_DEBUG2("CMPXConnectionEventHandler::DoHandlePSEventL, iState = %d", iState);

    MPX_DEBUG4("CMPXConnectionEventHandler::DoHandlePSEventL, iDeviceState = %d, EUsbDeviceStateAddress(%d), EUsbDeviceStateConfigured(%d)", iDeviceState, EUsbDeviceStateAddress, EUsbDeviceStateConfigured);

    // events from lower level is not causing multiple callback on the same type

    // usb is really only connected if went through Address or Configured state

    if( (usbStatus == KUsbPersonalityIdMS) && (iDeviceState == EUsbDeviceStateAddress || iDeviceState == EUsbDeviceStateConfigured))

        {

        if ((iState == EMPXConnectionMTPIdle) || (iState == EMPXConnectionMTPActive))

            {

            MPX_DEBUG1("CMPXConnectionEventHandler::DoHandlePSEvent - MTP End");

            iObserver.HandleSystemEventL( EUSBMTPEndEvent, -1 );

            iState = EMPXConnectionNone;

            }

        if (iState != EMPXConnectionMassStorage)

            {

            DoMSStartEventL();

            }

        }

    else if (iState == EMPXConnectionMassStorage)

        {

        if (usbStatus != KUsbPersonalityIdMS)

            {

            MPX_DEBUG1("CMPXConnectionEventHandler::DoHandlePSEvent - USB MassStorage End");

            iObserver.HandleSystemEventL( EUSBMassStorageEndEvent, -1 );

            iState = EMPXConnectionNone;

            }

        }

    // after MassStorage End, it is possible that MTP is still connected

    if (iState != EMPXConnectionMassStorage)

        {

		if (err == KErrNone)

		    {

            if ((mtpStatus == EMtpPSStatusUninitialized) && (iState != EMPXConnectionNone))

                {

                MPX_DEBUG1("CMPXConnectionEventHandler::DoHandlePSEvent - MTP End");

                iObserver.HandleSystemEventL( EUSBMTPEndEvent, -1 );

                iState = EMPXConnectionNone;

                }

            else if ((mtpStatus == EMtpPSStatusActive) && (iState != EMPXConnectionMTPActive)

                    && ((usbStatus == KUsbPersonalityIdMTP) || (usbStatus == KUsbPersonalityIdPCSuiteMTP))) // only trigger MusicPlayer fully block and RAM Drive if USB MTP/PCSuiteMTP is connected

                {

                DoMTPStartEventL();

                }

            else if ((mtpStatus == EMtpPSStatusReadyToSync) && (iState != EMPXConnectionMTPIdle) && (iState != EMPXConnectionMTPActive))

                {

                DoMTPNotActiveEventL();

                }

            }

        else

            {

            // mtpwatcher can err out because the mtp ps key would only be defined and default after first use,

            // and this logic here might hit before that

            MPX_DEBUG2("CMPXConnectionEventHandler::DoHandlePSEvent - MTPWatcher err = %d", err);

            }

        }

    }

void CMPXConnectionEventHandler::DoMSStartEventL()

    {

    MPX_DEBUG1("CMPXConnectionEventHandler::DoMSStartEventL - USB MassStorage Start");

    iObserver.HandleSystemEventL( EUSBMassStorageStartEvent, -1 );

    iState = EMPXConnectionMassStorage;

    }

void CMPXConnectionEventHandler::DoMTPStartEventL()

    {

    MPX_DEBUG1("CMPXConnectionEventHandler::DoMTPStartEventL - MTP Start");

    iObserver.HandleSystemEventL( EUSBMTPStartEvent, -1 );

    iState = EMPXConnectionMTPActive;

    }

void CMPXConnectionEventHandler::DoMTPNotActiveEventL()

    {

    MPX_DEBUG1("CMPXConnectionEventHandler::DoMTPNotActiveEventL - MTP Not Active");

    iObserver.HandleSystemEventL( EUSBMTPNotActiveEvent, -1 );

    iState = EMPXConnectionMTPIdle;

    }

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

// CMPXConnectionEventHandler::RunL

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

//

void CMPXConnectionEventHandler::RunL()

    {

    MPX_FUNC("CMPXConnectionEventHandler::RunL()");

    TInt status( iStatus.Int() );

    MPX_DEBUG2("CMPXConnectionEventHandler::RunL status=%d", status );

    if ( status != KErrCancel && status != KErrServerTerminated )

        {

        iUsbMan.DeviceStateNotification( KUsbAllStates, iDeviceState, iStatus );

        SetActive();

        }

    if ( status == KErrNone )

        {

        MPX_DEBUG2("CMPXConnectionEventHandler::RunL - DeviceState = %d", iDeviceState);

        HandlePSEvent( TUid::Uid(0), 0 );

        }

    }

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

// CMPXConnectionEventHandler::DoCancel

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

//

void CMPXConnectionEventHandler::DoCancel()

    {

    MPX_FUNC("CMPXConnectionEventHandler::DoCancel()");

    if ( iUsbManConnected )

        {

        iUsbMan.DeviceStateNotificationCancel();

        }

    }

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

// CMPXConnectionEventHandler::ConnectUsbMan

// If error, default iDeviceState to EUsbDeviceStateConfigured so this would not

// block usb event mode change.

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

void CMPXConnectionEventHandler::ConnectUsbMan()

    {

    MPX_FUNC("CMPXConnectionEventHandler::ConnectUsbMan()");

    if ( iUsbMan.Connect() == KErrNone )

        {

        iUsbManConnected = ETrue;

        // get device state

        TInt err = iUsbMan.GetDeviceState( iDeviceState );

        if ( err )

            {

            iDeviceState = EUsbDeviceStateUndefined;

            }

        // start active object

        if ( !IsActive() )

            {

            iUsbMan.DeviceStateNotification( KUsbAllStates, iDeviceState, iStatus );

            SetActive();

            }

        }

    else

        {

        iDeviceState = EUsbDeviceStateConfigured;

        }

    }

// END OF FILE