← Back to branch summary

~sil2100/location-service/gps-arm64

« back to all changes in this revision

Viewing changes to include/location_service/com/ubuntu/location/provider.h

  • Committer: Thomas Voß
  • Date: 2013-05-28 14:20:45 UTC
  • Revision ID: thomas.voss@canonical.com-20130528142045-kq5umqdmm4o53vwk
Initial push.

Show diffs side-by-side

added added

removed removed

Lines of Context:
include/location_service/com/ubuntu/location/provider.h
 
1
#ifndef LOCATION_SERVICE_COM_UBUNTU_LOCATION_PROVIDER_H_
 
2
#define LOCATION_SERVICE_COM_UBUNTU_LOCATION_PROVIDER_H_
 
3
 
 
4
#include "com/ubuntu/location/channel.h"
 
5
#include "com/ubuntu/location/criteria.h"
 
6
#include "com/ubuntu/location/heading.h"
 
7
#include "com/ubuntu/location/position.h"
 
8
#include "com/ubuntu/location/update.h"
 
9
#include "com/ubuntu/location/velocity.h"
 
10
 
 
11
#include <atomic>
 
12
#include <bitset>
 
13
#include <memory>
 
14
 
 
15
namespace com
 
16
{
 
17
namespace ubuntu
 
18
{
 
19
namespace location
 
20
{
 
21
class Provider
 
22
{
 
23
public:
 
24
    typedef std::shared_ptr<Provider> Ptr;
 
25
 
 
26
    enum class Feature : std::size_t
 
27
    {
 
28
        position,
 
29
        velocity,
 
30
        heading
 
31
    };
 
32
 
 
33
    typedef std::bitset<3> FeatureFlags;
 
34
 
 
35
    enum class Requirement : std::size_t
 
36
    {
 
37
        satellites,
 
38
        cell_network,
 
39
        data_network,
 
40
        monetary_spending
 
41
    };
 
42
 
 
43
    typedef std::bitset<4> RequirementFlags;
 
44
 
 
45
    class Controller
 
46
    {
 
47
    public:
 
48
        typedef std::shared_ptr<Controller> Ptr;
 
49
 
 
50
        template<typename T> 
 
51
        class Cache
 
52
        {
 
53
          public:
 
54
            Cache() : d{ T{}, false }
 
55
            {
 
56
            }
 
57
            const T& value() const { return d.value; }
 
58
            void update(const T& new_value) { d.value = new_value; d.is_valid = true; }
 
59
            bool is_valid() const { return d.is_valid; }
 
60
            void invalidate() { d.is_valid = false; }
 
61
 
 
62
          private:
 
63
            struct
 
64
            {
 
65
                T value;
 
66
                bool is_valid;
 
67
            } d;
 
68
        };
 
69
 
 
70
        virtual ~Controller() = default;
 
71
        Controller(const Controller&) = delete;
 
72
        Controller& operator=(const Controller&) = delete;
 
73
 
 
74
        virtual void start_position_updates();
 
75
        virtual void stop_position_updates();
 
76
        bool are_position_updates_running() const;
 
77
 
 
78
        virtual void start_heading_updates();
 
79
        virtual void stop_heading_updates();
 
80
        bool are_heading_updates_running() const;
 
81
 
 
82
        virtual void start_velocity_updates();
 
83
        virtual void stop_velocity_updates();
 
84
        bool are_velocity_updates_running() const;
 
85
 
 
86
        const Cache<Update<Position>>& cached_position_update() const;
 
87
        const Cache<Update<Heading>>& cached_heading_update() const;
 
88
        const Cache<Update<Velocity>>& cached_velocity_update() const;
 
89
 
 
90
    protected:
 
91
        friend class Provider;
 
92
        explicit Controller(Provider& instance);
 
93
 
 
94
    private:
 
95
        void on_position_updated(const Update<Position>& position);
 
96
        void on_velocity_updated(const Update<Velocity>& velocity);
 
97
        void on_heading_updated(const Update<Heading>& heading);
 
98
 
 
99
        Provider& instance;
 
100
        std::atomic<int> position_updates_counter;
 
101
        std::atomic<int> heading_updates_counter;
 
102
        std::atomic<int> velocity_updates_counter;
 
103
        ScopedChannelConnection position_update_connection;
 
104
        ScopedChannelConnection velocity_update_connection;
 
105
        ScopedChannelConnection heading_update_connection;
 
106
        struct
 
107
        {
 
108
            Cache<Update<Position>> position;
 
109
            Cache<Update<Velocity>> velocity;
 
110
            Cache<Update<Heading>> heading;            
 
111
        } cached;
 
112
    };
 
113
 
 
114
    virtual ~Provider() = default;
 
115
 
 
116
    Provider(const Provider&) = delete;
 
117
    Provider& operator=(const Provider&) = delete;
 
118
 
 
119
    virtual const Controller::Ptr& state_controller() const;
 
120
 
 
121
    virtual ChannelConnection subscribe_to_position_updates(std::function<void(const Update<Position>&)> f);
 
122
    virtual ChannelConnection subscribe_to_heading_updates(std::function<void(const Update<Heading>&)> f);
 
123
    virtual ChannelConnection subscribe_to_velocity_updates(std::function<void(const Update<Velocity>&)> f);
 
124
 
 
125
    virtual bool supports(const Feature& f) const;
 
126
    virtual bool requires(const Requirement& r) const;
 
127
 
 
128
    virtual bool matches_criteria(const Criteria&);
 
129
    
 
130
protected:
 
131
    explicit Provider(
 
132
        const FeatureFlags& feature_flags = FeatureFlags(),
 
133
        const RequirementFlags& requirement_flags = RequirementFlags());
 
134
 
 
135
    void deliver_position_updates(const Update<Position>& update);
 
136
    void deliver_heading_updates(const Update<Heading>& update);
 
137
    void deliver_velocity_updates(const Update<Velocity>& update);
 
138
    
 
139
    virtual void start_position_updates();
 
140
    virtual void stop_position_updates();
 
141
 
 
142
    virtual void start_heading_updates();
 
143
    virtual void stop_heading_updates();
 
144
 
 
145
    virtual void start_velocity_updates();
 
146
    virtual void stop_velocity_updates();
 
147
 
 
148
private:
 
149
    FeatureFlags feature_flags;
 
150
    RequirementFlags requirement_flags;
 
151
    Channel<Update<Position>> position_updates_channel;
 
152
    Channel<Update<Heading>> heading_updates_channel;
 
153
    Channel<Update<Velocity>> velocity_updates_channel;
 
154
    Controller::Ptr controller;
 
155
};
 
156
}
 
157
}
 
158
}
 
159
 
 
160
#endif // LOCATION_SERVICE_COM_UBUNTU_LOCATION_PROVIDER_H_