1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
|
// Copyright (c) 2012 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CONTENT_BROWSER_DEVICE_ORIENTATION_MOTION_H_
#define CONTENT_BROWSER_DEVICE_ORIENTATION_MOTION_H_
#include "base/compiler_specific.h"
#include "content/browser/device_orientation/device_data.h"
#include "content/common/content_export.h"
namespace content {
class Motion : public DeviceData {
public:
// acceleration_x, acceleration_y, and acceleration_z are the accelerations
// excluding gravity along the axes specified in
// http://dev.w3.org/geo/api/spec-source-orientation.html
// acceleration_including_gravity_x, acceleration_including_gravity_y, and
// acceleration_including_gravity_z are the accelerations including gravity
// along the same axes as above
// rotation_rate_alpha, rotation_rate_beta, and rotataion_rate_gamma are the
// rotations around the same axes as above
// interval is the time interval at which data is obtained from the hardware,
// as specified in the document referenced above
// can_provide_{acceleration_x, acceleration_y, acceleration_z,
// acceleration_including_gravity_x, acceleration_including_gravity_y,
// acceleration_including_gravity_z, rotation_rate_alpha, rotation_rate_beta,
// rotation_rate_gamma, interval} is true if data can be provided for that
// variable
CONTENT_EXPORT Motion();
// From DeviceData.
virtual IPC::Message* CreateIPCMessage(int render_view_id) const OVERRIDE;
virtual bool ShouldFireEvent(const DeviceData* old_data) const OVERRIDE;
void set_acceleration_x(double acceleration_x) {
can_provide_acceleration_x_ = true;
acceleration_x_ = acceleration_x;
}
bool can_provide_acceleration_x() const {
return can_provide_acceleration_x_;
}
double acceleration_x() const { return acceleration_x_; }
void set_acceleration_y(double acceleration_y) {
can_provide_acceleration_y_ = true;
acceleration_y_ = acceleration_y;
}
bool can_provide_acceleration_y() const {
return can_provide_acceleration_y_;
}
double acceleration_y() const { return acceleration_y_; }
void set_acceleration_z(double acceleration_z) {
can_provide_acceleration_z_ = true;
acceleration_z_ = acceleration_z;
}
bool can_provide_acceleration_z() const {
return can_provide_acceleration_z_;
}
double acceleration_z() const { return acceleration_z_; }
void set_acceleration_including_gravity_x(
double acceleration_including_gravity_x) {
can_provide_acceleration_including_gravity_x_ = true;
acceleration_including_gravity_x_ = acceleration_including_gravity_x;
}
bool can_provide_acceleration_including_gravity_x() const {
return can_provide_acceleration_x_;
}
double acceleration_including_gravity_x() const {
return acceleration_including_gravity_x_;
}
void set_acceleration_including_gravity_y(
double acceleration_including_gravity_y) {
can_provide_acceleration_including_gravity_y_ = true;
acceleration_including_gravity_y_ = acceleration_including_gravity_y;
}
bool can_provide_acceleration_including_gravity_y() const {
return can_provide_acceleration_y_;
}
double acceleration_including_gravity_y() const {
return acceleration_including_gravity_y_;
}
void set_acceleration_including_gravity_z(
double acceleration_including_gravity_z) {
can_provide_acceleration_including_gravity_z_ = true;
acceleration_including_gravity_z_ = acceleration_including_gravity_z;
}
bool can_provide_acceleration_including_gravity_z() const {
return can_provide_acceleration_z_;
}
double acceleration_including_gravity_z() const {
return acceleration_including_gravity_z_;
}
void set_rotation_rate_alpha(double rotation_rate_alpha) {
can_provide_rotation_rate_alpha_ = true;
rotation_rate_alpha_ = rotation_rate_alpha;
}
bool can_provide_rotation_rate_alpha() const {
return can_provide_rotation_rate_alpha_;
}
double rotation_rate_alpha() const { return rotation_rate_alpha_; }
void set_rotation_rate_beta(double rotation_rate_beta) {
can_provide_rotation_rate_beta_ = true;
rotation_rate_beta_ = rotation_rate_beta;
}
bool can_provide_rotation_rate_beta() const {
return can_provide_rotation_rate_beta_;
}
double rotation_rate_beta() const { return rotation_rate_beta_; }
void set_rotation_rate_gamma(double rotation_rate_gamma) {
can_provide_rotation_rate_gamma_ = true;
rotation_rate_gamma_ = rotation_rate_gamma;
}
bool can_provide_rotation_rate_gamma() const {
return can_provide_rotation_rate_gamma_;
}
double rotation_rate_gamma() const { return rotation_rate_gamma_; }
void set_interval(double interval) {
can_provide_interval_ = true;
interval_ = interval;
}
bool can_provide_interval() const { return can_provide_interval_; }
double interval() const { return interval_; }
private:
virtual ~Motion();
double acceleration_x_;
double acceleration_y_;
double acceleration_z_;
double acceleration_including_gravity_x_;
double acceleration_including_gravity_y_;
double acceleration_including_gravity_z_;
double rotation_rate_alpha_;
double rotation_rate_beta_;
double rotation_rate_gamma_;
double interval_;
bool can_provide_acceleration_x_;
bool can_provide_acceleration_y_;
bool can_provide_acceleration_z_;
bool can_provide_acceleration_including_gravity_x_;
bool can_provide_acceleration_including_gravity_y_;
bool can_provide_acceleration_including_gravity_z_;
bool can_provide_rotation_rate_alpha_;
bool can_provide_rotation_rate_beta_;
bool can_provide_rotation_rate_gamma_;
bool can_provide_interval_;
};
} // namespace content
#endif // CONTENT_BROWSER_DEVICE_ORIENTATION_MOTION_H_
|
