summaryrefslogtreecommitdiff
path: root/src
diff options
context:
space:
mode:
Diffstat (limited to 'src')
-rw-r--r--src/FLoc_Config.h33
-rw-r--r--src/FLoc_LocationImpl.cpp2
-rw-r--r--src/FLoc_LocationManager.cpp909
-rw-r--r--src/FLoc_LocationManager.h70
-rw-r--r--src/FLoc_LocationProviderImpl.cpp396
-rw-r--r--src/FLoc_LocationProviderImpl.h106
-rw-r--r--src/FLoc_LocationRequestInfo.h2
-rw-r--r--src/FLoc_MathUtils.cpp29
-rw-r--r--src/FLoc_MathUtils.h11
-rw-r--r--src/FLoc_SyncLocationRequestInfo.h28
10 files changed, 1026 insertions, 560 deletions
diff --git a/src/FLoc_Config.h b/src/FLoc_Config.h
index 83d336a..819d1a1 100644
--- a/src/FLoc_Config.h
+++ b/src/FLoc_Config.h
@@ -16,18 +16,23 @@
//
/**
- * @file FLoc_Config.h
- * @brief This header file contains the constants used in the location namespace internally.
+ * @file FLoc_Config.h
+ * @brief This header file contains the constants used in the location namespace internally.
*
- */
-
-#ifndef _FLOC_INTERNAL_CONFIG_H_
-#define _FLOC_INTERNAL_CONFIG_H_
-
-namespace Tizen { namespace Locations
-{
-
-const int MAX_WAIT_TIME_FOR_SYNC_LOC = 5;
-
-}} // Tizen::Locations
-#endif //_FLOC_INTERNAL_CONFIG_H_ \ No newline at end of file
+ */
+
+#ifndef _FLOC_INTERNAL_CONFIG_H_
+#define _FLOC_INTERNAL_CONFIG_H_
+
+namespace Tizen { namespace Locations
+{
+
+const int MAX_WAIT_TIME_FOR_SYNC_LOC = 5;
+const int MIN_LOCATION_UPDATE_INTERVAL = 1;
+const int DEFAULT_WAITING_TIME_FOR_FIXING_LOCATION = 40;
+const int DEFAULT_AVG_SPEED = 20; //Take average car speed as 72 km/hr = 20 m/s
+const int DEFAULT_REGION_MONITORING_CYCLE_INTERVAL = 5;
+const int DEFAULT_DISTANCE_CHECKING_INTERVAL = 10;
+
+}} // Tizen::Locations
+#endif //_FLOC_INTERNAL_CONFIG_H_
diff --git a/src/FLoc_LocationImpl.cpp b/src/FLoc_LocationImpl.cpp
index b072933..56791ed 100644
--- a/src/FLoc_LocationImpl.cpp
+++ b/src/FLoc_LocationImpl.cpp
@@ -41,8 +41,6 @@ _LocationImpl::_LocationImpl(void)
, __horizontalAccuracy(Tizen::Locations::NaN)
, __verticalAccuracy(Tizen::Locations::NaN)
, __timestamp(0)
- , __locationMethod("")
- , __satelliteInformation("")
, __isLocationValid(false)
, __isDenied(false)
{
diff --git a/src/FLoc_LocationManager.cpp b/src/FLoc_LocationManager.cpp
index 6c1002d..cb7d55e 100644
--- a/src/FLoc_LocationManager.cpp
+++ b/src/FLoc_LocationManager.cpp
@@ -32,6 +32,7 @@
#include <FBaseRtMutex.h>
#include <FBaseRtTimer.h>
#include <FBaseRtMonitor.h>
+#include <FBaseRtWaitingLoop.h>
#include <FBaseSysLog.h>
#include <FLocCoordinates.h>
#include <FSysSystemTime.h>
@@ -60,15 +61,8 @@ _LocationManager::_LocationManager(void)
, __locMethodRequested(LOC_METHOD_REQUESTED_NONE)
, __locationMgrState(LOC_MGR_STATE_IDLE)
, __minRequestedAccuracy(LOC_ACCURACY_INVALID)
- , __nativeGPSServiceState(LOCATIONS_SERVICE_DISABLED)
- , __nativeWPSServiceState(LOCATIONS_SERVICE_DISABLED)
- , __nativeCPSServiceState(LOCATIONS_SERVICE_DISABLED)
, __timerInterval(0)
, __timerTicks(0)
- , __gpsHandler(null)
- , __wpsHandler(null)
- , __cpsHandler(null)
- , __pCurrentLocation(null)
, __pLocRequestInfoList(null)
, __pSyncLocRequestInfoList(null)
, __pLocUpdateTimer(null)
@@ -145,6 +139,44 @@ _LocationManager::StopLocationUpdates(RequestId reqId)
}
result
+_LocationManager::ChangeUpdateInterval(RequestId reqId, int interval)
+{
+ SysLog(NID_LOC, "Interval update requested for request ID (%d).", reqId);
+
+ result r = E_SUCCESS;
+ const int ARRAY_LIST_CAPACITY = 2;
+
+ std::unique_ptr< Tizen::Base::Collection::ArrayList, Tizen::Base::Collection::AllElementsDeleter > pArgList(new (std::nothrow) ArrayList());
+ SysTryReturn(NID_LOC, pArgList, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
+
+ r = pArgList->Construct(ARRAY_LIST_CAPACITY);
+ SysTryReturn(NID_LOC, r == E_SUCCESS, r, r, "[%s] Array Construct failed. Propogating.", GetErrorMessage(r));
+
+ std::unique_ptr< Integer > pReqId(new (std::nothrow) Integer(static_cast< int >(reqId)));
+ SysTryReturn(NID_LOC, pReqId, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
+
+ r = pArgList->Add(*pReqId);
+ SysTryReturn(NID_LOC, r == E_SUCCESS, r, r, "[%s] Arraylist addition of an object failed. Propogating.", GetErrorMessage(r));
+
+ pReqId.release();
+
+ std::unique_ptr< Integer > pInterval(new (std::nothrow) Integer(interval));
+ SysTryReturn(NID_LOC, pInterval, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
+
+ r = pArgList->Add(*pInterval);
+ SysTryReturn(NID_LOC, r == E_SUCCESS, r, r, "[%s] Arraylist addition of an object failed. Propogating.", GetErrorMessage(r));
+
+ pInterval.release();
+
+ r = SendUserEvent(REQ_ID_UPDATE_INTERVAL, pArgList.get());
+ SysTryReturn(NID_LOC, r == E_SUCCESS, r, r, "[%s] Failed to send the user event. Propagating.", GetErrorMessage(r));
+
+ pArgList.release();
+
+ return E_SUCCESS;
+}
+
+result
_LocationManager::RegisterLocationMonitor(_LocationMonitor* pLocationMonitor)
{
RequestId reqId;
@@ -194,18 +226,18 @@ _LocationManager::GetLastKnownLocation(void)
SysTryReturn(NID_LOC, r == E_SUCCESS, location, r, "[%s] Propogating.", GetErrorMessage(r));
r = pArgList->Add(location);
- SysTryReturn(NID_LOC, r == E_SUCCESS, location, r, "[%s] Propogating.", GetErrorMessage(r));
+ SysTryCatch(NID_LOC, r == E_SUCCESS, , r, "[%s] Propogating", GetErrorMessage(r));
r = pArgList->Add(synchronizer);
- SysTryCatch(NID_LOC, r == E_SUCCESS, pArgList->RemoveAll(false), r, "[%s] Propogating", GetErrorMessage(r));
+ SysTryCatch(NID_LOC, r == E_SUCCESS, , r, "[%s] Propogating", GetErrorMessage(r));
r = synchronizer.Enter();
- SysTryCatch(NID_LOC, r == E_SUCCESS, pArgList->RemoveAll(false), r, "[%s] Propogating", GetErrorMessage(r));
+ SysTryCatch(NID_LOC, r == E_SUCCESS, , r, "[%s] Propogating", GetErrorMessage(r));
r = SendUserEvent(REQ_ID_GET_LAST_LOCATION, pArgList.get());
- SysTryCatch(NID_LOC, r == E_SUCCESS, pArgList->RemoveAll(false); synchronizer.Exit(), r, "[%s] Propogating", GetErrorMessage(r));
+ SysTryCatch(NID_LOC, r == E_SUCCESS, synchronizer.Exit(), r, "[%s] Propogating", GetErrorMessage(r));
pArgList.release();
- SysLog(NID_LOC, "Wait the location manager to get the last location.");
+ SysLog(NID_LOC, "Wait till location manager gets the last location.");
r = synchronizer.Wait();
SysTryCatch(NID_LOC, r == E_SUCCESS, synchronizer.Exit(), r, "[%s] Propogating", GetErrorMessage(r));
synchronizer.Exit();
@@ -216,6 +248,7 @@ _LocationManager::GetLastKnownLocation(void)
return location;
CATCH:
+ pArgList->RemoveAll(false);
return location;
}
@@ -273,7 +306,7 @@ _LocationManager::IsAppEnabled(void)
SysTryCatch(NID_LOC, r == E_SUCCESS, synchronizer.Exit(), r, "[%s] Propogating", GetErrorMessage(r));
pArgList.release();
- SysLog(NID_LOC, "Wait the location manager to check the app is allowed to use location.");
+ SysLog(NID_LOC, "Wait till location manager checks if the app is allowed to use location.");
r = synchronizer.Wait();
SysTryCatch(NID_LOC, r == E_SUCCESS, synchronizer.Exit(), r, "[%s] Propogating", GetErrorMessage(r));
SysLog(NID_LOC, "Application setting state is '%ls'.", enable.ToString().GetPointer());
@@ -347,9 +380,9 @@ _LocationManager::RemoveFromLocRequestInfoList(RequestId reqId)
_PowerManagerImpl::PowerControl(1, 0);
__pLocUpdateTimer->Cancel();
- location_manager_stop(__gpsHandler);
- location_manager_stop(__wpsHandler);
- location_manager_stop(__cpsHandler);
+ location_manager_stop(__gpsHandler.handle);
+ location_manager_stop(__wpsHandler.handle);
+ location_manager_stop(__cpsHandler.handle);
Reset();
}
@@ -364,13 +397,38 @@ void
_LocationManager::AddToSyncLocationRequestInfoList(_SyncLocationRequestInfo& syncLocRequestInfo)
{
result r = E_SUCCESS;
-
- r = syncLocRequestInfo.StartTimer(*this);
- SysTryCatch(NID_LOC, r == E_SUCCESS, , r, "[%s] Failed to start the sync timer.", GetErrorMessage(r));
+ static bool hasRetrievalStarted = false;
r = __pSyncLocRequestInfoList->Add(syncLocRequestInfo);
SysTryCatch(NID_LOC, r == E_SUCCESS, , r, "[%s] Failed to add the sync request into the list.", GetErrorMessage(r));
+ if (hasRetrievalStarted == true)
+ {
+ SysLog(NID_LOC, "The retrieval under process.");
+ return;
+ }
+
+ while (__pSyncLocRequestInfoList->GetCount() != 0)
+ {
+ hasRetrievalStarted = true;
+ const int WAIT_TIME = 1000;
+ WaitingLoop::GetInstance()->Wait(WAIT_TIME);
+
+ int count = __pSyncLocRequestInfoList->GetCount();
+ for (int i = 0; i < count; i++)
+ {
+ _SyncLocationRequestInfo* pSyncLocRequestInfo = static_cast< _SyncLocationRequestInfo* >(__pSyncLocRequestInfoList->GetAt(i));
+ if (pSyncLocRequestInfo != null)
+ {
+ SysLog(NID_LOC, "Handle the sync location request with request ID (%ld)", pSyncLocRequestInfo->GetRequestId());
+
+ HandleSyncRetrievalTimerExpiry(*pSyncLocRequestInfo);
+ }
+ }
+ }
+
+ hasRetrievalStarted = false;
+
return;
CATCH:
@@ -410,25 +468,65 @@ _LocationManager::RestartLocationUpdates(void)
SysLog(NID_LOC, "Location updates are restarted and new minimum requested Accuracy is (%d).", __minRequestedAccuracy);
- __pLocUpdateTimer->Cancel();
+ switch (__locMethodRequested)
+ {
+ case LOC_METHOD_REQUESTED_NONE:
+ {
+ SysLog(NID_LOC, "None of the methods running. Start all");
- location_manager_stop(__gpsHandler);
- location_manager_stop(__wpsHandler);
- location_manager_stop(__cpsHandler);
+ result = location_manager_start(__gpsHandler.handle);
+ SysTryLog(NID_LOC, result == 0, "Failed to start the location updates for GPS.");
- __nativeGPSServiceState = LOCATIONS_SERVICE_DISABLED;
- __nativeWPSServiceState = LOCATIONS_SERVICE_DISABLED;
- __nativeCPSServiceState = LOCATIONS_SERVICE_DISABLED;
+ result = location_manager_start(__wpsHandler.handle);
+ SysTryLog(NID_LOC, result == 0, "Failed to start the location updates for WPS.");
+ result = location_manager_start(__cpsHandler.handle);
+ SysTryLog(NID_LOC, result == 0, "Failed to start the location updates for CPS.");
+ }
+ break;
+
+ case LOC_METHOD_REQUESTED_GPS:
+ {
+ SysLog(NID_LOC, "GPS Running. Start other two.");
- result = location_manager_start(__gpsHandler);
- SysTryLog(NID_LOC, result == 0, "Failed to start the location updates for GPS.");
+ result = location_manager_start(__wpsHandler.handle);
+ SysTryLog(NID_LOC, result == 0, "Failed to start the location updates for WPS.");
- result = location_manager_start(__wpsHandler);
- SysTryLog(NID_LOC, result == 0, "Failed to start the location updates for WPS.");
+ result = location_manager_start(__cpsHandler.handle);
+ SysTryLog(NID_LOC, result == 0, "Failed to start the location updates for CPS.");
+ }
+ break;
+
+ case LOC_METHOD_REQUESTED_WPS:
+ {
+ SysLog(NID_LOC, "WPS Running. Start other two.");
- result = location_manager_start(__cpsHandler);
- SysTryLog(NID_LOC, result == 0, "Failed to start the location updates for CPS.");
+ result = location_manager_start(__gpsHandler.handle);
+ SysTryLog(NID_LOC, result == 0, "Failed to start the location updates for GPS.");
+
+ result = location_manager_start(__cpsHandler.handle);
+ SysTryLog(NID_LOC, result == 0, "Failed to start the location updates for CPS.");
+ }
+ break;
+
+ case LOC_METHOD_REQUESTED_CPS:
+ {
+ SysLog(NID_LOC, "CPS Running. Start other two.");
+
+ result = location_manager_start(__gpsHandler.handle);
+ SysTryLog(NID_LOC, result == 0, "Failed to start the location updates for GPS.");
+
+ result = location_manager_start(__wpsHandler.handle);
+ SysTryLog(NID_LOC, result == 0, "Failed to start the location updates for WPS.");
+ }
+ break;
+
+ case LOC_METHOD_REQUESTED_ALL:
+ {
+ SysLog(NID_LOC, "All the providers are already started.");
+ }
+ break;
+ }
__locationMgrState = LOC_MGR_STATE_FAST_SENSING;
__locMethodRequested = LOC_METHOD_REQUESTED_ALL;
@@ -442,6 +540,8 @@ _LocationManager::RestartUpdateTimer(void)
int count = __pLocRequestInfoList->GetCount();
result r = E_SUCCESS;
+ __pLocUpdateTimer->Cancel();
+
if (count > 0)
{
const _LocationRequestInfo* pLocRequestInfo = static_cast< _LocationRequestInfo* >(__pLocRequestInfoList->GetAt(0));
@@ -523,7 +623,7 @@ _LocationManager::HandleSyncRetrievalTimerExpiry(_SyncLocationRequestInfo& syncL
}
SysLog(NID_LOC, "Wait for next location(Tick: %d).", syncLocRequestInfo.GetTickCount());
- syncLocRequestInfo.StartTimer(*this);
+ syncLocRequestInfo.IncrementTickCount();
return;
NOTIFY:
@@ -532,7 +632,7 @@ NOTIFY:
}
result
-_LocationManager::SetLocationInformation(double latitude, double longitude, double altitude, time_t timestamp, location_method_e locMethod)
+_LocationManager::SetLocationInformation(double latitude, double longitude, double altitude, time_t timestamp, location_method_e locMethod, Location* pLocation)
{
SysLog(NID_LOC, "Location Information is: Latitude (%lf), Longitude (%lf), Altitude (%lf), TimeStamp (%ld), Location method (%d)", latitude, longitude, altitude, timestamp, locMethod);
@@ -560,11 +660,11 @@ _LocationManager::SetLocationInformation(double latitude, double longitude, doub
{
case LOCATIONS_METHOD_GPS:
{
- res = location_manager_get_accuracy(__gpsHandler, &accLevel, &horAcc, &verAcc);
+ res = location_manager_get_accuracy(__gpsHandler.handle, &accLevel, &horAcc, &verAcc);
SysLog(NID_LOC, "Get Accuracy: Result (%d), Horizontal Acc (%lf), Vertical Acc (%lf)", res, horAcc, verAcc);
SysTryReturnResult(NID_LOC, res == 0, E_SYSTEM, "Invalid accuracy values from Native Location Provider.");
- res = location_manager_get_velocity(__gpsHandler, &climb, &direction, &speed, &time_stamp);
+ res = location_manager_get_velocity(__gpsHandler.handle, &climb, &direction, &speed, &time_stamp);
SysLog(NID_LOC, "Get Velocity: Result (%d), Climb (%lf), Direction (%lf), Speed (%lf), Time stamp (%ld)", res, climb, direction, speed, time_stamp);
SysTryReturnResult(NID_LOC, res == 0, E_SYSTEM, "Invalid accuracy values from Native Location Provider.");
@@ -575,11 +675,11 @@ _LocationManager::SetLocationInformation(double latitude, double longitude, doub
case LOCATIONS_METHOD_WPS:
{
- res = location_manager_get_accuracy(__wpsHandler, &accLevel, &horAcc, &verAcc);
+ res = location_manager_get_accuracy(__wpsHandler.handle, &accLevel, &horAcc, &verAcc);
SysLog(NID_LOC, "Get Accuracy: Result (%d), Horizontal Acc (%lf), Vertical Acc (%lf)", res, horAcc, verAcc);
SysTryReturnResult(NID_LOC, res == 0, E_SYSTEM, "Invalid accuracy values from Native Location Provider.");
- res = location_manager_get_velocity(__wpsHandler, &climb, &direction, &speed, &time_stamp);
+ res = location_manager_get_velocity(__wpsHandler.handle, &climb, &direction, &speed, &time_stamp);
SysTryLog(NID_LOC, res == 0, "Get Velocity: Result (%d), Climb (%lf), Direction (%lf), Speed (%lf), Time stamp (%ld)", res, climb, direction, speed, time_stamp);
pLocDataImpl->SetExtraInfo(L"location_method", L"network");
@@ -589,7 +689,7 @@ _LocationManager::SetLocationInformation(double latitude, double longitude, doub
case LOCATIONS_METHOD_CPS:
{
- res = location_manager_get_accuracy(__cpsHandler, &accLevel, &horAcc, &verAcc);
+ res = location_manager_get_accuracy(__cpsHandler.handle, &accLevel, &horAcc, &verAcc);
SysLog(NID_LOC, "Get Accuracy: Result (%d), Horizontal Acc (%lf), Vertical Acc (%lf)", res, horAcc, verAcc);
SysTryReturnResult(NID_LOC, res == 0, E_SYSTEM, "Invalid accuracy values from Native Location Provider.");
@@ -612,7 +712,7 @@ _LocationManager::SetLocationInformation(double latitude, double longitude, doub
pLocDataImpl->SetCourse(direction);
pLocDataImpl->SetSpeed(speed);
pLocDataImpl->SetValidity(true);
- *__pCurrentLocation = locationData;
+ *pLocation = locationData;
requiredAcc = __minRequestedAccuracy;
switch (requiredAcc)
@@ -662,9 +762,10 @@ void
_LocationManager::SendLocationCallbacks(void)
{
bool isAllowed = GetAppAccessibility();
- SysLog(NID_LOC, "Send location(validity: %x) and accessibility(%x) through the callback.", __pCurrentLocation->IsValid(), isAllowed);
+ const Location* pBestLocation = FindBestLocation();
- unique_ptr< Location > pLocation(new (std::nothrow) Location(*__pCurrentLocation));
+ SysLog(NID_LOC, "Send location(validity: %x) and accessibility(%x) through the callback.", pBestLocation->IsValid(), isAllowed);
+ unique_ptr< Location > pLocation(new (std::nothrow) Location(*pBestLocation));
SysTryReturnVoidResult(NID_LOC, pLocation != null, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
int interval = __timerTicks * __timerInterval;
@@ -690,9 +791,6 @@ _LocationManager::Reset(void)
__minRequestedAccuracy = LOC_ACCURACY_INVALID;
__timerInterval = 0;
__timerTicks = 0;
- __nativeGPSServiceState = LOCATIONS_SERVICE_DISABLED;
- __nativeWPSServiceState = LOCATIONS_SERVICE_DISABLED;
- __nativeCPSServiceState = LOCATIONS_SERVICE_DISABLED;
}
result
@@ -701,18 +799,351 @@ _LocationManager::Construct()
return EventDrivenThread::Construct();
}
+Location
+_LocationManager::GetLastKnownLocation(location_method_e nativeLocMethod)
+{
+ String locationMethod;
+ location_manager_h nativeHandle = null;
+ switch (nativeLocMethod)
+ {
+ case LOCATIONS_METHOD_GPS:
+ nativeHandle = __gpsHandler.handle;
+ locationMethod = L"gps";
+ break;
+ case LOCATIONS_METHOD_WPS:
+ nativeHandle = __wpsHandler.handle;
+ locationMethod = L"network";
+ break;
+ case LOCATIONS_METHOD_CPS:
+ nativeHandle = __cpsHandler.handle;
+ locationMethod = L"network";
+ break;
+ default:
+ break;
+ }
+ SysLog(NID_LOC, "Last location requested(method: %x, handle: %x).", nativeLocMethod, nativeHandle);
+
+ Location location = _LocationImpl::GetLocationInstance();
+ if (nativeHandle != null)
+ {
+ _LocationImpl* pLocationImpl = _LocationImpl::GetInstance(location);
+
+ double altitude = Tizen::Locations::NaN;
+ double latitude = Tizen::Locations::NaN;
+ double longitude = Tizen::Locations::NaN;
+ time_t timestampPosition = 0;
+
+ int res = location_manager_get_last_position(nativeHandle, &altitude, &latitude, &longitude, &timestampPosition);
+ SysTryCatch(NID_LOC, res == 0, , E_SYSTEM, "[E_SYSTEM] Failed to fetch last position from nativeHandle(%x).", nativeHandle);
+ SysLog(NID_LOC, "Last position(latitude: %lf, longitude: %lf, altitude: %lf, timestamp: %ld",
+ latitude, longitude, altitude, timestampPosition);
+
+ Coordinates coord;
+ coord.Set(latitude, longitude, altitude);
+ pLocationImpl->SetCoordinates(coord);
+
+ double horAcc = Tizen::Locations::NaN;
+ double verAcc = Tizen::Locations::NaN;
+ location_accuracy_level_e level;
+ res = location_manager_get_last_accuracy(nativeHandle, &level, &horAcc, &verAcc);
+ if (res == 0)
+ {
+ SysLog(NID_LOC, "Last accuracy(horAcc: %lf, vAcc: %lf, level: %x)", horAcc, verAcc, level);
+ pLocationImpl->SetHorizontalAccuracy(horAcc);
+ pLocationImpl->SetVerticalAccuracy(verAcc);
+ }
+
+ double climb = Tizen::Locations::NaN;
+ double direction = Tizen::Locations::NaN;
+ double speed = Tizen::Locations::NaN;
+ time_t timestampVelocity = 0;
+ res = location_manager_get_last_velocity(nativeHandle, &climb, &direction, &speed, &timestampVelocity);
+ if (res == 0)
+ {
+ SysLog(NID_LOC, "Last velocity(climb: %lf, direction: %lf, speed: %lf, timestamp: %ld)",
+ climb, direction, speed, timestampVelocity);
+ pLocationImpl->SetCourse(direction);
+ pLocationImpl->SetSpeed(speed);
+ }
+
+ if (nativeLocMethod == LOCATIONS_METHOD_GPS)
+ {
+ int satUsedCount = 0;
+ int satViewCount = 0;
+ time_t timestampSatellite = 0;
+ String satInfo = L"";
+ res = gps_status_get_last_satellite(nativeHandle, &satUsedCount, &satViewCount, &timestampSatellite);
+ if (res == 0)
+ {
+ long timeDiff = abs(timestampPosition - timestampSatellite);
+ res = gps_status_foreach_last_satellites_in_view(nativeHandle, SatelliteInfoUpdated, &satInfo);
+ SysLog(NID_LOC, "Last satellite(foreachResult: %d, inUse: %d, inView: %d, timestamp: %ld, timeDiff: %ld)",
+ res, satUsedCount, satViewCount, timestampSatellite, timeDiff);
+
+ satInfo.Trim();
+ SysLog(NID_LOC, "Last satellite(info: %ls)", satInfo.GetPointer());
+ pLocationImpl->SetExtraInfo(L"satellite", satInfo);
+ }
+ }
+
+ pLocationImpl->SetTimestamp(((long long)timestampPosition) * 1000); // in milliseconds
+ pLocationImpl->SetValidity(true);
+ pLocationImpl->SetExtraInfo(L"location_method", locationMethod);
+ }
+
+ ClearLastResult();
+ return location;
+
+CATCH:
+ return location;
+}
+
+Location
+_LocationManager::GetRecentLocationAvailable(void)
+{
+ long long gpsTimestamp = 0;
+ long long wpsTimestamp = 0;
+ long long cpsTimestamp = 0;
+
+ Location lastGpsLocation = GetLastKnownLocation(LOCATIONS_METHOD_GPS);
+ if (lastGpsLocation.IsValid())
+ {
+ gpsTimestamp = _LocationImpl::GetInstance(lastGpsLocation)->GetTimestampInMs();
+ }
+
+ Location lastWpsLocation = GetLastKnownLocation(LOCATIONS_METHOD_WPS);
+ if (lastWpsLocation.IsValid())
+ {
+ wpsTimestamp = _LocationImpl::GetInstance(lastWpsLocation)->GetTimestampInMs();
+ }
+
+ Location lastCpsLocation = GetLastKnownLocation(LOCATIONS_METHOD_CPS);
+ if (lastCpsLocation.IsValid())
+ {
+ cpsTimestamp = _LocationImpl::GetInstance(lastCpsLocation)->GetTimestampInMs();
+ }
+
+ SysLog(NID_LOC, "Compare timestamp(gps: %lld, wps: %lld, cps: %lld) for recent location.",
+ gpsTimestamp, wpsTimestamp, cpsTimestamp);
+
+ if (gpsTimestamp >= wpsTimestamp && gpsTimestamp >= cpsTimestamp)
+ {
+ return lastGpsLocation;
+ }
+ else if (wpsTimestamp > gpsTimestamp && wpsTimestamp > cpsTimestamp)
+ {
+ return lastWpsLocation;
+ }
+ else
+ {
+ return lastCpsLocation;
+ }
+}
+
+void
+_LocationManager::UpdateLocRequestInfoList(RequestId reqId, int interval)
+{
+ int count = __pLocRequestInfoList->GetCount();
+
+ for (int i = 0; i < count; i++)
+ {
+ _LocationRequestInfo* pLocRequestInfo = static_cast< _LocationRequestInfo* >(__pLocRequestInfoList->GetAt(i));
+ if (reqId == pLocRequestInfo->GetRequestId())
+ {
+ pLocRequestInfo->SetInterval(interval);
+ RestartUpdateTimer();
+ break;
+ }
+ }
+}
+
+const Location*
+_LocationManager::FindBestLocation(void)
+{
+ switch (__locMethodRequested)
+ {
+ case LOC_METHOD_REQUESTED_GPS:
+ SysLog(NID_LOC, "GPS location provider running.");
+ return __gpsHandler.pLocation.get();
+ break;
+
+ case LOC_METHOD_REQUESTED_WPS:
+ SysLog(NID_LOC, "WPS location provider running.");
+ return __wpsHandler.pLocation.get();
+ break;
+
+ case LOC_METHOD_REQUESTED_CPS:
+ SysLog(NID_LOC, "CPS location provider running.");
+ return __cpsHandler.pLocation.get();
+ break;
+
+ case LOC_METHOD_REQUESTED_ALL:
+ {
+ SysLog(NID_LOC, "All the methods are running. Get the best location among all the providers.");
+
+ long long gpsTimestamp = 0;
+ long long wpsTimestamp = 0;
+ long long cpsTimestamp = 0;
+
+ if (__gpsHandler.pLocation->IsValid() && !_LocationImpl::GetInstance(*__gpsHandler.pLocation)->IsDenied())
+ {
+ gpsTimestamp = _LocationImpl::GetInstance(*__gpsHandler.pLocation)->GetTimestampInMs();
+ }
+ if (__wpsHandler.pLocation->IsValid() && !_LocationImpl::GetInstance(*__wpsHandler.pLocation)->IsDenied())
+ {
+ wpsTimestamp = _LocationImpl::GetInstance(*__wpsHandler.pLocation)->GetTimestampInMs();
+ }
+ if (__cpsHandler.pLocation->IsValid() && !_LocationImpl::GetInstance(*__cpsHandler.pLocation)->IsDenied())
+ {
+ cpsTimestamp = _LocationImpl::GetInstance(*__cpsHandler.pLocation)->GetTimestampInMs();
+ }
+
+ SysLog(NID_LOC, "Compare timestamp(gps: %lld, wps: %lld, cps: %lld) of different locations.", gpsTimestamp, wpsTimestamp, cpsTimestamp);
+
+ if (gpsTimestamp > wpsTimestamp && gpsTimestamp > cpsTimestamp)
+ {
+ SysLog(NID_LOC, "GPS time stamp is greater than WPS and CPS.");
+ return __gpsHandler.pLocation.get();
+ }
+ else if (wpsTimestamp > gpsTimestamp && wpsTimestamp > cpsTimestamp)
+ {
+ SysLog(NID_LOC, "WPS time stamp is greater than GPS and CPS.");
+ return __wpsHandler.pLocation.get();
+ }
+ else if (cpsTimestamp > gpsTimestamp && cpsTimestamp > wpsTimestamp)
+ {
+ SysLog(NID_LOC, "CPS time stamp is greater than GPS and WPS.");
+ return __cpsHandler.pLocation.get();
+ }
+ else if (gpsTimestamp == wpsTimestamp)
+ {
+ if (__gpsHandler.pLocation->GetHorizontalAccuracy() <= __wpsHandler.pLocation->GetHorizontalAccuracy())
+ {
+ SysLog(NID_LOC, "GPS time stamp is equal to WPS and GPS accuracy is better than WPS.");
+ return __gpsHandler.pLocation.get();
+ }
+ else
+ {
+ SysLog(NID_LOC, "GPS time stamp is equal to WPS but GPS accuracy is worse than WPS.");
+ return __wpsHandler.pLocation.get();
+ }
+ }
+ else if (gpsTimestamp == cpsTimestamp)
+ {
+ if (__gpsHandler.pLocation->GetHorizontalAccuracy() <= __cpsHandler.pLocation->GetHorizontalAccuracy())
+ {
+ SysLog(NID_LOC, "GPS time stamp is equal to CPS and GPS accuracy is better than CPS.");
+ return __gpsHandler.pLocation.get();
+ }
+ else
+ {
+ SysLog(NID_LOC, "GPS time stamp is equal to CPS but GPS accuracy is worse than CPS.");
+ return __cpsHandler.pLocation.get();
+ }
+ }
+ else if (wpsTimestamp == cpsTimestamp)
+ {
+ if (__wpsHandler.pLocation->GetHorizontalAccuracy() <= __cpsHandler.pLocation->GetHorizontalAccuracy())
+ {
+ SysLog(NID_LOC, "WPS time stamp is equal to CPS and WPS accuracy is better than CPS.");
+ return __wpsHandler.pLocation.get();
+ }
+ else
+ {
+ SysLog(NID_LOC, "WPS time stamp is equal to CPS but WPS accuracy is worse than CPS.");
+ return __cpsHandler.pLocation.get();
+ }
+ }
+ }
+ break;
+
+ case LOC_METHOD_REQUESTED_NONE:
+ // follow through
+ default:
+ SysLog(NID_LOC, "Location updates not running.");
+ return null;
+ }
+
+ SysLog(NID_LOC, "Returning null as none of the conditions are satsfied.");
+ return null;
+}
+
+result
+_LocationManager::GetLocation(location_method_e nativeLocMethod)
+{
+ const int MAX_VALID_TIME_DIFFERENCE = 2000;
+ result r = E_SUCCESS;
+ double altitude = 0.0;
+ double latitude = 0.0;
+ double longitude = 0.0;
+ time_t timestamp;
+ int res = -1;
+ int satellitesInViewCount = 0;
+ int satellitesInUseCount = 0;
+ time_t timestampSatellite = 0;
+ String satInfo = L"";
+ long long timeDiff = 0;
+ location_manager_h nativeHandle = null;
+ Location* pLocation = null;
+
+ switch (nativeLocMethod)
+ {
+ case LOCATIONS_METHOD_GPS:
+ nativeHandle = __gpsHandler.handle;
+ pLocation = __gpsHandler.pLocation.get();
+ break;
+ case LOCATIONS_METHOD_WPS:
+ nativeHandle = __wpsHandler.handle;
+ pLocation = __wpsHandler.pLocation.get();
+ break;
+ case LOCATIONS_METHOD_CPS:
+ nativeHandle = __cpsHandler.handle;
+ pLocation = __cpsHandler.pLocation.get();
+ break;
+ default:
+ break;
+ }
+
+ res = location_manager_get_position(nativeHandle, &altitude, &latitude, &longitude, &timestamp);
+ SysTryReturnResult(NID_LOC, res == 0, E_SYSTEM, "[E_SYSTEM] Failed to obtain the natvie location information for the method (%x)", nativeLocMethod);
+
+ if (res == 0)
+ {
+ r = SetLocationInformation(latitude, longitude, altitude, timestamp, nativeLocMethod, pLocation);
+ if (r != E_SUCCESS)
+ {
+ SysLog(NID_LOC, "Failed to set the location information");
+ }
+
+ if (nativeLocMethod == LOCATIONS_METHOD_GPS)
+ {
+ res = gps_status_get_satellite(__gpsHandler.handle, &satellitesInUseCount, &satellitesInViewCount, &timestampSatellite);
+
+ timeDiff = abs(timestamp - timestampSatellite);
+ timeDiff = timeDiff * 1000;
+ SysLog(NID_LOC, "Result (%d), Satellites in Use (%d), Satellites in View (%d), Time stamp (%ld), Time Difference (Loc and Sat) (%ld)",
+ res, satellitesInUseCount, satellitesInViewCount, timestampSatellite, timeDiff);
+ if (res == 0 && timeDiff <= MAX_VALID_TIME_DIFFERENCE)
+ {
+ res = gps_status_foreach_satellites_in_view(__gpsHandler.handle, SatelliteInfoUpdated, &satInfo);
+ }
+
+ satInfo.Trim();
+ SysLog(NID_LOC, "Result of get satellite is (%d) and satelliteInfo string representation is (%ls)", res, satInfo.GetPointer());
+
+ _LocationImpl::GetInstance(*__gpsHandler.pLocation.get())->SetExtraInfo(L"satellite", satInfo);
+ }
+ }
+
+ return E_SUCCESS;
+}
+
bool
_LocationManager::OnStart(void)
{
int res = -1;
result r = E_SUCCESS;
- unique_ptr< Mutex > pMutex(new (std::nothrow) Mutex());
- SysTryReturn(NID_LOC, pMutex != null, false, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
-
- r = pMutex->Create();
- SysTryReturn(NID_LOC, r == E_SUCCESS, false, E_SYSTEM, "[E_SYSTEM] Failed to construct the mutex.");
-
std::unique_ptr< Tizen::Base::Collection::ArrayList, AllElementsDeleter > pLocInfoRequestList(new (std::nothrow) ArrayList());
SysTryReturn(NID_LOC, pLocInfoRequestList != null, false, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
@@ -725,52 +1156,62 @@ _LocationManager::OnStart(void)
r = pSyncLocInfoRequestList->Construct();
SysTryReturn(NID_LOC, r == E_SUCCESS, false, E_SYSTEM, "[E_SYSTEM] Failed to construct the Sync Location Request list.");
- unique_ptr< Tizen::Locations::Location > pLocation(_LocationImpl::GetLocationInstanceN());
- SysTryReturn(NID_LOC, pLocation != null, false, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
+ unique_ptr< Tizen::Locations::Location > pGpsLocation(_LocationImpl::GetLocationInstanceN());
+ SysTryReturn(NID_LOC, pGpsLocation != null, false, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
+
+ unique_ptr< Tizen::Locations::Location > pWpsLocation(_LocationImpl::GetLocationInstanceN());
+ SysTryReturn(NID_LOC, pWpsLocation != null, false, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
+
+ unique_ptr< Tizen::Locations::Location > pCpsLocation(_LocationImpl::GetLocationInstanceN());
+ SysTryReturn(NID_LOC, pCpsLocation != null, false, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
std::unique_ptr< Tizen::Base::Runtime::Timer > pLocUpdateTimer(new (std::nothrow) Timer());
r = pLocUpdateTimer->Construct(*this);
SysTryReturn(NID_LOC, r == E_SUCCESS, false, E_SYSTEM, "[E_SYSTEM] Failed to construct the location timer.");
- res = location_manager_create(LOCATIONS_METHOD_GPS, &__gpsHandler);
+ res = location_manager_create(LOCATIONS_METHOD_GPS, &__gpsHandler.handle);
SysTryReturn(NID_LOC, res == 0, false, E_SYSTEM, "[E_SYSTEM] Failed to create Native GPS Location provider.");
- res = location_manager_set_service_state_changed_cb(__gpsHandler, GpsServiceUpdateCallback, this);
+ res = location_manager_set_service_state_changed_cb(__gpsHandler.handle, GpsServiceUpdateCallback, this);
SysTryCatch(NID_LOC, res == 0, , E_SYSTEM, "[E_SYSTEM] Failed to register service callback for Native GPS Location provider.");
- res = location_manager_create(LOCATIONS_METHOD_WPS, &__wpsHandler);
+ res = location_manager_create(LOCATIONS_METHOD_WPS, &__wpsHandler.handle);
SysTryCatch(NID_LOC, res == 0, , E_SYSTEM, "[E_SYSTEM] Failed to create Native WPS Location provider.");
- res = location_manager_set_service_state_changed_cb(__wpsHandler, WpsServiceUpdateCallback, this);
+ res = location_manager_set_service_state_changed_cb(__wpsHandler.handle, WpsServiceUpdateCallback, this);
SysTryCatch(NID_LOC, res == 0, , E_SYSTEM, "[E_SYSTEM] Failed to register service callback for Native WPS Location provider.");
- res = location_manager_create(LOCATIONS_METHOD_CPS, &__cpsHandler);
+ res = location_manager_create(LOCATIONS_METHOD_CPS, &__cpsHandler.handle);
SysTryCatch(NID_LOC, res == 0, , E_SYSTEM, "[E_SYSTEM] Failed to create Native CPS Location provider.");
- res = location_manager_set_service_state_changed_cb(__cpsHandler, CpsServiceUpdateCallback, this);
+ res = location_manager_set_service_state_changed_cb(__cpsHandler.handle, CpsServiceUpdateCallback, this);
SysTryCatch(NID_LOC, res == 0, , E_SYSTEM, "[E_SYSTEM] Failed to register service callback for Native CPS Location provider.");
__pLocRequestInfoList = std::move(pLocInfoRequestList);
__pSyncLocRequestInfoList = std::move(pSyncLocInfoRequestList);
__pLocUpdateTimer = std::move(pLocUpdateTimer);
- __pCurrentLocation = std::move(pLocation);
+ __gpsHandler.pLocation= std::move(pGpsLocation);
+ __wpsHandler.pLocation= std::move(pWpsLocation);
+ __cpsHandler.pLocation= std::move(pCpsLocation);
+
+ SysLog(NID_LOC, "All the resources for location manager successfully created.");
return true;
CATCH:
- if (__gpsHandler)
+ if (__gpsHandler.handle)
{
- location_manager_destroy(__gpsHandler);
+ location_manager_destroy(__gpsHandler.handle);
}
- if (__wpsHandler)
+ if (__wpsHandler.handle)
{
- location_manager_destroy(__wpsHandler);
+ location_manager_destroy(__wpsHandler.handle);
}
- if (__cpsHandler)
+ if (__cpsHandler.handle)
{
- location_manager_destroy(__cpsHandler);
+ location_manager_destroy(__cpsHandler.handle);
}
return false;
}
@@ -778,19 +1219,19 @@ CATCH:
void
_LocationManager::OnStop(void)
{
- if (__gpsHandler)
+ if (__gpsHandler.handle)
{
- location_manager_destroy(__gpsHandler);
+ location_manager_destroy(__gpsHandler.handle);
}
- if (__wpsHandler)
+ if (__wpsHandler.handle)
{
- location_manager_destroy(__wpsHandler);
+ location_manager_destroy(__wpsHandler.handle);
}
- if (__cpsHandler)
+ if (__cpsHandler.handle)
{
- location_manager_destroy(__cpsHandler);
+ location_manager_destroy(__cpsHandler.handle);
}
}
@@ -837,8 +1278,8 @@ _LocationManager::OnUserEventReceivedN(RequestId requestId, IList* pArgs)
case REQ_ID_SUSTAIN_GPS:
{
SysLog(NID_LOC, "REQ_ID_SUSTAIN_GPS.");
- location_manager_stop(__wpsHandler);
- location_manager_stop(__cpsHandler);
+ location_manager_stop(__wpsHandler.handle);
+ location_manager_stop(__cpsHandler.handle);
__locMethodRequested = LOC_METHOD_REQUESTED_GPS;
}
break;
@@ -846,8 +1287,8 @@ _LocationManager::OnUserEventReceivedN(RequestId requestId, IList* pArgs)
case REQ_ID_SUSTAIN_WPS:
{
SysLog(NID_LOC, "REQ_ID_SUSTAIN_WPS.");
- location_manager_stop(__gpsHandler);
- location_manager_stop(__cpsHandler);
+ location_manager_stop(__gpsHandler.handle);
+ location_manager_stop(__cpsHandler.handle);
__locMethodRequested = LOC_METHOD_REQUESTED_WPS;
}
break;
@@ -855,8 +1296,8 @@ _LocationManager::OnUserEventReceivedN(RequestId requestId, IList* pArgs)
case REQ_ID_SUSTAIN_CPS:
{
SysLog(NID_LOC, "REQ_ID_SUSTAIN_CPS.");
- location_manager_stop(__gpsHandler);
- location_manager_stop(__wpsHandler);
+ location_manager_stop(__gpsHandler.handle);
+ location_manager_stop(__wpsHandler.handle);
__locMethodRequested = LOC_METHOD_REQUESTED_CPS;
}
break;
@@ -921,6 +1362,27 @@ _LocationManager::OnUserEventReceivedN(RequestId requestId, IList* pArgs)
pArgs->RemoveAt(0);
}
break;
+
+ case REQ_ID_UPDATE_INTERVAL:
+ {
+ const int ARRAY_LIST_LENGTH = 2;
+
+ SysLog(NID_LOC, "REQ_ID_UPDATE_INTERVAL");
+ SysTryReturnVoidResult(NID_LOC, pArgs, E_INVALID_ARG, "[E_INVALID_ARG] Null argument encountered. Ignored.");
+ SysTryCatch(NID_LOC, pArgs->GetCount() == ARRAY_LIST_LENGTH, pArgs->RemoveAll(true), E_INVALID_ARG, "[E_INVALID_ARG] Invalid argument encountered. Ignored.");
+
+ Integer* pReqId = null;
+ pReqId = static_cast< Integer* >(pArgs->GetAt(0));
+ SysTryCatch(NID_LOC, pReqId, , E_INVALID_ARG, "[E_INVALID_ARG] Invalid argument encountered. Ignored.");
+
+ Integer* pInterval = null;
+ pInterval = static_cast< Integer* >(pArgs->GetAt(1));
+ SysTryCatch(NID_LOC, pInterval, , E_INVALID_ARG, "[E_INVALID_ARG] Invalid argument encountered. Ignored.");
+
+ UpdateLocRequestInfoList(static_cast< long >(pReqId->ToInt()), pInterval->ToInt());
+ }
+ break;
+
}
if (pArgs)
@@ -939,159 +1401,69 @@ CATCH:
void
_LocationManager::OnTimerExpired(Tizen::Base::Runtime::Timer& timer)
{
- const int MAX_VALID_TIME_DIFFERENCE = 2000;
-
if (__pLocUpdateTimer->Equals(timer))
{
__timerTicks++;
SysLog(NID_LOC, "LocationManager update timer expired. Timer Tick value is (%d).", __timerTicks);
result r = E_SUCCESS;
- double altitude = 0.0;
- double latitude = 0.0;
- double longitude = 0.0;
- time_t timestamp;
-
- int res = -1;
- int satellitesInViewCount = 0;
- int satellitesInUseCount = 0;
- time_t timestampSatellite = 0;
- String satInfo = L"";
- long long timeDiff = 0;
switch (__locMethodRequested)
{
case LOC_METHOD_REQUESTED_GPS:
- res = location_manager_get_position(__gpsHandler, &altitude, &latitude, &longitude, &timestamp);
- SysTryLog(NID_LOC, res == 0, "[E_SYSTEM] Failed to obtain the GPS location information");
-
- if (res == 0)
- {
- r = SetLocationInformation(latitude, longitude, altitude, timestamp, LOCATIONS_METHOD_GPS);
- if (r != E_SUCCESS)
- {
- SysLog(NID_LOC, "Failed to set the location information");
- }
-
- res = gps_status_get_satellite(__gpsHandler, &satellitesInUseCount, &satellitesInViewCount, &timestampSatellite);
+ r = GetLocation(LOCATIONS_METHOD_GPS);
+ SysTryLog(NID_LOC, r == E_SUCCESS, "[E_SYSTEM] Failed to obtain the GPS location information");
- timeDiff = abs(timestamp - timestampSatellite);
- timeDiff = timeDiff * 1000;
- SysLog(NID_LOC, "Result (%d), Satellites in Use (%d), Satellites in View (%d), Time stamp (%ld), Time Difference (Loc and Sat) (%ld)",
- res, satellitesInUseCount, satellitesInViewCount, timestampSatellite, timeDiff);
- if (res == 0 && timeDiff <= MAX_VALID_TIME_DIFFERENCE)
- {
- res = gps_status_foreach_satellites_in_view(__gpsHandler, SatelliteInfoUpdated, &satInfo);
- }
- SysLog(NID_LOC, "Result of get satellite is (%d) and satelliteInfo string representation is (%ls)", res, satInfo.GetPointer());
-
- _LocationImpl::GetInstance(*__pCurrentLocation.get())->SetExtraInfo(L"satellite", satInfo);
- }
- else
+ if (IsFailed(r))
{
SendUserEvent(REQ_ID_RESTART_LOC_UPDATES, null);
- return;
}
break;
case LOC_METHOD_REQUESTED_WPS:
- res = location_manager_get_position(__wpsHandler, &altitude, &latitude, &longitude, &timestamp);
- SysTryLog(NID_LOC, res == 0, "[E_SYSTEM] Failed to obtain the WPS location information");
- if (res == 0)
- {
- r = SetLocationInformation(latitude, longitude, altitude, timestamp, LOCATIONS_METHOD_WPS);
- if (r != E_SUCCESS)
- {
- SysLog(NID_LOC, "Failed to set the location information");
- }
- }
- else
+ r = GetLocation(LOCATIONS_METHOD_WPS);
+ SysTryLog(NID_LOC, r == E_SUCCESS, "[E_SYSTEM] Failed to obtain the WPS location information");
+
+ if (IsFailed(r))
{
SendUserEvent(REQ_ID_RESTART_LOC_UPDATES, null);
- return;
}
break;
case LOC_METHOD_REQUESTED_CPS:
- res = location_manager_get_position(__cpsHandler, &altitude, &latitude, &longitude, &timestamp);
- SysTryLog(NID_LOC, res == 0, "[E_SYSTEM] Failed to obtain the CPS location information");
- if (res == 0)
- {
- r = SetLocationInformation(latitude, longitude, altitude, timestamp, LOCATIONS_METHOD_CPS);
- if (r != E_SUCCESS)
- {
- SysLog(NID_LOC, "Failed to set the location information");
- }
- }
- else
+ r = GetLocation(LOCATIONS_METHOD_CPS);
+ SysTryLog(NID_LOC, r == E_SUCCESS, "[E_SYSTEM] Failed to obtain the CPS location information");
+
+ if (IsFailed(r))
{
SendUserEvent(REQ_ID_RESTART_LOC_UPDATES, null);
- return;
}
break;
case LOC_METHOD_REQUESTED_ALL:
- if (__nativeCPSServiceState == LOCATIONS_SERVICE_ENABLED)
+ if (__cpsHandler.serviceState == LOCATIONS_SERVICE_ENABLED)
{
- res = location_manager_get_position(__cpsHandler, &altitude, &latitude, &longitude, &timestamp);
- SysTryLog(NID_LOC, res == 0, "[E_SYSTEM] Failed to obtain the CPS location information");
- if (res == 0)
- {
- r = SetLocationInformation(latitude, longitude, altitude, timestamp, LOCATIONS_METHOD_CPS);
- if (r != E_SUCCESS)
- {
- SysLog(NID_LOC, "Failed to set the location information");
- }
- }
+ r = GetLocation(LOCATIONS_METHOD_CPS);
+ SysTryLog(NID_LOC, r == E_SUCCESS, "[E_SYSTEM] Failed to obtain the CPS location information");
}
else
{
SysLog(NID_LOC, "CPS Location not available at the Native side.");
}
- if (__nativeWPSServiceState == LOCATIONS_SERVICE_ENABLED)
+ if (__wpsHandler.serviceState == LOCATIONS_SERVICE_ENABLED)
{
- res = location_manager_get_position(__wpsHandler, &altitude, &latitude, &longitude, &timestamp);
- SysTryLog(NID_LOC, res == 0, "[E_SYSTEM] Failed to obtain the WPS location information");
- if (res == 0)
- {
- r = SetLocationInformation(latitude, longitude, altitude, timestamp, LOCATIONS_METHOD_WPS);
- if (r != E_SUCCESS)
- {
- SysLog(NID_LOC, "Failed to set the location information");
- }
- }
+ r = GetLocation(LOCATIONS_METHOD_WPS);
+ SysTryLog(NID_LOC, r == E_SUCCESS, "[E_SYSTEM] Failed to obtain the WPS location information");
}
else
{
SysLog(NID_LOC, "WPS Location not available at the Native side.");
}
- if (__nativeGPSServiceState == LOCATIONS_SERVICE_ENABLED)
+ if (__gpsHandler.serviceState == LOCATIONS_SERVICE_ENABLED)
{
- res = location_manager_get_position(__gpsHandler, &altitude, &latitude, &longitude, &timestamp);
- SysTryLog(NID_LOC, res == 0, "[E_SYSTEM] Failed to obtain the GPS location information");
- if (res == 0)
- {
- r = SetLocationInformation(latitude, longitude, altitude, timestamp, LOCATIONS_METHOD_GPS);
- if (r != E_SUCCESS)
- {
- SysLog(NID_LOC, "Failed to set the location information");
- }
-
- res = gps_status_get_satellite(__gpsHandler, &satellitesInUseCount, &satellitesInViewCount, &timestampSatellite);
-
- timeDiff = abs(timestamp - timestampSatellite);
- timeDiff = timeDiff * 1000;
- SysLog(NID_LOC, "Result (%d), Satellites in Use (%d), Satellites in View (%d), Time stamp (%ld), Time Difference (Loc and Sat) (%ld)",
- res, satellitesInUseCount, satellitesInViewCount, timestampSatellite, timeDiff);
- if (res == 0 && timeDiff <= MAX_VALID_TIME_DIFFERENCE)
- {
- res = gps_status_foreach_satellites_in_view(__gpsHandler, SatelliteInfoUpdated, &satInfo);
- }
- SysLog(NID_LOC, "Result of get satellite is (%d) and satelliteInfo string representation is (%ls)", res, satInfo.GetPointer());
-
- _LocationImpl::GetInstance(*__pCurrentLocation.get())->SetExtraInfo(L"satellite", satInfo);
- }
+ r = GetLocation(LOCATIONS_METHOD_GPS);
+ SysTryLog(NID_LOC, r == E_SUCCESS, "[E_SYSTEM] Failed to obtain the GPS location information");
}
else
{
@@ -1109,21 +1481,6 @@ _LocationManager::OnTimerExpired(Tizen::Base::Runtime::Timer& timer)
__pLocUpdateTimer->Start(__timerInterval * 1000);
SendLocationCallbacks();
}
- else
- {
- int count = __pSyncLocRequestInfoList->GetCount();
- for (int i = 0; i < count; i++)
- {
- _SyncLocationRequestInfo* pSyncLocRequestInfo = static_cast< _SyncLocationRequestInfo* >(__pSyncLocRequestInfoList->GetAt(i));
- if (pSyncLocRequestInfo != null && pSyncLocRequestInfo->Equals(timer))
- {
- SysLog(NID_LOC, "Timer expired for the sync location request with request ID (%ld)", pSyncLocRequestInfo->GetRequestId());
-
- HandleSyncRetrievalTimerExpiry(*pSyncLocRequestInfo);
- break;
- }
- }
- }
return;
}
@@ -1167,7 +1524,7 @@ _LocationManager::GpsServiceUpdateCallback(location_service_state_e state, void*
}
_LocationManager* pThis = static_cast< _LocationManager* >(user_data);
- pThis->__nativeGPSServiceState = state;
+ pThis->__gpsHandler.serviceState = state;
}
void
@@ -1181,7 +1538,7 @@ _LocationManager::WpsServiceUpdateCallback(location_service_state_e state, void*
}
_LocationManager* pThis = static_cast< _LocationManager* >(user_data);
- pThis->__nativeWPSServiceState = state;
+ pThis->__wpsHandler.serviceState = state;
}
void
@@ -1195,7 +1552,7 @@ _LocationManager::CpsServiceUpdateCallback(location_service_state_e state, void*
}
_LocationManager* pThis = static_cast< _LocationManager* >(user_data);
- pThis->__nativeCPSServiceState = state;
+ pThis->__cpsHandler.serviceState = state;
}
void
@@ -1223,104 +1580,6 @@ _LocationManager::DestroyLocationManager(void)
delete __pUniqueInstance;
}
-Location
-_LocationManager::GetLastKnownLocation(location_method_e nativeLocMethod)
-{
- String locationMethod;
- location_manager_h nativeHandle = null;
- switch (nativeLocMethod)
- {
- case LOCATIONS_METHOD_GPS:
- nativeHandle = __gpsHandler;
- locationMethod = L"gps";
- break;
- case LOCATIONS_METHOD_WPS:
- nativeHandle = __wpsHandler;
- locationMethod = L"network";
- break;
- case LOCATIONS_METHOD_CPS:
- nativeHandle = __cpsHandler;
- locationMethod = L"network";
- break;
- default:
- break;
- }
- SysLog(NID_LOC, "Last location requested(method: %x, handle: %x).", nativeLocMethod, nativeHandle);
-
- Location location = _LocationImpl::GetLocationInstance();
- if (nativeHandle != null)
- {
- _LocationImpl* pLocationImpl = _LocationImpl::GetInstance(location);
-
- double altitude = Tizen::Locations::NaN;
- double latitude = Tizen::Locations::NaN;
- double longitude = Tizen::Locations::NaN;
- time_t timestampPosition = 0;
-
- int res = location_manager_get_last_position(nativeHandle, &altitude, &latitude, &longitude, &timestampPosition);
- SysTryCatch(NID_LOC, res == 0, , E_SYSTEM, "[E_SYSTEM] Failed to fetch last position from nativeHandle(%x).", nativeHandle);
- SysLog(NID_LOC, "Last position(latitude: %lf, longitude: %lf, altitude: %lf, timestamp: %lld",
- latitude, longitude, altitude, timestampPosition);
-
- Coordinates coord;
- coord.Set(latitude, longitude, altitude);
- pLocationImpl->SetCoordinates(coord);
-
- double horAcc = Tizen::Locations::NaN;
- double verAcc = Tizen::Locations::NaN;
- location_accuracy_level_e level;
- res = location_manager_get_last_accuracy(nativeHandle, &level, &horAcc, &verAcc);
- if (res == 0)
- {
- SysLog(NID_LOC, "Last accuracy(horAcc: %lf, vAcc: %lf, level: %x)", horAcc, verAcc, level);
- pLocationImpl->SetHorizontalAccuracy(horAcc);
- pLocationImpl->SetVerticalAccuracy(verAcc);
- }
-
- double climb = Tizen::Locations::NaN;
- double direction = Tizen::Locations::NaN;
- double speed = Tizen::Locations::NaN;
- time_t timestampVelocity = 0;
- res = location_manager_get_last_velocity(nativeHandle, &climb, &direction, &speed, &timestampVelocity);
- if (res == 0)
- {
- SysLog(NID_LOC, "Last velocity(climb: %lf, direction: %lf, speed: %x, timestamp: %lld)",
- climb, direction, speed, timestampVelocity);
- pLocationImpl->SetCourse(direction);
- pLocationImpl->SetSpeed(speed);
- }
-
- if (nativeLocMethod == LOCATIONS_METHOD_GPS)
- {
- int satUsedCount = 0;
- int satViewCount = 0;
- time_t timestampSatellite = 0;
- String satInfo = L"";
- res = gps_status_get_last_satellite(nativeHandle, &satUsedCount, &satViewCount, &timestampSatellite);
- if (res == 0)
- {
- long timeDiff = abs(timestampPosition - timestampSatellite);
- res = gps_status_foreach_last_satellites_in_view(nativeHandle, SatelliteInfoUpdated, &satInfo);
- SysLog(NID_LOC, "Last satellite(foreachResult: %d, inUse: %d, inView: %d, timestamp: %lld, timeDiff: %ld)",
- res, satUsedCount, satViewCount, timestampSatellite, timeDiff);
-
- SysLog(NID_LOC, "Last satellite(info: %ls)", satInfo.GetPointer());
- pLocationImpl->SetExtraInfo(L"satellite", satInfo);
- }
- }
-
- pLocationImpl->SetTimestamp(((long long)timestampPosition) * 1000); // in milliseconds
- pLocationImpl->SetValidity(true);
- pLocationImpl->SetExtraInfo(L"location_method", locationMethod);
- }
-
- ClearLastResult();
- return location;
-
-CATCH:
- return location;
-}
-
bool
_LocationManager::GetAppAccessibility(void)
{
@@ -1348,46 +1607,4 @@ _LocationManager::GetAppAccessibility(void)
return (accessState == LOCATIONS_ACCESS_STATE_ALLOWED) ? true : false;
}
-
-Location
-_LocationManager::GetRecentLocationAvailable(void)
-{
- long long gpsTimestamp = 0;
- long long wpsTimestamp = 0;
- long long cpsTimestamp = 0;
-
- Location lastGpsLocation = GetLastKnownLocation(LOCATIONS_METHOD_GPS);
- if (lastGpsLocation.IsValid())
- {
- gpsTimestamp = _LocationImpl::GetInstance(lastGpsLocation)->GetTimestampInMs();
- }
-
- Location lastWpsLocation = GetLastKnownLocation(LOCATIONS_METHOD_WPS);
- if (lastWpsLocation.IsValid())
- {
- wpsTimestamp = _LocationImpl::GetInstance(lastWpsLocation)->GetTimestampInMs();
- }
-
- Location lastCpsLocation = GetLastKnownLocation(LOCATIONS_METHOD_CPS);
- if (lastCpsLocation.IsValid())
- {
- cpsTimestamp = _LocationImpl::GetInstance(lastCpsLocation)->GetTimestampInMs();
- }
-
- SysLog(NID_LOC, "Compare timestamp(gps: %lld, wps: %lld, cps: %lld) for recent location.",
- gpsTimestamp, wpsTimestamp, cpsTimestamp);
-
- if (gpsTimestamp >= wpsTimestamp && gpsTimestamp >= cpsTimestamp)
- {
- return lastGpsLocation;
- }
- else if (wpsTimestamp > gpsTimestamp && wpsTimestamp > cpsTimestamp)
- {
- return lastWpsLocation;
- }
- else
- {
- return lastCpsLocation;
- }
-}
}}
diff --git a/src/FLoc_LocationManager.h b/src/FLoc_LocationManager.h
index 531eabb..75c5d97 100644
--- a/src/FLoc_LocationManager.h
+++ b/src/FLoc_LocationManager.h
@@ -57,6 +57,12 @@ public:
//
result StopLocationUpdates(RequestId reqId);
+ // This method updates the requested interval from the location provider.
+ //
+ // @since 2.0
+ //
+ result ChangeUpdateInterval(RequestId reqId, int interval);
+
// This method initiates the synchronous location retrieval. The location monitor instance provided is used to intimate back the location.
//
// @since 2.0
@@ -158,7 +164,7 @@ private:
//
// @since 2.0
//
- result SetLocationInformation(double latitude, double longitude, double altitude, time_t timestamp, location_method_e locMethod);
+ result SetLocationInformation(double latitude, double longitude, double altitude, time_t timestamp, location_method_e locMethod, Location* pLocation);
// The method is called to send back the callbacks in case of async location updates.
//
@@ -184,6 +190,30 @@ private:
//
Location GetLastKnownLocation(location_method_e nativeLocMethod);
+ // This method returns the most recent location among available last known locations.
+ //
+ // @since 2.0
+ //
+ Location GetRecentLocationAvailable(void);
+
+ // This method updates the timer interval for a particular request Id.
+ //
+ // @since 2.0
+ //
+ void UpdateLocRequestInfoList(RequestId reqId, int interval);
+
+ // This method gets the better location among the three location providers.
+ //
+ // @since 2.0
+ //
+ const Location* FindBestLocation(void);
+
+ // This method gets the location from the native side depending on the location handle.
+ //
+ // @since 2.0
+ //
+ result GetLocation(location_method_e nativeLocMethod);
+
// @see @ref Tizen::Base::Runtime::EventDrivenThread::OnStart()
//
// @since 2.0
@@ -251,12 +281,6 @@ private:
//
static bool GetAppAccessibility(void);
- // This method returns the most recent location among available last known locations.
- //
- // @since 2.0
- //
- Location GetRecentLocationAvailable(void);
-
private:
const static RequestId REQ_ID_START_LOC_UPDATES = 1;
const static RequestId REQ_ID_STOP_LOC_UPDATES = 2;
@@ -267,6 +291,7 @@ private:
const static RequestId REQ_ID_SYNC_LOC_RETRIEVAL = 7;
const static RequestId REQ_ID_GET_APP_ACCESSIBILITY = 8;
const static RequestId REQ_ID_GET_LAST_LOCATION = 9;
+ const static RequestId REQ_ID_UPDATE_INTERVAL = 10;
enum _LocationMethodRequested
{
@@ -286,19 +311,34 @@ private:
}
__locationMgrState;
+ class __LocationManagerHandle
+ {
+ public:
+ __LocationManagerHandle(void)
+ : serviceState(LOCATIONS_SERVICE_DISABLED)
+ , handle(null)
+ , pLocation(null)
+ {
+ }
+
+ ~__LocationManagerHandle(void)
+ {
+ }
+
+ public:
+ location_service_state_e serviceState;
+ location_manager_h handle;
+ std::unique_ptr< Tizen::Locations::Location > pLocation;
+ };
+
LocationAccuracy __minRequestedAccuracy;
- location_service_state_e __nativeGPSServiceState;
- location_service_state_e __nativeWPSServiceState;
- location_service_state_e __nativeCPSServiceState;
int __timerInterval;
int __timerTicks;
- location_manager_h __gpsHandler;
- location_manager_h __wpsHandler;
- location_manager_h __cpsHandler;
- std::unique_ptr< Tizen::Locations::Location > __pCurrentLocation;
+ __LocationManagerHandle __gpsHandler;
+ __LocationManagerHandle __wpsHandler;
+ __LocationManagerHandle __cpsHandler;
std::unique_ptr< Tizen::Base::Collection::ArrayList, Tizen::Base::Collection::AllElementsDeleter > __pLocRequestInfoList;
std::unique_ptr< Tizen::Base::Collection::ArrayList, Tizen::Base::Collection::AllElementsDeleter > __pSyncLocRequestInfoList;
- std::unique_ptr< Tizen::Base::Runtime::Mutex > __pLocMgrMutex;
std::unique_ptr< Tizen::Base::Runtime::Timer > __pLocUpdateTimer;
static _LocationManager* __pUniqueInstance;
diff --git a/src/FLoc_LocationProviderImpl.cpp b/src/FLoc_LocationProviderImpl.cpp
index 02a1229..bccc8a3 100644
--- a/src/FLoc_LocationProviderImpl.cpp
+++ b/src/FLoc_LocationProviderImpl.cpp
@@ -39,7 +39,9 @@
#include <FLocTypes.h>
#include <FSysPowerManager.h>
#include <FSysSystemTime.h>
+#include <FSys_AlarmImpl.h>
#include <FSys_SettingInfoImpl.h>
+#include "FLoc_Config.h"
#include "FLoc_LocationImpl.h"
#include "FLoc_LocationManager.h"
#include "FLoc_LocationMonitor.h"
@@ -60,21 +62,9 @@ namespace Tizen { namespace Locations
_LocationProviderImpl::_LocationProviderImpl(void)
: Tizen::Base::Runtime::_Event()
- , __firstLocationUpdate(true)
- , __regionMonitoringActive(false)
- , __awakeEnabled(false)
- , __updateInterval(0)
- , __locationUpdateType(_LOCATION_UPDATE_TYPE_NONE)
- , __locationUpdateStatus(LOC_SVC_STATUS_IDLE)
- , __regionMonitorStatus(LOC_SVC_STATUS_IDLE)
, __lastLocationAccuracy(LOC_ACCURACY_INVALID)
- , __reqId(-1)
- , __regionReqId(-1)
- , __distanceThreshold(0.0)
, __pLocationListener(null)
, __pLocationManager(null)
- , __pLastLocation(null)
- , __pRegionList(null)
{
}
@@ -109,6 +99,18 @@ _LocationProviderImpl::Construct(const LocationCriteria& criteria, ILocationProv
r = pRegionList->Construct();
SysTryReturn(NID_LOC, r == E_SUCCESS, r, r, "[%s] Failed to construct the list. Propagating.", GetErrorMessage(r));
+ std::unique_ptr< Tizen::Base::Runtime::Timer> pTimer (new (std::nothrow) Timer());
+ SysTryReturn(NID_LOC, pTimer != null, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
+
+ r = pTimer->Construct(*this);
+ SysTryReturn(NID_LOC, r == E_SUCCESS, r, r, "[%s] Failed to construct the timer. Propagating.", GetErrorMessage(r));
+
+ std::unique_ptr< Tizen::System::Alarm> pAlarm (new (std::nothrow) Alarm());
+ SysTryReturn(NID_LOC, pAlarm != null, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
+
+ r = pAlarm->Construct(*this);
+ SysTryReturn(NID_LOC, r == E_SUCCESS, r, r, "[%s] Failed to construct the alarm. Propagating.", GetErrorMessage(r));
+
UiApp* pAppInstance = Tizen::App::UiApp::GetInstance();
if (pAppInstance != null)
{
@@ -119,14 +121,21 @@ _LocationProviderImpl::Construct(const LocationCriteria& criteria, ILocationProv
SysTryReturn(NID_LOC, r == E_SUCCESS, r, r, "[%s] Error occured during adding the event listener to app manager. Propagating.", GetErrorMessage(r));
}
- std::unique_ptr< Tizen::Locations::Location > pLocation(_LocationImpl::GetLocationInstanceN());
- SysTryReturn(NID_LOC, pLocation != null, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
+ std::unique_ptr< Tizen::Locations::Location > pLastLocation(_LocationImpl::GetLocationInstanceN());
+ SysTryReturn(NID_LOC, pLastLocation != null, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
+
+ std::unique_ptr<Tizen::Locations::Location> pLastRegionLocation (_LocationImpl::GetLocationInstanceN());
+ SysTryReturn(NID_LOC, pLastRegionLocation != null, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
_Event::Initialize();
_Event::AddListener(*this);
- __pRegionList = std::move(pRegionList);
- __pLastLocation = std::move(pLocation);
+ __regionMonitor.pRegionList = std::move(pRegionList);
+ __regionMonitor.pTimer = std::move(pTimer);
+ __regionMonitor.pAlarm = std::move(pAlarm);
+ __regionMonitor.pLocation = std::move(pLastRegionLocation);
+ __locationUpdater.pLocation = std::move(pLastLocation);
+
__criteria = criteria;
__pLocationListener = &listener;
__pLocationManager = pLocationManager;
@@ -144,15 +153,10 @@ _LocationProviderImpl::StartLocationUpdatesByInterval(int interval)
SysTryReturn(NID_LOC, interval >= 1, E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] The interval(%d) should be greater than or equal to 1", interval);
- if (__locationUpdateType == _LOCATION_UPDATE_TYPE_INTERVAL && __updateInterval == interval)
+ if (__locationUpdater.type == _LOCATION_UPDATE_TYPE_INTERVAL && __locationUpdater.updateInterval == interval)
{
return E_SUCCESS;
}
- else if (__locationUpdateType == _LOCATION_UPDATE_TYPE_DISTANCE || __locationUpdateType == _LOCATION_UPDATE_TYPE_INTERVAL)
- {
- __pLocationManager->StopLocationUpdates(__reqId);
- __locationUpdateStatus = LOC_SVC_STATUS_IDLE;
- }
const double INVALID_DISTANCE_THRESHOLD = 0.0;
return StartLocationUpdates(_LOCATION_UPDATE_TYPE_INTERVAL, interval, INVALID_DISTANCE_THRESHOLD);
@@ -168,15 +172,10 @@ _LocationProviderImpl::StartLocationUpdatesByDistance(double distance)
SysTryReturn(NID_LOC, Double::IsNaN(distance) == false, E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] The distance is NaN.");
- if (__locationUpdateType == _LOCATION_UPDATE_TYPE_DISTANCE && (Double::Compare(__distanceThreshold, distance) == 0))
+ if (__locationUpdater.type == _LOCATION_UPDATE_TYPE_DISTANCE && (Double::Compare(__locationUpdater.distanceThreshold, distance) == 0))
{
return E_SUCCESS;
}
- else if (__locationUpdateType == _LOCATION_UPDATE_TYPE_DISTANCE || __locationUpdateType == _LOCATION_UPDATE_TYPE_INTERVAL)
- {
- __pLocationManager->StopLocationUpdates(__reqId);
- __locationUpdateStatus = LOC_SVC_STATUS_IDLE;
- }
const int INVALID_INTERVAL = 0;
return StartLocationUpdates(_LOCATION_UPDATE_TYPE_DISTANCE, INVALID_INTERVAL, distance);
@@ -185,11 +184,11 @@ _LocationProviderImpl::StartLocationUpdatesByDistance(double distance)
result
_LocationProviderImpl::StopLocationUpdates(void)
{
- SysLog(NID_LOC, "Stopping the location updates for the request ID (%ld)", __reqId);
+ SysLog(NID_LOC, "Stopping the location updates for the request ID (%ld)", __locationUpdater.reqId);
- SysTryReturn(NID_LOC, __locationUpdateType != _LOCATION_UPDATE_TYPE_NONE, E_INVALID_OPERATION, E_INVALID_OPERATION, "[E_INVALID_OPERATION] Location update has not been requested.");
+ SysTryReturn(NID_LOC, __locationUpdater.type != _LOCATION_UPDATE_TYPE_NONE, E_INVALID_OPERATION, E_INVALID_OPERATION, "[E_INVALID_OPERATION] Location update has not been requested.");
- result r = __pLocationManager->StopLocationUpdates(__reqId);
+ result r = __pLocationManager->StopLocationUpdates(__locationUpdater.reqId);
ResetLocationUpdates();
@@ -199,11 +198,11 @@ _LocationProviderImpl::StopLocationUpdates(void)
void
_LocationProviderImpl::KeepLocationUpdateAwake(bool enable)
{
- if (__awakeEnabled == enable)
+ if (__locationUpdater.awakeEnabled == enable)
{
return;
}
- __awakeEnabled = enable;
+ __locationUpdater.awakeEnabled = enable;
UiApp* appInstance = Tizen::App::UiApp::GetInstance();
if (appInstance == null) // This is service APP. So should be handled now.
@@ -211,24 +210,24 @@ _LocationProviderImpl::KeepLocationUpdateAwake(bool enable)
SysLog(NID_LOC, "Handling the request awake mode(%d) for the service application.", enable);
if (enable == true)
{
- if (__locationUpdateType != _LOCATION_UPDATE_TYPE_NONE && __locationUpdateStatus == LOC_SVC_STATUS_PAUSED)
+ if (__locationUpdater.type != _LOCATION_UPDATE_TYPE_NONE && __locationUpdater.status == LOC_SVC_STATUS_PAUSED)
{
- SysLog(NID_LOC, "Requesting to start the location updates as the update type is (%x)", __locationUpdateType);
- __locationUpdateStatus = LOC_SVC_STATUS_NOT_FIXED;
- __pLocationManager->StartLocationUpdates(__criteria.GetAccuracy(), __updateInterval, this, __reqId);
+ SysLog(NID_LOC, "Requesting to start the location updates as the update type is (%x)", __locationUpdater.type);
+ __locationUpdater.status = LOC_SVC_STATUS_NOT_FIXED;
+ __pLocationManager->StartLocationUpdates(__criteria.GetAccuracy(), __locationUpdater.updateInterval, this, __locationUpdater.reqId);
- NotifyServiceStatus(_LOC_PRV_EVENT_SEND_LOC_SVC_CB, __locationUpdateStatus);
+ NotifyServiceStatus(_LOC_PRV_EVENT_SEND_LOC_SVC_CB, __locationUpdater.status);
}
}
else
{
- if (__locationUpdateType != _LOCATION_UPDATE_TYPE_NONE && (__locationUpdateStatus == LOC_SVC_STATUS_RUNNING || __locationUpdateStatus == LOC_SVC_STATUS_NOT_FIXED))
+ if (__locationUpdater.type != _LOCATION_UPDATE_TYPE_NONE && (__locationUpdater.status == LOC_SVC_STATUS_RUNNING || __locationUpdater.status == LOC_SVC_STATUS_NOT_FIXED))
{
- SysLog(NID_LOC, "Requesting to stop the location updates as the update type is (%x)", __locationUpdateType);
- __locationUpdateStatus = LOC_SVC_STATUS_PAUSED;
- __pLocationManager->StopLocationUpdates(__reqId);
+ SysLog(NID_LOC, "Requesting to stop the location updates as the update type is (%x)", __locationUpdater.type);
+ __locationUpdater.status = LOC_SVC_STATUS_PAUSED;
+ __pLocationManager->StopLocationUpdates(__locationUpdater.reqId);
- NotifyServiceStatus(_LOC_PRV_EVENT_SEND_LOC_SVC_CB, __locationUpdateStatus);
+ NotifyServiceStatus(_LOC_PRV_EVENT_SEND_LOC_SVC_CB, __locationUpdater.status);
}
}
}
@@ -247,50 +246,51 @@ _LocationProviderImpl::AddMonitoringRegion(const Coordinates& regionCenter, doub
SysLog(NID_LOC, "Requested to add the monitoring region with center (Latitude: %lf, Longitude %lf) and radius (%lf).", regionCenter.GetLatitude(), regionCenter.GetLongitude(), radius);
- const int DEAULT_REGION_MONITOR_INTERVAL = 5;
static int nextRegionId = 0;
result r = E_SUCCESS;
std::unique_ptr< _RegionInfo > pRegionInfo(new (std::nothrow) _RegionInfo(regionCenter, radius, nextRegionId));
SysTryReturn(NID_LOC, pRegionInfo != null, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY, "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
- r = __pRegionList->Add(*pRegionInfo.get());
+ r = __regionMonitor.pRegionList->Add(*pRegionInfo.get());
SysTryReturn(NID_LOC, r == E_SUCCESS, r, r, "[%s] Failed to add the Region info into the list. Propogated.", GetErrorMessage(r));
pRegionInfo.release();
regionId = nextRegionId;
nextRegionId++;
- if (__regionMonitoringActive == true)
+ if (__regionMonitor.status != LOC_SVC_STATUS_IDLE)
{
return E_SUCCESS;
}
- r = __pLocationManager->StartLocationUpdates(__criteria.GetAccuracy(), DEAULT_REGION_MONITOR_INTERVAL, this, __regionReqId);
- SysTryReturn(NID_LOC, r == E_SUCCESS, r, r, "[%s] Failed to start the location updates. Propogating.", GetErrorMessage(r));
+ r = ActivateRegionMonitoring();
+ SysTryCatch(NID_LOC, r == E_SUCCESS, , r, "[%s] Failed to start the region monitoring. Propogating.", GetErrorMessage(r));
- __regionMonitoringActive = true;
- __regionMonitorStatus = LOC_SVC_STATUS_NOT_FIXED;
- NotifyServiceStatus(_LOC_PRV_EVENT_SEND_MONITOR_SVC_CB, __regionMonitorStatus);
+ __regionMonitor.status = LOC_SVC_STATUS_NOT_FIXED;
+ NotifyServiceStatus(_LOC_PRV_EVENT_SEND_MONITOR_SVC_CB, __regionMonitor.status);
return E_SUCCESS;
+
+CATCH:
+ __regionMonitor.pRegionList->RemoveAt(0);
+ return r;
}
result
_LocationProviderImpl::RemoveMonitoringRegion(RegionId regionId)
{
- int count = __pRegionList->GetCount();
- result r = E_SUCCESS;
+ int count = __regionMonitor.pRegionList->GetCount();
bool isIdValid = false;
SysLog(NID_LOC, "Total regions currently monitored is (%d).", count);
for (int i = 0; i < count; i++)
{
- _RegionInfo* pRegionInfo = static_cast< _RegionInfo* >(__pRegionList->GetAt(i));
+ _RegionInfo* pRegionInfo = static_cast< _RegionInfo* >(__regionMonitor.pRegionList->GetAt(i));
if (regionId == pRegionInfo->GetRegionId())
{
- __pRegionList->RemoveAt(i, true);
+ __regionMonitor.pRegionList->RemoveAt(i, true);
isIdValid = true;
break;
}
@@ -298,16 +298,14 @@ _LocationProviderImpl::RemoveMonitoringRegion(RegionId regionId)
SysTryReturn(NID_LOC, isIdValid == true, E_INVALID_ARG, E_INVALID_ARG, "[E_INVALID_ARG] The region ID is invalid.");
- if (__pRegionList->GetCount() == 0)
+ if (__regionMonitor.pRegionList->GetCount() == 0)
{
- __regionMonitoringActive = false;
- __regionMonitorStatus = LOC_SVC_STATUS_IDLE;
- if (__locationUpdateStatus == LOC_SVC_STATUS_IDLE) // As we are using the same variable for both region monitoring and location updates, this set is required here.
+ __regionMonitor.status = LOC_SVC_STATUS_IDLE;
+ if (__locationUpdater.status == LOC_SVC_STATUS_IDLE) // As we are using the same variable for both region monitoring and location updates, this set is required here.
{
__lastLocationAccuracy = LOC_ACCURACY_INVALID;
}
- r = __pLocationManager->StopLocationUpdates(__regionReqId);
- SysTryReturn(NID_LOC, r == E_SUCCESS, r, r, "[%s] All regions are removed but failed to stop the location updates. Propagating.", GetErrorMessage(r));
+ StopRegionMonitoring();
}
return E_SUCCESS;
@@ -316,20 +314,16 @@ _LocationProviderImpl::RemoveMonitoringRegion(RegionId regionId)
void
_LocationProviderImpl::RemoveAllMonitoringRegions(void)
{
- result r = E_SUCCESS;
+ __regionMonitor.pRegionList->RemoveAll(true);
- __pRegionList->RemoveAll(true);
-
- if (__regionMonitoringActive == true)
+ if (__regionMonitor.status != LOC_SVC_STATUS_IDLE)
{
- __regionMonitoringActive = false;
- __regionMonitorStatus = LOC_SVC_STATUS_IDLE;
- if (__locationUpdateStatus == LOC_SVC_STATUS_IDLE) // As we are using the same variable for both region monitoring and location updates, this set is required here.
+ __regionMonitor.status = LOC_SVC_STATUS_IDLE;
+ if (__locationUpdater.status == LOC_SVC_STATUS_IDLE) // As we are using the same variable for both region monitoring and location updates, this set is required here.
{
__lastLocationAccuracy = LOC_ACCURACY_INVALID;
}
- r = __pLocationManager->StopLocationUpdates(__regionReqId);
- SysTryReturnVoidResult(NID_LOC, r == E_SUCCESS, r, "[%s] All regions are removed but failed to stop the location updates. Ignored.", GetErrorMessage(r));
+ StopRegionMonitoring();
}
return;
@@ -338,13 +332,13 @@ _LocationProviderImpl::RemoveAllMonitoringRegions(void)
LocationServiceStatus
_LocationProviderImpl::GetLocationUpdateStatus(void) const
{
- return __locationUpdateStatus;
+ return __locationUpdater.status;
}
LocationServiceStatus
_LocationProviderImpl::GetRegionMonitoringStatus(void) const
{
- return __regionMonitorStatus;
+ return __regionMonitor.status;
}
LocationAccuracy
@@ -464,12 +458,19 @@ _LocationProviderImpl::OnLocationEventReceivedN(RequestId reqId, Tizen::Location
Location* pLocation = &location;
_LocationImpl* pLocationImpl = _LocationImpl::GetInstance(*pLocation);
- if (__pLastLocation)
+
+ if (reqId == __locationUpdater.reqId)
{
- lastLocationTime = _LocationImpl::GetInstance(*__pLastLocation.get())->GetTimestampInMs();
+ SysLog(NID_LOC, "The location is updated for Location request.");
+ lastLocationTime = _LocationImpl::GetInstance(*__locationUpdater.pLocation.get())->GetTimestampInMs();
+ }
+ else if (reqId == __regionMonitor.reqId)
+ {
+ SysLog(NID_LOC, "The location is updated for Region monitoring.");
+ lastLocationTime = _LocationImpl::GetInstance(*__regionMonitor.pLocation.get())->GetTimestampInMs();
}
- long long timeDifference = abs(pLocationImpl->GetTimestampInMs() - lastLocationTime);
+ long long timeDifference = pLocationImpl->GetTimestampInMs() - lastLocationTime;
SysLog(NID_LOC, "Time difference between last location timestamp (%lld) and current location timestamp (%lld) is (%lld).", lastLocationTime, pLocationImpl->GetTimestampInMs(), timeDifference);
if (timeDifference > 0)
{
@@ -484,13 +485,31 @@ _LocationProviderImpl::OnLocationEventReceivedN(RequestId reqId, Tizen::Location
__pLocationListener->OnAccuracyChanged(currentAccuracy);
}
- if (reqId == __reqId)
+ if (reqId == __locationUpdater.reqId)
{
HandleLocationUpdate(location, isNew);
}
- else if (reqId == __regionReqId)
+ else if (reqId == __regionMonitor.reqId)
{
- HandleRegionMonitoring(location, isNew);
+ if (isNew) // Copy the location only if it is new.
+ {
+ *__regionMonitor.pLocation = location;
+ }
+
+ if (currentAccuracy != LOC_ACCURACY_INVALID && currentAccuracy <= __criteria.GetAccuracy())
+ {
+ SysLog(NID_LOC, "Location criteria (accuracy: %ld) is met for handling region monitoring.", currentAccuracy);
+ result r = __regionMonitor.pTimer->Cancel();
+ SysTryLog(NID_LOC, r == E_SUCCESS, "Failed to cancel the timer.");
+
+ r = __pLocationManager->StopLocationUpdates(__regionMonitor.reqId);
+ SysTryLog(NID_LOC, r == E_SUCCESS, "Failed to stop the location updates.");
+ HandleRegionMonitoring(location, isNew);
+ }
+ else
+ {
+ SysLog(NID_LOC, "Location criteria (accuracy: %ld) is not met for handling region monitoring.", currentAccuracy);
+ }
}
delete pLocation;
@@ -520,81 +539,111 @@ _LocationProviderImpl::OnActiveAppChanged(const Tizen::App::AppId& appId)
{
SysLog(NID_LOC, "Application is active.");
- if (__locationUpdateStatus == LOC_SVC_STATUS_PAUSED)
+ if (__locationUpdater.status == LOC_SVC_STATUS_PAUSED)
{
SysLog(NID_LOC, "Start the location updates as the location update status is PAUSED.");
- __pLocationManager->StartLocationUpdates(__criteria.GetAccuracy(), __updateInterval, this, __reqId);
- __locationUpdateStatus = LOC_SVC_STATUS_NOT_FIXED;
- __pLocationListener->OnLocationUpdateStatusChanged(__locationUpdateStatus);
+ __pLocationManager->StartLocationUpdates(__criteria.GetAccuracy(), __locationUpdater.updateInterval, this, __locationUpdater.reqId);
+ __locationUpdater.status = LOC_SVC_STATUS_NOT_FIXED;
+ __pLocationListener->OnLocationUpdateStatusChanged(__locationUpdater.status);
}
}
else
{
SysLog(NID_LOC, "Application is not active.");
- if (__awakeEnabled == false && (__locationUpdateStatus == LOC_SVC_STATUS_RUNNING || __locationUpdateStatus == LOC_SVC_STATUS_NOT_FIXED))
+
+ if (__locationUpdater.awakeEnabled == false && (__locationUpdater.status == LOC_SVC_STATUS_RUNNING || __locationUpdater.status == LOC_SVC_STATUS_NOT_FIXED))
{
- SysLog(NID_LOC, "Stop the location updates as application is not active with awake mode as (%d) and location update state as (%x).", __awakeEnabled, __locationUpdateStatus);
- __pLocationManager->StopLocationUpdates(__reqId);
- __locationUpdateStatus = LOC_SVC_STATUS_PAUSED;
- __pLocationListener->OnLocationUpdateStatusChanged(__locationUpdateStatus);
+ SysLog(NID_LOC, "Stop the location updates as application is not active with awake mode as (%d) and location update state as (%x).", __locationUpdater.awakeEnabled, __locationUpdater.status);
+ __pLocationManager->StopLocationUpdates(__locationUpdater.reqId);
+ __locationUpdater.status = LOC_SVC_STATUS_PAUSED;
+ __pLocationListener->OnLocationUpdateStatusChanged(__locationUpdater.status);
}
}
}
+void
+_LocationProviderImpl::OnAlarmExpired(Alarm& alarm)
+{
+ SysLog(NID_LOC, "Region Monitor Alarm expired.");
+
+ result r = ActivateRegionMonitoring();
+ SysTryReturnVoidResult(NID_LOC, r == E_SUCCESS, r, "[%s] Failed to start the region monitoring. Propogating.", GetErrorMessage(r));
+}
+
+void
+_LocationProviderImpl::OnTimerExpired(Timer& timer)
+{
+ SysLog(NID_LOC, "Region Monitor timer expired due to unavailability of location information.");
+ __pLocationManager->StopLocationUpdates(__regionMonitor.reqId);
+ HandleRegionMonitoring(*__regionMonitor.pLocation, __regionMonitor.pLocation->IsValid());
+}
+
result
_LocationProviderImpl::StartLocationUpdates(LocationUpdateType updateType, int interval, double distance)
{
result r = E_SUCCESS;
- const int CHECKING_INTERVAL = 10;
+ bool startUpdate = true;
if (updateType == _LOCATION_UPDATE_TYPE_INTERVAL)
{
- __updateInterval = interval;
+ __locationUpdater.updateInterval = interval;
}
else if (updateType == _LOCATION_UPDATE_TYPE_DISTANCE)
{
- __updateInterval = CHECKING_INTERVAL;
- __distanceThreshold = distance;
+ __locationUpdater.updateInterval = DEFAULT_DISTANCE_CHECKING_INTERVAL;
+ __locationUpdater.distanceThreshold = distance;
}
- __locationUpdateType = updateType;
-
- if (__awakeEnabled == true)
- {
- r = __pLocationManager->StartLocationUpdates(__criteria.GetAccuracy(), __updateInterval, this, __reqId);
- SysTryReturn(NID_LOC, r == E_SUCCESS, r, r, "[%s] Failed to start the Native location updates.", GetErrorMessage(r));
- __locationUpdateStatus = LOC_SVC_STATUS_NOT_FIXED;
- }
- else
+ if (!__locationUpdater.awakeEnabled)
{
UiApp* pAppInstance = Tizen::App::UiApp::GetInstance();
if (pAppInstance == null)
{
- __locationUpdateStatus = LOC_SVC_STATUS_PAUSED;
+ startUpdate = false;
}
- else
+ else
{
AppUiState appUiState = pAppInstance->GetAppUiState();
- if (appUiState == APP_UI_STATE_FOREGROUND || appUiState == APP_UI_STATE_PARTIAL_BACKGROUND)
- {
- r = __pLocationManager->StartLocationUpdates(__criteria.GetAccuracy(), __updateInterval, this, __reqId);
- SysTryCatch(NID_LOC, r == E_SUCCESS, , r, "[%s] Failed to start the location updates. Propagating.", GetErrorMessage(r));
- __locationUpdateStatus = LOC_SVC_STATUS_NOT_FIXED;
- }
- else
+
+ if (appUiState == APP_UI_STATE_BACKGROUND)
{
- __locationUpdateStatus = LOC_SVC_STATUS_PAUSED;
+ SysLog(NID_LOC, "App is background.");
+ startUpdate = false;
}
}
}
- SysLog(NID_LOC, "Update type is (%x). The request Id is (%ld) and the update status is (%x).", __locationUpdateType, __reqId, __locationUpdateStatus);
- NotifyServiceStatus(_LOC_PRV_EVENT_SEND_LOC_SVC_CB, __locationUpdateStatus);
+ if (startUpdate)
+ {
+ if (__locationUpdater.type != _LOCATION_UPDATE_TYPE_NONE)
+ {
+ SysLog(NID_LOC, "Update session already running. Updating the interval to %d seconds", __locationUpdater.updateInterval);
+ r = __pLocationManager->ChangeUpdateInterval(__locationUpdater.reqId, __locationUpdater.updateInterval);
+ SysTryCatch(NID_LOC, r == E_SUCCESS, , r, "[%s] Failed to update the request interval. Propagating.", GetErrorMessage(r));
+ __locationUpdater.type = updateType;
+ return E_SUCCESS;
+ }
+ else
+ {
+ r = __pLocationManager->StartLocationUpdates(__criteria.GetAccuracy(), __locationUpdater.updateInterval, this, __locationUpdater.reqId);
+ SysTryCatch(NID_LOC, r == E_SUCCESS, , r, "[%s] Failed to start the Native location updates. Propagating.", GetErrorMessage(r));
+ __locationUpdater.status = LOC_SVC_STATUS_NOT_FIXED;
+ }
+ }
+ else
+ {
+ __locationUpdater.status = LOC_SVC_STATUS_PAUSED;
+ }
+
+ __locationUpdater.type = updateType;
+
+ SysLog(NID_LOC, "Update type is (%x). The request Id is (%ld) and the update status is (%x).", __locationUpdater.type, __locationUpdater.reqId, __locationUpdater.status);
+ NotifyServiceStatus(_LOC_PRV_EVENT_SEND_LOC_SVC_CB, __locationUpdater.status);
return E_SUCCESS;
CATCH:
- __locationUpdateType = _LOCATION_UPDATE_TYPE_NONE;
+ __locationUpdater.type = _LOCATION_UPDATE_TYPE_NONE;
return r;
}
@@ -605,28 +654,28 @@ _LocationProviderImpl::CheckDistanceThreshold(const Location& oldPosition, const
const Coordinates coordOld = oldPosition.GetCoordinates();
const Coordinates coordNew = newPosition.GetCoordinates();
- if (__firstLocationUpdate)
+ if (__locationUpdater.firstLocationUpdate)
{
SysLog(NID_LOC, "First location update. So send true.");
- __firstLocationUpdate = false;
+ __locationUpdater.firstLocationUpdate = false;
return true;
}
displacement = coordOld.GetDistanceTo(coordNew);
SysLog(NID_LOC, "Displacement is (%lf)", displacement);
- return ((displacement > __distanceThreshold) ? true : false);
+ return ((displacement > __locationUpdater.distanceThreshold) ? true : false);
}
void
_LocationProviderImpl::ResetLocationUpdates(void)
{
- __firstLocationUpdate = true;
- __reqId = -1;
+ __locationUpdater.firstLocationUpdate = true;
+ __locationUpdater.reqId = -1;
__lastLocationAccuracy = LOC_ACCURACY_INVALID;
- __locationUpdateType = _LOCATION_UPDATE_TYPE_NONE;
- __locationUpdateStatus = LOC_SVC_STATUS_IDLE;
- __updateInterval = 0;
- __distanceThreshold = 0.0;
+ __locationUpdater.type = _LOCATION_UPDATE_TYPE_NONE;
+ __locationUpdater.status = LOC_SVC_STATUS_IDLE;
+ __locationUpdater.updateInterval = 0;
+ __locationUpdater.distanceThreshold = 0.0;
}
void
@@ -659,11 +708,11 @@ _LocationProviderImpl::FireImpl(Tizen::Base::Runtime::IEventListener& listener,
void
_LocationProviderImpl::HandleLocationUpdate(Tizen::Locations::Location& location, bool isNew)
{
- LocationServiceStatus newLocationUpdateStatus = __locationUpdateStatus;
+ LocationServiceStatus newLocationUpdateStatus = __locationUpdater.status;
if (isNew)
{
- if (__locationUpdateType != _LOCATION_UPDATE_TYPE_NONE && __locationUpdateStatus != LOC_SVC_STATUS_PAUSED)
+ if (__locationUpdater.type != _LOCATION_UPDATE_TYPE_NONE && __locationUpdater.status != LOC_SVC_STATUS_PAUSED)
{
newLocationUpdateStatus = LOC_SVC_STATUS_RUNNING;
}
@@ -671,7 +720,7 @@ _LocationProviderImpl::HandleLocationUpdate(Tizen::Locations::Location& location
else if (_LocationImpl::GetInstance(location)->IsDenied())
{
SysLog(NID_LOC, "User consent not available.");
- if (__locationUpdateType != _LOCATION_UPDATE_TYPE_NONE && __locationUpdateStatus != LOC_SVC_STATUS_PAUSED)
+ if (__locationUpdater.type != _LOCATION_UPDATE_TYPE_NONE && __locationUpdater.status != LOC_SVC_STATUS_PAUSED)
{
newLocationUpdateStatus = LOC_SVC_STATUS_DENIED;
}
@@ -679,35 +728,35 @@ _LocationProviderImpl::HandleLocationUpdate(Tizen::Locations::Location& location
else
{
SysLog(NID_LOC, "Invalid Location Update.");
- if (__locationUpdateType != _LOCATION_UPDATE_TYPE_NONE && __locationUpdateStatus != LOC_SVC_STATUS_PAUSED)
+ if (__locationUpdater.type != _LOCATION_UPDATE_TYPE_NONE && __locationUpdater.status != LOC_SVC_STATUS_PAUSED)
{
newLocationUpdateStatus = LOC_SVC_STATUS_NOT_FIXED;
}
}
- if (newLocationUpdateStatus != __locationUpdateStatus)
+ if (newLocationUpdateStatus != __locationUpdater.status)
{
SysLog(NID_LOC, "Location Update Satus changed to (%x). Notify the status.", newLocationUpdateStatus);
- __locationUpdateStatus = newLocationUpdateStatus;
- __pLocationListener->OnLocationUpdateStatusChanged(__locationUpdateStatus);
+ __locationUpdater.status = newLocationUpdateStatus;
+ __pLocationListener->OnLocationUpdateStatusChanged(__locationUpdater.status);
}
if (newLocationUpdateStatus == LOC_SVC_STATUS_RUNNING)
{
- if (__locationUpdateType == _LOCATION_UPDATE_TYPE_DISTANCE)
+ if (__locationUpdater.type == _LOCATION_UPDATE_TYPE_DISTANCE)
{
- if (CheckDistanceThreshold(*__pLastLocation.get(), location) == true)
+ if (CheckDistanceThreshold(*__locationUpdater.pLocation.get(), location) == true)
{
- SysLog(NID_LOC, "Location displacement exceeds the distance threshold (%lf). Notify the location.", __distanceThreshold);
+ SysLog(NID_LOC, "Location displacement exceeds the distance threshold (%lf). Notify the location.", __locationUpdater.distanceThreshold);
__pLocationListener->OnLocationUpdated(location);
- *__pLastLocation.get() = location;
+ *__locationUpdater.pLocation.get() = location;
}
}
- else if (__locationUpdateType == _LOCATION_UPDATE_TYPE_INTERVAL)
+ else if (__locationUpdater.type == _LOCATION_UPDATE_TYPE_INTERVAL)
{
SysLog(NID_LOC, "Location time interval expired. Notify the location.");
__pLocationListener->OnLocationUpdated(location);
- *__pLastLocation.get() = location;
+ *__locationUpdater.pLocation.get() = location;
}
}
}
@@ -715,7 +764,7 @@ _LocationProviderImpl::HandleLocationUpdate(Tizen::Locations::Location& location
void
_LocationProviderImpl::HandleRegionMonitoring(Tizen::Locations::Location& location, bool isNew)
{
- LocationServiceStatus newRegionMonitorStatus = __regionMonitorStatus;
+ LocationServiceStatus newRegionMonitorStatus = __regionMonitor.status;
if (isNew)
{
@@ -730,30 +779,31 @@ _LocationProviderImpl::HandleRegionMonitoring(Tizen::Locations::Location& locati
newRegionMonitorStatus = LOC_SVC_STATUS_NOT_FIXED;
}
- if (newRegionMonitorStatus != __regionMonitorStatus)
+ if (newRegionMonitorStatus != __regionMonitor.status)
{
SysLog(NID_LOC, "Region Monitoring Satus changed to (%x). Notify the status.", newRegionMonitorStatus);
- __regionMonitorStatus = newRegionMonitorStatus;
- __pLocationListener->OnRegionMonitoringStatusChanged(__regionMonitorStatus);
+ __regionMonitor.status = newRegionMonitorStatus;
+ __pLocationListener->OnRegionMonitoringStatusChanged(__regionMonitor.status);
}
if (newRegionMonitorStatus == LOC_SVC_STATUS_RUNNING)
{
NotifyRegionCrossedStatus(location);
- *__pLastLocation.get() = location;
}
+
+ SetNextRegionMonitoringTime();
}
void
_LocationProviderImpl::NotifyRegionCrossedStatus(const Tizen::Locations::Location& location)
{
- int count = __pRegionList->GetCount();
+ int count = __regionMonitor.pRegionList->GetCount();
SysLog(NID_LOC, "Number of regions currently monitored is (%d)", count);
for (int i = 0; i < count; i++)
{
- _RegionInfo* pRegionInfo = static_cast< _RegionInfo* >(__pRegionList->GetAt(i));
+ _RegionInfo* pRegionInfo = static_cast< _RegionInfo* >(__regionMonitor.pRegionList->GetAt(i));
if (pRegionInfo)
{
@@ -920,4 +970,66 @@ _LocationProviderImpl::GetUserPrivilege(void)
return true;
}
+
+result
+_LocationProviderImpl::ActivateRegionMonitoring(void)
+{
+ long long currentTime;
+ SystemTime::GetTicks(currentTime);
+
+ SysLog(NID_LOC, "Current system time is %lld", currentTime);
+
+ _LocationImpl::GetInstance(*__regionMonitor.pLocation)->SetValidity(false);
+ _LocationImpl::GetInstance(*__regionMonitor.pLocation)->SetTimestamp(currentTime);
+
+ result r = __regionMonitor.pTimer->Start(DEFAULT_WAITING_TIME_FOR_FIXING_LOCATION * 1000);
+ SysTryReturn(NID_LOC, r == E_SUCCESS, r, r, "[%s] Failed to start the timer. Propogating.", GetErrorMessage(r));
+
+ r = __pLocationManager->StartLocationUpdates(__criteria.GetAccuracy(), MIN_LOCATION_UPDATE_INTERVAL, this, __regionMonitor.reqId);
+ SysTryReturn(NID_LOC, r == E_SUCCESS, r, r, "[%s] Failed to start the location updates. Propogating.", GetErrorMessage(r));
+
+ SysLog(NID_LOC, "Timer & Location updates are started.");
+ return E_SUCCESS;
+}
+
+void
+_LocationProviderImpl::StopRegionMonitoring(void)
+{
+ result r = _AlarmImpl::GetInstance(__regionMonitor.pAlarm.get())->Cancel();
+ SysTryReturnVoidResult(NID_LOC, r == E_SUCCESS, r, "[%s] Failed to stop the alarm. Ignored.", GetErrorMessage(r));
+
+ r = __regionMonitor.pTimer->Cancel();
+ SysTryReturnVoidResult(NID_LOC, r == E_SUCCESS, r, "[%s] Failed to stop the timer. Ignored.", GetErrorMessage(r));
+
+ r = __pLocationManager->StopLocationUpdates(__regionMonitor.reqId);
+ SysTryReturnVoidResult(NID_LOC, r == E_SUCCESS, r, "[%s] All regions are removed but failed to stop the location updates. Ignored.", GetErrorMessage(r));
+}
+
+void
+_LocationProviderImpl::SetNextRegionMonitoringTime(void)
+{
+ DateTime alarmDateTime;
+ long long alarmTime = DEFAULT_REGION_MONITORING_CYCLE_INTERVAL;
+ SystemTime::GetCurrentTime(TIME_MODE_WALL, alarmDateTime);
+
+ SysLog(NID_LOC, "Current System Time is %ls", alarmDateTime.ToString().GetPointer());
+
+ if (__regionMonitor.pLocation->IsValid())
+ {
+ const int bufferTime = 5; //Buffer of 5 seconds for determining the alarmTime;
+ double minDistance = _MathUtils::GetShortestDistance(*__regionMonitor.pLocation, *__regionMonitor.pRegionList);
+ long long newAlarmTime = ((int) minDistance / DEFAULT_AVG_SPEED) - bufferTime; //Calculate the alarm time based on the shortest distance between current location and nearest region boundary.
+
+ if (newAlarmTime > alarmTime)
+ {
+ alarmTime = newAlarmTime;
+ }
+ }
+
+ alarmDateTime.AddSeconds(alarmTime);
+ result r = _AlarmImpl::GetInstance(__regionMonitor.pAlarm.get())->Set(alarmDateTime, 0, null);
+ SysTryLog(NID_LOC, r == E_SUCCESS, "Failed to set the alarm for next cycle.");
+
+ SysLog(NID_LOC, "Next alarm expires after %ld seconds.", alarmTime);
+}
}}
diff --git a/src/FLoc_LocationProviderImpl.h b/src/FLoc_LocationProviderImpl.h
index 3b78e53..cc23a48 100644
--- a/src/FLoc_LocationProviderImpl.h
+++ b/src/FLoc_LocationProviderImpl.h
@@ -28,9 +28,12 @@
#include <unique_ptr.h>
#include <FAppIActiveAppEventListener.h>
#include <FBaseColAllElementsDeleter.h>
-#include <FBaseRtTimer.h>
#include <FBaseRtIEventListener.h>
+#include <FBaseRtITimerEventListener.h>
+#include <FBaseRtTimer.h>
#include <FLocLocationCriteria.h>
+#include <FSysAlarm.h>
+#include <FSysIAlarmEventListener.h>
#include <FBaseRt_Event.h>
#include "FLoc_ILocationManagerListener.h"
#include "FLoc_ILocProviderEventListener.h"
@@ -56,6 +59,8 @@ class _LocationProviderImpl
, public Tizen::Locations::_ILocationManagerListener
, public Tizen::Locations::_ILocProviderEventListener
, public Tizen::App::IActiveAppEventListener
+ , public Tizen::Base::Runtime::ITimerEventListener
+ , public Tizen::System::IAlarmEventListener
{
public:
/**
@@ -175,6 +180,16 @@ private:
*/
virtual void OnActiveAppChanged(const Tizen::App::AppId& appId);
+ /**
+ * @see @ref Tizen::System::IAlarmEventListener::OnAlarmExpired()
+ */
+ virtual void OnAlarmExpired(Tizen::System::Alarm& alarm);
+
+ /**
+ * @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
@@ -226,29 +241,92 @@ private:
//
void NotifyServiceStatus(_LocProviderEventType eventType, LocationServiceStatus svcStatus);
- // This method is returns the bool value depicting the privilege details depending on the location settings.
+ // 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(void);
+
+ // 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:
- bool __firstLocationUpdate;
- bool __regionMonitoringActive;
- bool __awakeEnabled;
- int __updateInterval;
- LocationUpdateType __locationUpdateType;
- LocationServiceStatus __locationUpdateStatus;
- LocationServiceStatus __regionMonitorStatus;
+ 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)
+ , pTimer(null)
+ , pAlarm(null)
+ , pLocation(null)
+ , pRegionList(null)
+ {
+ }
+
+ ~_RegionMonitor(void)
+ {
+ }
+
+ public:
+ RequestId reqId;
+ LocationServiceStatus status;
+ std::unique_ptr<Tizen::Base::Runtime::Timer> pTimer;
+ std::unique_ptr<Tizen::System::Alarm> pAlarm;
+ std::unique_ptr<Tizen::Locations::Location> pLocation;
+ std::unique_ptr< Tizen::Base::Collection::ArrayList, Tizen::Base::Collection::AllElementsDeleter > pRegionList;
+ }__regionMonitor;
+
LocationAccuracy __lastLocationAccuracy;
- RequestId __reqId;
- RequestId __regionReqId;
- double __distanceThreshold;
LocationCriteria __criteria;
ILocationProviderListener* __pLocationListener;
_LocationManager* __pLocationManager;
- std::unique_ptr< Tizen::Locations::Location > __pLastLocation;
- std::unique_ptr< Tizen::Base::Collection::ArrayList, Tizen::Base::Collection::AllElementsDeleter > __pRegionList;
+
}; // _LocationProviderImpl
}} // Tizen::Locations
diff --git a/src/FLoc_LocationRequestInfo.h b/src/FLoc_LocationRequestInfo.h
index de3602c..ef3046c 100644
--- a/src/FLoc_LocationRequestInfo.h
+++ b/src/FLoc_LocationRequestInfo.h
@@ -67,6 +67,8 @@ public:
RequestId GetRequestId(void) const {return __reqId;}
+ void SetInterval(int interval) { __interval = interval;}
+
private:
_LocationRequestInfo(void);
diff --git a/src/FLoc_MathUtils.cpp b/src/FLoc_MathUtils.cpp
index 25c2b6a..dc6042b 100644
--- a/src/FLoc_MathUtils.cpp
+++ b/src/FLoc_MathUtils.cpp
@@ -23,6 +23,7 @@
*/
#include <math.h>
+#include <FBaseDouble.h>
#include <FBaseSysLog.h>
#include <FBaseUtilMath.h>
#include <FLocLocation.h>
@@ -30,7 +31,7 @@
#include "FLoc_RegionInfo.h"
using namespace Tizen::Base::Utility;
-
+using namespace Tizen::Base;
namespace Tizen { namespace Locations
{
@@ -70,4 +71,30 @@ _MathUtils::CalculateOverlapRegion(const _RegionInfo& region, const Location& lo
return overlapArea;
}
+double
+_MathUtils::GetShortestDistance(const Location& location, const Tizen::Base::Collection::IList& regionList)
+{
+ double minDistance = Double::GetMaxValue();
+ int count = regionList.GetCount();
+
+ for (int i = 0; i < count; i++)
+ {
+ const _RegionInfo* pRegionInfo = static_cast<const _RegionInfo*> (regionList.GetAt(i));
+
+ if (pRegionInfo)
+ {
+ Coordinates regionCoordinate = pRegionInfo->GetCoordinate();
+ double distance = abs(regionCoordinate.GetDistanceTo(location.GetCoordinates()) - pRegionInfo->GetRadius());
+
+ if (minDistance > distance)
+ {
+ minDistance = distance;
+ }
+ }
+ }
+
+ SysLog(NID_LOC, "Shortest distance from location (lat: %lf and lon: %lf) to the nearest region boundary is (%lf) meters", location.GetCoordinates().GetLatitude(), location.GetCoordinates().GetLongitude(), minDistance);
+
+ return minDistance;
+}
} } // Tizen::Locations
diff --git a/src/FLoc_MathUtils.h b/src/FLoc_MathUtils.h
index 082de85..7459b2d 100644
--- a/src/FLoc_MathUtils.h
+++ b/src/FLoc_MathUtils.h
@@ -27,6 +27,11 @@
#ifndef _FLOC_INTERNAL_MATH_UTILS_H_
#define _FLOC_INTERNAL_MATH_UTILS_H_
+namespace Tizen { namespace Base { namespace Collection
+{
+ class IList;
+}}}
+
namespace Tizen { namespace Locations
{
@@ -48,6 +53,12 @@ public:
//
static double CalculateOverlapRegion(const _RegionInfo& region, const Location& location);
+ // This method returns the distance between the user's current location and the the nearest boundary among the added monitoring regions.
+ // @since 2.0
+ //
+ static double GetShortestDistance(const Location& location, const Tizen::Base::Collection::IList& regionList);
+
+
public:
static const double PI;
static const double PI2;
diff --git a/src/FLoc_SyncLocationRequestInfo.h b/src/FLoc_SyncLocationRequestInfo.h
index 0b22c78..f286707 100644
--- a/src/FLoc_SyncLocationRequestInfo.h
+++ b/src/FLoc_SyncLocationRequestInfo.h
@@ -45,7 +45,6 @@ public:
_SyncLocationRequestInfo(_LocationMonitor* pLocMonitor, RequestId reqId)
: Tizen::Base::Object()
, __pLocMonitor(pLocMonitor)
- , __pTimer(null)
, __reqId(reqId)
, __tickCount(0)
{
@@ -56,34 +55,12 @@ public:
_LocationMonitor* GetLocationMonitor(void) const {return __pLocMonitor;}
- result StartTimer(Tizen::Base::Runtime::ITimerEventListener& listener)
- {
- result r = E_SUCCESS;
-
- if (__pTimer == null)
- {
- std::unique_ptr< Tizen::Base::Runtime::Timer > pTimer(new (std::nothrow) Tizen::Base::Runtime::Timer());
- SysTryReturn(NID_LOC, pTimer != null, E_OUT_OF_MEMORY, E_OUT_OF_MEMORY,
- "[%s] Memory allocation failed.", GetErrorMessage(E_OUT_OF_MEMORY));
- r = pTimer->Construct(listener);
- SysTryReturn(NID_LOC, r == E_SUCCESS, r, r, "[%s] Failed to construct the timer.", GetErrorMessage(r));
-
- __pTimer = std::move(pTimer);
- }
-
- const int DEFAULT_TIME_OUT = 1000;
- r = __pTimer->Start(DEFAULT_TIME_OUT);
- SysTryReturn(NID_LOC, r == E_SUCCESS, r, r, "[%s] Failed to start the timer.", GetErrorMessage(r));
- __tickCount++;
- return E_SUCCESS;
- }
-
- bool Equals(const Tizen::Base::Runtime::Timer& timer) {return __pTimer->Equals(timer);}
-
RequestId GetRequestId(void) const {return __reqId;}
int GetTickCount(void) const {return __tickCount;}
+ void IncrementTickCount(void) { __tickCount++;}
+
bool IsInTime(const Tizen::Base::DateTime& timestamp)
{
return (timestamp > __requestTime) ? true : false;
@@ -109,7 +86,6 @@ private:
private:
Tizen::Base::DateTime __requestTime;
_LocationMonitor* __pLocMonitor;
- std::unique_ptr< Tizen::Base::Runtime::Timer > __pTimer;
RequestId __reqId;
int __tickCount;
}; //_SyncLocationRequestInfo
generated by cgit v1.2.3 (git 2.25.1) at 2024-11-25 09:31:56 +0000