// 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/mmtpdataproviderframework.h>

#include <f32file.h>

#include "cptpsession.h"

#include "cptpserver.h"

#include "cptpreceivedmsghandler.h"

#include "cmtppictbridgeprinter.h"

#include "cptptimer.h"

#include "mtppictbridgedpconst.h"

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

// 

// 2-phased constructor.

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

//

CPtpSession* CPtpSession::NewL(CPtpServer* aServer)

    {

    CPtpSession* self= new (ELeave) CPtpSession(aServer);

    CleanupStack::PushL(self);

    self->ConstructL();

    CleanupStack::Pop(self);

    return self;

    }

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

// 

// C++ constructor.

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

//

CPtpSession::CPtpSession(CPtpServer* aServer) : iServerP(aServer) 

    {

    iServerP->Printer()->RegisterObserver(this); // since PTP register service 

                  // is deprecated we register the observer at session creation

    iServerP->IncrementSessionCount();                  

    }

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

// 

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

//

void CPtpSession::ConstructL()

    {

    iTimerP=CPtpTimer::NewL(*this);

    }

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

// 

// C++ destructor.

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

//

CPtpSession::~CPtpSession()

    {

    delete iTimerP;

    CancelOutstandingRequest();

    TRAP_IGNORE(CleanupL()); // there is not much we can do at this phase if the removal fails, so just ignore

    if(iServerP->NumSession())

        {

        iServerP->DecrementSessionCount();

        }

    }

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

// 

// From CSession2, passes the request forward to DispatchMessageL.

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

//

void CPtpSession::ServiceL( const RMessage2& aMessage )

    {

    DispatchMessageL(aMessage);

    }

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

//  Cleans up the previously received DPS file, since the files are used only 

//  for communication

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

//

void CPtpSession::CleanupL()

    {

    if(iReceivedFile.Size())

        {

        iServerP->RemoveObjectL(iReceivedFile);

        iReceivedFile.Zero();

        }

    }

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

// Handles the request from client.

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

//

void CPtpSession::DispatchMessageL( const RMessage2& aMessage )

    {

    TInt ret = KErrNone;

    TBool complete = ETrue;        

    CleanupL(); // calling this here assumes that the client never makes a new call 

                // before it has handled the received DPS message

    switch( aMessage.Function() )

        {        

        case EIsDpsPrinter:

            ret = IsDpsPrinter(aMessage, complete);

            break;

        case ECancelIsDpsPrinter:

            CancelIsDpsPrinter();

            break;

        case EGetObjectHandleByName:  

            GetObjectHandleByNameL(aMessage);

            break;

        case EGetNameByObjectHandle:

            GetNameByObjectHandleL(aMessage);

            break;

        case ESendObject:

            ret = SendObject(aMessage, complete);

            break;

        case ECancelSendObject:

            CancelSendObject();

            break;

        case EObjectReceivedNotify:

            ret = ObjectReceivedNotify(aMessage, complete);

            break;

        case ECancelObjectReceivedNotify:

            CancelObjectReceivedNotify();

            break;

        case EPtpFolder:

            ret = PtpFolder(aMessage);

            break;

        default:

            aMessage.Panic(KPTPClientPanicCategory, EBadRequest);

            break;

        }

    if (complete)

        {

        aMessage.Complete(ret);

        }

    }

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

// CPtpSession::CancelIsDpsPrinter()

// Cancels Asynchronous request IsDpsPrinter

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

//

void CPtpSession::CancelIsDpsPrinter()

    {

    if (iDpsPrinterMsg.Handle())

        {

        iDpsPrinterMsg.Complete(KErrCancel);

        iServerP->Printer()->DeRegisterDpsPrinterNotify(this);

        iTimerP->Cancel();

        iServerP->CancelNotifyOnMtpSessionOpen(this);

        } 

    }

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

// CPtpSession::CancelSendObject()

// Cancel Asynchronous request send Object

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

//

void CPtpSession::CancelSendObject()

    {

    if (iSendObjectMsg.Handle())

        {

        iServerP->Printer()->CancelSendDpsFile();

        iSendObjectMsg.Complete(KErrCancel);

        iTimerP->Cancel();

        }

    }

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

// CPtpSession::CancelObjectReceivedNotify()

// Deregisters for Object received notification

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

//

void CPtpSession::CancelObjectReceivedNotify()

    {

    if (iObjectReceivedNotifyMsg.Handle())

        {

        iServerP->Printer()->MsgHandlerP()->DeRegisterReceiveObjectNotify();

        iObjectReceivedNotifyMsg.Complete(KErrCancel);                    

        }

    }

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

// CPtpSession::IsDpsPrinter()

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

//    

TInt CPtpSession::IsDpsPrinter(const RMessage2& aMessage, TBool& aComplete)

    {

    TInt ret=EPrinterNotAvailable;

    if (!iDpsPrinterMsg.Handle()) // not already pending

        {

        switch (iServerP->Printer()->Status())

            {   

            case CMTPPictBridgePrinter::ENotConnected:

                iDpsPrinterMsg = aMessage;    

                iServerP->Printer()->RegisterDpsPrinterNotify(this);

                aComplete = EFalse;

                if(iServerP->MtpSessionOpen())

                    {

                    if (!iTimerP->IsActive()) 

                        {

                        iTimerP->After(KDiscoveryTime);

                        }

                    }

                else

                    {

                    iServerP->NotifyOnMtpSessionOpen(this);

                    }                    

                // we do not set ret since the  value does not really matter, we will be waiting for the discovery to complete

                break;

            case CMTPPictBridgePrinter::EConnected:

                ret=EPrinterAvailable;

                aComplete = ETrue;

                break;

            case CMTPPictBridgePrinter::ENotPrinter:

                ret=EPrinterNotAvailable;

                aComplete = ETrue;

                break;

            default:

                break;                

            }

        }

    else

        aMessage.Panic(KPTPClientPanicCategory, ERequestPending);

        aComplete = EFalse;

        }

    return ret;

    }

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

