// Copyright (c) 2007-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:
//



/**
 @file
 @internalComponent
*/

#include "cmtpoperator.h"
#include "mtpdebug.h"
#include "OstTraceDefinitions.h"
#ifdef OST_TRACE_COMPILER_IN_USE
#include "cmtpoperatorTraces.h"
#endif

CMTPOperator* CMTPOperator::NewL( MMTPOperatorNotifier& aNotifier )
    {
    CMTPOperator* self = new( ELeave ) CMTPOperator( aNotifier );
    self->ConstructL();
    return self;
    }

CMTPOperator::~CMTPOperator()
    {
    OstTraceFunctionEntry0( CMTPOPERATOR_DES_ENTRY );
    Cancel();
    iPendingOperations.Reset();
    iPendingOperations.Close();
    iMTPClient.Close();
    iProperty.Close();
    delete iTimer;
    OstTraceFunctionExit0( CMTPOPERATOR_DES_EXIT );
    }

void CMTPOperator::StartTransport( TUid aTransport )
    {
    OstTraceFunctionEntry0( CMTPOPERATOR_STARTTRANSPORT_ENTRY );
    OstTrace1( TRACE_NORMAL, CMTPOPERATOR_STARTTRANSPORT, "The transport uid is 0x%08X", aTransport.iUid );
    TInt err = AppendOperation( EStartTransport, aTransport );
    if ( KErrNone != err )
        {
        iNotifier.HandleStartTrasnportCompleteL( err );
        }
    OstTraceFunctionExit0( CMTPOPERATOR_STARTTRANSPORT_EXIT );
    }

void CMTPOperator::StopTransport( TUid aTransport )
    {
    OstTraceFunctionEntry0( CMTPOPERATOR_STOPTRANSPORT_ENTRY );
    OstTrace1( TRACE_NORMAL, CMTPOPERATOR_STOPTRANSPORT, "The transport uid is 0x%08X", aTransport.iUid );
    TInt err = AppendOperation( EStopTransport, aTransport );
    if ( KErrNone != err )
        {
        iNotifier.HandleStartTrasnportCompleteL( err );
        }
    OstTraceFunctionExit0( CMTPOPERATOR_STOPTRANSPORT_EXIT );
    }

void CMTPOperator::StartTimer(TInt aSecond)
    {
    OstTraceFunctionEntry0( CMTPOPERATOR_STARTTIMER_ENTRY );
    iTimer->Start(aSecond);    
    OstTraceFunctionExit0( CMTPOPERATOR_STARTTIMER_EXIT );
    }

void CMTPOperator::DoCancel()
    {
    OstTraceFunctionEntry0( CMTPOPERATOR_DOCANCEL_ENTRY );
    iProperty.Cancel();
    iConSubscribed = EFalse;
    OstTraceFunctionExit0( CMTPOPERATOR_DOCANCEL_EXIT );
    }

void CMTPOperator::RunL()
    {
    OstTraceFunctionEntry0( CMTPOPERATOR_RUNL_ENTRY );
    
    iConSubscribed = EFalse;
    TInt count = iPendingOperations.Count();
    
    TInt connState = KInitialValue;
    
    if ( count > 0 )
        {
        TOperation& operation = iPendingOperations[0];
        TRAP_IGNORE( HandleOperationL( operation ) );
        iPendingOperations.Remove( 0 );
        }
    else
        {
        //this will go on to get the updated connection status.
        SubscribeConnState();


        TInt error = iProperty.Get(KMTPPublishConnStateCat, EMTPConnStateKey, connState);
        OstTraceExt2( TRACE_NORMAL, CMTPOPERATOR_RUNL, "Before, the iConnState is %d and connState is %d", iConnState, connState );
        if ( KErrNotFound == error )
            {
            iConnState = KInitialValue;
            OstTrace0( TRACE_NORMAL, DUP1_CMTPOPERATOR_RUNL, "The key is deleted and mtp server shut down!" );
            }
        else
            {
            if (iTimer->IsActive() && !iTimer->GetStopTransportStatus())
                {
                OstTrace0( TRACE_NORMAL, DUP2_CMTPOPERATOR_RUNL, "Timer is cancelled!" );
                iTimer->Cancel();
                }
            //if the disconnect is not set, set the disconnect
            //else if the connState is disconnect, launch the timer to restart the server to unload dps.
            if ( KInitialValue == iConnState )
                {
                iConnState = connState;
                OstTrace0( TRACE_NORMAL, DUP3_CMTPOPERATOR_RUNL, "the first time to launch mtp" );
                }
            else
                {
                if (EDisconnectedFromHost == connState)
                    {
                    iConnState = connState;
                    if (!iTimer->IsActive())
                        {
                        iTimer->Start(KStopMTPSeconds);
                        }
                    OstTrace0( TRACE_NORMAL, DUP4_CMTPOPERATOR_RUNL, "Timer is launched." );
                    }
                else
                    {

                    iConnState = connState;
                    }
                }
            }
        OstTraceExt2( TRACE_NORMAL, DUP5_CMTPOPERATOR_RUNL, "After, the iConnState is %d and connState is %d", iConnState, connState );
        }
    OstTraceFunctionExit0( CMTPOPERATOR_RUNL_EXIT );
    }

