path: root/src/FScl_AccountProviderImpl.cpp

//
// Copyright (c) 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		FScl_AccountProviderImpl.cpp
 * @brief		This is the implementation for _AccountProviderImpl class.
 *
 * This file contains definitions of @e _AccountProviderImpl class.
 */

#include <FBaseColIList.h>
#include <FBaseResult.h>
#include <FBaseString.h>
#include <FBaseSysLog.h>
#include <FSclAccountProvider.h>
#include "FScl_AccountProviderImpl.h"

using namespace Tizen::App;
using namespace Tizen::Base;
using namespace Tizen::Base::Collection;

namespace Tizen { namespace Social
{

_AccountProviderImpl::_AccountProviderImpl(void)
	: __isMultipleAccountSupported(false)
{
	std::unique_ptr<ArrayList, AllElementsDeleter> pCapabilityList(new (std::nothrow) ArrayList());
	SysTryReturnVoidResult(NID_SCL, pCapabilityList != null, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));

	result r = pCapabilityList->Construct();
	SysTryReturnVoidResult(NID_SCL, !IsFailed(r), r, "[%s] Failed to construct pCapabilityList.", GetErrorMessage(r));

	__pCapabilityList = std::move(pCapabilityList);
}

_AccountProviderImpl::_AccountProviderImpl(const _AccountProviderImpl& rhs)
{
	std::unique_ptr<ArrayList, AllElementsDeleter> pCapabilityList(new (std::nothrow) ArrayList());
	SysTryReturnVoidResult(NID_SCL, pCapabilityList != null, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));

	result r = pCapabilityList->Construct();
	SysTryReturnVoidResult(NID_SCL, !IsFailed(r), r, "[%s] Failed to construct pCapabilityList.", GetErrorMessage(r));

	std::unique_ptr<IEnumerator> pEnum(rhs.__pCapabilityList->GetEnumeratorN());
	SysTryReturnVoidResult(NID_SCL, pEnum != null, GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));

	std::unique_ptr<String> pCapability(null);
	String* pTempCapability = null;

	while (pEnum->MoveNext() == E_SUCCESS)
	{
		pTempCapability = static_cast<String*> (pEnum->GetCurrent());
		pCapability.reset(new (std::nothrow) String(*pTempCapability));
		SysTryReturnVoidResult(NID_SCL, pCapability != null, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));

		r = pCapabilityList->Add(pCapability.get());
		SysTryReturnVoidResult(NID_SCL, !IsFailed(r), r, "[%s] Propagating.", GetErrorMessage(r));

		pCapability.release();
	}

	__pCapabilityList = std::move(pCapabilityList);

	__appId = rhs.__appId;
	__displayName = rhs.__displayName;
	__iconPath = rhs.__iconPath;
	__smallIconPath = rhs.__smallIconPath;
	__isMultipleAccountSupported = rhs.__isMultipleAccountSupported;
}

_AccountProviderImpl::~_AccountProviderImpl(void)
{
	// empty body
}

_AccountProviderImpl&
_AccountProviderImpl::operator =(const _AccountProviderImpl& rhs)
{
	if (this == &rhs)
	{
		return *this;
	}

	std::unique_ptr<ArrayList, AllElementsDeleter> pCapabilityList(new (std::nothrow) ArrayList());
	SysTryReturn(NID_SCL, pCapabilityList != null, *this, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));

	result r = pCapabilityList->Construct();
	SysTryReturn(NID_SCL, !IsFailed(r), *this, r, "[%s] Failed to construct pCapabilityList.", GetErrorMessage(r));

	result prevResult = GetLastResult();

	std::unique_ptr<IEnumerator> pEnum(rhs.__pCapabilityList->GetEnumeratorN());
	SysTryReturn(NID_SCL, pEnum != null, *this, GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));

	SetLastResult(prevResult);

	std::unique_ptr<String> pCapability(null);
	String* pTempCapability = null;

	while (pEnum->MoveNext() == E_SUCCESS)
	{
		pTempCapability = static_cast<String*> (pEnum->GetCurrent());
		pCapability.reset(new (std::nothrow) String(*pTempCapability));
		SysTryReturn(NID_SCL, pCapability != null, *this, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));

		r = pCapabilityList->Add(pCapability.get());
		SysTryReturn(NID_SCL, !IsFailed(r), *this, r, "[%s] Propagating.", GetErrorMessage(r));

		pCapability.release();
	}

	__pCapabilityList = std::move(pCapabilityList);

	__appId = rhs.__appId;
	__displayName = rhs.__displayName;
	__iconPath = rhs.__iconPath;
	__smallIconPath = rhs.__smallIconPath;
	__isMultipleAccountSupported = rhs.__isMultipleAccountSupported;

	return *this;
}

bool
_AccountProviderImpl::operator ==(const _AccountProviderImpl& rhs) const
{
	if ((__appId == rhs.__appId) &&
		(__displayName == rhs.__displayName) &&
		(__iconPath == rhs.__iconPath) &&
		(__smallIconPath == rhs.__smallIconPath) &&
		(__isMultipleAccountSupported == rhs.__isMultipleAccountSupported) &&
		(__pCapabilityList->Equals(*(rhs.__pCapabilityList))))
	{
		return true;
	}

	return false;
}