// start the timer for printer detection, since we have now session open and 

// we are ready to communicate wioth the host

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

void CPtpSession::MTPSessionOpened()

    {

    if (!iTimerP->IsActive() && iDpsPrinterMsg.Handle()) 

        {

        iTimerP->After(KDiscoveryTime);

        }        

    }

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

// CPtpSession::GetObjectHandleByNameL()

// 

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

//

void CPtpSession::GetObjectHandleByNameL(const RMessage2& aMessage)

    {

    TFileName file;

    TUint32 handle=0;

    TRAP_IGNORE(iServerP->GetObjectHandleByNameL(file, handle));

    TPckgBuf<TUint32> handlePckg(handle);

    aMessage.WriteL(1, handlePckg);     

    }

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

// CPtpSession::GetNameByObjectHandle()

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

//

void CPtpSession::GetNameByObjectHandleL(const RMessage2& aMessage)

    {

    TUint32 handle = 0;

    TPckgBuf<TUint32> pckgHandle(handle);

    TFileName file; 

    handle = pckgHandle();

    TRAP_IGNORE(iServerP->GetObjectNameByHandleL(file, handle));

    aMessage.WriteL(0, file);

    }

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

// CPtpSession::SendObject()

// Asynch. request send Object

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

//

TInt CPtpSession::SendObject(const RMessage2& aMessage, TBool& aComplete)

    {

    TInt err(KErrNone);

    if (iSendObjectMsg.Handle())

        {

        aMessage.Panic(KPTPClientPanicCategory, ERequestPending);

        aComplete = EFalse;

        return KErrNone;

        }

    else

        {

        // Parameter add is depracated. We do not send Object added and we do not keep ther DPS object permanently in

        // our system.

        //

        // Sending ObjectAdded Event is not mandatory ( See Appendix B page 78. DPS Usage of USB and PTP in CIPA DC-001-2003)

        TFileName file; 

        err = aMessage.Read(0, file);

        if (err == KErrNone)

            {

            TInt size = aMessage.Int3();

            TRAP(err, iServerP->Printer()->SendDpsFileL(file, timeout, size));

            if (err == KErrNone)

                {

                iSendObjectMsg = aMessage;

                aComplete = EFalse;    

                }

            }

        if ((EFalse != timeout) && !iTimerP->IsActive())

            {

            iTimerP->After(KSendTimeout);

            }

        return err;    

        }    

    }             

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

// CPtpSession::ObjectReceivedNotify()

// 

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

//   

TInt CPtpSession::ObjectReceivedNotify(const RMessage2& aMessage, 

                                       TBool& aComplete)

    {

    if (iObjectReceivedNotifyMsg.Handle())

        {

        aMessage.Panic(KPTPClientPanicCategory, ERequestPending);

        aComplete = EFalse;

        return KErrNone;

        }

    else

        {

        TBuf<KFileExtLength> ext; 

        TInt err = aMessage.Read(0, ext);

        if (err == KErrNone)

            {

            iObjectReceivedNotifyMsg = aMessage; 

            aComplete = EFalse;

            iServerP->Printer()->MsgHandlerP()->RegisterReceiveObjectNotify(ext);

        return err;

        }

    }

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

// CPtpSession::PtpFolder()

// Returns PtpFolder Name and Path

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

//    

TInt CPtpSession::PtpFolder(const RMessage2& aMessage)

    {

    TInt err(KErrNotReady);

    TFileName folder = iServerP->PtpFolder();

    err = aMessage.Write(0,folder);

    return err;

    }

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

// CPtpSession::SendObjectCompleted()

// 

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

//    

void CPtpSession::SendObjectCompleted(TInt aStatus)

    {

    if (iSendObjectMsg.Handle())

        {

        iSendObjectMsg.Complete(aStatus);    

        iTimerP->Cancel();

        }

    else

        {

        }

    }

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

// CPtpSession::IsDpsPrinterCompleted()

// 

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

//

void CPtpSession::IsDpsPrinterCompleted(TDpsPrinterState aState)

    {

    if (iDpsPrinterMsg.Handle())

        {

        iDpsPrinterMsg.Complete(aState);

        iTimerP->Cancel();

        iServerP->Printer()->DeRegisterDpsPrinterNotify(this);

        }

    else

        {

    }

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

// CPtpSession::ReceivedObjectCompleted()

// 

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

//

void CPtpSession::ReceivedObjectCompleted(TDes& aFile)

    {

    if (iObjectReceivedNotifyMsg.Handle())

        {

        TInt err = iObjectReceivedNotifyMsg.Write(1, aFile);

        iReceivedFile.Copy(aFile);

        iObjectReceivedNotifyMsg.Complete(err);

        }

    else

        {

        }