// 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 "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 <mtp/cmtptypeobjectinfo.h>

#include <mtp/mmtpconnection.h>

#include <mtp/mtpprotocolconstants.h>

#include "cptpserver.h"

#include "cptpsession.h"

#include "cptpreceivedmsghandler.h"

#include "cmtppictbridgeprinter.h"

#include "mtppictbridgedpconst.h"

#include "cmtppictbridgeusbconnection.h"

#include "OstTraceDefinitions.h"

#ifdef OST_TRACE_COMPILER_IN_USE

#include "cmtppictbridgeprinterTraces.h"

#endif

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

// 

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

//

CMTPPictBridgePrinter* CMTPPictBridgePrinter::NewL(CPtpServer& aServer)

    {

    CMTPPictBridgePrinter* selfP = new (ELeave) CMTPPictBridgePrinter(aServer);

    CleanupStack::PushL(selfP);

    selfP->ConstructL();

    CleanupStack::Pop(selfP);

    return selfP;    

    }

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

// 

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

//

void CMTPPictBridgePrinter::ConstructL()

    {

    iMsgHandlerP = CPtpReceivedMsgHandler::NewL(&iServer);

    iUsbConnectionP = CMTPPictBridgeUsbConnection::NewL(*this);

    }

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

// 

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

//

CMTPPictBridgePrinter::CMTPPictBridgePrinter(CPtpServer& aServer):iServer(aServer), iPrinterStatus(ENotConnected)

    {

    }

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

// 

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

//

CMTPPictBridgePrinter::~CMTPPictBridgePrinter()

    {

    delete iMsgHandlerP;

    delete iUsbConnectionP;

    }

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

// 

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

//

void CMTPPictBridgePrinter::ConnectionClosed()

    {

    iPrinterConnectionP=NULL; 

    iPrinterStatus=ENotConnected;

    iMsgHandlerP->Initialize();

    iServer.RemoveTemporaryObjects();

    CancelSendDpsFile(); // we rely on the client to get notification on 

                         // disconnectrion from elsewhere. If not the timer 

                         // will expire and handle completing the message

    }

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

//

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

//

CMTPPictBridgePrinter::TPrinterStatus CMTPPictBridgePrinter::Status() const

    {

    return iPrinterStatus;

    }

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

//

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

//

void CMTPPictBridgePrinter::NoDpsDiscovery()

    {

    if (iPrinterStatus != EConnected)

        {

        iPrinterStatus=ENotPrinter;

        }

    else

        {

        OstTrace0( TRACE_WARNING, CMTPPICTBRIDGEPRINTER_NODPSDISCOVERY, 

                "WARNING! trying to say no printer even though already discovered" );

        }

    }

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

//

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

//

void CMTPPictBridgePrinter::DpsObjectReceived(TUint32 aHandle)

    {

    OstTraceFunctionEntry0( CMTPPICTBRIDGEPRINTER_DPSOBJECTRECEIVED_ENTRY );                 

    if(iPrinterStatus==EConnected) // we only handle the object when we are connected to the printer

        {

        iMsgHandlerP->ObjectReceived(aHandle);

        }

    else

        {

        OstTrace0( TRACE_WARNING, CMTPPICTBRIDGEPRINTER_DPSOBJECTRECEIVED, 

                "!!!!WARNING: CMTPPictBridgePrinter::DpsObjectReceived Rx dps file when printer not connected!" );

        }

    OstTraceFunctionExit0( CMTPPICTBRIDGEPRINTER_DPSOBJECTRECEIVED_EXIT );

    }        

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

// 

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

//

void CMTPPictBridgePrinter::DpsDiscovery(const TFileName& aFileName, MMTPConnection* aConnectionP)

    {

    OstTraceFunctionEntry0( CMTPPICTBRIDGEPRINTER_DPSDISCOVERY_ENTRY );

    if ( iPrinterStatus != EConnected )

        {

        if (KErrNotFound!=aFileName.Find(KHostDiscovery))

            {

            OstTrace0( TRACE_NORMAL, DUP1_CMTPPICTBRIDGEPRINTER_DPSDISCOVERY, "***Dps printer Discovered." );

            iPrinterConnectionP=aConnectionP;

            iPrinterStatus=EConnected;

            iUsbConnectionP->Listen();

            if(iDpsPrinterNotifyCbP)

                {

                iDpsPrinterNotifyCbP->IsDpsPrinterCompleted(EPrinterAvailable);    

                }

            }

        }   

    OstTraceExt1( TRACE_NORMAL, CMTPPICTBRIDGEPRINTER_DPSDISCOVERY, "received file %S", aFileName );    

    OstTraceFunctionExit0( CMTPPICTBRIDGEPRINTER_DPSDISCOVERY_EXIT );

    }

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

//

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

//    

void CMTPPictBridgePrinter::DeRegisterDpsPrinterNotify(CPtpSession* /*aSessionP*/ )

    {

    OstTraceFunctionEntry0( CMTPPICTBRIDGEPRINTER_DEREGISTERDPSPRINTERNOTIFY_ENTRY );

    iDpsPrinterNotifyCbP=NULL;

    OstTraceFunctionExit0( CMTPPICTBRIDGEPRINTER_DEREGISTERDPSPRINTERNOTIFY_EXIT );

    }

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

//

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

//

void CMTPPictBridgePrinter::RegisterDpsPrinterNotify(CPtpSession* aSessionP)

    {

    OstTraceFunctionEntry0( CMTPPICTBRIDGEPRINTER_REGISTERDPSPRINTERNOTIFY_ENTRY );

    OstTraceExt2( TRACE_NORMAL, CMTPPICTBRIDGEPRINTER_REGISTERDPSPRINTERNOTIFY, 

            " 0x%x (old) 0x%x (new)", (TUint)iDpsPrinterNotifyCbP, (TUint)aSessionP );

    __ASSERT_DEBUG(iDpsPrinterNotifyCbP==NULL, User::Invariant());

    iDpsPrinterNotifyCbP=aSessionP;

    OstTraceFunctionExit0( CMTPPICTBRIDGEPRINTER_REGISTERDPSPRINTERNOTIFY_EXIT );

    }

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

