// found in the LICENSE file.
#include "browser/geolocation/location_provider_efl.h"
-
#include "base/bind.h"
#include "base/logging.h"
#include "base/time/time.h"
-#include "base/message_loop/message_loop.h"
-#include "content/public/common/geoposition.h"
-namespace content {
+#include "services/device/public/cpp/geolocation/geolocation_manager.h"
-LocationProviderEfl::LocationProviderEfl()
- : LocationProviderBase()
- , location_manager_(NULL)
- , geolocation_message_loop_(base::MessageLoop::current()) {
+namespace device {
+
+static double KilometerPerHourToMeterPerSecond(double kilometer_per_hour) {
+ return kilometer_per_hour * 5 / 18;
}
+LocationProviderEfl::LocationProviderEfl()
+ : location_manager_(nullptr),
+ task_runner_(base::ThreadTaskRunnerHandle::Get()) {}
+
LocationProviderEfl::~LocationProviderEfl() {
StopProvider();
}
// static
-void LocationProviderEfl::GeoPositionChangedCb(
- double latitude, double longitude, double altitude,
- time_t timestamp, void* user_data) {
+void LocationProviderEfl::GeoPositionChangedCb(double latitude,
+ double longitude,
+ double altitude,
+ double speed,
+ double direction,
+ double horizontal_accuracy,
+ time_t timestamp,
+ void* user_data) {
LocationProviderEfl* location_provider =
static_cast<LocationProviderEfl*>(user_data);
DCHECK(location_provider);
- location_provider->NotifyPositionChanged(
- latitude, longitude, altitude, timestamp);
+ location_provider->NotifyPositionChanged(latitude, longitude, altitude, speed,
+ direction, horizontal_accuracy,
+ timestamp);
+}
+void LocationProviderEfl::NotifyCallback(const mojom::Geoposition& position) {
+ if (!callback_.is_null())
+ callback_.Run(this, position);
}
-void LocationProviderEfl::NotifyPositionChanged(
- double latitude, double longitude, double altitude, time_t timestamp) {
- location_accuracy_level_e level;
+void LocationProviderEfl::SetUpdateCallback(
+ const LocationProviderUpdateCallback& callback) {
+ callback_ = callback;
+}
+void LocationProviderEfl::NotifyPositionChanged(double latitude,
+ double longitude,
+ double altitude,
+ double speed,
+ double direction,
+ double horizontal_accuracy,
+ time_t timestamp) {
DCHECK(location_manager_);
- DCHECK(geolocation_message_loop_);
+ DCHECK(task_runner_);
last_position_.latitude = latitude;
last_position_.longitude = longitude;
+ last_position_.altitude = altitude;
last_position_.timestamp = base::Time::FromTimeT(timestamp);
+ last_position_.speed = KilometerPerHourToMeterPerSecond(speed);
+ last_position_.heading = direction;
+ location_accuracy_level_e level;
location_manager_get_last_accuracy(location_manager_,
&level, &last_position_.accuracy, &last_position_.altitude_accuracy);
- base::Closure task = base::BindOnce(&LocationProviderEfl::NotifyCallback,
- base::Unretained(this), last_position_);
- geolocation_message_loop_->PostTask(FROM_HERE, task);
+ base::OnceClosure task =
+ base::BindOnce(&LocationProviderEfl::NotifyCallback,
+ base::Unretained(this), last_position_);
+ task_runner_->PostTask(FROM_HERE, std::move(task));
}
-bool LocationProviderEfl::StartProvider(bool high_accuracy) {
+void LocationProviderEfl::StartProvider(bool high_accuracy) {
if (location_manager_) {
// already started!
- return false;
+ return;
}
int ret = location_manager_create(LOCATIONS_METHOD_HYBRID, &location_manager_);
if (ret != LOCATIONS_ERROR_NONE) {
LOG(ERROR) << "Failed to create location manager!";
- return false;
+ return;
}
- ret = location_manager_set_position_updated_cb(
- location_manager_, GeoPositionChangedCb, 1, this);
+ ret = location_manager_set_location_changed_cb(location_manager_,
+ GeoPositionChangedCb, 1, this);
if (ret != LOCATIONS_ERROR_NONE) {
LOG(ERROR) << "Failed to register position changed callback!";
location_manager_destroy(location_manager_);
- location_manager_ = NULL;
- return false;
+ location_manager_ = nullptr;
+ return;
}
ret = static_cast<location_error_e>(location_manager_start(location_manager_));
LOG(ERROR) << "Failed to start location manager: " << ret;
location_manager_unset_position_updated_cb(location_manager_);
location_manager_destroy(location_manager_);
- location_manager_ = NULL;
- return false;
+ location_manager_ = nullptr;
}
-
- return true;
}
void LocationProviderEfl::StopProvider() {
- if (location_manager_) {
- int ret = location_manager_stop(location_manager_);
- if (ret == LOCATIONS_ERROR_NONE) {
- location_manager_unset_position_updated_cb(location_manager_);
- }
+ if (!location_manager_)
+ return;
- // TODO: didn't stop but destroy?
- location_manager_destroy(location_manager_);
- location_manager_ = NULL;
- }
-}
+ int ret = location_manager_stop(location_manager_);
+ if (ret == LOCATIONS_ERROR_NONE)
+ location_manager_unset_position_updated_cb(location_manager_);
-void LocationProviderEfl::GetPosition(Geoposition* position) {
- DCHECK(position);
- *position = last_position_;
+ // TODO: didn't stop but destroy?
+ location_manager_destroy(location_manager_);
+ location_manager_ = nullptr;
}
-void LocationProviderEfl::RequestRefresh() {
+const mojom::Geoposition& LocationProviderEfl::GetPosition() {
+ return last_position_;
}
void LocationProviderEfl::OnPermissionGranted() {
}
-//static
-LocationProvider* LocationProviderEfl::Create() {
- return new LocationProviderEfl();
+std::unique_ptr<LocationProvider> NewSystemLocationProvider(
+ scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
+ GeolocationManager* geolocation_manager) {
+ return base::WrapUnique(new LocationProviderEfl());
}
-} // namespace content
+} // namespace device
#define LOCATION_PROVIDER_EFL_H_
#include "base/compiler_specific.h"
-#include "content/browser/geolocation/location_provider_base.h"
-#include "content/public/common/geoposition.h"
+#include "base/memory/ptr_util.h"
+#include "services/device/geolocation/geolocation_provider.h"
+#include "services/device/public/cpp/geolocation/geoposition.h"
+#include "services/device/public/cpp/geolocation/location_provider.h"
#include <location/locations.h>
-namespace base {
-class MessageLoop;
-}
+namespace device {
-namespace content {
-
-class LocationProviderEfl : public LocationProviderBase {
+class LocationProviderEfl : public LocationProvider {
public:
- virtual ~LocationProviderEfl();
+ LocationProviderEfl();
+ ~LocationProviderEfl() override;
- static LocationProvider* Create();
+ void SetUpdateCallback(
+ const LocationProviderUpdateCallback& callback) override;
+ void StartProvider(bool high_accuracy) override;
+ void StopProvider() override;
+ const mojom::Geoposition& GetPosition() override;
- virtual bool StartProvider(bool high_accuracy) override;
- virtual void StopProvider() override;
- virtual void GetPosition(Geoposition* position) override;
- virtual void RequestRefresh() override;
- virtual void OnPermissionGranted() override;
+ void OnPermissionGranted() override;
private:
- LocationProviderEfl();
-
LocationProviderEfl(const LocationProviderEfl&) = delete;
LocationProviderEfl& operator=(const LocationProviderEfl&) = delete;
- static void GeoPositionChangedCb(double, double, double, time_t, void*);
- void NotifyPositionChanged(double, double, double, time_t);
-
- Geoposition last_position_;
+ static void GeoPositionChangedCb(double,
+ double,
+ double,
+ double,
+ double,
+ double,
+ time_t,
+ void*);
+ void
+ NotifyPositionChanged(double, double, double, double, double, double, time_t);
+ void NotifyCallback(const mojom::Geoposition&);
+
+ mojom::Geoposition last_position_;
location_manager_h location_manager_;
- base::MessageLoop* geolocation_message_loop_;
+ scoped_refptr<base::SingleThreadTaskRunner> task_runner_;
+ LocationProviderUpdateCallback callback_;
};
-} // namespace content
+} // namespace device
#endif // LOCATION_PROVIDER_EFL_H_
projects / platform / framework / web / chromium-efl.git / commitdiff