/*

* 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:  Obex Server image receiver module implementation

*

*/

// INCLUDE FILES

#include    <avkon.hrh>                    // AVKON components

#include    "BIPController.h"

#include    "BIPCapabilityHandler.h"

#include    "BIPImageHandler.h"

#include    <e32base.h>

#include    <StringLoader.h>               // Series 60 localisation stringloader

#include    <obexutilsmessagehandler.h>

#include    <obexutilsuilayer.h>

#include    <obexutilsdialog.h>

#include    <UiklafInternalCRKeys.h>

#include    <obexutils.rsg>

#include    <sysutil.h>

#include    <bautils.h>

#include    <pathinfo.h>                   // provides interface for quering system paths 

#include    <AknWaitDialog.h>

#include    <btengdomaincrkeys.h> 

#include    <e32math.h> 

#include    <es_sock.h>

#include    <bt_sock.h>

#include    <msvids.h>

#include    "debug.h"

// CONSTANTS

_LIT8(KBipCapabilityType, "x-bt/img-capabilities\0");

const TInt    KBufferSize = 0x4000;  // 16kB

// ================= MEMBER FUNCTIONS =======================

CBIPController* CBIPController::NewL()

    {

    CBIPController* self = new ( ELeave ) CBIPController();

	CleanupStack::PushL( self );

	self->ConstructL();

	CleanupStack::Pop(self); 

	return self;

    }

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

// CBIPController()

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

//

CBIPController::CBIPController()

    {

    }

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

// ConstructL()

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

//

void CBIPController::ConstructL()

    {

    TRACE_FUNC_ENTRY

    iBIPImageHandler = CBIPImageHandler::NewL();

    iLowMemoryActiveCDrive = CObexUtilsPropertyNotifier::NewL(this, ECheckPhoneMemory);

    iLowMemoryActiveMMC = CObexUtilsPropertyNotifier::NewL(this, ECheckMMCMemory);

    iDevMan = CBTEngDevMan::NewL(this);

    iResultArray = new(ELeave) CBTDeviceArray(1);

    // Get default folder from CenRep 

    TObexUtilsMessageHandler::GetCenRepKeyStringValueL(KCRUidBluetoothEngine, KLCReceiveFolder, iCenRepFolder);

    TRACE_FUNC_EXIT

    }

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

// ~CBIPController()

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

//

CBIPController::~CBIPController()

    {   

    TRACE_FUNC_ENTRY    

    delete iGetObject;    

    delete iBIPCapabilityHandler;    

    delete iBIPImageHandler;    

    delete iLowMemoryActiveCDrive;    

    delete iLowMemoryActiveMMC;    

    delete iBuf;

    delete iProgressDialog;

    delete iWaitDialog;

    delete iBTObject;

    delete iDevMan;

    if (iResultArray)

        {

        iResultArray->ResetAndDestroy();

        delete iResultArray;

        }

    iFs.Close();

    TRACE_FUNC_EXIT    

    }

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

// ErrorIndication()

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

//

void CBIPController::ErrorIndication(TInt TRACE_ONLY(aError))

    {

    TRACE_FUNC_ENTRY

    TRACE_ERROR((_L("[obexreceiveservicebip] CBIPController: ErrorIndication error:\t %d"), aError));

    HandleError(EFalse); // false because this is not an explicit abort

    TRACE_FUNC_EXIT

    }

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

// AbortIndication()

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

//

void CBIPController::AbortIndication()

    {

    TRACE_FUNC_ENTRY

    HandleError(ETrue); // true because this is an explicit abort

    TRACE_FUNC_EXIT

    }

