← Back to branch summary

~thomas-voss/location-service/fix-1347887

« back to all changes in this revision

Viewing changes to src/location_service/com/ubuntu/location/provider.cpp

This MP consolidates multiple related changes together, with the goal of:

(1.) Make the service instance accessible via a cli. Useful for testing scenarios.
(2.) To cut down time-to-first-fix (ttff) by:
  (2.1) Leveraging SUPL and other supplementary data downloaded over ordinary data connections.
  (2.2) Enabling network-based positioning providers to acquire fast position estimates.

In more detail:

* Added tests for daemon and cli.
* Unified daemon and cli header and implementation files.
* Add a command-line interface to the service.
* Split up provider selection policy to rely on an interface ProviderEnumerator to ease in testing.
* Trimmed down on types.
* Removed connectivity API draft to prepare for simpler approach.
* Refactored includes.
* Added a configuration option to handle cell and wifi ID reporting.
* Add a mock for a connectivity API exposed to providers and reporters.
* Add units for connectivity api.
* Refactor cell class into namespace radio. Fixes: 1226204, 1248973, 1281817

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/location_service/com/ubuntu/location/provider.cpp
15
15
 *
16
16
 * Authored by: Thomas Voß <thomas.voss@canonical.com>
17
17
 */
18
 
#include "com/ubuntu/location/provider.h"
 
18
#include <com/ubuntu/location/provider.h>
19
19
 
20
20
#include <atomic>
21
21
#include <bitset>
86
86
    return velocity_updates_counter > 0;
87
87
}
88
88
 
89
 
const cul::Provider::Controller::Cache<cul::Update<cul::Position>>& cul::Provider::Controller::cached_position_update() const
90
 
{
91
 
    return cached.position;
92
 
}
93
 
 
94
 
const cul::Provider::Controller::Cache<cul::Update<cul::Heading>>& cul::Provider::Controller::cached_heading_update() const
95
 
{
96
 
    return cached.heading;
97
 
}
98
 
 
99
 
const cul::Provider::Controller::Cache<cul::Update<cul::Velocity>>& cul::Provider::Controller::cached_velocity_update() const
100
 
{
101
 
    return cached.velocity;
102
 
}
103
 
 
104
89
cul::Provider::Controller::Controller(cul::Provider& instance)
105
90
    : instance(instance),
106
91
      position_updates_counter(0),
107
92
      heading_updates_counter(0),
108
 
      velocity_updates_counter(0),
109
 
      cached
110
 
      {
111
 
          Cache<Update<Position>>{},
112
 
          Cache<Update<Velocity>>{},
113
 
          Cache<Update<Heading>>{}
114
 
      }
115
 
{
116
 
    position_update_connection =
117
 
            instance.subscribe_to_position_updates(
118
 
                std::bind(&Controller::on_position_updated,
119
 
                          this,
120
 
                          std::placeholders::_1));
121
 
 
122
 
    velocity_update_connection =
123
 
            instance.subscribe_to_velocity_updates(
124
 
                std::bind(&Controller::on_velocity_updated,
125
 
                          this,
126
 
                          std::placeholders::_1));
127
 
 
128
 
    heading_update_connection =
129
 
            instance.subscribe_to_heading_updates(
130
 
                std::bind(&Controller::on_heading_updated,
131
 
                          this,
132
 
                          std::placeholders::_1));
133
 
}
134
 
 
135
 
void cul::Provider::Controller::on_position_updated(const cul::Update<cul::Position>& position)
136
 
{
137
 
    cached.position.update(position);
138
 
}
139
 
 
140
 
void cul::Provider::Controller::on_velocity_updated(const cul::Update<cul::Velocity>& velocity)
141
 
{
142
 
    cached.velocity.update(velocity);
143
 
}
144
 
 
145
 
void cul::Provider::Controller::on_heading_updated(const cul::Update<cul::Heading>& heading)
146
 