// CPtpEventSender::SendL()

// Adds Object To List PTP Stack Object List,Sends RequestObjectTransfer Event

// and registers observer for object sent notification 

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

//    

void CMTPPictBridgePrinter::SendDpsFileL(const TDesC& aFile, TBool /*aTimeout*/, TInt /*aSize*/)

    {

    OstTraceFunctionEntry0( CMTPPICTBRIDGEPRINTER_SENDDPSFILEL_ENTRY );

    OstTraceExt1( TRACE_NORMAL, CMTPPICTBRIDGEPRINTER_SENDDPSFILEL, "DpsFile %S", aFile );          

    TUint32 handle(0);  

    TRAPD(err, iServer.GetObjectHandleByNameL(aFile, handle));

    if(err!=KErrNone || handle==0)

        {

        OstTrace1( TRACE_WARNING, DUP1_CMTPPICTBRIDGEPRINTER_SENDDPSFILEL, 

                "   Object does not exist, adding it, errorcode = %d", err);

        iServer.AddTemporaryObjectL(aFile, handle);    

        }

    CreateRequestObjectTransfer(handle, iEvent);

    iServer.SendEventL(iEvent);

    iOutgoingObjectHandle=handle;

    OstTrace1( TRACE_NORMAL, DUP2_CMTPPICTBRIDGEPRINTER_SENDDPSFILEL, "handle 0x%x", iOutgoingObjectHandle );    

    OstTraceFunctionExit0( CMTPPICTBRIDGEPRINTER_SENDDPSFILEL_EXIT );

    }

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

// CPtpServer::CancelSendDpsFile()

// Cancels Object sedn and call for deregister object sent notification

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

//

void CMTPPictBridgePrinter::CancelSendDpsFile()

    {

    OstTraceFunctionEntry0( CMTPPICTBRIDGEPRINTER_CANCELSENDDPSFILE_ENTRY );  

    iOutgoingObjectHandle=0; 

    OstTraceFunctionExit0( CMTPPICTBRIDGEPRINTER_CANCELSENDDPSFILE_EXIT );

    }

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

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

//

TBool CMTPPictBridgePrinter::SendObjectPending() const

    {

    return (iOutgoingObjectHandle!=0);

    }

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

// CPtpEventSender::CreateRequestObjectTransfer

// Creates PTP event RequestObjectTransfer

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

//

void CMTPPictBridgePrinter::CreateRequestObjectTransfer(TUint32 aHandle, 

                                                 TMTPTypeEvent& aEvent )

    {

    OstTraceFunctionEntry0( CMTPPICTBRIDGEPRINTER_CREATEREQUESTOBJECTTRANSFER_ENTRY );

    OstTrace1( TRACE_NORMAL, CMTPPICTBRIDGEPRINTER_CREATEREQUESTOBJECTTRANSFER, 

            " for handle 0x%x", aHandle );

    aEvent.Reset();

    aEvent.SetUint16(TMTPTypeEvent::EEventCode, EMTPEventCodeRequestObjectTransfer);

    aEvent.SetUint32(TMTPTypeEvent::EEventSessionID, KMTPSessionAll); 

    aEvent.SetUint32(TMTPTypeEvent::EEventTransactionID, KMTPTransactionIdLast);

    aEvent.SetUint32(TMTPTypeEvent::EEventParameter1, aHandle);

    aEvent.SetUint32(TMTPTypeEvent::EEventParameter2, KPtpNoValue);

    aEvent.SetUint32(TMTPTypeEvent::EEventParameter3, KPtpNoValue);

    OstTraceFunctionExit0( CMTPPICTBRIDGEPRINTER_CREATEREQUESTOBJECTTRANSFER_EXIT );

    }

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

// CPtpServer::ObjectReceived

// Notifies of object received

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

//

void CMTPPictBridgePrinter::ObjectReceived(TDes& aFile)

    {

    OstTraceFunctionEntry0( CMTPPICTBRIDGEPRINTER_OBJECTRECEIVED_ENTRY );                  

    iObserverP->ReceivedObjectCompleted(aFile);

    OstTraceFunctionExit0( CMTPPICTBRIDGEPRINTER_OBJECTRECEIVED_EXIT );

    }    

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

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

//

void CMTPPictBridgePrinter::DpsFileSent(TInt aError)

    {

    OstTraceFunctionEntry0( CMTPPICTBRIDGEPRINTER_DPSFILESENT_ENTRY );

    OstTraceExt2( TRACE_NORMAL, CMTPPICTBRIDGEPRINTER_DPSFILESENT, "error %d handle 0x%x", (TInt32)aError, iOutgoingObjectHandle );

    if( SendObjectPending() )

        {

        iObserverP->SendObjectCompleted(aError); 

        iOutgoingObjectHandle=0;

        }

    OstTraceFunctionExit0( CMTPPICTBRIDGEPRINTER_DPSFILESENT_EXIT );

    }

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

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

//    

void CMTPPictBridgePrinter::RegisterObserver(MServiceHandlerObserver* aObserverP)

    {

    iObserverP = aObserverP;

    }

MMTPConnection* CMTPPictBridgePrinter::ConnectionP() const

    {

    return iPrinterConnectionP;    

    }

CPtpReceivedMsgHandler* CMTPPictBridgePrinter::MsgHandlerP() const

    {

    return iMsgHandlerP;

    }