void CBIPController::HandleError(TBool aAbort)

    {

    TRACE_FUNC_ENTRY

    if( iBTTransferState == ETransferPut || (!aAbort && iBTTransferState == ETransferPutDiskError) )

        {

        if(iBTObject)

            {

            iBTObject->Reset();

            }

        CancelTransfer();

        TRAP_IGNORE(TObexUtilsUiLayer::ShowGlobalConfirmationQueryL( R_BT_FAILED_TO_RECEIVE));

        }

    delete iBuf;

    iBuf = NULL;

    iBTTransferState = ETransferIdle;

    TRAP_IGNORE(TObexUtilsMessageHandler::RemoveInboxEntriesL(iBTObject,iMsvIdParent));

    TRAP_IGNORE(TObexUtilsMessageHandler::RemoveTemporaryRFileL(iFullPathFilename));

    TRACE_FUNC_EXIT

    }

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

// CancelTransfer()

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

//

void CBIPController::CancelTransfer()

    {

    TRACE_FUNC_ENTRY

    CloseReceivingIndicator();

    if(iBTTransferState == ETransferPut)

        {

        iBTTransferState = ETransferPutCancel;

        }

    else // go to idle for all other states

        {

        iBTTransferState = ETransferIdle;

        }

    }

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

// TransportUpIndication()

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

//

void CBIPController::TransportUpIndication()

    {

    TRACE_FUNC

    if (!iFs.Handle())

        {

        TRACE_INFO( (_L( "[bipreceiveservice] TransportUpIndication iFs.Connect()" )) ); 

        if (iFs.Connect())   // error value not checked, iFs.Handle() checked one more time before first useage

            {

            TRACE_INFO( (_L( "[bipreceiveservice] TransportUpIndication iFs.Connect() failed" )) ); 

            }

        }

    iFile = RFile();

    iFullPathFilename.Zero();

    iCapabilityFileName.Zero();

    iMsvIdArray.Reset(); 

    }

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

// ObexConnectIndication()

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

//

TInt CBIPController::ObexConnectIndication( const TObexConnectInfo& /*aRemoteInfo*/, const TDesC8& /*aInfo*/ )

    {

    TRACE_FUNC

    // Get remote device socket address and bluetooth name

    // Remote bluetooth name will be displayed in the new message in inbox.

    //

    TSockAddr addr;

    iBTObexServer->RemoteAddr(addr);

    TBTDevAddr tBTDevAddr = static_cast<TBTSockAddr>(addr).BTAddr();

    TBTRegistrySearch nameSearch;

    nameSearch.FindAddress(tBTDevAddr);

    iResultArray->Reset();

    // Ignore any errors here, if we don't get the name, we don't get the name.

    // It is also possible that the name is received too late....

    static_cast<void>(iDevMan->GetDevices(nameSearch, iResultArray));

    return KErrNone;

    }

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

// ObexDisconnectIndication()

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

//

void CBIPController::ObexDisconnectIndication(const TDesC8& /*aInfo*/)

    {

    TRACE_FUNC

    }

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

// TransportDownIndication()

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

//

void CBIPController::TransportDownIndication()

    {

    TRACE_FUNC   

    TRAP_IGNORE(ShowFileReceivedQueryL());

    iFs.Close();

    }

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

// PutRequestIndication()

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

//

CObexBufObject* CBIPController::PutRequestIndication()

    {   

    TRACE_FUNC_ENTRY

    iLengthHeaderReceived = EFalse; // New put request so clear header based state

    iBTTransferState = ETransferPut;

    TRAPD(err, HandlePutImageRequestL());

    if (err == KErrNone)

        {

        return iBTObject;

        }

    if (iBTTransferState != ETransferPutInitError)

        {

        iBTTransferState = ETransferPutDiskError;

        }

    TRACE_FUNC_EXIT

    return NULL;

    }

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

// PutPacketIndication() 

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

//

