path: root/src/FLoc_LocationProviderImpl.h

//
// Open Service Platform
// Copyright (c) 2012 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	FLoc_LocationProviderImpl.h
 * @brief	This is the header file for the %_LocationProviderImpl class.
 *
 * This header file contains the declarations of the %_LocationProviderImpl class.
 */

#ifndef _FLOC_INTERNAL_LOCATION_PROVIDER_IMPL_H_
#define _FLOC_INTERNAL_LOCATION_PROVIDER_IMPL_H_

#include <unique_ptr.h>
#include <FAppIActiveAppEventListener.h>
#include <FBaseColAllElementsDeleter.h>
#include <FBaseRtIEventListener.h>
#include <FBaseRtITimerEventListener.h>
#include <FBaseRtTimer.h>
#include <FLocLocationCriteria.h>
#include <FBaseRt_Event.h>
#include <FLoc_Config.h>
#include "FLoc_ILocationManagerListener.h"
#include "FLoc_ILocProviderEventListener.h"
#include "FLoc_LocProviderEventArg.h"
#include "FLoc_RegionInfo.h"

namespace Tizen { namespace Locations
{

class Coordinates;
class _LocationManager;
class _LocProviderEventArg;

enum LocationUpdateType
{
	_LOCATION_UPDATE_TYPE_NONE,
	_LOCATION_UPDATE_TYPE_INTERVAL,
	_LOCATION_UPDATE_TYPE_DISTANCE
};

class _LocationProviderImpl
	: public Tizen::Base::Runtime::_Event
	, public Tizen::Locations::_ILocationManagerListener
	, public Tizen::Locations::_ILocProviderEventListener
	, public Tizen::App::IActiveAppEventListener
	, public Tizen::Base::Runtime::ITimerEventListener
{
public:
	/**
	* This is the default constructor of this class.
	*
	* @since 2.0
	*/
	_LocationProviderImpl(void);

	/**
	* This is the destructor of this class
	*
	* @since 2.0
	*/
	virtual ~_LocationProviderImpl(void);

	/**
	 * @see @ref Tizen::Locations::LocationProvider::Construct()
	 */
	result Construct(const LocationCriteria& criteria, ILocationProviderListener& listener);

	/**
	 * @see @ref Tizen::Locations::LocationProvider::StartLocationUpdates()
	 */
	result StartLocationUpdatesByInterval(int interval);

	/**
	 * @see @ref Tizen::Locations::LocationProvider::StartLocationUpdates()
	 */
	result StartLocationUpdatesByDistance(double distance);

	/**
	 * @see @ref Tizen::Locations::LocationProvider::StopLocationUdpates()
	 */
	result StopLocationUpdates(void);

	/**
	 * @see @ref Tizen::Locations::LocationProvider::KeepLocationUpdateAwake()
	 */
	void KeepLocationUpdateAwake(bool enable);

	/**
	 * @see @ref Tizen::Locations::LocationProvider::AddRegionMonitoring()
	 */
	result AddMonitoringRegion(const Tizen::Locations::Coordinates& regionCenter, double radius, RegionId& regionId);

	/**
	 * @see @ref Tizen::Locations::LocationProvider::RemoveRegionMonitoring()
	 */
	result RemoveMonitoringRegion(int regionId);

	/**
	 * @see @ref Tizen::Locations::LocationProvider::RemoveAllRegionMonitoring()
	 */
	void RemoveAllMonitoringRegions(void);

	/**
	 * @see @ref Tizen::Locations::LocationProvider::GetLocationUpdateStatus()
	 */
	LocationServiceStatus GetLocationUpdateStatus(void) const;

	/**
	 * @see @ref Tizen::Locations::LocationProvider::GetRegionMonitoringStatus()
	 */
	LocationServiceStatus GetRegionMonitoringStatus(void) const;

	/**
	 * @see @ref Tizen::Locations::LocationProvider::GetCurrentAccuracy()
	 */
	LocationAccuracy GetCurrentAccuracy(void) const;

	/**
	 * @see @ref Tizen::Locations::LocationProvider::GetLocation()
	 */
	static Location GetLocation(const LocationCriteria& criteria);

	/**
	 * @see @ref Tizen::Locations::LocationProvider::GetLocation()
	 */
	static Location GetLastKnownLocation(void);

private:
	// The implementation of this copy constructor is intentionally blank and declared as private to prohibit copying of objects.
	//
	// @since 2.0
	//
	_LocationProviderImpl(const _LocationProviderImpl& rhs);

	// The implementation of this copy assignment operator is intentionally blank and declared as private to prohibit copying of objects.
	//
	// @since 2.0
	//
	_LocationProviderImpl& operator =(const _LocationProviderImpl& rhs);

	/**
	 * @see @ref Tizen::Locations::_ILocationManagerListener::OnLocationUpdated()
	 */
	virtual void OnLocationUpdated(RequestId reqId, const Tizen::Locations::Location& location);

	/**
	 * @see @ref Tizen::Locations::_ILocationManagerListener::OnAlarmExpired()
	 */
	virtual void OnAlarmExpired(void);

	/**
	 * @see @ref Tizen::Locations::_ILocProviderEventListener::OnLocationEventReceivedN()
	 */
	virtual void OnLocationEventReceivedN(RequestId reqId, Tizen::Locations::Location& location);

	/**
	 * @see @ref Tizen::Locations::_ILocProviderEventListener::OnLocationUpdateStatusChanged()
	 */
	virtual void OnLocationUpdateStatusChanged(Tizen::Locations::LocationServiceStatus locSvcStatus);

	/**
	 * @see @ref Tizen::Locations::_ILocProviderEventListener::OnRegionMonitoringStatusChanged()
	 */
	virtual void OnRegionMonitoringStatusChanged(Tizen::Locations::LocationServiceStatus locSvcStatus);

	/**
	 * @see @ref Tizen::Locations::_ILocProviderEventListener::OnAlarmExpiredEventReceived()
	 */
	virtual void OnAlarmExpiredEventReceived(void);

	/**
	 * @see @ref Tizen::App::IActiveAppEventListener::OnActiveAppChanged()
	 */
	virtual void OnActiveAppChanged(const Tizen::App::AppId& appId);

	/**
	 * @see @ref Tizen::Base::Runtime::ITimerEventListener::OnTimerExpired()
	 */
	virtual void OnTimerExpired(Tizen::Base::Runtime::Timer& timer);

	// This method requests the location update to the Location Manager.
	//
	// @since 2.0
	//
	result StartLocationUpdates(LocationUpdateType updateType, int interval, double distance);

	// This method is used to check if the new position is at a certain distance from the original position.
	//
	// @since 2.0
	//
	bool CheckDistanceThreshold(const Tizen::Locations::Location& oldPosition, const Tizen::Locations::Location& newPosition);

	// This method is used to reset the member variables.
	//
	// @since 2.0
	//
	void ResetLocationUpdates(void);

	// @see @ref Tizen::Base::Runtime::Event::FireImpl()
	//
	// @since 2.0
	//
	virtual void FireImpl(Tizen::Base::Runtime::IEventListener& listener, const Tizen::Base::Runtime::IEventArg& arg);

	// This method is handles the location udpates.
	//
	// @since 2.0
	//
	void HandleLocationUpdate(Tizen::Locations::Location& location, bool isLocationValid);

	// This method handles the region monitoring.
	//
	// @since 2.0
	//
	void HandleRegionMonitoring(Tizen::Locations::Location& location, bool isLocationValid);

	// This method sends the callbacks to the applications regarding the Region events.
	// @since 2.0
	//
	void NotifyRegionCrossedStatus(const Tizen::Locations::Location& location);

	// This method finds the region status of a particular region w.r.t the given location.
	// @since 2.0
	//
	_RegionState GetRegionCurrentState(const _RegionInfo& region, const Location& location);

	// This method sends the service status update callback to the application.
	// @since 2.0
	//
	void NotifyServiceStatus(_LocProviderEventType eventType, LocationServiceStatus svcStatus);

	// This method returns the bool value depicting the privilege details depending on the location settings.
	//
	// @since 2.0
	//
	static bool GetUserPrivilege(void);

	// This method starts the location updates and the timer for region monitoring.
	//
	// @since 2.0
	//
	result ActivateRegionMonitoring(bool startUpdate);

	// This method stops the location updates and cancels the timer and alarm set for the area monitoring.
	//
	// @since 2.0
	//
	void StopRegionMonitoring(void);

	// This method determines the time for the alarm to be set for next cycle of region monitoring.
	//
	// @since 2.0
	//
	void SetNextRegionMonitoringTime(void);

private:
	class _LocationUpdater
	{
	public:
		_LocationUpdater(void)
			: firstLocationUpdate(true)
			, awakeEnabled(false)
			, updateInterval(0)
			, status(LOC_SVC_STATUS_IDLE)
			, type(_LOCATION_UPDATE_TYPE_NONE)
			, reqId(-1)
			, distanceThreshold(0.0)
			, pLocation(null)
		{
		}

		~_LocationUpdater(void)
		{
		}

	public:
		bool firstLocationUpdate;
		bool awakeEnabled;
		int updateInterval;
		LocationServiceStatus status;
		LocationUpdateType type;
		RequestId reqId;
		double distanceThreshold;
		std::unique_ptr< Tizen::Locations::Location > pLocation;
	}
	__locationUpdater;

	class _RegionMonitor
	{
	public:
		_RegionMonitor(void)
			: reqId(-1)
			, status(LOC_SVC_STATUS_IDLE)
			, speed(DEFAULT_AVG_SPEED)
			, pTimer(null)
			, pLocation(null)
			, pRegionList(null)
		{
		}

		~_RegionMonitor(void)
		{
		}

	public:
		RequestId reqId;
		LocationServiceStatus status;
		double speed;
		std::unique_ptr< Tizen::Base::Runtime::Timer > pTimer;
		std::unique_ptr< Tizen::Locations::Location > pLocation;
		std::unique_ptr< Tizen::Base::Collection::ArrayList, Tizen::Base::Collection::AllElementsDeleter > pRegionList;
	}
	__regionMonitor;

	LocationAccuracy __lastLocationAccuracy;
	LocationCriteria __criteria;
	ILocationProviderListener* __pLocationListener;
	_LocationManager* __pLocationManager;

}; // _LocationProviderImpl
}}  // Tizen::Locations

#endif // _FLOC_INTERNAL_LOCATION_PROVIDER_IMPL_H_