path: root/src/FNetBt_BluetoothOppClientImpl.cpp

//
// Open Service Platform
// Copyright (c) 2012-2013 Samsung Electronics Co., Ltd.
//
// Licensed under the Apache License, Version 2.0 (the License);
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//     http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
//
// @file    FNetBtBluetoothOppClientImpl.cpp
// @brief   This is the implementation file for the _BluetoothOppClientImpl class.
//

#include <FNetBtBluetoothTypes.h>
#include <FNetBtBluetoothDevice.h>
#include <FNetBtIBluetoothOppClientEventListener.h>
#include <FBaseSysLog.h>
#include <FIo_FileImpl.h>
#include <FApp_AppInfo.h>
#include "FNetBt_BluetoothOppClientImpl.h"
#include "FNetBt_BluetoothOppSystemAdapter.h"
#include "FNetBt_BluetoothGapSystemAdapter.h"
#include "FNetBt_BluetoothOppClientEvent.h"
#include "FNetBt_BluetoothOppClientEventArg.h"

using namespace std;
using namespace Tizen::App;
using namespace Tizen::Base;
using namespace Tizen::Base::Runtime;

namespace Tizen { namespace Net { namespace Bluetooth
{

_BluetoothOppClientImpl::_BluetoothOppClientImpl(void)
	: __pGapAdapter(null)
	, __pOppAdapter(null)
	, __pEvent(null)
	, __stateMutex()
	, __currentState(_BT_OPP_CLI_STATE_DISABLED)
	, __pairingAddress()
	, __pushedFilePath()
	, __minProgressInterval(__defaultProgressInterval)
	, __previousProgress(0)
{
}

_BluetoothOppClientImpl::~_BluetoothOppClientImpl(void)
{
	if (__pOppAdapter != null)
	{
		if ((__currentState == _BT_OPP_CLI_STATE_PUSH_READY)
			|| (__currentState == _BT_OPP_CLI_STATE_ON_TRANSFER))
		{
			(void) CancelPush();
		}
	}

	if (__pGapAdapter != null)
	{
		__pGapAdapter->UnregisterManagerEventListener(*this);
		__pGapAdapter->UnregisterDeviceEventListener(*this);
	}
}

result
_BluetoothOppClientImpl::Construct(IBluetoothOppClientEventListener& listener)
{
	result r = E_SUCCESS;
	std::unique_ptr<_BluetoothOppClientEvent> pEvent;

	r = __stateMutex.Create();
	SysTryReturn(NID_NET_BT, r == E_SUCCESS, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] Failed to create the state mutex.");

	r = __pairingAddress.Construct(_BT_ADDRESS_LENGTH);
	SysTryReturn(NID_NET_BT, r == E_SUCCESS, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] Failed to construct the address for pairing.");

	__pGapAdapter = _BluetoothGapSystemAdapter::GetInstance();
	SysTryReturn(NID_NET_BT, __pGapAdapter != null, E_SYSTEM, E_SYSTEM,
				"[E_SYSTEM] Failed to invoke _BluetoothGapSystemAdapter::GetInstance().");

	__pOppAdapter = _BluetoothOppSystemAdapter::GetInstance();

	pEvent.reset(new (std::nothrow) _BluetoothOppClientEvent());
	SysTryReturn(NID_NET_BT, pEvent != null, r = E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient.");
	r = pEvent->Construct();
	SysTryReturn(NID_NET_BT, r == E_SUCCESS, E_SYSTEM, E_SYSTEM, "[E_SYSTEM] Failed to construct the event.");
	// add the IBluetoothOppClientEventListener instance to a new created _BluetoothOppClientEvent.
	r = pEvent->AddListener(listener, true);
	SysTryReturn(NID_NET_BT, r == E_SUCCESS, E_SYSTEM, E_SYSTEM,
			"[%s] Propagating. Failed to add the application listener for OPP client", GetErrorMessage(r));

	// registers this callback listener to the system adapter for activation/deactivation event
	r = __pGapAdapter->RegisterManagerEventListener(*this, true);
	SysTryReturn(NID_NET_BT, r == E_SUCCESS, E_SYSTEM, E_SYSTEM,
			   "[E_SYSTEM] Failed to register the callback listener to _BluetoothGapSystemAdapter.");

	// registers this callback listener to the system adapter for paired event
	r = __pGapAdapter->RegisterDeviceEventListener(*this);
	if (r != E_SUCCESS)
	{
		__pGapAdapter->UnregisterManagerEventListener(*this);
	}
	SysTryReturn(NID_NET_BT, r == E_SUCCESS, E_SYSTEM, E_SYSTEM,
			   "[E_SYSTEM] Failed to register the callback listener to _BluetoothGapSystemAdapter.");

	// checks whether the Bluetooth is available
	__stateMutex.Acquire();

	if (__pGapAdapter->IsActivated() == true)
	{
		__currentState = _BT_OPP_CLI_STATE_IDLE;
	}

	__stateMutex.Release();

	__pEvent = move(pEvent);

	return E_SUCCESS;
}


result
_BluetoothOppClientImpl::PushFile(const BluetoothDevice& remoteDevice, const Base::String& filePath)
{
	SysLog(NID_NET_BT, "EntryPoint, [CurrentState:%s]", GetStringOfCurrentState());

	result r = E_FAILURE;
	String physicalPath;

	__stateMutex.Acquire();

	switch (__currentState)
	{
	case _BT_OPP_CLI_STATE_DISABLED:
		r = E_INVALID_STATE;
		break;

	case _BT_OPP_CLI_STATE_IDLE:
		if (_AppInfo::GetApiVersion() == _API_VERSION_2_0 && _AppInfo::IsOspCompat())
		{
			if (Tizen::Io::_FileImpl::ConvertVirtualToPhysicalPath(filePath, physicalPath) != E_SUCCESS)
			{
				r = E_INACCESSIBLE_PATH;
				break;
			}
		}
		else
		{
			physicalPath = filePath;
		}

		if (__pGapAdapter->IsPaired(*(remoteDevice.GetAddress())) == true)
		{
			r = __pOppAdapter->PushOppFile(*this, *(remoteDevice.GetAddress()), physicalPath);
			if (r == E_SUCCESS)
			{
				__currentState = _BT_OPP_CLI_STATE_PUSH_READY;
			}
		}
		else
		{
			// start the pairing process
			if (__pGapAdapter->Pair(*(remoteDevice.GetAddress())) == E_SUCCESS)
			{
				// copy the address of the pairing device to the local variable
				__pairingAddress.SetArray(remoteDevice.GetAddress()->GetPointer(), 0, _BT_ADDRESS_LENGTH);
				__pairingAddress.SetPosition(0);
				// copy the file path to the local variable
				__pushedFilePath.Clear();
				__pushedFilePath = physicalPath;

				r = E_SUCCESS;
				__currentState = _BT_OPP_CLI_STATE_BONDING;
			}
			else
			{
				r = E_FAILURE;
			}
		}
		break;

	case _BT_OPP_CLI_STATE_BONDING:
	case _BT_OPP_CLI_STATE_PUSH_READY:
	case _BT_OPP_CLI_STATE_REQ_CANCELING:   //TODO: this state should return E_INVALID_OPERATION. (Versioning)
	case _BT_OPP_CLI_STATE_ON_TRANSFER:
	case _BT_OPP_CLI_STATE_TRANS_CANCELING:   //TODO: this state should return E_INVALID_OPERATION. (Versioning)
		r = E_IN_PROGRESS;
		break;

	default:
		// ignore other cases
		break;
	}

	__stateMutex.Release();

	if (r != E_SUCCESS)
	{
		SysLogException(NID_NET_BT, r, "[%s] exception occurred on pushing a file.", GetErrorMessage(r));
	}

	SysLog(NID_NET_BT, "ExitPoint, [CurrentState:%s], [ActionResult:%s]", GetStringOfCurrentState(), GetErrorMessage(r));

	return r;
}

result
_BluetoothOppClientImpl::CancelPush()
{
	SysLog(NID_NET_BT, "EntryPoint, [CurrentState:%s]", GetStringOfCurrentState());

	result r = E_FAILURE;

	__stateMutex.Acquire();

	switch (__currentState)
	{
	case _BT_OPP_CLI_STATE_DISABLED:
		r = E_INVALID_STATE;
		break;

	case _BT_OPP_CLI_STATE_IDLE:
		r = E_INVALID_OPERATION;
		break;

	case _BT_OPP_CLI_STATE_REQ_CANCELING:
	case _BT_OPP_CLI_STATE_TRANS_CANCELING:
		r = E_IN_PROGRESS;
		break;

	case _BT_OPP_CLI_STATE_BONDING: //TODO: Versioning check
		if (__pGapAdapter->CancelPair() == E_SUCCESS)
		{
			r = E_SUCCESS;
			__currentState = _BT_OPP_CLI_STATE_REQ_CANCELING;
		}
		// It will be changed to IDLE after receiving the OnBluetoothPaired event.
		break;

	case _BT_OPP_CLI_STATE_PUSH_READY:
		r = __pOppAdapter->CancelOppPush();

		if (r == E_SUCCESS)
		{
			__currentState = _BT_OPP_CLI_STATE_REQ_CANCELING;
		}
		// It will be changed to IDLE after receiving the OnOppTransferDone event.
		break;

	case _BT_OPP_CLI_STATE_ON_TRANSFER:
		r = __pOppAdapter->CancelOppPush();

		if (r == E_SUCCESS)
		{
			__currentState = _BT_OPP_CLI_STATE_TRANS_CANCELING;
		}
		// It will be changed to IDLE after receiving the OnOppTransferDone event.
		break;

	default:
		// ignore other cases
		break;
	}

	__stateMutex.Release();

	if (r != E_SUCCESS)
	{
		SysLogException(NID_NET_BT, r, "[%s] exception occurred on canceling the push.", GetErrorMessage(r));
	}

	SysLog(NID_NET_BT, "ExitPoint, [CurrentState:%s], [ActionResult:%s]", GetStringOfCurrentState(), GetErrorMessage(r));

	return r;
}

result
_BluetoothOppClientImpl::SetMinProgressInterval(int percent)
{
	result r = E_SUCCESS;

	if ((percent < 1) || (percent > 100))
	{
		r = E_OUT_OF_RANGE;
		SysLogException(NID_NET_BT, E_OUT_OF_RANGE, "[E_OUT_OF_RANGE] The input argument - percent - is outside the valid range.");
	}
	else
	{
		__minProgressInterval = percent;
	}

	return r;
}

void
_BluetoothOppClientImpl::OnBluetoothActivated(result r)
{
	SysLog(NID_NET_BT, "EntryPoint, [CurrentState:%s], [ActionResult:%s]", GetStringOfCurrentState(), GetErrorMessage(r));

	__stateMutex.Acquire();

	if ((__currentState == _BT_OPP_CLI_STATE_DISABLED)
		&& (r == E_SUCCESS))
	{
		__currentState = _BT_OPP_CLI_STATE_IDLE;
	}

	__stateMutex.Release();

	SysLog(NID_NET_BT, "ExitPoint, [CurrentState:%s]", GetStringOfCurrentState());
}

void
_BluetoothOppClientImpl::OnBluetoothDeactivated(result r)
{
	SysLog(NID_NET_BT, "EntryPoint, [CurrentState:%s], [ActionResult:%s]", GetStringOfCurrentState(), GetErrorMessage(r));

	__stateMutex.Acquire();

	if (r == E_SUCCESS)
	{
		__currentState = _BT_OPP_CLI_STATE_DISABLED;
	}

	__stateMutex.Release();

	SysLog(NID_NET_BT, "ExitPoint, [CurrentState:%s]", GetStringOfCurrentState());
}

void
_BluetoothOppClientImpl::OnOppPushResponded(result r)
{
	SysLog(NID_NET_BT, "EntryPoint, [CurrentState:%s], [ActionResult:%s]", GetStringOfCurrentState(), GetErrorMessage(r));

	bool isFired = false;

	__stateMutex.Acquire();

	if ((__currentState == _BT_OPP_CLI_STATE_PUSH_READY) || (__currentState == _BT_OPP_CLI_STATE_REQ_CANCELING))
	{
		if (r == E_SUCCESS)
		{
			__currentState = _BT_OPP_CLI_STATE_ON_TRANSFER;
		}
		else // including both cases of being canceled by the user and rejected by the remote device
		{
			__currentState = _BT_OPP_CLI_STATE_IDLE;
			SysLogException(NID_NET_BT, r, "[%s] exception occurred on the response of the OPP push request.", GetErrorMessage(r));
		}

		isFired = true;
	}

	__stateMutex.Release();

	if (isFired)
	{
		_BluetoothOppClientEventArg* pArg = new (std::nothrow) _BluetoothOppClientEventArg(r);
		if (pArg == null)
		{
			SysLogException(NID_NET_BT, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient.");
			isFired = false;
		}
		else
		{
			__pEvent->FireAsync(*pArg);
		}
	}

	SysLog(NID_NET_BT, "ExitPoint, [CurrentState:%s], [PUSH_RESPONDED_Event:%s]",
				GetStringOfCurrentState(), isFired ? "Fired" : "NotFired");
}

void
_BluetoothOppClientImpl::OnOppTransferInProgress(int percent)
{
	SysLog(NID_NET_BT, "EntryPoint, [CurrentState:%s], [Progress:%d]", GetStringOfCurrentState(), percent);

	bool isFired = false;

	__stateMutex.Acquire();

	if ((__currentState == _BT_OPP_CLI_STATE_ON_TRANSFER) || (__currentState == _BT_OPP_CLI_STATE_TRANS_CANCELING))
	{
		if (((percent - __previousProgress) >= __minProgressInterval) || (percent >= 100))
		{
			isFired = true;
			__previousProgress = percent;
		}
	}

	__stateMutex.Release();

	if (isFired)
	{
		_BluetoothOppClientEventArg* pArg = new (std::nothrow) _BluetoothOppClientEventArg(percent);
		if (pArg == null)
		{
			SysLogException(NID_NET_BT, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient.");
			isFired = false;
		}
		else
		{
			__pEvent->FireAsync(*pArg);
		}
	}

	SysLog(NID_NET_BT, "ExitPoint, [CurrentState:%s], [TRANSFER_IN_PROGRESS_Event:%s]",
				GetStringOfCurrentState(), isFired ? "Fired" : "NotFired");
}

void
_BluetoothOppClientImpl::OnOppTransferDone(const Tizen::Base::String& filePath, int fileSize, bool isCompleted)
{
	SysLog(NID_NET_BT, "EntryPoint, [CurrentState:%s], [filePath:%ls], [fileSize:%d], [%s]",
				GetStringOfCurrentState(), filePath.GetPointer(), fileSize, isCompleted ? "Completed" : "Incompleted");

	bool isFired = false;
	String pushedFilePath;
	result r = E_SUCCESS;

	__stateMutex.Acquire();

	if ((__currentState == _BT_OPP_CLI_STATE_ON_TRANSFER) || (__currentState == _BT_OPP_CLI_STATE_TRANS_CANCELING))
	{
		__currentState = _BT_OPP_CLI_STATE_IDLE;
		isFired = true;
		__previousProgress = 0;        // initialization for the next push transaction
	}

	__stateMutex.Release();

	if (_AppInfo::GetApiVersion() == _API_VERSION_2_0 && _AppInfo::IsOspCompat())
	{
		r = Tizen::Io::_FileImpl::ConvertPhysicalToVirtualPath(__pushedFilePath, pushedFilePath);
		if(r != E_SUCCESS)
		{
			SysLogException(NID_NET_BT, r, "[%s] exception occurred on converting the file path from physical to virtual.", GetErrorMessage(r));
			pushedFilePath = __pushedFilePath;
		}
	}
	else
	{
		pushedFilePath = __pushedFilePath;
	}

	if (isFired)
	{
		_BluetoothOppClientEventArg* pArg = new (std::nothrow) _BluetoothOppClientEventArg(pushedFilePath, fileSize, isCompleted);
		if (pArg == null)
		{
			SysLogException(NID_NET_BT, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient.");
			isFired = false;
		}
		else
		{
			__pEvent->FireAsync(*pArg);
		}
	}

	SysLog(NID_NET_BT, "ExitPoint, [CurrentState:%s], [TRANSFER_DONE_Event:%s]",
				GetStringOfCurrentState(), isFired ? "Fired" : "NotFired");
}

void
_BluetoothOppClientImpl::OnBluetoothPaired(const BluetoothDevice* pPairedDevice, result r)
{
	SysLog(NID_NET_BT, "EntryPoint, [CurrentState:%s], [ActionResult:%s]", GetStringOfCurrentState(), GetErrorMessage(r));

	bool isFired = false;
	result responseResult = E_SYSTEM;

	__stateMutex.Acquire();

	if (pPairedDevice->GetAddress()->Equals(__pairingAddress))
	{
		if (__currentState == _BT_OPP_CLI_STATE_BONDING)
		{
			if (r == E_SUCCESS)
			{
				if (__pOppAdapter->PushOppFile(*this, __pairingAddress, __pushedFilePath) == E_SUCCESS)
				{
					__currentState = _BT_OPP_CLI_STATE_PUSH_READY;
				}
				else
				{
					// callback responded with E_SYSTEM
					isFired = true;
					__currentState = _BT_OPP_CLI_STATE_IDLE;
					responseResult = E_SYSTEM;
				}
			}
			else
			{
				// callback responded with r
				isFired = true;
				__currentState = _BT_OPP_CLI_STATE_IDLE;
				responseResult = r;
			}

			__pairingAddress.Clear();
		}
		else if (__currentState == _BT_OPP_CLI_STATE_REQ_CANCELING)
		{
			// callback responded with E_SYSTEM or E_OPERATION_CANCELED
			isFired = true;
			__currentState = _BT_OPP_CLI_STATE_IDLE;
			responseResult = E_SYSTEM;
		}
	}
	// ignored otherwise

	__stateMutex.Release();

	if (isFired)
	{
		_BluetoothOppClientEventArg* pArg = new (std::nothrow) _BluetoothOppClientEventArg(responseResult);
		if (pArg == null)
		{
			SysLogException(NID_NET_BT, E_OUT_OF_MEMORY, "[E_OUT_OF_MEMORY] The memory is insufficient.");
			isFired = false;
		}
		else
		{
			__pEvent->FireAsync(*pArg);
		}
	}

	SysLog(NID_NET_BT, "ExitPoint, [CurrentState:%s], [PUSH_RESPONDED_Event:%s]",
				GetStringOfCurrentState(), isFired ? "Fired" : "NotFired");
}

const char*
_BluetoothOppClientImpl::GetStringOfCurrentState(void) const
{
	const char* pStateString = null;

	switch (__currentState)
	{
	case _BT_OPP_CLI_STATE_DISABLED:
		pStateString = "DISABLED";
		break;

	case _BT_OPP_CLI_STATE_IDLE:
		pStateString = "IDLE";
		break;

	case _BT_OPP_CLI_STATE_BONDING:
		pStateString = "BONDING";
		break;

	case _BT_OPP_CLI_STATE_PUSH_READY:
		pStateString = "PUSH_READY";
		break;

	case _BT_OPP_CLI_STATE_REQ_CANCELING:
		pStateString = "REQ_CANCELING";
		break;

	case _BT_OPP_CLI_STATE_ON_TRANSFER:
		pStateString = "ON_TRANSFER";
		break;

	case _BT_OPP_CLI_STATE_TRANS_CANCELING:
		pStateString = "TRANS_CANCELING";
		break;

	default:
		pStateString = "Unknown";
		break;
	}

	return pStateString;
}

} } } // Tizen::Net::Bluetooth