TInt CBIPController::PutPacketIndication()

    {

    TRACE_FUNC_ENTRY

    if(iBTTransferState == ETransferPutCancel)

        {

        // User cancelled the put request, so error the next packet to terminate the put request.

        // BIP considers the Unauthorized error response suitable for this...

        HandleError(ETrue); // reset state and clear up

        return KErrIrObexRespUnauthorized;

        }

    if (iBTObject)

        {

        iTotalSizeByte = iBTObject->Length();     // get size of receiving file

        iReceivingFileName = iBTObject->Name();   // get name of receiving file

        // Check that capacity is suitable as soon as possible

        if(!iLengthHeaderReceived && iTotalSizeByte > 0)

            {

            iLengthHeaderReceived = ETrue; // total size value is from length header

            TBool capacity = ETrue;

            TRAPD(retTrap, capacity = CheckCapacityL());

            if(retTrap != KErrNone)

                {

                return KErrGeneral;

                }

            if(!capacity)

                {

                TRAP_IGNORE(TObexUtilsUiLayer::ShowGlobalConfirmationQueryL(R_OUT_OF_MEMORY));

                return KErrDiskFull;

                }

            }

        if(iBTObject->Name().Length() > KMaxFileName)

            {

            return KErrAccessDenied;

            }

        if(iBTTransferState == ETransferPutDiskError)

            {

            return KErrDiskFull;

            }

        // successfully received put packet if we reached here

        iBTTransferState = ETransferPut;

        // Now we need to either create (in the first instance) or update the dialog on the UI.

        if(ReceivingIndicatorActive())

            {

            UpdateReceivingIndicator();

            }

        else if(!iNoteDisplayed)

            {

            // No note launched yet, so try to launch

            TRAPD(err, LaunchReceivingIndicatorL());

            iNoteDisplayed = (err == KErrNone);

            }

        }

    TRACE_FUNC_EXIT

    return KErrNone;

    }

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

// PutCompleteIndication() 

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

//

TInt CBIPController::PutCompleteIndication()  // Once receive has completed.

    {

    TRACE_FUNC_ENTRY

    TInt retVal = KErrNone;

    if(iBTTransferState == ETransferPutCancel)

        {

        retVal = KErrIrObexRespUnauthorized;

        HandleError(ETrue);

        }

    else

        {

        retVal = HandlePutCompleteIndication();

        iBTTransferState = ETransferIdle;

        CloseReceivingIndicator();

        }

    TRACE_FUNC_EXIT

    return retVal;

    }

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

// GetRequestIndication()

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

//

CObexBufObject* CBIPController::GetRequestIndication( CObexBaseObject* aRequiredObject )

    {

    TRACE_FUNC_ENTRY

    iBTTransferState = ETransferGet;

    TInt err = RemoveCapabilityObject();

    if (err == KErrNone)

        {

        if( aRequiredObject->Type() == KBipCapabilityType )

            {

            TRAP( err, HandleGetCapabilityRequestL( ) );

            if( err == KErrNone )

                {

                return iGetObject;

                }

            }

        }

    TRACE_FUNC_EXIT

    return NULL;

    }

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

// GetPacketIndication()

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

//

TInt CBIPController::GetPacketIndication()

    {

    TRACE_FUNC_ENTRY

    return KErrNone;

    }

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

// GetCompleteIndication()

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

//

TInt CBIPController::GetCompleteIndication()

    {

    TRACE_FUNC_ENTRY

    delete iGetObject;

    iGetObject=NULL;

    TInt err = RemoveCapabilityObject();

    if (err != KErrNone)

        {

        err = KErrGeneral;

        }

    iBTTransferState = ETransferIdle;

    TRACE_FUNC_EXIT

    return err;

    }

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

// SetPathIndication()

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

//

TInt CBIPController::SetPathIndication( const CObex::TSetPathInfo& /*aPathInfo*/, 

                                        const TDesC8& /*aInfo*/)

    {

    TRACE_FUNC

    // SetPath is not implemented in BIP - so following IrOBEX guidance, return

    // the Forbidden response code.

    return KErrIrObexRespForbidden;

    }