CMTPOperator::CMTPOperator( MMTPOperatorNotifier& aNotifier ):
    CActive( EPriorityStandard ),
    iNotifier( aNotifier )
    {
    OstTraceFunctionEntry0( CMTPOPERATOR_CONS_ENTRY );
    OstTraceFunctionExit0( CMTPOPERATOR_CONS_EXIT );
    }

void CMTPOperator::ConstructL()
    {
    OstTraceFunctionEntry0( CMTPOPERATOR_CONSTRUCTL_ENTRY );
    CActiveScheduler::Add( this );
    //if the server is running, the first disconnction shows the conection is down!
    if(KErrNone == iMTPClient.IsProcessRunning())
        {
        iConnState = EDisconnectedFromHost;
        }
    else
        {
        iConnState = KInitialValue;
        }
    OstTrace1( TRACE_NORMAL, CMTPOPERATOR_CONSTRUCTL, "The connstate is set to %d", iConnState );
    
    LEAVEIFERROR( iMTPClient.Connect(),
            OstTrace0( TRACE_ERROR, DUP1_CMTPOPERATOR_CONSTRUCTL, "Leave when the client connects to mtp server" ));
    
    LEAVEIFERROR(iProperty.Attach(KMTPPublishConnStateCat, EMTPConnStateKey),
            OstTrace0( TRACE_ERROR, DUP2_CMTPOPERATOR_CONSTRUCTL, "iProperty attached failed." ));
    iTimer = CMTPControllerTimer::NewL(iMTPClient, *this);
    
    iConSubscribed = EFalse;
    OstTraceFunctionExit0( CMTPOPERATOR_CONSTRUCTL_EXIT );
    }

TInt CMTPOperator::AppendOperation( TOperationType aType, TUid aTransport )
    {
    OstTraceFunctionEntry0( CMTPOPERATOR_APPENDOPERATION_ENTRY );
    TOperation operation = { aType, aTransport };
    TInt err = iPendingOperations.Append( operation );
    OstTrace1( TRACE_NORMAL, CMTPOPERATOR_APPENDOPERATION, "The return value is %d", err );
    if ( ( KErrNone == err ) && !IsActive() )
        {
        Schedule( KErrNone );
        }
    else
        {
        if (iConSubscribed)
            {
            Cancel();
            if (KErrNone == err)
                {
                Schedule( KErrNone );
                }
            }
        }

    OstTraceFunctionExit0( CMTPOPERATOR_APPENDOPERATION_EXIT );
    return err;
    }

void CMTPOperator::Schedule( TInt aError )
    {
    OstTraceFunctionEntry0( CMTPOPERATOR_SCHEDULE_ENTRY );
    OstTrace1( TRACE_NORMAL, CMTPOPERATOR_SCHEDULE, "The error value is %d", aError );
    if(iTimer->IsActive())
        {
        iTimer->Cancel();
        }
    TRequestStatus* status = &iStatus;
    User::RequestComplete( status, aError );
    SetActive();
    OstTraceFunctionExit0( CMTPOPERATOR_SCHEDULE_EXIT );
    }

void CMTPOperator::HandleOperationL( const TOperation& aOperation )
    {
    OstTraceFunctionEntry0( CMTPOPERATOR_HANDLEOPERATIONL_ENTRY );
    OstTraceExt2( TRACE_NORMAL, CMTPOPERATOR_HANDLEOPERATIONL, "The transport id is 0x%08X and the operation is 0x%08X", (TInt)aOperation.iTransport.iUid, aOperation.iType );
    TInt err = KErrNone;
    switch ( aOperation.iType )
        {
        case EStartTransport:
            err = iMTPClient.StartTransport( aOperation.iTransport );
            iNotifier.HandleStartTrasnportCompleteL( err );
            SubscribeConnState();
            break;
        default:
            __ASSERT_DEBUG( ( EStopTransport == aOperation.iType ), User::Invariant() );
            if(!iTimer->GetStopTransportStatus())
                {
                err = iMTPClient.StopTransport( aOperation.iTransport );
                }
         
            iNotifier.HandleStopTrasnportCompleteL( err );
            break;
        }
    OstTraceFunctionExit0( CMTPOPERATOR_HANDLEOPERATIONL_EXIT );
    }

void CMTPOperator::SubscribeConnState()
    {
    OstTraceFunctionEntry0( CMTPOPERATOR_SUBSCRIBECONNSTATE_ENTRY );
    if(!IsActive())
        {
        iProperty.Subscribe(iStatus);
        iConSubscribed = ETrue;
        SetActive();
        }
  
    OstTraceFunctionExit0( CMTPOPERATOR_SUBSCRIBECONNSTATE_EXIT );
    }