/*

* Copyright (c) 2004-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:  

*

*/

#include <avkon.hrh>

#include <aknnotewrappers.h>

#include "cbtprintingdevice.h"

#include "cbtobjectserver.h"

#include "btprotocolconsts.h"

#include "clog.h"

#include "printmessagecodes.h"

#include "tbtmapper.h"

#include "xhtmlfilecomposerconst.h"

#include "rsutils.h"

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

// CBtObjectServer::NewL()

// Creates a new instance of the class

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

CBtObjectServer* CBtObjectServer::NewL(const TBTDevAddr& aDeviceAddress,

                                               RArray<CImageInfo> &aImgArray,

                                               MBtObjectServerObserver &aObs)

{

    CBtObjectServer* self = CBtObjectServer::NewLC( aDeviceAddress, aImgArray, aObs );

    CleanupStack::Pop( self );

    return self;

}

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

// CBtObjectServer::NewLC()

// Creates a new instance of the class

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

CBtObjectServer* CBtObjectServer::NewLC(const TBTDevAddr& aDeviceAddress,

                                                RArray<CImageInfo> &aImgArray,

                                                MBtObjectServerObserver &aObs)

{

    CBtObjectServer* self = new ( ELeave ) CBtObjectServer( aDeviceAddress, aObs );

    CleanupStack::PushL( self );

    self->ConstructL(aImgArray);

    return self;

}

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

// CBtObjectServer::CBtObjectServer

// The actual constructor of the class

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

CBtObjectServer::CBtObjectServer(const TBTDevAddr& aDeviceAddress, MBtObjectServerObserver& aObs )

:  	iAllowedAddress ( aDeviceAddress ),

	iObs ( aObs ),

	iStarted(EFalse),

	iConnected(EFalse),

	iTransportUp(EFalse)

{

    LOG("CBtObjectServer::CBtObjectServer]\t default constructor");

   iImgArray.Reset();

   iImgArray.Close();

}

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

// CBtObjectServer::~CBtObjectServer()

// Destructor.

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

//

CBtObjectServer::~CBtObjectServer()

{

    LOG("CBtObjectServer::~CBtObjectServer]\t");

	iStarted = EFalse;

	iOperation = EIdle;

    if ( iObexServer && iObexServer->IsStarted() )

    {

        iObexServer->Stop();

    }

	iFs.Close();

    if (iObexServer)

    	delete iObexServer;

    iObexServer = NULL;

	if(iObexBufObject)

    	delete iObexBufObject;

    iObexBufObject = NULL;

	// This must be deleted after the iObexBufObject who uses it.

    if (iObexBody)

	    delete iObexBody;

    iObexBody = NULL;

	if(iAdvertiser)

    	delete iAdvertiser;

    iAdvertiser = NULL;

    iImgArray.Close();

}

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

// CBtObjectServer::Cancel()

// Sends current file to the server and then stops the server

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

void CBtObjectServer::Cancel()

{

    LOG("[CBtObjectServer::Cancel]\t");

    if (!IsSendingData())

    {

        LOG("[CBtObjectServer::Cancel]\t - not sending data - stopping server now! \n");

        Stop();

    }

    else

    {

    	iOperation = EIdle;

    }

}

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

// CBtObjectServer::ConstructL()

// Constucts everything that can leave in the class

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

void CBtObjectServer::ConstructL(RArray<CImageInfo> &aImgArray)

{

    LOG("[CBtObjectServer::ConstructL]\t");

    LOG1("[CBtObjectServer::ConstructL]\t aImgArray.Count(): %d", aImgArray.Count());

	for(TInt i = 0; i < aImgArray.Count(); ++i)

	{

		iImgArray.Append(aImgArray[i]);

/* For debug		

#ifdef ENABLE_LOGGING		

		TFileName8 uri;

		aImgArray[i].GetUri(uri);

		TFileName8 log;

		CImageInfo::UriLog(uri, log);

    	LOG1("[CBtObjectServer::ConstructL]\t uri: %d", log);

#endif // ENABLE_LOGGING

*/

	}

    iAdvertiser = CBtDprServiceAdvertiser::NewL();

    // create OBEX object to receive obex transfer. 8 for reserving data in 8 bytes segments

    iObexBody = CBufFlat::NewL( 8 );

    User::LeaveIfError(iFs.Connect());

	InitTransferData();

	iRemoteAddress.Reset();

}

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

// CBtObjectServer::Stop()

// Disconnects the server.

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

//

void CBtObjectServer::Stop()

{

    LOG("[CBtObjectServer::Stop]\t");

    // already stopping

    if(!iStarted)

    	return;

	iOperation = ETerminating;

    LOG("[CBtObjectServer::Stop]\t cont...");

    iRemoteAddress.Reset();

    //cannot delete here. Stop called from iObexServer Callback function.

    if ( iObexServer && iObexServer->IsStarted())

    {

	    LOG("[CBtObjectServer::Stop]\t stopping iObexServer...");

    	iObexServer->Stop();

	}

    // Trap this: if it fails, we cannot do anything.

    TInt leave; // for remove compiling warnings

    TRAP(leave, iAdvertiser->StopAdvertisingL());

    LOG1("[CBtObjectServer::Stop]\t iAdvertiser->StopAdvertising() leaves with %d", leave);

    LOG1("[CBtObjectServer::Stop]\t iObexServer: %d", iObexServer);

	iOperation = EIdle; 

	iStarted = EFalse;

	iConnected = EFalse;

	iTransportUp = EFalse;

    /* Sending 'stopped' status */

    iObs.HandleObjectServerEvent(MBtObjectServerObserver::KObjectServerStopped);

}

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