/**

* This function is implementation for mixin-class for Obexutils.

* It is called every time another instance modifies disk status,

* for example when it cross warning/critical level.

* Parameters:

* @param aCheckType             Disktype changes.

*/

void CBIPController::HandleNotifyL(TMemoryPropertyCheckType aCheckType)

    {    

    TRACE_FUNC_ENTRY    

    // Only interested on this notification if we are receiving something

    if ( iBTTransferState == ETransferPut )

        {

       // Check the keys, what has been changed.

       if ( aCheckType == ECheckPhoneMemory )

           {

           if ( SysUtil::FFSSpaceBelowCriticalLevelL( NULL, 0 ) )

               {                

               TRACE_INFO( _L( "[obexreceiveservicebip] CBIPController: Obex Server error diskfull:\t" ) );

               iBTTransferState = ETransferPutDiskError;

               }

           }

       else if ( aCheckType == ECheckMMCMemory )

           {                

           if ( SysUtil::MMCSpaceBelowCriticalLevelL( NULL, 0 ) )

               {                    

               TRACE_INFO( _L( "[obexreceiveservicebip] CBIPController: Obex Server error diskfull:\t" ) );

               iBTTransferState = ETransferPutDiskError;

               }

           }            

        }        

    TRACE_FUNC_EXIT    

    }

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

// HandleGetCapabilityRequestL()

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

//

void CBIPController::HandleGetCapabilityRequestL()

    {

    TRACE_FUNC_ENTRY    

    CBIPCapabilityHandler* capHandler = CBIPCapabilityHandler::NewL();

    CleanupStack::PushL(capHandler);

    capHandler->CreateCapabilityObjectL(iCapabilityFileName);

    delete iGetObject;

    iGetObject = NULL; 

    iGetObject = CObexBufObject::NewL(NULL);

    iGetObject->SetDataBufL(iCapabilityFileName);

    CleanupStack::PopAndDestroy(capHandler);

    TRACE_FUNC_EXIT

    }

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

// HandlePutImageRequest()

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

//

void CBIPController::HandlePutImageRequestL()

    {

    TRACE_FUNC_ENTRY

    delete iBTObject;

    iBTObject = NULL;

    if (!iFs.Handle())

        {

        User::Leave(KErrGeneral);

        }

    // Assign an initial value to iDrive

    iDrive = GetDriveWithMaximumFreeSpaceL();    

    // If iDrive is at critical space level, we immediately show out_of_memory.

    //

    if (SysUtil::DiskSpaceBelowCriticalLevelL(&iFs, 0, iDrive))

        {

        TRAP_IGNORE(TObexUtilsUiLayer::ShowGlobalConfirmationQueryL(R_OUT_OF_MEMORY));

        User::Leave(KErrGeneral);

        }

    iBTObject = CObexBufObject::NewL(NULL);    

    delete iBuf;

    iBuf = NULL;

    TChar driveLetter;

    iDefaultFolder.Zero();

    iFs.DriveToChar(iDrive, driveLetter);

    iDefaultFolder.Append(driveLetter);

    if ( iDrive == EDriveC )

        {

        iDefaultFolder.Append(_L(":\\data\\"));

        }

    else

        {

        iDefaultFolder.Append(_L(":\\"));

        }

    iDefaultFolder.Append(iCenRepFolder);

    iFile = RFile();

    iFullPathFilename.Zero();

    TObexUtilsMessageHandler::CreateReceiveBufferAndRFileL(iFile, iDefaultFolder, iFullPathFilename, iBuf, KBufferSize);

    User::LeaveIfError(iFile.Open(iFs, iFullPathFilename, EFileWrite));

    TObexRFileBackedBuffer bufferdetails(*iBuf, iFile, CObexBufObject::EDoubleBuffering);

    TRAPD(err, iBTObject->SetDataBufL(bufferdetails));

    if (err != KErrNone)

        {

        iBTTransferState = ETransferPutInitError;

        User::Leave(KErrGeneral); 

        }