{
147
 
    cached.heading.update(heading);
 
93
      velocity_updates_counter(0)
 
94
{
148
95
}
149
96
 
150
97
const cul::Provider::Controller::Ptr& cul::Provider::state_controller() const
151
98
{
152
 
    return controller;
153
 
}
154
 
 
155
 
cul::ChannelConnection cul::Provider::subscribe_to_position_updates(std::function<void(const cul::Update<cul::Position>&)> f)
156
 
{
157
 
    return position_updates_channel.connect(f);
158
 
}
159
 
 
160
 
cul::ChannelConnection cul::Provider::subscribe_to_heading_updates(std::function<void(const cul::Update<cul::Heading>&)> f)
161
 
{
162
 
    return heading_updates_channel.connect(f);
163
 
}
164
 
 
165
 
cul::ChannelConnection cul::Provider::subscribe_to_velocity_updates(std::function<void(const cul::Update<cul::Velocity>&)> f)
166
 
{
167
 
    return velocity_updates_channel.connect(f);
168
 
}
169
 
 
170
 
bool cul::Provider::supports(const cul::Provider::Feature& f) const
171
 
{
172
 
    return feature_flags.test(static_cast<std::size_t>(f));
173
 
}
174
 
 
175
 
bool cul::Provider::requires(const cul::Provider::Requirement& r) const
176
 
{
177
 
    return requirement_flags.test(static_cast<std::size_t>(r));
 
99
    return d.controller;
 
100
}
 
101
 
 
102
bool cul::Provider::supports(const cul::Provider::Features& f) const
 
103
{
 
104
    return (d.features & f) != Features::none;
 
105
}
 
106
 
 
107
bool cul::Provider::requires(const cul::Provider::Requirements& r) const
 
108
{
 
109
    return (d.requirements & r) != Requirements::none;
178
110
}
179
111
 
180
112
bool cul::Provider::matches_criteria(const cul::Criteria&)
182
114
    return false;
183
115
}
184
116
 
 
117
const cul::Provider::Updates& cul::Provider::updates() const
 
118
{
 
119
    return d.updates;
 
120
}
 
121
 
185
122
cul::Provider::Provider(
186
 
    const cul::Provider::FeatureFlags& feature_flags,
187
 
    const cul::Provider::RequirementFlags& requirement_flags)
188
 
    : feature_flags(feature_flags),
189
 
      requirement_flags(requirement_flags),
190
 
      controller(new Controller(*this))
191
 
{
192
 
}
193
 
 
194
 
void cul::Provider::deliver_position_updates(const cul::Update<cul::Position>& update)
195
 
{
196
 
    position_updates_channel(update);
197
 
}
198
 
 
199
 
void cul::Provider::deliver_heading_updates(const cul::Update<cul::Heading>& update)
200
 
{
201
 
    heading_updates_channel(update);
202
 
}
203
 
 
204
 
void cul::Provider::deliver_velocity_updates(const cul::Update<cul::Velocity>& update)
205
 
{
206
 
    velocity_updates_channel(update);
 
123
    const cul::Provider::Features& features,
 
124
    const cul::Provider::Requirements& requirements)
 
125
{
 
126
    d.features = features;
 
127
    d.requirements = requirements;
 
128
    d.controller = std::shared_ptr<Provider::Controller>(new Provider::Controller(*this));
 
129
}
 
130
 
 
131
cul::Provider::Updates& cul::Provider::mutable_updates()
 
132
{
 
133
    return d.updates;
 
134
}
 
135
 
 
136
void cul::Provider::on_wifi_and_cell_reporting_state_changed(cul::WifiAndCellIdReportingState)
 
137
{
 
138
}
 
139
 
 
140
void cul::Provider::on_reference_location_updated(const cul::Update<cul::Position>&)
 
141
{
 
142
}
 
143
 
 
144
void cul::Provider::on_reference_velocity_updated(const cul::Update<cul::Velocity>&)
 
145
{
 
146
}
 
147
 
 
148
void cul::Provider::on_reference_heading_updated(const cul::Update<cul::Heading>&)
 
149
{
207
150
}
208
151
 
209
152
void cul::Provider::start_position_updates() {}
212
155
void cul::Provider::stop_heading_updates() {}
213
156
void cul::Provider::start_velocity_updates() {}
214
157
void cul::Provider::stop_velocity_updates() {}
 
158
 
 
159
cul::Provider::Features cul::operator|(cul::Provider::Features lhs, cul::Provider::Features rhs)
 
160
{
 
161
    return static_cast<cul::Provider::Features>(static_cast<unsigned int>(lhs) | static_cast<unsigned int>(rhs));
 
162
}
 
163
 
 
164
cul::Provider::Features cul::operator&(cul::Provider::Features lhs, cul::Provider::Features rhs)
 
165
{
 
166
    return static_cast<cul::Provider::Features>(static_cast<unsigned int>(lhs) & static_cast<unsigned int>(rhs));
 
167
}
 
168
 
 
169
cul::Provider::Requirements cul::operator|(cul::Provider::Requirements lhs, cul::Provider::Requirements rhs)
 
170
{
 
171
    return static_cast<cul::Provider::Requirements>(static_cast<unsigned int>(lhs) | static_cast<unsigned int>(rhs));
 
172
}
 
173
 
 
174
cul::Provider::Requirements cul::operator&(cul::Provider::Requirements lhs, cul::Provider::Requirements rhs)
 
175
{
 
176
    return static_cast<cul::Provider::Requirements>(static_cast<unsigned int>(lhs) & static_cast<unsigned int>(rhs));
 
177
}