// CBtObjectServer::StartL()

// Starts the server.

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

//

void CBtObjectServer::StartL()

{

    LOG("[CBtObjectServer::StartL]\t");

	TBool btOn = RsUtils::IsBluetoothOn();

	LOG1("[CBtObjectServer::StartL]\t btOn: %d", btOn);

	if( !btOn )

		User::Leave(KErrCancel);

    TRAPD( err, InitialiseServerL() );

    LOG1("CBtObjectServer::StartL]\t InitialiseServerL leaves with %d", err);

    if ( err != KErrNone )

    {

        Stop();

    	User::Leave(err);

    }

    iStarted = ETrue;

    /* Send 'server started' status */

    iObs.HandleObjectServerEvent(MBtObjectServerObserver::KObjectServerStarted);

}

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

// CBtObjectServer::InitialiseServerL()

// Initialises the server.

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

//

void CBtObjectServer::InitialiseServerL()

{

    LOG("CBtObjectServer::InitialiseServerL]\t");

    if ( iObexServer )

    {

        ASSERT( IsConnected() ); // server already running

        return;

    }

    LOG("[CBtObjectServer::InitialiseServerL]\t - getting channel");

	// Set the Socket's security with parameters,

	// Authentication, Encryption, Authorisation and Denied

	// Method also return the channel available to listen to.

	TInt channel = SetSecurityWithChannelL( EFalse, EFalse, EFalse, EFalse );

    // start the OBEX server

    TObexBluetoothProtocolInfo obexProtocolInfo;

    LOG1("[CBtObjectServer::InitialiseServerL]\t setting %S ", &KRFCOMMDesC);

    obexProtocolInfo.iTransport.Copy( KRFCOMMDesC() );

    LOG1("[CBtObjectServer::InitialiseServerL]\t setting port %d", channel);

    obexProtocolInfo.iAddr.SetPort( channel );

    LOG("[CBtObjectServer::InitialiseServerL]\t CObexServer::NewL()");

    if(iObexServer)

    {

    	delete iObexServer;

    	iObexServer = NULL;

    }

    iObexServer = CObexServer::NewL( obexProtocolInfo );

    LOG("[CBtObjectServer::InitialiseServerL]\t iObexServer->Start()");

    User::LeaveIfError(iObexServer->Start( this ) );

    TUUID who(KBTSDPDPROService);

	User::LeaveIfError(iObexServer->SetLocalWho(who.LongForm()));

    // advertise this service

    LOG("[CBtObjectServer::InitialiseServerL]\t iAdvertiser->StartAdvertisingL()");

    iAdvertiser->StartAdvertisingL( channel );

    LOG("[CBtObjectServer::InitialiseServerL]\t iAdvertiser->UpdateAvailabilityL()");

    iAdvertiser->UpdateAvailabilityL( ETrue );

}

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

// CBtObjectServer::InitTransferData()

// Initialises the variables needed for progressing and processing the printing

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

//

void CBtObjectServer::InitTransferData()

{

    LOG("CBtObjectServer::InitTransferData]\t");

	InitHeaderVariables();

	iProgress = 0;

	// delete this to be ready to send NULL object.

    if(iObexBufObject)

    	delete iObexBufObject;

    iObexBufObject = NULL;

    // no need to delete. Reset is enough.

    iObexBody->Reset();

}

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

// CBtObjectServer::InitHeaderVariables()

// Initialises the variables needed for progressing and processing the printing

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

//

void CBtObjectServer::InitHeaderVariables()

{

    LOG("CBtObjectServer::InitHeaderVariables]\t");

	iOffset = 0;

	iCount = 0; // KErrNotFound indicates "the rest"

	iSize = KErrNotFound;

}

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

// CBtObjectServer::SetSecurityWithChannelL()

// Sets the security on the channel port and returns the available port.

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

//

TInt CBtObjectServer::SetSecurityWithChannelL( TBool aAuthentication,

                                                  TBool aEncryption,

                                                  TBool aAuthorisation,

												  TBool aDenied )

