gneiss 0.1.0

Safe Rust SDK for Pebble watchapps and watchfaces
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

//! Accelerometer readings and tap events.
use crate::sys;

/// The axis a tap was along.
pub enum Axis {
	X,
	Y,
	Z,
}

/// Which way along its [`Axis`] a tap went.
pub enum Direction {
	Positive,
	Negative,
}

#[repr(C, packed)]
#[derive(Clone, Copy)]
/// One reading of all three axes.
pub struct Sample {
	x: i16,
	y: i16,
	z: i16,
}

#[repr(C, packed)]
#[derive(Clone, Copy)]
/// A [`Sample`] with its timestamp, from [`AccelDataService`](crate::service::AccelDataService).
pub struct AccelData {
	sample:      Sample,
	did_vibrate: bool,
	timestamp:   u64,
}

impl Sample {
	pub fn x(&self) -> i16 {
		self.x
	}

	pub fn y(&self) -> i16 {
		self.y
	}

	pub fn z(&self) -> i16 {
		self.z
	}
}

impl AccelData {
	/// The reading.
	pub fn sample(&self) -> Sample {
		self.sample
	}

	pub fn x(&self) -> i16 {
		self.sample.x
	}

	pub fn y(&self) -> i16 {
		self.sample.y
	}

	pub fn z(&self) -> i16 {
		self.sample.z
	}

	/// The watch was vibrating at the time, which disturbs the reading.
	pub fn did_vibrate(&self) -> bool {
		self.did_vibrate
	}

	/// When the reading was taken, in milliseconds.
	pub fn timestamp(&self) -> u64 {
		self.timestamp
	}
}

impl From<sys::AccelAxisType> for Axis {
	fn from(value: sys::AccelAxisType) -> Self {
		match value {
			sys::AccelAxisType_ACCEL_AXIS_X => Self::X,
			sys::AccelAxisType_ACCEL_AXIS_Y => Self::Y,
			sys::AccelAxisType_ACCEL_AXIS_Z => Self::Z,
			#[expect(
				clippy::panic,
				reason = "FFI Boundary: Value outside of known variants"
			)]
			_ => panic!("Invalid Axis variant"),
		}
	}
}

impl From<Axis> for sys::AccelAxisType {
	fn from(value: Axis) -> Self {
		match value {
			Axis::X => sys::AccelAxisType_ACCEL_AXIS_X,
			Axis::Y => sys::AccelAxisType_ACCEL_AXIS_Y,
			Axis::Z => sys::AccelAxisType_ACCEL_AXIS_Z,
		}
	}
}

impl From<i32> for Direction {
	fn from(value: i32) -> Self {
		if value.is_positive() {
			Self::Positive
		} else {
			Self::Negative
		}
	}
}

impl From<Direction> for i32 {
	fn from(value: Direction) -> Self {
		match value {
			Direction::Positive => 1,
			Direction::Negative => -1,
		}
	}
}

/// The following From-by-transmute impls are only valid while these all hold.
const _PACKED_VALUE_EQ: () = {
	use core::mem::{align_of, offset_of, size_of};
	assert!(size_of::<Sample>() == size_of::<sys::AccelRawData>());
	assert!(align_of::<Sample>() == align_of::<sys::AccelRawData>());
	assert!(offset_of!(Sample, x) == offset_of!(sys::AccelRawData, x));
	assert!(offset_of!(Sample, y) == offset_of!(sys::AccelRawData, y));
	assert!(offset_of!(Sample, z) == offset_of!(sys::AccelRawData, z));

	assert!(size_of::<AccelData>() == size_of::<sys::AccelData>());
	assert!(align_of::<AccelData>() == align_of::<sys::AccelData>());
	assert!(offset_of!(AccelData, sample) == offset_of!(sys::AccelData, x));
	assert!(offset_of!(AccelData, did_vibrate) == offset_of!(sys::AccelData, did_vibrate));
	assert!(offset_of!(AccelData, timestamp) == offset_of!(sys::AccelData, timestamp));
};

impl From<sys::AccelData> for AccelData {
	fn from(value: sys::AccelData) -> Self {
		unsafe { core::mem::transmute(value) }
	}
}

impl From<sys::AccelRawData> for Sample {
	fn from(value: sys::AccelRawData) -> Self {
		unsafe { core::mem::transmute(value) }
	}
}