bool
_AccountProviderImpl::operator !=(const _AccountProviderImpl& rhs) const
{
	return !(*this == rhs);
}

bool
_AccountProviderImpl::Equals(const Object& rhs) const
{
	const _AccountProviderImpl* pAccountProviderImpl = dynamic_cast<const _AccountProviderImpl*> (&rhs);
	if (pAccountProviderImpl == null)
	{
		return false;
	}

	if ((__appId != pAccountProviderImpl->__appId) ||
		(__displayName != pAccountProviderImpl->__displayName) ||
		(__iconPath != pAccountProviderImpl->__iconPath) ||
		(__smallIconPath != pAccountProviderImpl->__smallIconPath) ||
		(__isMultipleAccountSupported != pAccountProviderImpl->__isMultipleAccountSupported) ||
		!(__pCapabilityList->Equals(*(pAccountProviderImpl->__pCapabilityList))))
	{
		return false;
	}

	return true;
}

int
_AccountProviderImpl::GetHashCode(void) const
{
	int hashCode = 0;

	hashCode += __appId.GetHashCode();
	hashCode += __displayName.GetHashCode();

	return hashCode;
}

result
_AccountProviderImpl::AddCapability(const String& capability)
{
	std::unique_ptr<IEnumerator> pEnum(__pCapabilityList->GetEnumeratorN());
	SysTryReturnResult(NID_SCL, pEnum != null, GetLastResult(), "Propagating.");

	String* pTempCapability = null;
	bool alreadyExist = false;

	while (pEnum->MoveNext() == E_SUCCESS)
	{
		pTempCapability = static_cast<String*> (pEnum->GetCurrent());
		if (*pTempCapability == capability)
		{
			alreadyExist = true;
			break;
		}
	}

	SysTryReturnResult(NID_SCL, !alreadyExist, E_OBJ_ALREADY_EXIST, "The capability already exists.");

	std::unique_ptr<String> pCapability(new (std::nothrow) String(capability));
	SysTryReturnResult(NID_SCL, pCapability != null, E_OUT_OF_MEMORY, "Memory allocation failed.");

	result r = __pCapabilityList->Add(pCapability.get());
	SysTryReturn(NID_SCL, !IsFailed(r), r, r, "[%s] Propagating.", GetErrorMessage(r));

	pCapability.release();

	return E_SUCCESS;
}

AppId
_AccountProviderImpl::GetAppId(void) const
{
	return __appId;
}

IList*
_AccountProviderImpl::GetCapabilitiesN(void) const
{
	ClearLastResult();

	std::unique_ptr<ArrayList, AllElementsDeleter> pCapabilityList(new (std::nothrow) ArrayList());
	SysTryReturn(NID_SCL, pCapabilityList != null, null, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));

	result r = pCapabilityList->Construct();
	SysTryReturn(NID_SCL, !IsFailed(r), null, r, "[%s] Failed to construct pCapabilityList.", GetErrorMessage(r));

	std::unique_ptr<IEnumerator> pEnum(__pCapabilityList->GetEnumeratorN());
	SysTryReturn(NID_SCL, pEnum != null, null, GetLastResult(), "[%s] Propagating.", GetErrorMessage(GetLastResult()));

	std::unique_ptr<String> pCapability(null);
	String* pTempCapability = null;

	while (pEnum->MoveNext() == E_SUCCESS)
	{
		pTempCapability = static_cast<String*> (pEnum->GetCurrent());
		pCapability.reset(new (std::nothrow) String(*pTempCapability));
		SysTryReturn(NID_SCL, pCapability != null, null, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));

		r = pCapabilityList->Add(pCapability.get());
		SysTryReturn(NID_SCL, !IsFailed(r), null, r, "[%s] Propagating.", GetErrorMessage(r));

		pCapability.release();
	}

	return pCapabilityList.release();
}

String
_AccountProviderImpl::GetDisplayName(void) const
{
	return __displayName;
}

String
_AccountProviderImpl::GetIconPath(void) const
{
	return __iconPath;
}

String
_AccountProviderImpl::GetSmallIconPath(void) const
{
	return __smallIconPath;
}

bool
_AccountProviderImpl::IsMultipleAccountSupported(void) const
{
	return __isMultipleAccountSupported;
}

void
_AccountProviderImpl::SetAppId(const AppId& appId)
{
	__appId = appId;
}

void
_AccountProviderImpl::SetDisplayName(const String& displayName)
{
	__displayName = displayName;
}

void
_AccountProviderImpl::SetIconPath(const String& iconPath)
{
	__iconPath = iconPath;
}

void
_AccountProviderImpl::SetSmallIconPath(const String& smallIconPath)
{
	__smallIconPath = smallIconPath;
}

void
_AccountProviderImpl::SetMultipleAccountsSupport(bool isSupported)
{
	__isMultipleAccountSupported = isSupported;
}

const _AccountProviderImpl*
_AccountProviderImpl::GetInstance(const AccountProvider& accountProvider)
{
	return accountProvider.__pAccountProviderImpl;
}

_AccountProviderImpl*
_AccountProviderImpl::GetInstance(AccountProvider& accountProvider)
{
	return accountProvider.__pAccountProviderImpl;
}

}} //Tizen::Social