{

    LOG("CBtObjectServer::SetSecurityWithChannelL]\t");

	// Local variable to channel to listen to.

	TInt channel;

	RSocketServ socketServer;

	// Connect to SocetServer

    LOG("[CBtObjectServer::SetSecurityWithChannelL]\t - connecting to socketServer");

	User::LeaveIfError( socketServer.Connect() );

	CleanupClosePushL( socketServer );

	RSocket socket;

	// Open the Socket connection

    LOG("[CBtObjectServer::SetSecurityWithChannelL]\t - opening a socket");

	User::LeaveIfError( socket.Open( socketServer, KRFCOMMDesC() ) );

	CleanupClosePushL( socket );

	// Retreive to one channel that is available.

    LOG("[CBtObjectServer::SetSecurityWithChannelL]\t - get one channel");

	User::LeaveIfError( socket.GetOpt( KRFCOMMGetAvailableServerChannel,KSolBtRFCOMM, channel ) );

	// Set the Socket's Port.

	TBTSockAddr sockaddr;

	sockaddr.SetPort( channel );

    LOG("[CBtObjectServer::SetSecurityWithChannelL]\t - setting security settings");

	// Set the security according to.

	TBTServiceSecurity serviceSecurity;

	serviceSecurity.SetUid ( KBtProtocolUid ); // UID for _this_ security service; internal inside the phone

	serviceSecurity.SetAuthentication ( aAuthentication );

	serviceSecurity.SetEncryption ( aEncryption );

	serviceSecurity.SetAuthorisation ( aAuthorisation );

	serviceSecurity.SetDenied( aDenied );

	// Attach the security settings.

	sockaddr.SetSecurity(serviceSecurity);

    LOG("[CBtObjectServer::SetSecurityWithChannelL]\t - binding socket to a address");

	// Bind and start listeing the port with security set,

	User::LeaveIfError(socket.Bind(sockaddr));

	User::LeaveIfError(socket.Listen(KSimultainousSocketsOpen ) );

	// now close the socket and the socket server

	CleanupStack::PopAndDestroy(2);  //  socket, socketServer

    LOG("[CBtObjectServer::SetSecurityWithChannelL]\t - returning");

	return channel;

}

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

// CBtObjectServer::IsConnected()

// Results true if the server is connected.

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

//

TBool CBtObjectServer::IsConnected()

{

    LOG1("CBtObjectServer::IsConnected]\t %d", iConnected);

    return iConnected;

}

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

// CBtObjectServer::IsTransporting()

// Results true if the transport connection is up.

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

//

TBool CBtObjectServer::IsTransporting()

{

    LOG1("CBtObjectServer::IsTransporting]\t %d", iTransportUp);

    return iTransportUp;

}

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

// IsSendingData()

// @return ETrue if the server is sending data to a Bluetooth device

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

TBool CBtObjectServer::IsSendingData()

{

    LOG("CBtObjectServer::IsSendingData]\t");

	if(ESending == iOperation)

		return ETrue;

	return EFalse;

}

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

// IsSendingData()

// @return ETrue if the server is finished and can be deleted

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

TBool CBtObjectServer::IsFinished()

{

    LOG("CBtObjectServer::IsFinished]\t");

	if(ESending != iOperation)

		return ETrue;

	return EFalse;

}

/*****************************************************************************/

/* Following methods implement the Obex Observer callbacks in this class     */

/*****************************************************************************/

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

// CBtObjectServer::ErrorIndication()

// Receive error indication.

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

//

void CBtObjectServer::ErrorIndication( TInt aError )

{

    LOG2("CBtObjectServer::ErrorIndication]\t iOperation: %d, aError: %d", iOperation, aError);

    iObs.HandleObjectServerEvent(MBtObjectServerObserver::KObjectServerError, aError);

}

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

// CBtObjectServer::TransportUpIndication()

// Called when the underlying socket transport connection is made from

// a remote client to the server

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

//

void CBtObjectServer::TransportUpIndication()

{

    LOG1("CBtObjectServer::TransportUpIndication]\t iOperation: %d", iOperation);

	iTransportUp = ETrue;

    iObs.HandleObjectServerEvent(MBtObjectServerObserver::KObjectServerTransportUp);

}

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

// CBtObjectServer::TransportDownIndication()

// Transport connection is dropped.

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

//

void CBtObjectServer::TransportDownIndication()

{

    LOG1("[CBtObjectServer::TransportDownIndication]\t iOperation: %d", iOperation);

	iTransportUp = EFalse;

	if(ETerminating != iOperation)

		iObs.HandleObjectServerEvent(MBtObjectServerObserver::KObjectServerTransportDown);

}

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

// CBtObjectServer::ObexConnectIndication()

// Invoked when an OBEX connection is made from a remote client.

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

//

TInt CBtObjectServer::ObexConnectIndication(

    const TObexConnectInfo& /*aRemoteInfo*/, const TDesC8& /*aInfo*/ )

{

    LOG("CBtObjectServer::ObexConnectIndication]\t");

	TInt message = KErrAccessDenied;

    /* Check the address of the remote device */

    if(AllowConnection())

    {

    	message = KErrNone;

    	iConnected = ETrue;

	    iObs.HandleObjectServerEvent(MBtObjectServerObserver::KObjectServerConnected);

    }

    LOG1("CBtObjectServer::ObexConnectIndication]\t returns %d", message);

	return message;

}

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

// CBtObjectServer::ObexDisconnectIndication()

// OBEX server has been disconnected.

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

//

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

{

    LOG("CBtObjectServer::ObexDisconnectIndication]\t");

	if(ETerminating != iOperation)