buttplug.io
Buttplug sex toy control library
feat: Add per-output-type-property configurations
Instead of just having a single configuration that's settable in any output,
allow all fields to be limitable.
qdot.tngl.sh
+21
buttplug-user-device-config-v4.json
+21
buttplug-user-device-config-v4.json
+32
-12
crates/buttplug_core/schema/buttplug-schema.json
+32
-12
crates/buttplug_core/schema/buttplug-schema.json
···
306
"type": "string"
307
},
308
"Output": {
309
-
"type": "object",
310
-
"patternProperties": {
311
-
"^.*$": {
312
-
"type": "object",
313
-
"properties": {
314
-
"StepCount": {
315
-
"type": "integer"
316
-
}
317
},
318
-
"required": [
319
-
"StepCount"
320
-
]
321
-
}
322
}
323
},
324
"Input": {
···
306
"type": "string"
307
},
308
"Output": {
309
+
"type": "array",
310
+
"items": {
311
+
"type": "object",
312
+
"patternProperties": {
313
+
"^(Vibrate|Rotate|Oscillate|Constrict|Spray|Position|Heater|Led)$": {
314
+
"type": "object",
315
+
"properties": {
316
+
"Value": {
317
+
"$ref": "#/components/RangeInclusive"
318
+
}
319
+
},
320
+
"required": [
321
+
"Value"
322
+
]
323
},
324
+
"PositionWithDuration": {
325
+
"type": "object",
326
+
"properties": {
327
+
"Position": {
328
+
"$ref": "#/components/RangeInclusive"
329
+
},
330
+
"Duration": {
331
+
"$ref": "#/components/RangeInclusive"
332
+
}
333
+
},
334
+
"required": [
335
+
"Position",
336
+
"Duration"
337
+
]
338
+
}
339
+
},
340
+
"minProperties": 1,
341
+
"maxProperties": 1
342
}
343
},
344
"Input": {
+78
-13
crates/buttplug_core/src/message/device_feature.rs
+78
-13
crates/buttplug_core/src/message/device_feature.rs
···
9
use getset::{CopyGetters, Getters, MutGetters, Setters};
10
use serde::{ser::SerializeSeq, Deserialize, Serialize, Serializer};
11
use std::{
12
-
collections::{HashMap, HashSet},
13
-
ops::RangeInclusive,
14
};
15
16
#[derive(Debug, Display, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Hash, EnumIter)]
···
70
// then we denote this by prefixing the type with Client/Server. Server attributes will usually be
71
// hosted in the server/device/configuration module.
72
#[derive(
73
-
Clone, Debug, Default, PartialEq, Getters, MutGetters, CopyGetters, Setters, Serialize, Deserialize,
74
)]
75
pub struct DeviceFeature {
76
// Index of the feature on the device. This was originally implicit as the position in the feature
···
83
#[serde(default)]
84
#[serde(rename = "FeatureDescription")]
85
description: String,
86
#[getset(get = "pub")]
87
#[serde(skip_serializing_if = "Option::is_none")]
88
#[serde(rename = "Output")]
89
-
output: Option<HashMap<OutputType, DeviceFeatureOutput>>,
90
#[getset(get = "pub")]
91
#[serde(skip_serializing_if = "Option::is_none")]
92
#[serde(rename = "Input")]
···
97
pub fn new(
98
index: u32,
99
description: &str,
100
-
output: &Option<HashMap<OutputType, DeviceFeatureOutput>>,
101
input: &Option<HashMap<InputType, DeviceFeatureInput>>,
102
) -> Self {
103
Self {
···
123
seq.end()
124
}
125
126
-
#[derive(Clone, Debug, PartialEq, Eq, CopyGetters, Serialize, Deserialize)]
127
-
pub struct DeviceFeatureOutput {
128
-
#[getset(get_copy = "pub")]
129
-
#[serde(rename = "StepCount")]
130
-
step_count: u32,
131
}
132
133
-
impl DeviceFeatureOutput {
134
-
pub fn new(step_count: u32) -> Self {
135
-
Self { step_count }
136
}
137
}
138
···
9
use getset::{CopyGetters, Getters, MutGetters, Setters};
10
use serde::{ser::SerializeSeq, Deserialize, Serialize, Serializer};
11
use std::{
12
+
collections::{HashMap, HashSet}, hash::Hash, ops::RangeInclusive
13
};
14
15
#[derive(Debug, Display, Clone, Copy, PartialEq, Eq, Serialize, Deserialize, Hash, EnumIter)]
···
69
// then we denote this by prefixing the type with Client/Server. Server attributes will usually be
70
// hosted in the server/device/configuration module.
71
#[derive(
72
+
Clone, Debug, Default, Getters, MutGetters, CopyGetters, Setters, Serialize, Deserialize,
73
)]
74
pub struct DeviceFeature {
75
// Index of the feature on the device. This was originally implicit as the position in the feature
···
82
#[serde(default)]
83
#[serde(rename = "FeatureDescription")]
84
description: String,
85
+
// TODO Maybe make this its own object instead of a HashMap?
86
#[getset(get = "pub")]
87
#[serde(skip_serializing_if = "Option::is_none")]
88
#[serde(rename = "Output")]
89
+
output: Option<HashSet<DeviceFeatureOutput>>,
90
#[getset(get = "pub")]
91
#[serde(skip_serializing_if = "Option::is_none")]
92
#[serde(rename = "Input")]
···
97
pub fn new(
98
index: u32,
99
description: &str,
100
+
output: &Option<HashSet<DeviceFeatureOutput>>,
101
input: &Option<HashMap<InputType, DeviceFeatureInput>>,
102
) -> Self {
103
Self {
···
123
seq.end()
124
}
125
126
+
#[derive(Serialize, Deserialize, Clone, Debug, Getters)]
127
+
pub struct DeviceFeatureOutputValueProperties {
128
+
#[getset(get = "pub")]
129
+
#[serde(rename = "Value")]
130
+
value: RangeInclusive<i32>,
131
+
}
132
+
133
+
impl DeviceFeatureOutputValueProperties {
134
+
pub fn new(value: &RangeInclusive<i32>) -> Self {
135
+
DeviceFeatureOutputValueProperties { value: value.clone() }
136
+
}
137
+
}
138
+
139
+
#[derive(Serialize, Deserialize, Clone, Debug, Getters)]
140
+
pub struct DeviceFeatureOutputPositionWithDurationProperties {
141
+
#[getset(get = "pub")]
142
+
#[serde(rename = "Position")]
143
+
position: RangeInclusive<u32>,
144
+
#[getset(get = "pub")]
145
+
#[serde(rename = "Duration")]
146
+
duration: RangeInclusive<u32>,
147
+
}
148
+
149
+
impl DeviceFeatureOutputPositionWithDurationProperties {
150
+
pub fn new(position: &RangeInclusive<u32>, duration: &RangeInclusive<u32>) -> Self {
151
+
DeviceFeatureOutputPositionWithDurationProperties { position: position.clone(), duration: duration.clone() }
152
+
}
153
+
}
154
+
155
+
#[derive(Serialize, Deserialize, Clone, Debug)]
156
+
pub enum DeviceFeatureOutput {
157
+
Unknown,
158
+
Vibrate(DeviceFeatureOutputValueProperties),
159
+
Rotate(DeviceFeatureOutputValueProperties),
160
+
RotateWithDirection(DeviceFeatureOutputValueProperties),
161
+
Oscillate(DeviceFeatureOutputValueProperties),
162
+
Constrict(DeviceFeatureOutputValueProperties),
163
+
Heater(DeviceFeatureOutputValueProperties),
164
+
Led(DeviceFeatureOutputValueProperties),
165
+
Position(DeviceFeatureOutputValueProperties),
166
+
PositionWithDuration(DeviceFeatureOutputPositionWithDurationProperties),
167
+
Spray(DeviceFeatureOutputValueProperties),
168
+
}
169
+
170
+
impl From<&DeviceFeatureOutput> for OutputType {
171
+
fn from(value: &DeviceFeatureOutput) -> Self {
172
+
match value {
173
+
DeviceFeatureOutput::Constrict(_) => OutputType::Constrict,
174
+
DeviceFeatureOutput::Heater(_) => OutputType::Heater,
175
+
DeviceFeatureOutput::Led(_) => OutputType::Led,
176
+
DeviceFeatureOutput::Oscillate(_) => OutputType::Oscillate,
177
+
DeviceFeatureOutput::Position(_) => OutputType::Position,
178
+
DeviceFeatureOutput::PositionWithDuration(_) => OutputType::PositionWithDuration,
179
+
DeviceFeatureOutput::Rotate(_) => OutputType::Rotate,
180
+
DeviceFeatureOutput::RotateWithDirection(_) => OutputType::RotateWithDirection,
181
+
DeviceFeatureOutput::Spray(_) => OutputType::Spray,
182
+
DeviceFeatureOutput::Unknown => OutputType::Unknown,
183
+
DeviceFeatureOutput::Vibrate(_) => OutputType::Vibrate
184
+
}
185
+
}
186
}
187
188
+
impl PartialEq for DeviceFeatureOutput {
189
+
fn eq(&self, other: &Self) -> bool {
190
+
// Just make sure our two DeviceFeatureOutput's are the same variant, their values may not match
191
+
// but we should never store two of the same variant in the same structure.
192
+
std::mem::discriminant(self) == std::mem::discriminant(other)
193
+
}
194
+
}
195
+
196
+
impl Eq for DeviceFeatureOutput {}
197
+
198
+
impl Hash for DeviceFeatureOutput {
199
+
fn hash<H: std::hash::Hasher>(&self, state: &mut H) {
200
+
OutputType::from(self).hash(state)
201
}
202
}
203
+1
-1
crates/buttplug_server/src/message/mod.rs
+1
-1
crates/buttplug_server/src/message/mod.rs
+14
-14
crates/buttplug_server_device_config/build-config/buttplug-device-config-v4.json
+14
-14
crates/buttplug_server_device_config/build-config/buttplug-device-config-v4.json
···
1
{
2
"version": {
3
"major": 4,
4
-
"minor": 62
5
},
6
"protocols": {
7
"activejoy": {
···
10042
"output": {
10043
"rotate_with_direction": {
10044
"value": [
10045
-
0,
10046
20
10047
]
10048
}
···
10574
"output": {
10575
"rotate_with_direction": {
10576
"value": [
10577
-
0,
10578
20
10579
]
10580
}
···
10920
"output": {
10921
"rotate_with_direction": {
10922
"value": [
10923
-
0,
10924
20
10925
]
10926
}
···
11325
"output": {
11326
"rotate_with_direction": {
11327
"value": [
11328
-
0,
11329
20
11330
]
11331
}
···
13297
"output": {
13298
"rotate_with_direction": {
13299
"value": [
13300
-
0,
13301
255
13302
]
13303
}
···
13916
"output": {
13917
"rotate_with_direction": {
13918
"value": [
13919
-
0,
13920
2
13921
]
13922
}
···
18226
"output": {
18227
"rotate_with_direction": {
18228
"value": [
18229
-
0,
18230
6
18231
]
18232
}
···
18463
"output": {
18464
"rotate_with_direction": {
18465
"value": [
18466
-
0,
18467
100
18468
]
18469
}
···
18778
"output": {
18779
"rotate_with_direction": {
18780
"value": [
18781
-
0,
18782
10
18783
]
18784
}
···
18859
"output": {
18860
"rotate_with_direction": {
18861
"value": [
18862
-
0,
18863
99
18864
]
18865
}
···
18880
"output": {
18881
"rotate_with_direction": {
18882
"value": [
18883
-
0,
18884
99
18885
]
18886
}
···
18901
"output": {
18902
"rotate_with_direction": {
18903
"value": [
18904
-
0,
18905
99
18906
]
18907
}
···
18912
"output": {
18913
"rotate_with_direction": {
18914
"value": [
18915
-
0,
18916
99
18917
]
18918
}
···
1
{
2
"version": {
3
"major": 4,
4
+
"minor": 63
5
},
6
"protocols": {
7
"activejoy": {
···
10042
"output": {
10043
"rotate_with_direction": {
10044
"value": [
10045
+
-20,
10046
20
10047
]
10048
}
···
10574
"output": {
10575
"rotate_with_direction": {
10576
"value": [
10577
+
-20,
10578
20
10579
]
10580
}
···
10920
"output": {
10921
"rotate_with_direction": {
10922
"value": [
10923
+
-20,
10924
20
10925
]
10926
}
···
11325
"output": {
11326
"rotate_with_direction": {
11327
"value": [
11328
+
-20,
11329
20
11330
]
11331
}
···
13297
"output": {
13298
"rotate_with_direction": {
13299
"value": [
13300
+
-255,
13301
255
13302
]
13303
}
···
13916
"output": {
13917
"rotate_with_direction": {
13918
"value": [
13919
+
-2,
13920
2
13921
]
13922
}
···
18226
"output": {
18227
"rotate_with_direction": {
18228
"value": [
18229
+
-6,
18230
6
18231
]
18232
}
···
18463
"output": {
18464
"rotate_with_direction": {
18465
"value": [
18466
+
-100,
18467
100
18468
]
18469
}
···
18778
"output": {
18779
"rotate_with_direction": {
18780
"value": [
18781
+
-10,
18782
10
18783
]
18784
}
···
18859
"output": {
18860
"rotate_with_direction": {
18861
"value": [
18862
+
-99,
18863
99
18864
]
18865
}
···
18880
"output": {
18881
"rotate_with_direction": {
18882
"value": [
18883
+
-99,
18884
99
18885
]
18886
}
···
18901
"output": {
18902
"rotate_with_direction": {
18903
"value": [
18904
+
-99,
18905
99
18906
]
18907
}
···
18912
"output": {
18913
"rotate_with_direction": {
18914
"value": [
18915
+
-99,
18916
99
18917
]
18918
}
+40
-35
crates/buttplug_server_device_config/device-config-v4/buttplug-device-config-schema-v4.json
+40
-35
crates/buttplug_server_device_config/device-config-v4/buttplug-device-config-schema-v4.json
···
241
],
242
"additionalProperties": false
243
}
244
-
}
245
},
246
-
"feature-settings": {
247
"type": "object",
248
"properties": {
249
-
"alt-protocol-index": {
250
"type": "number"
251
}
252
}
···
255
"required": [
256
"id"
257
],
258
-
"additionalProperties": false
259
}
260
},
261
"user-config-features": {
···
295
"properties": {
296
"value": {
297
"$ref": "#/components/value-range"
298
-
},
299
"reverse": {
300
"type": "boolean"
301
},
302
"disabled": {
303
"type": "boolean"
304
}
305
-
}
306
},
307
"^position_with_duration$": {
308
"type": "object",
309
"properties": {
310
"position": {
311
"$ref": "#/components/value-range"
312
-
},
313
"reverse": {
314
"type": "boolean"
315
},
···
347
],
348
"additionalProperties": false
349
}
350
-
}
351
}
352
},
353
"required": [
···
379
"deny",
380
"index"
381
]
382
-
},
383
-
"user-config-definition": {
384
-
"type": "object",
385
-
"properties": {
386
-
"name": {
387
-
"type": "string"
388
-
},
389
-
"id": {
390
-
"$ref": "#/components/uuid"
391
-
},
392
-
"base-id": {
393
-
"$ref": "#/components/uuid"
394
-
},
395
-
"features": {
396
-
"$ref": "#/components/user-config-features"
397
-
},
398
-
"user-config": {
399
-
"$ref": "#/components/user-config-customization"
400
-
}
401
-
},
402
-
"required": [
403
-
"id",
404
-
"features",
405
-
"user-config"
406
-
],
407
-
"additionalProperties": false
408
},
409
"defaults-definition": {
410
"type": "object",
···
597
]
598
},
599
"config": {
600
-
"$ref": "#/components/user-config-definition"
601
}
602
},
603
"additionalProperties": false,
···
241
],
242
"additionalProperties": false
243
}
244
+
}
245
},
246
+
"feature_settings": {
247
"type": "object",
248
"properties": {
249
+
"alt_protocol_index": {
250
"type": "number"
251
}
252
}
···
255
"required": [
256
"id"
257
],
258
+
"additionalProperties": false
259
}
260
},
261
"user-config-features": {
···
295
"properties": {
296
"value": {
297
"$ref": "#/components/value-range"
298
+
},
299
"reverse": {
300
"type": "boolean"
301
},
302
"disabled": {
303
"type": "boolean"
304
}
305
+
}
306
},
307
"^position_with_duration$": {
308
"type": "object",
309
"properties": {
310
"position": {
311
"$ref": "#/components/value-range"
312
+
},
313
+
"duration": {
314
+
"$ref": "#/components/value-range"
315
+
},
316
"reverse": {
317
"type": "boolean"
318
},
···
350
],
351
"additionalProperties": false
352
}
353
+
}
354
}
355
},
356
"required": [
···
382
"deny",
383
"index"
384
]
385
},
386
"defaults-definition": {
387
"type": "object",
···
574
]
575
},
576
"config": {
577
+
"type": "object",
578
+
"properties": {
579
+
"name": {
580
+
"type": "string"
581
+
},
582
+
"id": {
583
+
"$ref": "#/components/uuid"
584
+
},
585
+
"base-id": {
586
+
"$ref": "#/components/uuid"
587
+
},
588
+
"features": {
589
+
"$ref": "#/components/user-config-features"
590
+
},
591
+
"user-config": {
592
+
"$ref": "#/components/user-config-customization"
593
+
},
594
+
"message-gap-ms": {
595
+
"type": "integer",
596
+
"min": 0
597
+
}
598
+
},
599
+
"required": [
600
+
"id",
601
+
"base-id",
602
+
"features",
603
+
"user-config"
604
+
],
605
+
"additionalProperties": false
606
}
607
},
608
"additionalProperties": false,
+1
-1
crates/buttplug_server_device_config/device-config-v4/version.yaml
+1
-1
crates/buttplug_server_device_config/device-config-v4/version.yaml
+44
crates/buttplug_server_device_config/src/device_config_file/base.rs
+44
crates/buttplug_server_device_config/src/device_config_file/base.rs
···
···
1
+
use std::collections::HashMap;
2
+
3
+
use getset::Getters;
4
+
use serde::{Deserialize, Serialize};
5
+
6
+
use crate::device_config_file::{get_internal_config_version, protocol::ProtocolDefinition, ConfigVersion, ConfigVersionGetter};
7
+
8
+
9
+
#[derive(Deserialize, Serialize, Debug, Getters)]
10
+
#[getset(get_mut = "pub", set = "pub")]
11
+
pub struct BaseConfigFile {
12
+
#[getset(get_copy = "pub")]
13
+
version: ConfigVersion,
14
+
#[getset(get = "pub")]
15
+
#[serde(default, skip_serializing_if = "Option::is_none")]
16
+
protocols: Option<HashMap<String, ProtocolDefinition>>,
17
+
}
18
+
19
+
impl Default for BaseConfigFile {
20
+
fn default() -> Self {
21
+
Self {
22
+
version: get_internal_config_version(),
23
+
protocols: Some(HashMap::new()),
24
+
}
25
+
}
26
+
}
27
+
28
+
impl ConfigVersionGetter for BaseConfigFile {
29
+
fn version(&self) -> ConfigVersion {
30
+
self.version
31
+
}
32
+
}
33
+
34
+
impl BaseConfigFile {
35
+
pub fn new(major_version: u32, minor_version: u32) -> Self {
36
+
Self {
37
+
version: ConfigVersion {
38
+
major: major_version,
39
+
minor: minor_version,
40
+
},
41
+
protocols: None,
42
+
}
43
+
}
44
+
}
+81
crates/buttplug_server_device_config/src/device_config_file/device.rs
+81
crates/buttplug_server_device_config/src/device_config_file/device.rs
···
···
1
+
use getset::{CopyGetters, Getters, MutGetters};
2
+
use serde::{Deserialize, Serialize};
3
+
use uuid::Uuid;
4
+
5
+
use crate::{ServerDeviceDefinition, ServerDeviceDefinitionBuilder};
6
+
7
+
use super::feature::{ConfigBaseDeviceFeature, ConfigUserDeviceFeature};
8
+
9
+
#[derive(Debug, Clone, Getters, CopyGetters, Serialize, Deserialize)]
10
+
pub struct ConfigBaseDeviceDefinition {
11
+
#[getset(get = "pub")]
12
+
/// Given name of the device this instance represents.
13
+
name: String,
14
+
#[getset(get_copy = "pub")]
15
+
id: Uuid,
16
+
#[getset(get = "pub")]
17
+
protocol_variant: Option<String>,
18
+
#[getset(get_copy = "pub")]
19
+
message_gap_ms: Option<u32>,
20
+
#[getset(get = "pub")]
21
+
features: Vec<ConfigBaseDeviceFeature>,
22
+
}
23
+
24
+
impl Into<ServerDeviceDefinition> for ConfigBaseDeviceDefinition {
25
+
fn into(self) -> ServerDeviceDefinition {
26
+
let mut builder = ServerDeviceDefinitionBuilder::new(&self.name, &self.id);
27
+
if let Some(variant) = self.protocol_variant {
28
+
builder.protocol_variant(&variant);
29
+
}
30
+
if let Some(gap) = self.message_gap_ms {
31
+
builder.message_gap_ms(gap);
32
+
}
33
+
for feature in self.features {
34
+
builder.add_feature(feature.into());
35
+
}
36
+
builder.finish()
37
+
}
38
+
}
39
+
40
+
#[derive(Serialize, Deserialize, Debug, Getters, CopyGetters, Default, Clone, MutGetters)]
41
+
pub struct ConfigUserDeviceCustomization {
42
+
#[serde(
43
+
rename = "display-name",
44
+
default,
45
+
skip_serializing_if = "Option::is_none"
46
+
)]
47
+
#[getset(get = "pub")]
48
+
display_name: Option<String>,
49
+
#[serde(default)]
50
+
#[getset(get_copy = "pub")]
51
+
allow: bool,
52
+
#[serde(default)]
53
+
#[getset(get_copy = "pub")]
54
+
deny: bool,
55
+
#[getset(get_copy = "pub", get_mut = "pub")]
56
+
index: u32,
57
+
#[getset(get_copy = "pub")]
58
+
#[serde(
59
+
rename = "message-gap-ms",
60
+
default,
61
+
skip_serializing_if = "Option::is_none"
62
+
)]
63
+
message_gap_ms: Option<u32>,
64
+
}
65
+
66
+
#[derive(Debug, Clone, Getters, MutGetters, Serialize, Deserialize, CopyGetters)]
67
+
pub struct ConfigUserDeviceDefinition {
68
+
#[getset(get_copy = "pub")]
69
+
id: Uuid,
70
+
#[getset(get_copy = "pub")]
71
+
#[serde(rename = "base-id")]
72
+
base_id: Uuid,
73
+
#[getset(get = "pub")]
74
+
/// Message attributes for this device instance.
75
+
#[getset(get = "pub", get_mut = "pub")]
76
+
features: Vec<ConfigUserDeviceFeature>,
77
+
#[getset(get = "pub", get_mut = "pub")]
78
+
#[serde(rename = "user-config")]
79
+
/// Per-user configurations specific to this device instance.
80
+
user_config: ConfigUserDeviceCustomization,
81
+
}
+221
crates/buttplug_server_device_config/src/device_config_file/feature.rs
+221
crates/buttplug_server_device_config/src/device_config_file/feature.rs
···
···
1
+
use std::{collections::HashSet, ops::RangeInclusive};
2
+
3
+
use buttplug_core::message::InputCommandType;
4
+
use getset::{CopyGetters, Getters, MutGetters, Setters};
5
+
use serde::{Deserialize, Serialize};
6
+
use uuid::Uuid;
7
+
use crate::{ServerDeviceFeature, ServerDeviceFeatureOutput, ServerDeviceFeatureOutputPositionWithDurationProperties, ServerDeviceFeatureOutputValueProperties};
8
+
9
+
use super::range_sequence_serialize;
10
+
11
+
#[derive(Serialize, Deserialize, Clone, Debug)]
12
+
struct BaseDeviceFeatureOutputValueProperties {
13
+
value: RangeInclusive<i32>
14
+
}
15
+
16
+
impl Into<ServerDeviceFeatureOutputValueProperties> for BaseDeviceFeatureOutputValueProperties {
17
+
fn into(self) -> ServerDeviceFeatureOutputValueProperties {
18
+
ServerDeviceFeatureOutputValueProperties::new(&self.value.into(), false)
19
+
}
20
+
}
21
+
22
+
#[derive(Serialize, Deserialize, Clone, Debug)]
23
+
struct BaseDeviceFeatureOutputPositionWithDurationProperties {
24
+
position: RangeInclusive<u32>,
25
+
duration: RangeInclusive<u32>,
26
+
}
27
+
28
+
impl Into<ServerDeviceFeatureOutputPositionWithDurationProperties> for BaseDeviceFeatureOutputPositionWithDurationProperties {
29
+
fn into(self) -> ServerDeviceFeatureOutputPositionWithDurationProperties {
30
+
ServerDeviceFeatureOutputPositionWithDurationProperties::new(&self.position.into(), &self.duration.into(), false, false)
31
+
}
32
+
}
33
+
34
+
#[derive(Serialize, Deserialize, Clone, Debug)]
35
+
struct BaseDeviceFeatureOutput {
36
+
#[serde(skip_serializing_if="Option::is_none")]
37
+
vibrate: Option<BaseDeviceFeatureOutputValueProperties>,
38
+
#[serde(skip_serializing_if="Option::is_none")]
39
+
rotate: Option<BaseDeviceFeatureOutputValueProperties>,
40
+
#[serde(skip_serializing_if="Option::is_none")]
41
+
rotate_with_direction: Option<BaseDeviceFeatureOutputValueProperties>,
42
+
#[serde(skip_serializing_if="Option::is_none")]
43
+
oscillate: Option<BaseDeviceFeatureOutputValueProperties>,
44
+
#[serde(skip_serializing_if="Option::is_none")]
45
+
constrict: Option<BaseDeviceFeatureOutputValueProperties>,
46
+
#[serde(skip_serializing_if="Option::is_none")]
47
+
heater: Option<BaseDeviceFeatureOutputValueProperties>,
48
+
#[serde(skip_serializing_if="Option::is_none")]
49
+
led: Option<BaseDeviceFeatureOutputValueProperties>,
50
+
#[serde(skip_serializing_if="Option::is_none")]
51
+
position: Option<BaseDeviceFeatureOutputValueProperties>,
52
+
#[serde(skip_serializing_if="Option::is_none")]
53
+
position_with_duration: Option<BaseDeviceFeatureOutputPositionWithDurationProperties>,
54
+
#[serde(skip_serializing_if="Option::is_none")]
55
+
spray: Option<BaseDeviceFeatureOutputValueProperties>,
56
+
}
57
+
/*
58
+
impl Into<ServerDeviceFeatureOutput> for BaseDeviceFeatureOutput {
59
+
fn into(self) -> ServerDeviceFeatureOutput {
60
+
if let Some(vibrate) = self.vibrate {
61
+
}
62
+
}
63
+
}
64
+
*/
65
+
66
+
#[derive(Serialize, Deserialize, Clone, Debug)]
67
+
struct UserDeviceFeatureOutputValueProperties {
68
+
#[serde(skip_serializing_if="Option::is_none")]
69
+
value: Option<RangeInclusive<i32>>,
70
+
#[serde(default)]
71
+
disabled: bool,
72
+
#[serde(default)]
73
+
reverse: bool
74
+
}
75
+
76
+
77
+
#[derive(Serialize, Deserialize, Clone, Debug)]
78
+
struct UserDeviceFeatureOutputPositionProperties {
79
+
#[serde(skip_serializing_if="Option::is_none")]
80
+
value: Option<RangeInclusive<u32>>,
81
+
#[serde(default)]
82
+
disabled: bool,
83
+
#[serde(default)]
84
+
reverse: bool
85
+
}
86
+
87
+
#[derive(Serialize, Deserialize, Clone, Debug)]
88
+
struct UserDeviceFeatureOutputPositionWithDurationProperties {
89
+
#[serde(skip_serializing_if="Option::is_none")]
90
+
position: Option<RangeInclusive<u32>>,
91
+
#[serde(skip_serializing_if="Option::is_none")]
92
+
duration: Option<RangeInclusive<u32>>,
93
+
#[serde(default)]
94
+
disabled: bool,
95
+
#[serde(default)]
96
+
reverse: bool
97
+
}
98
+
99
+
#[derive(Serialize, Deserialize, Clone, Debug)]
100
+
struct UserDeviceFeatureOutput {
101
+
#[serde(skip_serializing_if="Option::is_none")]
102
+
vibrate: Option<UserDeviceFeatureOutputValueProperties>,
103
+
#[serde(skip_serializing_if="Option::is_none")]
104
+
rotate: Option<UserDeviceFeatureOutputValueProperties>,
105
+
#[serde(skip_serializing_if="Option::is_none")]
106
+
rotate_with_direction: Option<UserDeviceFeatureOutputValueProperties>,
107
+
#[serde(skip_serializing_if="Option::is_none")]
108
+
oscillate: Option<UserDeviceFeatureOutputValueProperties>,
109
+
#[serde(skip_serializing_if="Option::is_none")]
110
+
constrict: Option<UserDeviceFeatureOutputValueProperties>,
111
+
#[serde(skip_serializing_if="Option::is_none")]
112
+
heater: Option<UserDeviceFeatureOutputValueProperties>,
113
+
#[serde(skip_serializing_if="Option::is_none")]
114
+
led: Option<UserDeviceFeatureOutputValueProperties>,
115
+
#[serde(skip_serializing_if="Option::is_none")]
116
+
position: Option<UserDeviceFeatureOutputPositionProperties>,
117
+
#[serde(skip_serializing_if="Option::is_none")]
118
+
position_with_duration: Option<UserDeviceFeatureOutputPositionWithDurationProperties>,
119
+
#[serde(skip_serializing_if="Option::is_none")]
120
+
spray: Option<UserDeviceFeatureOutputValueProperties>,
121
+
}
122
+
123
+
#[derive(
124
+
Clone, Debug, Default, PartialEq, Eq, Getters, MutGetters, Setters, Serialize, Deserialize,
125
+
)]
126
+
pub struct DeviceFeatureInputProperties {
127
+
#[getset(get = "pub", get_mut = "pub(super)")]
128
+
#[serde(serialize_with = "range_sequence_serialize")]
129
+
value_range: Vec<RangeInclusive<i32>>,
130
+
#[getset(get = "pub")]
131
+
input_commands: HashSet<InputCommandType>
132
+
}
133
+
134
+
impl DeviceFeatureInputProperties {
135
+
pub fn new(
136
+
value_range: &Vec<RangeInclusive<i32>>,
137
+
sensor_commands: &HashSet<InputCommandType>,
138
+
) -> Self {
139
+
Self {
140
+
value_range: value_range.clone(),
141
+
input_commands: sensor_commands.clone(),
142
+
}
143
+
}
144
+
}
145
+
146
+
#[derive(
147
+
Clone, Debug, Default, Getters, Serialize, Deserialize,
148
+
)]
149
+
#[getset(get = "pub")]
150
+
pub struct DeviceFeatureInput {
151
+
battery: Option<DeviceFeatureInputProperties>,
152
+
rssi: Option<DeviceFeatureInputProperties>,
153
+
pressure: Option<DeviceFeatureInputProperties>,
154
+
button: Option<DeviceFeatureInputProperties>
155
+
}
156
+
157
+
#[derive(
158
+
Clone, Debug, Default, Getters, Serialize, Deserialize, CopyGetters,
159
+
)]
160
+
pub struct ConfigBaseDeviceFeature {
161
+
#[getset(get = "pub")]
162
+
#[serde(default)]
163
+
description: String,
164
+
#[getset(get = "pub")]
165
+
#[serde(skip_serializing_if = "Option::is_none")]
166
+
output: Option<BaseDeviceFeatureOutput>,
167
+
#[getset(get = "pub")]
168
+
#[serde(skip_serializing_if = "Option::is_none")]
169
+
input: Option<DeviceFeatureInput>,
170
+
#[getset(get_copy = "pub")]
171
+
id: Uuid,
172
+
#[getset(get = "pub")]
173
+
#[serde(
174
+
skip_serializing_if = "BaseFeatureSettings::is_none",
175
+
default
176
+
)]
177
+
feature_settings: BaseFeatureSettings,
178
+
}
179
+
180
+
impl Into<ServerDeviceFeature> for ConfigBaseDeviceFeature {
181
+
fn into(self) -> ServerDeviceFeature {
182
+
ServerDeviceFeature::new(
183
+
&self.description,
184
+
self.id,
185
+
None,
186
+
self.feature_settings.alt_protocol_index,
187
+
self.output.into(),
188
+
self.input.into()
189
+
)
190
+
}
191
+
}
192
+
193
+
#[derive(
194
+
Clone, Debug, Default, Getters, Serialize, Deserialize, CopyGetters,
195
+
)]
196
+
pub struct ConfigUserDeviceFeature {
197
+
#[getset(get_copy = "pub")]
198
+
id: Uuid,
199
+
#[getset(get_copy = "pub")]
200
+
base_id: Uuid,
201
+
#[getset(get = "pub")]
202
+
#[serde(rename = "output", skip_serializing_if = "Option::is_none")]
203
+
output: Option<UserDeviceFeatureOutput>
204
+
}
205
+
206
+
#[derive(Serialize, Deserialize, Debug, Clone, Default, CopyGetters)]
207
+
pub struct BaseFeatureSettings {
208
+
#[serde(
209
+
rename = "alt-protocol-index",
210
+
skip_serializing_if = "Option::is_none",
211
+
default
212
+
)]
213
+
#[getset(get_copy = "pub")]
214
+
alt_protocol_index: Option<u32>,
215
+
}
216
+
217
+
impl BaseFeatureSettings {
218
+
pub fn is_none(&self) -> bool {
219
+
self.alt_protocol_index.is_none()
220
+
}
221
+
}
+270
crates/buttplug_server_device_config/src/device_config_file/mod.rs
+270
crates/buttplug_server_device_config/src/device_config_file/mod.rs
···
···
1
+
// Buttplug Rust Source Code File - See https://buttplug.io for more info.
2
+
//
3
+
// Copyright 2016-2024 Nonpolynomial Labs LLC. All rights reserved.
4
+
//
5
+
// Licensed under the BSD 3-Clause license. See LICENSE file in the project root
6
+
// for full license information.
7
+
8
+
mod base;
9
+
mod device;
10
+
mod feature;
11
+
mod protocol;
12
+
mod user;
13
+
14
+
use base::BaseConfigFile;
15
+
16
+
use crate::device_config_file::{protocol::ProtocolDefinition, user::{UserConfigDefinition, UserConfigFile, UserDeviceConfigPair}};
17
+
18
+
use super::{
19
+
BaseDeviceIdentifier,
20
+
DeviceConfigurationManager,
21
+
DeviceConfigurationManagerBuilder,
22
+
};
23
+
use buttplug_core::{
24
+
errors::{ButtplugDeviceError, ButtplugError},
25
+
util::json::JSONValidator,
26
+
};
27
+
use dashmap::DashMap;
28
+
use getset::CopyGetters;
29
+
use serde::{Deserialize, Serialize, Serializer, ser::{self, SerializeSeq}};
30
+
use std::{collections::HashMap, fmt::Display, ops::RangeInclusive};
31
+
32
+
pub static DEVICE_CONFIGURATION_JSON: &str =
33
+
include_str!("../../build-config/buttplug-device-config-v4.json");
34
+
static DEVICE_CONFIGURATION_JSON_SCHEMA: &str = include_str!(
35
+
"../../device-config-v4/buttplug-device-config-schema-v4.json"
36
+
);
37
+
38
+
fn range_serialize<S>(range: &Option<RangeInclusive<u32>>, serializer: S) -> Result<S::Ok, S::Error>
39
+
where
40
+
S: Serializer,
41
+
{
42
+
if let Some(range) = range {
43
+
let mut seq = serializer.serialize_seq(Some(2))?;
44
+
seq.serialize_element(&range.start())?;
45
+
seq.serialize_element(&range.end())?;
46
+
seq.end()
47
+
} else {
48
+
Err(ser::Error::custom(
49
+
"shouldn't be serializing if range is None",
50
+
))
51
+
}
52
+
}
53
+
54
+
fn range_sequence_serialize<S>(
55
+
range_vec: &Vec<RangeInclusive<i32>>,
56
+
serializer: S,
57
+
) -> Result<S::Ok, S::Error>
58
+
where
59
+
S: Serializer,
60
+
{
61
+
let mut seq = serializer.serialize_seq(Some(range_vec.len()))?;
62
+
for range in range_vec {
63
+
seq.serialize_element(&vec![*range.start(), *range.end()])?;
64
+
}
65
+
seq.end()
66
+
}
67
+
68
+
#[derive(Deserialize, Serialize, Debug, CopyGetters, Clone, Copy)]
69
+
#[getset(get_copy = "pub", get_mut = "pub")]
70
+
struct ConfigVersion {
71
+
pub major: u32,
72
+
pub minor: u32,
73
+
}
74
+
75
+
impl Display for ConfigVersion {
76
+
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
77
+
write!(f, "{}.{}", self.major, self.minor)
78
+
}
79
+
}
80
+
81
+
trait ConfigVersionGetter {
82
+
fn version(&self) -> ConfigVersion;
83
+
}
84
+
85
+
86
+
fn get_internal_config_version() -> ConfigVersion {
87
+
let config: BaseConfigFile = serde_json::from_str(DEVICE_CONFIGURATION_JSON)
88
+
.expect("If this fails, the whole library goes with it.");
89
+
config.version()
90
+
}
91
+
92
+
fn load_protocol_config_from_json<'a, T>(
93
+
config_str: &'a str,
94
+
skip_version_check: bool,
95
+
) -> Result<T, ButtplugDeviceError>
96
+
where
97
+
T: ConfigVersionGetter + Deserialize<'a>,
98
+
{
99
+
let config_validator = JSONValidator::new(DEVICE_CONFIGURATION_JSON_SCHEMA);
100
+
match config_validator.validate(config_str) {
101
+
Ok(_) => match serde_json::from_str::<T>(config_str) {
102
+
Ok(protocol_config) => {
103
+
let internal_config_version = get_internal_config_version();
104
+
if !skip_version_check && protocol_config.version().major != internal_config_version.major {
105
+
Err(ButtplugDeviceError::DeviceConfigurationError(format!(
106
+
"Device configuration file major version {} is different than internal major version {}. Cannot load external files that do not have matching major version numbers.",
107
+
protocol_config.version(),
108
+
internal_config_version
109
+
)))
110
+
} else {
111
+
Ok(protocol_config)
112
+
}
113
+
}
114
+
Err(err) => Err(ButtplugDeviceError::DeviceConfigurationError(format!(
115
+
"{err}"
116
+
))),
117
+
},
118
+
Err(err) => Err(ButtplugDeviceError::DeviceConfigurationError(format!(
119
+
"{err}"
120
+
))),
121
+
}
122
+
}
123
+
124
+
fn load_main_config(
125
+
main_config_str: &Option<String>,
126
+
skip_version_check: bool,
127
+
) -> Result<DeviceConfigurationManagerBuilder, ButtplugDeviceError> {
128
+
if main_config_str.is_some() {
129
+
info!("Loading from custom base device configuration...")
130
+
} else {
131
+
info!("Loading from internal base device configuration...")
132
+
}
133
+
// Start by loading the main config
134
+
let main_config = load_protocol_config_from_json::<BaseConfigFile>(
135
+
main_config_str
136
+
.as_ref()
137
+
.unwrap_or(&DEVICE_CONFIGURATION_JSON.to_owned()),
138
+
skip_version_check,
139
+
)?;
140
+
141
+
info!("Loaded config version {:?}", main_config.version());
142
+
143
+
let mut dcm_builder = DeviceConfigurationManagerBuilder::default();
144
+
145
+
for (protocol_name, protocol_def) in main_config.protocols().clone().unwrap_or_default() {
146
+
if let Some(specifiers) = protocol_def.communication() {
147
+
dcm_builder.communication_specifier(&protocol_name, &specifiers);
148
+
}
149
+
150
+
if let Some(features) = protocol_def.defaults() {
151
+
dcm_builder.protocol_features(&BaseDeviceIdentifier::new_default(&protocol_name), features);
152
+
}
153
+
154
+
for (config_ident, config) in protocol_def.configurations() {
155
+
let ident = BaseDeviceIdentifier::new(&protocol_name, config_ident);
156
+
dcm_builder.protocol_features(ident, config.clone());
157
+
}
158
+
}
159
+
160
+
Ok(dcm_builder)
161
+
}
162
+
163
+
fn load_user_config(
164
+
user_config_str: &str,
165
+
skip_version_check: bool,
166
+
dcm_builder: &mut DeviceConfigurationManagerBuilder,
167
+
) -> Result<(), ButtplugDeviceError> {
168
+
info!("Loading user configuration from string.");
169
+
let user_config_file =
170
+
load_protocol_config_from_json::<UserConfigFile>(user_config_str, skip_version_check)?;
171
+
172
+
if user_config_file.user_configs().is_none() {
173
+
info!("No user configurations provided in user config.");
174
+
return Ok(());
175
+
}
176
+
177
+
let user_config = user_config_file
178
+
.user_configs()
179
+
.clone()
180
+
.expect("Just checked validity");
181
+
182
+
for (protocol_name, protocol_def) in user_config.protocols().clone().unwrap_or_default() {
183
+
if let Some(specifiers) = protocol_def.communication() {
184
+
dcm_builder.user_communication_specifier(&protocol_name, &specifiers);
185
+
}
186
+
187
+
if let Some(features) = protocol_def.defaults() {
188
+
dcm_builder.protocol_features(&BaseDeviceIdentifier::new_default(&protocol_name), features);
189
+
}
190
+
191
+
for (config_ident, config) in protocol_def.configurations() {
192
+
let ident = BaseDeviceIdentifier::new(&protocol_name, config_ident);
193
+
dcm_builder.protocol_features(ident, config.clone());
194
+
}
195
+
}
196
+
197
+
for user_device_config_pair in user_config.user_device_configs().clone().unwrap_or_default() {
198
+
dcm_builder.user_protocol_features(
199
+
user_device_config_pair.identifier(),
200
+
user_device_config_pair.config(),
201
+
);
202
+
}
203
+
204
+
Ok(())
205
+
}
206
+
207
+
pub fn load_protocol_configs(
208
+
main_config_str: &Option<String>,
209
+
user_config_str: &Option<String>,
210
+
skip_version_check: bool,
211
+
) -> Result<DeviceConfigurationManagerBuilder, ButtplugDeviceError> {
212
+
let mut dcm_builder = load_main_config(main_config_str, skip_version_check)?;
213
+
214
+
if let Some(config_str) = user_config_str {
215
+
load_user_config(config_str, skip_version_check, &mut dcm_builder)?;
216
+
} else {
217
+
info!("No user configuration provided.");
218
+
}
219
+
220
+
Ok(dcm_builder)
221
+
}
222
+
223
+
// TODO Update save_user_config to work with new device structures
224
+
/*
225
+
pub fn save_user_config(dcm: &DeviceConfigurationManager) -> Result<String, ButtplugError> {
226
+
let user_specifiers = dcm.user_communication_specifiers();
227
+
let user_definitions_vec = dcm
228
+
.user_device_definitions()
229
+
.iter()
230
+
.map(|kv| UserDeviceConfigPair {
231
+
identifier: kv.key().clone(),
232
+
config: kv.value().user_device().clone(),
233
+
})
234
+
.collect();
235
+
let user_protos = DashMap::new();
236
+
for spec in user_specifiers {
237
+
user_protos.insert(
238
+
spec.key().clone(),
239
+
ProtocolDefinition {
240
+
communication: Some(spec.value().clone()),
241
+
..Default::default()
242
+
},
243
+
);
244
+
}
245
+
let user_config_definition = UserConfigDefinition {
246
+
protocols: Some(user_protos.clone()),
247
+
user_device_configs: Some(user_definitions_vec),
248
+
};
249
+
let mut user_config_file = UserConfigFile::new(4, 0);
250
+
user_config_file.set_user_configs(Some(user_config_definition));
251
+
serde_json::to_string(&user_config_file).map_err(|e| {
252
+
ButtplugError::from(ButtplugDeviceError::DeviceConfigurationError(format!(
253
+
"Cannot save device configuration file: {e:?}",
254
+
)))
255
+
})
256
+
}
257
+
*/
258
+
259
+
#[cfg(test)]
260
+
mod test {
261
+
use super::{load_protocol_config_from_json, DEVICE_CONFIGURATION_JSON, base::BaseConfigFile};
262
+
263
+
#[test]
264
+
fn test_config_file_parsing() {
265
+
load_protocol_config_from_json::<BaseConfigFile>(
266
+
&DEVICE_CONFIGURATION_JSON.to_owned(),
267
+
true
268
+
).unwrap();
269
+
}
270
+
}
+19
crates/buttplug_server_device_config/src/device_config_file/protocol.rs
+19
crates/buttplug_server_device_config/src/device_config_file/protocol.rs
···
···
1
+
use std::collections::HashMap;
2
+
3
+
use getset::{Getters, MutGetters, Setters};
4
+
use serde::{Deserialize, Serialize};
5
+
6
+
use super::device::ConfigBaseDeviceDefinition;
7
+
8
+
use crate::{ProtocolCommunicationSpecifier};
9
+
10
+
#[derive(Deserialize, Serialize, Debug, Clone, Default, Getters, Setters, MutGetters)]
11
+
#[getset(get = "pub", set = "pub", get_mut = "pub(crate)")]
12
+
pub(super) struct ProtocolDefinition {
13
+
#[serde(skip_serializing_if = "Option::is_none")]
14
+
pub communication: Option<Vec<ProtocolCommunicationSpecifier>>,
15
+
#[serde(skip_serializing_if = "Option::is_none")]
16
+
pub defaults: Option<ConfigBaseDeviceDefinition>,
17
+
#[serde(default)]
18
+
pub configurations: HashMap<String, ConfigBaseDeviceDefinition>,
19
+
}
+64
crates/buttplug_server_device_config/src/device_config_file/user.rs
+64
crates/buttplug_server_device_config/src/device_config_file/user.rs
···
···
1
+
use dashmap::DashMap;
2
+
use getset::{Getters, MutGetters, Setters};
3
+
use serde::{Deserialize, Serialize};
4
+
5
+
use crate::UserDeviceIdentifier;
6
+
7
+
use super::{get_internal_config_version, device::ConfigUserDeviceDefinition, protocol::ProtocolDefinition, ConfigVersion, ConfigVersionGetter};
8
+
9
+
#[derive(Deserialize, Serialize, Debug, Clone, Getters, Setters, MutGetters)]
10
+
#[getset(get = "pub", set = "pub", get_mut = "pub(crate)")]
11
+
pub struct UserDeviceConfigPair {
12
+
pub identifier: UserDeviceIdentifier,
13
+
pub config: ConfigUserDeviceDefinition,
14
+
}
15
+
16
+
#[derive(Deserialize, Serialize, Debug, Clone, Default, Getters, Setters, MutGetters)]
17
+
#[getset(get = "pub", set = "pub", get_mut = "pub")]
18
+
pub struct UserConfigDefinition {
19
+
#[serde(skip_serializing_if = "Option::is_none")]
20
+
pub protocols: Option<DashMap<String, ProtocolDefinition>>,
21
+
#[serde(rename = "devices", default, skip_serializing_if = "Option::is_none")]
22
+
pub user_device_configs: Option<Vec<UserDeviceConfigPair>>,
23
+
}
24
+
25
+
#[derive(Deserialize, Serialize, Debug, Getters, Setters)]
26
+
#[getset(get = "pub", get_mut = "pub", set = "pub")]
27
+
pub struct UserConfigFile {
28
+
version: ConfigVersion,
29
+
#[serde(rename = "user-configs", default)]
30
+
user_configs: Option<UserConfigDefinition>,
31
+
}
32
+
33
+
impl Default for UserConfigFile {
34
+
fn default() -> Self {
35
+
Self {
36
+
version: get_internal_config_version(),
37
+
user_configs: Some(UserConfigDefinition::default()),
38
+
}
39
+
}
40
+
}
41
+
42
+
impl ConfigVersionGetter for UserConfigFile {
43
+
fn version(&self) -> ConfigVersion {
44
+
self.version
45
+
}
46
+
}
47
+
48
+
impl UserConfigFile {
49
+
pub fn new(major_version: u32, minor_version: u32) -> Self {
50
+
Self {
51
+
version: ConfigVersion {
52
+
major: major_version,
53
+
minor: minor_version,
54
+
},
55
+
user_configs: None,
56
+
}
57
+
}
58
+
59
+
#[allow(dead_code)]
60
+
pub fn to_json(&self) -> String {
61
+
serde_json::to_string(self)
62
+
.expect("All types below this are Serialize, so this should be infallible.")
63
+
}
64
+
}
+328
crates/buttplug_server_device_config/src/device_config_manager.rs
+328
crates/buttplug_server_device_config/src/device_config_manager.rs
···
···
1
+
2
+
use buttplug_core::errors::ButtplugDeviceError;
3
+
use dashmap::DashMap;
4
+
use getset::Getters;
5
+
use std::{
6
+
collections::HashMap,
7
+
fmt::{self, Debug},
8
+
};
9
+
10
+
use crate::{BaseDeviceIdentifier, ProtocolCommunicationSpecifier, ServerDeviceDefinition, UserDeviceIdentifier};
11
+
12
+
#[derive(Default, Clone)]
13
+
pub struct DeviceConfigurationManagerBuilder {
14
+
communication_specifiers: HashMap<String, Vec<ProtocolCommunicationSpecifier>>,
15
+
user_communication_specifiers: DashMap<String, Vec<ProtocolCommunicationSpecifier>>,
16
+
base_device_definitions: HashMap<BaseDeviceIdentifier, ServerDeviceDefinition>,
17
+
user_device_definitions: DashMap<UserDeviceIdentifier, ServerDeviceDefinition>,
18
+
}
19
+
20
+
impl DeviceConfigurationManagerBuilder {
21
+
pub fn communication_specifier(
22
+
&mut self,
23
+
protocol_name: &str,
24
+
specifier: &[ProtocolCommunicationSpecifier],
25
+
) -> &mut Self {
26
+
self
27
+
.communication_specifiers
28
+
.entry(protocol_name.to_owned())
29
+
.or_default()
30
+
.extend(specifier.iter().cloned());
31
+
self
32
+
}
33
+
34
+
pub fn protocol_features(
35
+
&mut self,
36
+
identifier: &BaseDeviceIdentifier,
37
+
features: &ServerDeviceDefinition,
38
+
) -> &mut Self {
39
+
self
40
+
.base_device_definitions
41
+
.insert(identifier.clone(), features.clone());
42
+
self
43
+
}
44
+
45
+
pub fn user_communication_specifier(
46
+
&mut self,
47
+
protocol_name: &str,
48
+
specifier: &[ProtocolCommunicationSpecifier],
49
+
) -> &mut Self {
50
+
self
51
+
.user_communication_specifiers
52
+
.entry(protocol_name.to_owned())
53
+
.or_default()
54
+
.extend(specifier.iter().cloned());
55
+
self
56
+
}
57
+
58
+
pub fn user_protocol_features(
59
+
&mut self,
60
+
identifier: &UserDeviceIdentifier,
61
+
features: &ServerDeviceDefinition,
62
+
) -> &mut Self {
63
+
if let Some((_, base_definition)) = self
64
+
.base_device_definitions
65
+
.iter()
66
+
.find(|(_, x)| x.id() == features.base_id())
67
+
{
68
+
self.user_device_definitions.insert(
69
+
identifier.clone(),
70
+
ServerDeviceDefinition::new(base_definition, features),
71
+
);
72
+
} else {
73
+
error!(
74
+
"Cannot find protocol with base id {} for user id {}",
75
+
features.base_id(),
76
+
features.id()
77
+
)
78
+
}
79
+
self
80
+
}
81
+
82
+
pub fn finish(&mut self) -> Result<DeviceConfigurationManager, ButtplugDeviceError> {
83
+
// Build and validate the protocol attributes tree.
84
+
let mut attribute_tree_map = HashMap::new();
85
+
86
+
// Add all the defaults first, they won't have parent attributes.
87
+
for (ident, attr) in &self.base_device_definitions {
88
+
/*
89
+
for feature in attr.features() {
90
+
if let Err(e) = feature.is_valid() {
91
+
error!("Feature {attr:?} for ident {ident:?} is not valid, skipping addition: {e:?}");
92
+
continue;
93
+
}
94
+
}
95
+
*/
96
+
attribute_tree_map.insert(ident.clone(), attr.clone());
97
+
}
98
+
99
+
let user_attribute_tree_map = DashMap::new();
100
+
// Finally, add in user configurations, which will have an address.
101
+
for kv in &self.user_device_definitions {
102
+
let (ident, attr) = (kv.key(), kv.value());
103
+
for feature in attr.features() {
104
+
if let Err(e) = feature.is_valid() {
105
+
error!("Feature {attr:?} for ident {ident:?} is not valid, skipping addition: {e:?}");
106
+
continue;
107
+
}
108
+
}
109
+
user_attribute_tree_map.insert(kv.key().clone(), kv.value().clone());
110
+
}
111
+
112
+
Ok(DeviceConfigurationManager {
113
+
base_communication_specifiers: self.communication_specifiers.clone(),
114
+
user_communication_specifiers: self.user_communication_specifiers.clone(),
115
+
base_device_definitions: attribute_tree_map,
116
+
user_device_definitions: user_attribute_tree_map,
117
+
//protocol_map,
118
+
})
119
+
}
120
+
}
121
+
122
+
/// Correlates information about protocols and which devices they support.
123
+
///
124
+
/// The [DeviceConfigurationManager] handles stores information about which device protocols the
125
+
/// library supports, as well as which devices can use those protocols. When a
126
+
/// [DeviceCommunicationManager](crate::server::device::communication_manager) finds a device during scanning,
127
+
/// device information is given to the [DeviceConfigurationManager] to decide whether Buttplug
128
+
/// should try to connect to and communicate with the device.
129
+
///
130
+
/// Assuming the device is supported by the library, the [DeviceConfigurationManager] also stores
131
+
/// information about what commands can be sent to the device (Vibrate, Rotate, etc...), and the
132
+
/// parameters for those commands (number of power levels, stroke distances, etc...).
133
+
#[derive(Getters)]
134
+
#[getset(get = "pub")]
135
+
pub struct DeviceConfigurationManager {
136
+
/// Communication specifiers from the base device config, mapped from protocol name to vector of
137
+
/// specifiers. Should not change/update during a session.
138
+
base_communication_specifiers: HashMap<String, Vec<ProtocolCommunicationSpecifier>>,
139
+
/// Device definitions from the base device config. Should not change/update during a session.
140
+
base_device_definitions: HashMap<BaseDeviceIdentifier, ServerDeviceDefinition>,
141
+
/// Communication specifiers provided by the user, mapped from protocol name to vector of
142
+
/// specifiers. Loaded at session start, may change over life of session.
143
+
user_communication_specifiers: DashMap<String, Vec<ProtocolCommunicationSpecifier>>,
144
+
/// Device definitions from the user device config. Loaded at session start, may change over life
145
+
/// of session.
146
+
user_device_definitions: DashMap<UserDeviceIdentifier, ServerDeviceDefinition>,
147
+
}
148
+
149
+
impl Debug for DeviceConfigurationManager {
150
+
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
151
+
f.debug_struct("DeviceConfigurationManager").finish()
152
+
}
153
+
}
154
+
155
+
impl Default for DeviceConfigurationManager {
156
+
fn default() -> Self {
157
+
// Unwrap allowed here because we assume our built in device config will
158
+
// always work. System won't pass tests or possibly even build otherwise.
159
+
DeviceConfigurationManagerBuilder::default()
160
+
.finish()
161
+
.expect("Default creation of a DCM should always work.")
162
+
}
163
+
}
164
+
165
+
impl DeviceConfigurationManager {
166
+
pub fn add_user_communication_specifier(
167
+
&self,
168
+
protocol: &str,
169
+
specifier: &ProtocolCommunicationSpecifier,
170
+
) -> Result<(), ButtplugDeviceError> {
171
+
//self.protocol_map.contains_key(protocol);
172
+
self
173
+
.user_communication_specifiers
174
+
.entry(protocol.to_owned())
175
+
.or_default()
176
+
.push(specifier.clone());
177
+
Ok(())
178
+
}
179
+
180
+
pub fn remove_user_communication_specifier(
181
+
&self,
182
+
protocol: &str,
183
+
specifier: &ProtocolCommunicationSpecifier,
184
+
) {
185
+
if let Some(mut specifiers) = self.user_communication_specifiers.get_mut(protocol) {
186
+
let specifier_vec = specifiers.value_mut();
187
+
*specifier_vec = specifier_vec
188
+
.iter()
189
+
.filter(|s| *specifier != **s)
190
+
.cloned()
191
+
.collect();
192
+
}
193
+
}
194
+
195
+
pub fn add_user_device_definition(
196
+
&self,
197
+
identifier: &UserDeviceIdentifier,
198
+
definition: &ServerDeviceDefinition,
199
+
) -> Result<(), ButtplugDeviceError> {
200
+
//self.protocol_map.contains_key(identifier.protocol());
201
+
// Check validity of device
202
+
let mut index = definition.user_config().index();
203
+
let indexes: Vec<u32> = self.user_device_definitions().iter().map(|x| x.value().user_config().index()).collect();
204
+
// If we just added 1 to the maximum value of the current indexes, someone decides to set an
205
+
// index to u32::MAX-1, then we'd have a problem. This is kind of a shit solution but it'll work
206
+
// quickly for anyone that's not actively fucking with us by manually playing with user config files.
207
+
while indexes.contains(&index) {
208
+
index = index.wrapping_add(1);
209
+
}
210
+
let mut def = definition.clone();
211
+
*def.user_device_mut().user_config_mut().index_mut() = index;
212
+
self
213
+
.user_device_definitions
214
+
.entry(identifier.clone())
215
+
.insert(def);
216
+
Ok(())
217
+
}
218
+
219
+
pub fn remove_user_device_definition(&self, identifier: &UserDeviceIdentifier) {
220
+
self.user_device_definitions.remove(identifier);
221
+
}
222
+
223
+
pub fn address_allowed(&self, address: &str) -> bool {
224
+
// Make sure the device isn't on the deny list
225
+
if self
226
+
.user_device_definitions
227
+
.iter()
228
+
.any(|kv| kv.key().address() == address && kv.value().user_config().deny())
229
+
{
230
+
// If device is outright denied, deny
231
+
info!(
232
+
"Device {} denied by configuration, not connecting.",
233
+
address
234
+
);
235
+
false
236
+
} else if self
237
+
.user_device_definitions
238
+
.iter()
239
+
.any(|kv| kv.value().user_config().allow())
240
+
&& !self
241
+
.user_device_definitions
242
+
.iter()
243
+
.any(|kv| kv.key().address() == address && kv.value().user_config().allow())
244
+
{
245
+
// If device is not on allow list and allow list isn't empty, deny
246
+
info!(
247
+
"Device {} not on allow list and allow list not empty, not connecting.",
248
+
address
249
+
);
250
+
false
251
+
} else {
252
+
true
253
+
}
254
+
}
255
+
256
+
fn device_index(&self, identifier: &UserDeviceIdentifier) -> u32 {
257
+
// See if we have a reserved or reusable device index here.
258
+
if let Some(config) = self.user_device_definitions.get(identifier) {
259
+
let index = config.user_config().index();
260
+
debug!("Found index {index} for device {identifier:?}");
261
+
return index;
262
+
}
263
+
264
+
let current_indexes: Vec<u32> = self
265
+
.user_device_definitions
266
+
.iter()
267
+
.map(|x| x.user_config().index())
268
+
.collect();
269
+
270
+
// Someone is gonna make a max device index in their config file just to fuck with me, therefore
271
+
// we don't do "max + 1", we fill in holes (lol) in sequences. To whomever has 4 billion sex toys:
272
+
// sorry your index finding for new devices is slow and takes 16GB of allocation every time we
273
+
// want to search the index space.
274
+
275
+
let mut index = 0;
276
+
while current_indexes.contains(&index) {
277
+
index += 1;
278
+
}
279
+
debug!("Generating and assigning index {index:?} for device {identifier:?}");
280
+
index
281
+
}
282
+
283
+
/// Provides read-only access to the internal protocol/identifier map. Mainly
284
+
/// used for WebBluetooth filter construction, but could also be handy for
285
+
/// listing capabilities in UI, etc.
286
+
pub fn protocol_device_configurations(
287
+
&self,
288
+
) -> HashMap<String, Vec<ProtocolCommunicationSpecifier>> {
289
+
self.base_communication_specifiers.clone()
290
+
}
291
+
292
+
pub fn device_definition(&self, identifier: &UserDeviceIdentifier) -> Option<DeviceDefinition> {
293
+
let features = if let Some(attrs) = self.user_device_definitions.get(identifier) {
294
+
debug!("User device config found for {:?}", identifier);
295
+
attrs.clone()
296
+
} else if let Some(attrs) = self.base_device_definitions.get(&BaseDeviceIdentifier::new(
297
+
identifier.protocol(),
298
+
identifier.identifier(),
299
+
)) {
300
+
debug!(
301
+
"Protocol + Identifier device config found for {:?}",
302
+
identifier
303
+
);
304
+
DeviceDefinition::new_from_base_definition(attrs, self.device_index(identifier))
305
+
} else if let Some(attrs) = self
306
+
.base_device_definitions
307
+
.get(&BaseDeviceIdentifier::new(identifier.protocol(), &None))
308
+
{
309
+
debug!("Protocol device config found for {:?}", identifier);
310
+
DeviceDefinition::new_from_base_definition(attrs, self.device_index(identifier))
311
+
} else {
312
+
return None;
313
+
};
314
+
315
+
// If this is a new device, it needs to be added to the user device definition map.
316
+
//
317
+
// Device definitions are looked up before we fully initialize a device, mostly for algorithm
318
+
// preparation. There is a very small chance we may save the device config then error out when
319
+
// we connect to the device, but we'll assume we may connect successfully later.
320
+
if self.user_device_definitions.get(identifier).is_none() {
321
+
self
322
+
.user_device_definitions
323
+
.insert(identifier.clone(), features.clone());
324
+
}
325
+
326
+
Some(features)
327
+
}
328
+
}
-442
crates/buttplug_server_device_config/src/device_configuration.rs
-442
crates/buttplug_server_device_config/src/device_configuration.rs
···
1
-
// Buttplug Rust Source Code File - See https://buttplug.io for more info.
2
-
//
3
-
// Copyright 2016-2024 Nonpolynomial Labs LLC. All rights reserved.
4
-
//
5
-
// Licensed under the BSD 3-Clause license. See LICENSE file in the project root
6
-
// for full license information.
7
-
8
-
use super::{
9
-
BaseDeviceDefinition,
10
-
BaseDeviceIdentifier,
11
-
DeviceConfigurationManager,
12
-
DeviceConfigurationManagerBuilder,
13
-
DeviceSettings,
14
-
ProtocolCommunicationSpecifier,
15
-
ServerBaseDeviceFeature,
16
-
UserDeviceDefinition,
17
-
UserDeviceIdentifier,
18
-
};
19
-
use buttplug_core::{
20
-
errors::{ButtplugDeviceError, ButtplugError},
21
-
util::json::JSONValidator,
22
-
};
23
-
use dashmap::DashMap;
24
-
use getset::{CopyGetters, Getters, MutGetters, Setters};
25
-
use serde::{Deserialize, Serialize};
26
-
use std::{collections::HashMap, fmt::Display};
27
-
use uuid::Uuid;
28
-
29
-
pub static DEVICE_CONFIGURATION_JSON: &str =
30
-
include_str!("../build-config/buttplug-device-config-v4.json");
31
-
static DEVICE_CONFIGURATION_JSON_SCHEMA: &str = include_str!(
32
-
"../device-config-v4/buttplug-device-config-schema-v4.json"
33
-
);
34
-
35
-
/// The top level configuration for a protocol. Contains all data about devices that can use the
36
-
/// protocol, as well as names, message attributes, etc... for different devices.
37
-
///
38
-
/// Example: A Kiiroo ProtocolDeviceConfiguration would contain the Bluetooth LE information for all
39
-
/// devices supported under the Kiiroo protocol. It would also contain information about the names
40
-
/// and capabilities of different Kiiroo devices (Cliona, Onyx, Keon, etc...).
41
-
#[derive(Debug, Clone, Getters, MutGetters, Default)]
42
-
struct ProtocolDeviceConfiguration {
43
-
/// BLE/USB/etc info for device identification.
44
-
#[getset(get = "pub(crate)", get_mut = "pub(crate)")]
45
-
specifiers: Vec<ProtocolCommunicationSpecifier>,
46
-
/// Names and message attributes for all possible devices that use this protocol
47
-
#[getset(get = "pub(crate)", get_mut = "pub(crate)")]
48
-
configurations: HashMap<Option<String>, BaseDeviceDefinition>,
49
-
}
50
-
51
-
impl ProtocolDeviceConfiguration {
52
-
/// Create a new instance
53
-
pub fn new(
54
-
specifiers: Vec<ProtocolCommunicationSpecifier>,
55
-
configurations: HashMap<Option<String>, BaseDeviceDefinition>,
56
-
) -> Self {
57
-
Self {
58
-
specifiers,
59
-
configurations,
60
-
}
61
-
}
62
-
}
63
-
64
-
#[derive(Serialize, Deserialize, Debug, Clone, Default, Getters, Setters, MutGetters)]
65
-
#[getset(get = "pub", set = "pub", get_mut = "pub(crate)")]
66
-
struct ProtocolAttributes {
67
-
#[serde(skip_serializing_if = "Option::is_none")]
68
-
identifier: Option<Vec<String>>,
69
-
name: String,
70
-
id: Uuid,
71
-
#[serde(skip_serializing_if = "Option::is_none", rename = "protocol-variant")]
72
-
protocol_variant: Option<String>,
73
-
#[serde(skip_serializing_if = "Option::is_none")]
74
-
features: Option<Vec<ServerBaseDeviceFeature>>,
75
-
#[serde(skip_serializing_if = "Option::is_none")]
76
-
device_settings: Option<DeviceSettings>,
77
-
}
78
-
79
-
#[derive(Deserialize, Serialize, Debug, Clone, Default, Getters, Setters, MutGetters)]
80
-
#[getset(get = "pub", set = "pub", get_mut = "pub(crate)")]
81
-
struct ProtocolDefinition {
82
-
#[serde(skip_serializing_if = "Option::is_none")]
83
-
pub communication: Option<Vec<ProtocolCommunicationSpecifier>>,
84
-
#[serde(skip_serializing_if = "Option::is_none")]
85
-
pub defaults: Option<ProtocolAttributes>,
86
-
#[serde(default)]
87
-
pub configurations: Vec<ProtocolAttributes>,
88
-
}
89
-
90
-
#[derive(Deserialize, Serialize, Debug, Clone, Getters, Setters, MutGetters)]
91
-
#[getset(get = "pub", set = "pub", get_mut = "pub(crate)")]
92
-
struct UserDeviceConfigPair {
93
-
identifier: UserDeviceIdentifier,
94
-
config: UserDeviceDefinition,
95
-
}
96
-
97
-
#[derive(Deserialize, Serialize, Debug, Clone, Default, Getters, Setters, MutGetters)]
98
-
#[getset(get = "pub", set = "pub", get_mut = "pub")]
99
-
struct UserConfigDefinition {
100
-
#[serde(skip_serializing_if = "Option::is_none")]
101
-
protocols: Option<DashMap<String, ProtocolDefinition>>,
102
-
#[serde(rename = "devices", default, skip_serializing_if = "Option::is_none")]
103
-
user_device_configs: Option<Vec<UserDeviceConfigPair>>,
104
-
}
105
-
106
-
impl From<ProtocolDefinition> for ProtocolDeviceConfiguration {
107
-
fn from(protocol_def: ProtocolDefinition) -> Self {
108
-
let mut configurations = HashMap::new();
109
-
110
-
if let Some(defaults) = protocol_def.defaults() {
111
-
let config_attrs = BaseDeviceDefinition::new(
112
-
&defaults.name,
113
-
&defaults.id,
114
-
&defaults.protocol_variant,
115
-
defaults
116
-
.features
117
-
.as_ref()
118
-
.expect("This is a default, therefore we'll always have features."),
119
-
&defaults.device_settings,
120
-
);
121
-
configurations.insert(None, config_attrs);
122
-
}
123
-
for config in &protocol_def.configurations {
124
-
if let Some(identifiers) = &config.identifier {
125
-
for identifier in identifiers {
126
-
let config_attrs = BaseDeviceDefinition::new(
127
-
// Even subconfigurations always have names
128
-
&config.name,
129
-
&config.id,
130
-
&config.protocol_variant,
131
-
config.features.as_ref().unwrap_or(
132
-
protocol_def
133
-
.defaults()
134
-
.as_ref()
135
-
.unwrap_or(&ProtocolAttributes::default())
136
-
.features
137
-
.as_ref()
138
-
.unwrap_or(&vec![]),
139
-
),
140
-
&config.device_settings,
141
-
);
142
-
configurations.insert(Some(identifier.to_owned()), config_attrs);
143
-
}
144
-
}
145
-
}
146
-
147
-
Self::new(
148
-
protocol_def.communication.unwrap_or_default(),
149
-
configurations,
150
-
)
151
-
}
152
-
}
153
-
154
-
#[derive(Deserialize, Serialize, Debug, CopyGetters, Clone, Copy)]
155
-
#[getset(get_copy = "pub", get_mut = "pub")]
156
-
struct ConfigVersion {
157
-
pub major: u32,
158
-
pub minor: u32,
159
-
}
160
-
161
-
impl Display for ConfigVersion {
162
-
fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
163
-
write!(f, "{}.{}", self.major, self.minor)
164
-
}
165
-
}
166
-
167
-
trait ConfigVersionGetter {
168
-
fn version(&self) -> ConfigVersion;
169
-
}
170
-
171
-
#[derive(Deserialize, Serialize, Debug, Getters)]
172
-
#[getset(get = "pub", get_mut = "pub", set = "pub")]
173
-
pub struct BaseConfigFile {
174
-
version: ConfigVersion,
175
-
#[serde(default, skip_serializing_if = "Option::is_none")]
176
-
protocols: Option<HashMap<String, ProtocolDefinition>>,
177
-
}
178
-
179
-
impl Default for BaseConfigFile {
180
-
fn default() -> Self {
181
-
Self {
182
-
version: get_internal_config_version(),
183
-
protocols: Some(HashMap::new()),
184
-
}
185
-
}
186
-
}
187
-
188
-
impl ConfigVersionGetter for BaseConfigFile {
189
-
fn version(&self) -> ConfigVersion {
190
-
self.version
191
-
}
192
-
}
193
-
194
-
impl BaseConfigFile {
195
-
pub fn new(major_version: u32, minor_version: u32) -> Self {
196
-
Self {
197
-
version: ConfigVersion {
198
-
major: major_version,
199
-
minor: minor_version,
200
-
},
201
-
protocols: None,
202
-
}
203
-
}
204
-
}
205
-
206
-
#[derive(Deserialize, Serialize, Debug, Getters)]
207
-
#[getset(get = "pub", get_mut = "pub", set = "pub")]
208
-
struct UserConfigFile {
209
-
version: ConfigVersion,
210
-
#[serde(rename = "user-configs", default)]
211
-
user_configs: Option<UserConfigDefinition>,
212
-
}
213
-
214
-
impl Default for UserConfigFile {
215
-
fn default() -> Self {
216
-
Self {
217
-
version: get_internal_config_version(),
218
-
user_configs: Some(UserConfigDefinition::default()),
219
-
}
220
-
}
221
-
}
222
-
223
-
impl ConfigVersionGetter for UserConfigFile {
224
-
fn version(&self) -> ConfigVersion {
225
-
self.version
226
-
}
227
-
}
228
-
229
-
impl UserConfigFile {
230
-
pub fn new(major_version: u32, minor_version: u32) -> Self {
231
-
Self {
232
-
version: ConfigVersion {
233
-
major: major_version,
234
-
minor: minor_version,
235
-
},
236
-
user_configs: None,
237
-
}
238
-
}
239
-
240
-
#[allow(dead_code)]
241
-
pub fn to_json(&self) -> String {
242
-
serde_json::to_string(self)
243
-
.expect("All types below this are Serialize, so this should be infallible.")
244
-
}
245
-
}
246
-
247
-
fn get_internal_config_version() -> ConfigVersion {
248
-
let config: BaseConfigFile = serde_json::from_str(DEVICE_CONFIGURATION_JSON)
249
-
.expect("If this fails, the whole library goes with it.");
250
-
config.version
251
-
}
252
-
253
-
fn load_protocol_config_from_json<'a, T>(
254
-
config_str: &'a str,
255
-
skip_version_check: bool,
256
-
) -> Result<T, ButtplugDeviceError>
257
-
where
258
-
T: ConfigVersionGetter + Deserialize<'a>,
259
-
{
260
-
let config_validator = JSONValidator::new(DEVICE_CONFIGURATION_JSON_SCHEMA);
261
-
match config_validator.validate(config_str) {
262
-
Ok(_) => match serde_json::from_str::<T>(config_str) {
263
-
Ok(protocol_config) => {
264
-
let internal_config_version = get_internal_config_version();
265
-
if !skip_version_check && protocol_config.version().major != internal_config_version.major {
266
-
Err(ButtplugDeviceError::DeviceConfigurationError(format!(
267
-
"Device configuration file major version {} is different than internal major version {}. Cannot load external files that do not have matching major version numbers.",
268
-
protocol_config.version(),
269
-
internal_config_version
270
-
)))
271
-
} else {
272
-
Ok(protocol_config)
273
-
}
274
-
}
275
-
Err(err) => Err(ButtplugDeviceError::DeviceConfigurationError(format!(
276
-
"{err}"
277
-
))),
278
-
},
279
-
Err(err) => Err(ButtplugDeviceError::DeviceConfigurationError(format!(
280
-
"{err}"
281
-
))),
282
-
}
283
-
}
284
-
285
-
fn load_main_config(
286
-
main_config_str: &Option<String>,
287
-
skip_version_check: bool,
288
-
) -> Result<DeviceConfigurationManagerBuilder, ButtplugDeviceError> {
289
-
if main_config_str.is_some() {
290
-
info!("Loading from custom base device configuration...")
291
-
} else {
292
-
info!("Loading from internal base device configuration...")
293
-
}
294
-
// Start by loading the main config
295
-
let main_config = load_protocol_config_from_json::<BaseConfigFile>(
296
-
main_config_str
297
-
.as_ref()
298
-
.unwrap_or(&DEVICE_CONFIGURATION_JSON.to_owned()),
299
-
skip_version_check,
300
-
)?;
301
-
302
-
info!("Loaded config version {:?}", main_config.version);
303
-
304
-
let mut dcm_builder = DeviceConfigurationManagerBuilder::default();
305
-
306
-
// Each protocol will need to become a ProtocolDeviceConfiguration, so we'll need to
307
-
//
308
-
// - take the specifiers from both the main and user configs and make a vector out of them
309
-
// - for each configuration and user config, we'll need to create message lists and figure out
310
-
// what to do with allow/deny/index.
311
-
312
-
let mut protocol_specifiers = HashMap::new();
313
-
let mut protocol_features = HashMap::new();
314
-
315
-
// Iterate through all of the protocols in the main config first and build up a map of protocol
316
-
// name to ProtocolDeviceConfiguration structs.
317
-
for (protocol_name, protocol_def) in main_config.protocols.unwrap_or_default() {
318
-
let protocol_device_config: ProtocolDeviceConfiguration = protocol_def.into();
319
-
protocol_specifiers.insert(
320
-
protocol_name.clone(),
321
-
protocol_device_config.specifiers().clone(),
322
-
);
323
-
for (config_ident, config) in protocol_device_config.configurations() {
324
-
let ident = BaseDeviceIdentifier::new(&protocol_name, config_ident);
325
-
protocol_features.insert(ident, config.clone());
326
-
}
327
-
}
328
-
329
-
for (name, specifiers) in &protocol_specifiers {
330
-
dcm_builder.communication_specifier(name, specifiers);
331
-
}
332
-
333
-
for (ident, features) in protocol_features {
334
-
dcm_builder.protocol_features(&ident, &features);
335
-
}
336
-
337
-
Ok(dcm_builder)
338
-
}
339
-
340
-
fn load_user_config(
341
-
user_config_str: &str,
342
-
skip_version_check: bool,
343
-
dcm_builder: &mut DeviceConfigurationManagerBuilder,
344
-
) -> Result<(), ButtplugDeviceError> {
345
-
info!("Loading user configuration from string.");
346
-
let user_config_file =
347
-
load_protocol_config_from_json::<UserConfigFile>(user_config_str, skip_version_check)?;
348
-
349
-
if user_config_file.user_configs.is_none() {
350
-
info!("No user configurations provided in user config.");
351
-
return Ok(());
352
-
}
353
-
354
-
let user_config = user_config_file
355
-
.user_configs
356
-
.expect("Just checked validity");
357
-
358
-
let mut protocol_specifiers = HashMap::new();
359
-
let mut protocol_features = HashMap::new();
360
-
361
-
for (protocol_name, protocol_def) in user_config.protocols.unwrap_or_default() {
362
-
if let Some(comm_specifiers) = protocol_def.communication() {
363
-
dcm_builder.user_communication_specifier(&protocol_name, comm_specifiers);
364
-
}
365
-
info!("{:?}", protocol_def);
366
-
info!("Adding {}", protocol_name);
367
-
let protocol_device_config: ProtocolDeviceConfiguration = protocol_def.into();
368
-
protocol_specifiers.insert(
369
-
protocol_name.clone(),
370
-
protocol_device_config.specifiers().clone(),
371
-
);
372
-
info!("{:?}", protocol_device_config);
373
-
for (config_ident, config) in protocol_device_config.configurations() {
374
-
info!("Adding {:?}", config_ident);
375
-
let ident = BaseDeviceIdentifier::new(&protocol_name, config_ident);
376
-
protocol_features.insert(ident, config.clone());
377
-
}
378
-
}
379
-
380
-
for (ident, features) in protocol_features {
381
-
info!("Adding {}", features.id());
382
-
dcm_builder.protocol_features(&ident, &features);
383
-
}
384
-
385
-
for user_device_config_pair in user_config.user_device_configs.unwrap_or_default() {
386
-
dcm_builder.user_protocol_features(
387
-
user_device_config_pair.identifier(),
388
-
user_device_config_pair.config(),
389
-
);
390
-
}
391
-
392
-
Ok(())
393
-
}
394
-
395
-
pub fn load_protocol_configs(
396
-
main_config_str: &Option<String>,
397
-
user_config_str: &Option<String>,
398
-
skip_version_check: bool,
399
-
) -> Result<DeviceConfigurationManagerBuilder, ButtplugDeviceError> {
400
-
let mut dcm_builder = load_main_config(main_config_str, skip_version_check)?;
401
-
402
-
if let Some(config_str) = user_config_str {
403
-
load_user_config(config_str, skip_version_check, &mut dcm_builder)?;
404
-
} else {
405
-
info!("No user configuration provided.");
406
-
}
407
-
408
-
Ok(dcm_builder)
409
-
}
410
-
411
-
pub fn save_user_config(dcm: &DeviceConfigurationManager) -> Result<String, ButtplugError> {
412
-
let user_specifiers = dcm.user_communication_specifiers();
413
-
let user_definitions_vec = dcm
414
-
.user_device_definitions()
415
-
.iter()
416
-
.map(|kv| UserDeviceConfigPair {
417
-
identifier: kv.key().clone(),
418
-
config: kv.value().user_device().clone(),
419
-
})
420
-
.collect();
421
-
let user_protos = DashMap::new();
422
-
for spec in user_specifiers {
423
-
user_protos.insert(
424
-
spec.key().clone(),
425
-
ProtocolDefinition {
426
-
communication: Some(spec.value().clone()),
427
-
..Default::default()
428
-
},
429
-
);
430
-
}
431
-
let user_config_definition = UserConfigDefinition {
432
-
protocols: Some(user_protos.clone()),
433
-
user_device_configs: Some(user_definitions_vec),
434
-
};
435
-
let mut user_config_file = UserConfigFile::new(4, 0);
436
-
user_config_file.user_configs = Some(user_config_definition);
437
-
serde_json::to_string(&user_config_file).map_err(|e| {
438
-
ButtplugError::from(ButtplugDeviceError::DeviceConfigurationError(format!(
439
-
"Cannot save device configuration file: {e:?}",
440
-
)))
441
-
})
442
-
}
···
+51
-216
crates/buttplug_server_device_config/src/device_definitions.rs
+51
-216
crates/buttplug_server_device_config/src/device_definitions.rs
···
1
-
use std::time::Duration;
2
-
3
-
use getset::{CopyGetters, Getters, MutGetters};
4
-
use serde::{Deserialize, Serialize};
5
use uuid::Uuid;
6
7
use super::device_feature::{
8
-
ServerBaseDeviceFeature,
9
ServerDeviceFeature,
10
-
ServerUserDeviceFeature,
11
-
ServerUserDeviceFeatureOutput,
12
};
13
-
use buttplug_core::message::OutputType;
14
-
15
-
#[derive(Serialize, Deserialize, Debug, Clone, Default, CopyGetters)]
16
-
pub struct DeviceSettings {
17
-
#[serde(
18
-
rename = "message-gap-ms",
19
-
skip_serializing_if = "Option::is_none",
20
-
default
21
-
)]
22
-
#[getset(get_copy = "pub")]
23
-
message_gap_ms: Option<u32>,
24
-
}
25
-
26
-
impl DeviceSettings {
27
-
pub fn is_none(&self) -> bool {
28
-
self.message_gap_ms.is_none()
29
-
}
30
-
}
31
-
32
-
#[derive(Serialize, Deserialize, Debug, Clone, Default, CopyGetters)]
33
-
pub struct BaseFeatureSettings {
34
-
#[serde(
35
-
rename = "alt-protocol-index",
36
-
skip_serializing_if = "Option::is_none",
37
-
default
38
-
)]
39
-
#[getset(get_copy = "pub")]
40
-
alt_protocol_index: Option<u32>,
41
-
}
42
-
43
-
impl BaseFeatureSettings {
44
-
pub fn is_none(&self) -> bool {
45
-
self.alt_protocol_index.is_none()
46
-
}
47
-
}
48
-
49
-
#[derive(Serialize, Deserialize, Debug, Clone, Default)]
50
-
pub struct UserFeatureSettings {
51
-
#[serde(
52
-
rename = "reverse-position",
53
-
skip_serializing_if = "Option::is_none",
54
-
default
55
-
)]
56
-
reverse_position: Option<bool>,
57
-
}
58
-
59
-
impl UserFeatureSettings {
60
-
pub fn is_none(&self) -> bool {
61
-
self.reverse_position.is_none()
62
-
}
63
-
}
64
-
65
#[derive(Debug, Clone, Getters, CopyGetters)]
66
-
pub struct BaseDeviceDefinition {
67
#[getset(get = "pub")]
68
/// Given name of the device this instance represents.
69
name: String,
70
-
#[getset(get = "pub")]
71
-
/// Message attributes for this device instance.
72
-
features: Vec<ServerBaseDeviceFeature>,
73
#[getset(get_copy = "pub")]
74
id: Uuid,
75
#[getset(get = "pub")]
76
protocol_variant: Option<String>,
77
-
#[getset(get = "pub")]
78
-
device_settings: DeviceSettings,
79
-
}
80
-
81
-
impl BaseDeviceDefinition {
82
-
/// Create a new instance
83
-
pub fn new(
84
-
name: &str,
85
-
id: &Uuid,
86
-
protocol_variant: &Option<String>,
87
-
features: &[ServerBaseDeviceFeature],
88
-
device_settings: &Option<DeviceSettings>,
89
-
) -> Self {
90
-
Self {
91
-
name: name.to_owned(),
92
-
features: features.into(),
93
-
id: *id,
94
-
protocol_variant: protocol_variant.clone(),
95
-
device_settings: device_settings.clone().unwrap_or_default(),
96
-
}
97
-
}
98
-
}
99
-
100
-
#[derive(Serialize, Deserialize, Debug, Getters, CopyGetters, Default, Clone, MutGetters)]
101
-
pub struct UserDeviceCustomization {
102
-
#[serde(
103
-
rename = "display-name",
104
-
default,
105
-
skip_serializing_if = "Option::is_none"
106
-
)]
107
#[getset(get = "pub")]
108
display_name: Option<String>,
109
-
#[serde(default)]
110
#[getset(get_copy = "pub")]
111
allow: bool,
112
-
#[serde(default)]
113
#[getset(get_copy = "pub")]
114
deny: bool,
115
-
#[getset(get_copy = "pub", get_mut = "pub")]
116
index: u32,
117
-
#[getset(get_copy = "pub")]
118
-
#[serde(
119
-
rename = "message-gap-ms",
120
-
default,
121
-
skip_serializing_if = "Option::is_none"
122
-
)]
123
-
message_gap_ms: Option<u32>,
124
}
125
126
-
impl UserDeviceCustomization {
127
-
pub fn new(
128
-
display_name: &Option<String>,
129
-
allow: bool,
130
-
deny: bool,
131
-
index: u32,
132
-
message_gap_ms: Option<u32>,
133
-
) -> Self {
134
-
Self {
135
-
display_name: display_name.clone(),
136
-
allow,
137
-
deny,
138
-
index,
139
-
message_gap_ms,
140
-
}
141
-
}
142
-
143
-
pub fn default_with_index(index: u32) -> Self {
144
-
Self::new(&None, false, false, index, None)
145
-
}
146
}
147
148
-
#[derive(Debug, Clone, Getters, MutGetters, Serialize, Deserialize, CopyGetters)]
149
-
pub struct UserDeviceDefinition {
150
-
#[getset(get_copy = "pub")]
151
-
id: Uuid,
152
-
#[getset(get_copy = "pub")]
153
-
#[serde(rename = "base-id")]
154
-
base_id: Uuid,
155
-
#[getset(get = "pub")]
156
-
/// Message attributes for this device instance.
157
-
#[getset(get = "pub", get_mut = "pub")]
158
-
features: Vec<ServerUserDeviceFeature>,
159
-
#[getset(get = "pub", get_mut = "pub")]
160
-
#[serde(rename = "user-config")]
161
-
/// Per-user configurations specific to this device instance.
162
-
user_config: UserDeviceCustomization,
163
-
}
164
-
165
-
impl UserDeviceDefinition {
166
-
fn new(index: u32, base_id: Uuid, features: &Vec<ServerUserDeviceFeature>) -> Self {
167
Self {
168
-
id: Uuid::new_v4(),
169
-
base_id,
170
-
features: features.clone(),
171
-
user_config: UserDeviceCustomization::default_with_index(index),
172
}
173
}
174
-
}
175
176
-
#[derive(Debug, Clone, Getters, CopyGetters, MutGetters)]
177
-
pub struct DeviceDefinition {
178
-
#[getset(get = "pub")]
179
-
base_device: BaseDeviceDefinition,
180
-
#[getset(get = "pub", get_mut = "pub")]
181
-
user_device: UserDeviceDefinition,
182
-
}
183
-
184
-
impl DeviceDefinition {
185
-
/// Create a new instance
186
-
pub fn new(base_device: &BaseDeviceDefinition, user_device: &UserDeviceDefinition) -> Self {
187
-
Self {
188
-
base_device: base_device.clone(),
189
-
user_device: user_device.clone(),
190
-
}
191
}
192
193
-
pub fn id(&self) -> Uuid {
194
-
self.user_device.id()
195
}
196
197
-
pub fn name(&self) -> &str {
198
-
self.base_device.name()
199
}
200
201
-
pub fn protocol_variant(&self) -> &Option<String> {
202
-
self.base_device.protocol_variant()
203
}
204
205
-
pub fn features(&self) -> Vec<ServerDeviceFeature> {
206
-
// TODO Gross way to do this.
207
-
let mut features: Vec<ServerDeviceFeature> = vec![];
208
-
self.base_device.features().iter().for_each(|x| {
209
-
if let Some(user_feature) = self
210
-
.user_device
211
-
.features
212
-
.iter()
213
-
.find(|user_feature| user_feature.base_id() == x.id())
214
-
{
215
-
features.push(ServerDeviceFeature::new(x, user_feature));
216
-
}
217
-
});
218
-
features
219
}
220
221
-
pub fn user_config(&self) -> &UserDeviceCustomization {
222
-
self.user_device.user_config()
223
}
224
225
-
pub fn message_gap(&self) -> Option<Duration> {
226
-
if let Some(gap) = self.user_device.user_config().message_gap_ms() {
227
-
Some(Duration::from_millis(gap.into()))
228
-
} else if let Some(gap) = self.base_device.device_settings.message_gap_ms() {
229
-
Some(Duration::from_millis(gap.into()))
230
-
} else {
231
-
None
232
-
}
233
}
234
235
-
pub fn new_from_base_definition(def: &BaseDeviceDefinition, index: u32) -> Self {
236
-
let user_features = def
237
-
.features()
238
-
.iter()
239
-
.map(|x| x.as_user_device_feature())
240
-
.collect();
241
-
Self::new(
242
-
def,
243
-
&UserDeviceDefinition::new(index, def.id(), &user_features),
244
-
)
245
}
246
247
-
pub fn update_user_output(
248
-
&mut self,
249
-
feature_id: Uuid,
250
-
output_type: OutputType,
251
-
user_output: ServerUserDeviceFeatureOutput,
252
-
) {
253
-
if let Some(feature) = self
254
-
.user_device
255
-
.features_mut()
256
-
.iter_mut()
257
-
.find(|x| x.id() == feature_id)
258
-
{
259
-
feature.update_output(output_type, &user_output);
260
-
}
261
}
262
}
···
1
+
use getset::{CopyGetters, Getters};
2
use uuid::Uuid;
3
4
use super::device_feature::{
5
ServerDeviceFeature,
6
};
7
#[derive(Debug, Clone, Getters, CopyGetters)]
8
+
pub struct ServerDeviceDefinition {
9
#[getset(get = "pub")]
10
/// Given name of the device this instance represents.
11
name: String,
12
#[getset(get_copy = "pub")]
13
id: Uuid,
14
+
#[getset(get_copy = "pub")]
15
+
base_id: Option<Uuid>,
16
#[getset(get = "pub")]
17
protocol_variant: Option<String>,
18
+
#[getset(get_copy = "pub")]
19
+
message_gap_ms: Option<u32>,
20
#[getset(get = "pub")]
21
display_name: Option<String>,
22
#[getset(get_copy = "pub")]
23
allow: bool,
24
#[getset(get_copy = "pub")]
25
deny: bool,
26
+
#[getset(get_copy = "pub")]
27
index: u32,
28
+
#[getset(get = "pub")]
29
+
features: Vec<ServerDeviceFeature>
30
}
31
32
+
pub struct ServerDeviceDefinitionBuilder {
33
+
def: ServerDeviceDefinition,
34
}
35
36
+
impl ServerDeviceDefinitionBuilder {
37
+
pub fn new(name: &str, id: &Uuid) -> Self {
38
Self {
39
+
def: ServerDeviceDefinition {
40
+
name: name.to_owned(),
41
+
id: id.clone(),
42
+
base_id: None,
43
+
protocol_variant: None,
44
+
message_gap_ms: None,
45
+
display_name: None,
46
+
allow: false,
47
+
deny: false,
48
+
index: 0,
49
+
features: vec!()
50
+
},
51
}
52
}
53
54
+
pub fn base_id(&mut self, id: &Uuid) -> &mut Self {
55
+
self.def.base_id = Some(id.clone());
56
+
self
57
}
58
59
+
pub fn display_name(&mut self, name: &str) -> &mut Self {
60
+
self.def.display_name = Some(name.to_owned());
61
+
self
62
}
63
64
+
pub fn protocol_variant(&mut self, variant: &str) -> &mut Self {
65
+
self.def.protocol_variant = Some(variant.to_owned());
66
+
self
67
}
68
69
+
pub fn message_gap_ms(&mut self, gap: u32) -> &mut Self {
70
+
self.def.message_gap_ms = Some(gap);
71
+
self
72
}
73
74
+
pub fn allow(&mut self) -> &mut Self {
75
+
self.def.allow = true;
76
+
self
77
}
78
79
+
pub fn deny(&mut self) -> &mut Self {
80
+
self.def.deny = true;
81
+
self
82
}
83
84
+
pub fn index(&mut self, index: u32) -> &mut Self {
85
+
self.def.index = index;
86
+
self
87
}
88
89
+
pub fn add_feature(&mut self, feature: &ServerDeviceFeature) -> &mut Self {
90
+
self.def.features.push(feature.clone());
91
+
self
92
}
93
94
+
pub fn finish(self) -> ServerDeviceDefinition {
95
+
self.def
96
}
97
}
+148
-278
crates/buttplug_server_device_config/src/device_feature.rs
+148
-278
crates/buttplug_server_device_config/src/device_feature.rs
···
5
// Licensed under the BSD 3-Clause license. See LICENSE file in the project root
6
// for full license information.
7
8
-
use super::BaseFeatureSettings;
9
use buttplug_core::{
10
-
errors::ButtplugDeviceError,
11
message::{
12
DeviceFeature,
13
DeviceFeatureInput,
14
-
DeviceFeatureOutput,
15
InputCommandType,
16
-
InputType,
17
-
OutputType,
18
},
19
};
20
-
use getset::{CopyGetters, Getters, MutGetters, Setters};
21
use serde::{
22
-
ser::{self, SerializeSeq},
23
Deserialize,
24
Serialize,
25
Serializer,
26
};
27
use std::{
28
collections::{HashMap, HashSet},
···
60
seq.end()
61
}
62
63
-
#[derive(
64
-
Clone, Debug, Default, Getters, MutGetters, Setters, Serialize, Deserialize, CopyGetters,
65
-
)]
66
-
pub struct ServerBaseDeviceFeature {
67
-
#[getset(get = "pub", get_mut = "pub(super)")]
68
-
#[serde(default)]
69
-
description: String,
70
-
#[getset(get = "pub")]
71
-
#[serde(skip_serializing_if = "Option::is_none")]
72
-
#[serde(rename = "output")]
73
-
output: Option<HashMap<OutputType, ServerBaseDeviceFeatureOutput>>,
74
-
#[getset(get = "pub")]
75
-
#[serde(skip_serializing_if = "Option::is_none")]
76
-
#[serde(rename = "input")]
77
-
input: Option<HashMap<InputType, ServerDeviceFeatureInput>>,
78
-
#[getset(get_copy = "pub")]
79
-
id: Uuid,
80
-
#[getset(get = "pub")]
81
-
#[serde(
82
-
rename = "feature-settings",
83
-
skip_serializing_if = "BaseFeatureSettings::is_none",
84
-
default
85
-
)]
86
-
feature_settings: BaseFeatureSettings,
87
}
88
89
-
impl ServerBaseDeviceFeature {
90
-
pub fn as_user_device_feature(&self) -> ServerUserDeviceFeature {
91
-
ServerUserDeviceFeature {
92
-
id: Uuid::new_v4(),
93
-
base_id: self.id,
94
-
output: self.output.as_ref().and_then(|x| {
95
-
Some(
96
-
x.keys()
97
-
.map(|x| (*x, ServerUserDeviceFeatureOutput::default()))
98
-
.collect(),
99
-
)
100
-
}),
101
}
102
}
103
}
104
105
-
#[derive(
106
-
Clone, Debug, Default, Getters, MutGetters, Setters, Serialize, Deserialize, CopyGetters,
107
-
)]
108
-
pub struct ServerUserDeviceFeature {
109
#[getset(get_copy = "pub")]
110
-
id: Uuid,
111
-
#[getset(get_copy = "pub")]
112
-
#[serde(rename = "base-id")]
113
-
base_id: Uuid,
114
-
#[getset(get = "pub")]
115
-
#[serde(rename = "output", skip_serializing_if = "Option::is_none")]
116
-
output: Option<HashMap<OutputType, ServerUserDeviceFeatureOutput>>,
117
}
118
119
-
impl ServerUserDeviceFeature {
120
-
pub fn update_output(&mut self, output_type: OutputType, output: &ServerUserDeviceFeatureOutput) {
121
-
if let Some(ref mut output_map) = self.output {
122
-
if output_map.contains_key(&output_type) {
123
-
output_map.insert(output_type, output.clone());
124
-
}
125
}
126
}
127
}
128
129
-
#[derive(Clone, Debug, Getters, MutGetters, Setters, Serialize, Deserialize, CopyGetters)]
130
-
pub struct ServerBaseDeviceFeatureOutput {
131
#[getset(get = "pub")]
132
-
#[serde(rename = "step-range")]
133
-
step_range: RangeInclusive<u32>,
134
}
135
136
-
impl ServerBaseDeviceFeatureOutput {
137
-
pub fn new(step_range: &RangeInclusive<u32>) -> Self {
138
Self {
139
-
step_range: step_range.clone(),
140
}
141
}
142
}
143
144
-
#[derive(
145
-
Clone, Debug, Default, Getters, MutGetters, Setters, Serialize, Deserialize, CopyGetters,
146
-
)]
147
-
pub struct ServerUserDeviceFeatureOutput {
148
-
#[getset(get = "pub")]
149
-
#[serde(
150
-
rename = "step-limit",
151
-
default,
152
-
skip_serializing_if = "Option::is_none",
153
-
serialize_with = "range_serialize"
154
-
)]
155
-
step_limit: Option<RangeInclusive<u32>>,
156
-
#[getset(get = "pub")]
157
-
#[serde(
158
-
rename = "reverse-position",
159
-
default,
160
-
skip_serializing_if = "Option::is_none"
161
-
)]
162
-
reverse_position: Option<bool>,
163
-
#[getset(get = "pub")]
164
-
#[serde(rename = "disabled", default, skip_serializing_if = "Option::is_none")]
165
-
disabled: Option<bool>,
166
}
167
168
-
impl ServerUserDeviceFeatureOutput {
169
pub fn new(
170
-
step_limit: Option<RangeInclusive<u32>>,
171
-
reverse_position: Option<bool>,
172
-
disabled: Option<bool>,
173
) -> Self {
174
Self {
175
-
step_limit,
176
-
reverse_position,
177
-
disabled,
178
}
179
}
180
}
181
182
-
#[derive(Clone, Debug, Default, Getters, MutGetters, Setters, CopyGetters)]
183
pub struct ServerDeviceFeature {
184
-
base_feature: ServerBaseDeviceFeature,
185
-
#[getset(get_mut = "pub")]
186
-
user_feature: ServerUserDeviceFeature,
187
#[getset(get = "pub")]
188
-
output: Option<HashMap<OutputType, ServerDeviceFeatureOutput>>,
189
-
// input doesn't specialize across Base/User right now so we just return the base device input
190
}
191
192
impl PartialEq for ServerDeviceFeature {
···
199
}
200
201
impl ServerDeviceFeature {
202
-
pub fn new(
203
-
base_feature: &ServerBaseDeviceFeature,
204
-
user_feature: &ServerUserDeviceFeature,
205
-
) -> Self {
206
-
if base_feature.id() != user_feature.base_id() {
207
-
// TODO panic!
208
-
}
209
-
let output = {
210
-
if let Some(output_map) = base_feature.output() {
211
-
let mut output = HashMap::new();
212
-
if let Some(user_output_map) = user_feature.output() {
213
-
for (output_type, output_feature) in output_map {
214
-
// TODO What if we have a key in the user map that isn't in the base map? We should remove it.
215
-
if user_output_map.contains_key(output_type) {
216
-
output.insert(
217
-
*output_type,
218
-
ServerDeviceFeatureOutput::new(
219
-
output_feature,
220
-
user_output_map.get(output_type).clone().unwrap(),
221
-
),
222
-
);
223
-
}
224
-
}
225
-
}
226
-
Some(output)
227
-
} else {
228
-
None
229
-
}
230
-
};
231
-
232
Self {
233
-
output,
234
-
base_feature: base_feature.clone(),
235
-
user_feature: user_feature.clone(),
236
}
237
}
238
239
-
pub fn description(&self) -> &String {
240
-
self.base_feature.description()
241
-
}
242
-
243
-
pub fn id(&self) -> Uuid {
244
-
self.user_feature.id()
245
-
}
246
-
247
-
pub fn base_id(&self) -> Uuid {
248
-
self.base_feature.id()
249
-
}
250
-
251
-
pub fn alt_protocol_index(&self) -> Option<u32> {
252
-
self.base_feature.feature_settings().alt_protocol_index()
253
-
}
254
-
255
-
pub fn input(&self) -> &Option<HashMap<InputType, ServerDeviceFeatureInput>> {
256
-
self.base_feature.input()
257
-
}
258
-
259
-
pub fn is_valid(&self) -> Result<(), ButtplugDeviceError> {
260
if let Some(output_map) = &self.output {
261
-
for actuator in output_map.values() {
262
-
actuator.is_valid()?;
263
}
264
}
265
-
Ok(())
266
-
}
267
268
-
pub fn as_device_feature(&self, index: u32) -> DeviceFeature {
269
-
DeviceFeature::new(
270
index,
271
self.description(),
272
-
&self.output.clone().map(|x| {
273
-
x.iter()
274
-
.filter(|(_, a)| !a.user_feature().disabled().as_ref().unwrap_or(&false))
275
-
.map(|(t, a)| (*t, DeviceFeatureOutput::from(a.clone())))
276
-
.collect()
277
-
}),
278
&self.base_feature.input().clone().map(|x| {
279
x.iter()
280
.map(|(t, a)| (*t, DeviceFeatureInput::from(a.clone())))
281
.collect()
282
}),
283
-
)
284
}
285
-
}
286
-
287
-
#[derive(Clone, Debug, Getters, MutGetters)]
288
-
#[getset(get = "pub")]
289
-
pub struct ServerDeviceFeatureOutput {
290
-
base_feature: ServerBaseDeviceFeatureOutput,
291
-
#[getset(get_mut = "pub")]
292
-
user_feature: ServerUserDeviceFeatureOutput,
293
-
}
294
-
295
-
impl ServerDeviceFeatureOutput {
296
-
pub fn new(
297
-
base_feature: &ServerBaseDeviceFeatureOutput,
298
-
user_feature: &ServerUserDeviceFeatureOutput,
299
-
) -> Self {
300
-
Self {
301
-
base_feature: base_feature.clone(),
302
-
user_feature: user_feature.clone(),
303
-
}
304
-
}
305
-
306
-
pub fn step_range(&self) -> &RangeInclusive<u32> {
307
-
self.base_feature.step_range()
308
-
}
309
-
310
-
pub fn step_limit(&self) -> &RangeInclusive<u32> {
311
-
if let Some(limit) = self.user_feature.step_limit() {
312
-
limit
313
-
} else {
314
-
self.step_range()
315
-
}
316
-
}
317
-
318
-
pub fn step_count(&self) -> u32 {
319
-
if let Some(step_limit) = self.user_feature.step_limit() {
320
-
step_limit.end() - step_limit.start()
321
-
} else {
322
-
self.base_feature.step_range.end() - self.base_feature.step_range.start()
323
-
}
324
-
}
325
-
326
-
pub fn reverse_position(&self) -> bool {
327
-
*self
328
-
.user_feature
329
-
.reverse_position()
330
-
.as_ref()
331
-
.unwrap_or(&false)
332
-
}
333
-
334
-
pub fn is_valid(&self) -> Result<(), ButtplugDeviceError> {
335
-
let step_range = self.base_feature.step_range();
336
-
if step_range.is_empty() {
337
-
Err(ButtplugDeviceError::DeviceConfigurationError(
338
-
"Step range empty.".to_string(),
339
-
))
340
-
} else if let Some(step_limit) = self.user_feature.step_limit() {
341
-
if step_limit.is_empty() {
342
-
Err(ButtplugDeviceError::DeviceConfigurationError(
343
-
"Step limit empty.".to_string(),
344
-
))
345
-
} else if step_limit.start() < step_range.start() || step_limit.end() > step_range.end() {
346
-
Err(ButtplugDeviceError::DeviceConfigurationError(
347
-
"Step limit outside step range.".to_string(),
348
-
))
349
-
} else {
350
-
Ok(())
351
-
}
352
-
} else {
353
-
Ok(())
354
-
}
355
-
}
356
-
}
357
-
358
-
impl From<ServerDeviceFeatureOutput> for DeviceFeatureOutput {
359
-
fn from(value: ServerDeviceFeatureOutput) -> Self {
360
-
DeviceFeatureOutput::new(value.step_count())
361
-
}
362
-
}
363
-
364
-
#[derive(
365
-
Clone, Debug, Default, PartialEq, Eq, Getters, MutGetters, Setters, Serialize, Deserialize,
366
-
)]
367
-
pub struct ServerDeviceFeatureInput {
368
-
#[getset(get = "pub", get_mut = "pub(super)")]
369
-
#[serde(rename = "value-range")]
370
-
#[serde(serialize_with = "range_sequence_serialize")]
371
-
value_range: Vec<RangeInclusive<i32>>,
372
-
#[getset(get = "pub")]
373
-
#[serde(rename = "input-commands")]
374
-
input_commands: HashSet<InputCommandType>,
375
-
}
376
-
377
-
impl ServerDeviceFeatureInput {
378
-
pub fn new(
379
-
value_range: &Vec<RangeInclusive<i32>>,
380
-
sensor_commands: &HashSet<InputCommandType>,
381
-
) -> Self {
382
-
Self {
383
-
value_range: value_range.clone(),
384
-
input_commands: sensor_commands.clone(),
385
-
}
386
-
}
387
-
}
388
-
389
-
impl From<ServerDeviceFeatureInput> for DeviceFeatureInput {
390
-
fn from(value: ServerDeviceFeatureInput) -> Self {
391
-
// Unlike actuator, this is just a straight copy.
392
-
DeviceFeatureInput::new(value.value_range(), value.input_commands())
393
-
}
394
}
···
5
// Licensed under the BSD 3-Clause license. See LICENSE file in the project root
6
// for full license information.
7
8
+
use crate::ButtplugDeviceConfigError;
9
+
10
use buttplug_core::{
11
message::{
12
DeviceFeature,
13
DeviceFeatureInput,
14
InputCommandType,
15
},
16
};
17
+
use getset::{CopyGetters, Getters};
18
use serde::{
19
Deserialize,
20
Serialize,
21
Serializer,
22
+
ser::{self, SerializeSeq},
23
};
24
use std::{
25
collections::{HashMap, HashSet},
···
57
seq.end()
58
}
59
60
+
#[derive(Debug, Clone)]
61
+
pub struct RangeWithLimit<T: PartialOrd + Clone> {
62
+
base: RangeInclusive<T>,
63
+
user: Option<RangeInclusive<T>>,
64
+
}
65
+
66
+
impl<T: PartialOrd + Clone> From<RangeInclusive<T>> for RangeWithLimit<T> {
67
+
fn from(value: RangeInclusive<T>) -> Self {
68
+
Self::new(&value)
69
+
}
70
}
71
72
+
impl<T: PartialOrd + Clone> RangeWithLimit<T> {
73
+
pub fn new(base: &RangeInclusive<T>) -> Self {
74
+
Self {
75
+
base: base.clone(),
76
+
user: None
77
+
}
78
+
}
79
+
80
+
pub fn try_new(
81
+
base: &RangeInclusive<T>,
82
+
user: &Option<RangeInclusive<T>>,
83
+
) -> Result<Self, ButtplugDeviceConfigError<T>> {
84
+
if let Some(user) = user {
85
+
if user.is_empty() {
86
+
Err(ButtplugDeviceConfigError::InvalidUserRange(
87
+
(*user).clone(),
88
+
(*base).clone(),
89
+
))
90
+
} else {
91
+
if *user.start() < *base.start()
92
+
|| *user.end() > *base.end()
93
+
|| *user.start() > *base.end()
94
+
|| *user.end() < *base.start()
95
+
{
96
+
Err(ButtplugDeviceConfigError::InvalidUserRange(
97
+
(*user).clone(),
98
+
(*base).clone(),
99
+
))
100
+
} else {
101
+
Ok(Self {
102
+
base: (*base).clone(),
103
+
user: Some((*user).clone()),
104
+
})
105
+
}
106
+
}
107
+
} else {
108
+
if base.is_empty() {
109
+
Err(ButtplugDeviceConfigError::BaseRangeRequired)
110
+
} else {
111
+
Ok(Self {
112
+
base: (*base).clone(),
113
+
user: None,
114
+
})
115
+
}
116
}
117
}
118
}
119
120
+
#[derive(Debug, Clone, Getters, CopyGetters)]
121
+
pub struct ServerDeviceFeatureOutputValueProperties {
122
+
#[getset(get = "pub")]
123
+
value: RangeWithLimit<i32>,
124
#[getset(get_copy = "pub")]
125
+
disabled: bool,
126
}
127
128
+
impl ServerDeviceFeatureOutputValueProperties {
129
+
pub fn new(value: &RangeWithLimit<i32>, disabled: bool) -> Self {
130
+
Self {
131
+
value: value.clone(),
132
+
disabled
133
}
134
}
135
}
136
137
+
#[derive(Debug, Clone, Getters, CopyGetters)]
138
+
pub struct ServerDeviceFeatureOutputPositionWithDurationProperties {
139
+
#[getset(get = "pub")]
140
+
position: RangeWithLimit<u32>,
141
#[getset(get = "pub")]
142
+
duration: RangeWithLimit<u32>,
143
+
#[getset(get_copy = "pub")]
144
+
disabled: bool,
145
+
#[getset(get_copy = "pub")]
146
+
reverse_position: bool,
147
}
148
149
+
impl ServerDeviceFeatureOutputPositionWithDurationProperties {
150
+
pub fn new(position: &RangeWithLimit<u32>, duration: &RangeWithLimit<u32>, disabled: bool, reverse_position: bool) -> Self {
151
Self {
152
+
position: position.clone(),
153
+
duration: duration.clone(),
154
+
disabled,
155
+
reverse_position
156
}
157
}
158
}
159
160
+
#[derive(Clone, Debug)]
161
+
pub struct ServerDeviceFeatureOutput {
162
+
vibrate: Option<ServerDeviceFeatureOutputValueProperties>,
163
+
rotate: Option<ServerDeviceFeatureOutputValueProperties>,
164
+
rotate_with_direction: Option<ServerDeviceFeatureOutputValueProperties>,
165
+
oscillate: Option<ServerDeviceFeatureOutputValueProperties>,
166
+
constrict: Option<ServerDeviceFeatureOutputValueProperties>,
167
+
heater: Option<ServerDeviceFeatureOutputValueProperties>,
168
+
led: Option<ServerDeviceFeatureOutputValueProperties>,
169
+
position: Option<ServerDeviceFeatureOutputValueProperties>,
170
+
position_with_duration: Option<ServerDeviceFeatureOutputPositionWithDurationProperties>,
171
+
spray: Option<ServerDeviceFeatureOutputValueProperties>,
172
+
}
173
+
174
+
#[derive(Clone, Debug, Getters)]
175
+
#[getset(get = "pub")]
176
+
pub struct ServerDeviceFeatureInputProperties {
177
+
value_range: Vec<RangeInclusive<i32>>,
178
+
input_commands: HashSet<InputCommandType>,
179
}
180
181
+
impl ServerDeviceFeatureInputProperties {
182
pub fn new(
183
+
value_range: &Vec<RangeInclusive<i32>>,
184
+
sensor_commands: &HashSet<InputCommandType>,
185
) -> Self {
186
Self {
187
+
value_range: value_range.clone(),
188
+
input_commands: sensor_commands.clone(),
189
}
190
}
191
}
192
193
+
#[derive(Clone, Debug, Getters)]
194
+
#[getset(get = "pub")]
195
+
pub struct ServerDeviceFeatureInput {
196
+
battery: Option<ServerDeviceFeatureInputProperties>,
197
+
rssi: Option<ServerDeviceFeatureInputProperties>,
198
+
pressure: Option<ServerDeviceFeatureInputProperties>,
199
+
button: Option<ServerDeviceFeatureInputProperties>,
200
+
}
201
+
202
+
#[derive(Clone, Debug, Getters, CopyGetters)]
203
pub struct ServerDeviceFeature {
204
+
#[getset(get = "pub")]
205
+
description: String,
206
+
#[getset(get_copy = "pub")]
207
+
id: Uuid,
208
+
#[getset(get_copy = "pub")]
209
+
base_id: Option<Uuid>,
210
+
#[getset(get_copy = "pub")]
211
+
alt_protocol_index: Option<u32>,
212
+
#[getset(get = "pub")]
213
+
output: Option<ServerDeviceFeatureOutput>,
214
#[getset(get = "pub")]
215
+
input: Option<ServerDeviceFeatureInput>,
216
}
217
218
impl PartialEq for ServerDeviceFeature {
···
225
}
226
227
impl ServerDeviceFeature {
228
+
pub fn new(description: &str, id: Uuid, base_id: Option<Uuid>, alt_protocol_index: Option<u32>, output: &Option<ServerDeviceFeatureOutput>, input: &Option<ServerDeviceFeatureInput>) -> Self {
229
Self {
230
+
description: description.to_owned(),
231
+
id,
232
+
base_id,
233
+
alt_protocol_index,
234
+
output: output.clone(),
235
+
input: input.clone(),
236
}
237
}
238
239
+
/*
240
+
pub fn as_device_feature(&self, index: u32) -> Result<DeviceFeature, ButtplugDeviceConfigError> {
241
+
// try_collect() is still unstable so we extract the fallible-map call into a loop. This sucks.
242
+
let mut outputs = HashMap::new();
243
if let Some(output_map) = &self.output {
244
+
for (output_type, server_output) in output_map {
245
+
outputs.insert(
246
+
*output_type,
247
+
server_output.as_device_feature_output_variant(*output_type)?,
248
+
);
249
}
250
}
251
252
+
Ok(DeviceFeature::new(
253
index,
254
self.description(),
255
+
&outputs.is_empty().then_some(outputs).or(None),
256
&self.base_feature.input().clone().map(|x| {
257
x.iter()
258
.map(|(t, a)| (*t, DeviceFeatureInput::from(a.clone())))
259
.collect()
260
}),
261
+
))
262
}
263
+
*/
264
}
-5
crates/buttplug_server_device_config/src/endpoint.rs
-5
crates/buttplug_server_device_config/src/endpoint.rs
···
13
14
use core::hash::Hash;
15
16
-
// We need this array to be exposed in our WASM FFI, but the only way to do that
17
-
// is to expose it at the declaration level. Therefore, we use the WASM feature
18
-
// to assume we're building for WASM and attach our bindgen. The serde
19
-
// de/serialization is taken care of at the FFI level.
20
-
21
/// Endpoint names for device communication.
22
///
23
/// Endpoints denote different contextual communication targets on a device. For instance, for a
+9
-2
crates/buttplug_server_device_config/src/identifiers.rs
+9
-2
crates/buttplug_server_device_config/src/identifiers.rs
···
44
}
45
46
impl BaseDeviceIdentifier {
47
+
pub fn new_default(protocol: &str) -> Self {
48
+
Self {
49
+
protocol: protocol.to_owned(),
50
+
identifier: None,
51
+
}
52
+
}
53
+
54
+
pub fn new(protocol: &str, attributes_identifier: &str) -> Self {
55
Self {
56
protocol: protocol.to_owned(),
57
+
identifier: Some(attributes_identifier.to_owned()),
58
}
59
}
60
}
+21
-327
crates/buttplug_server_device_config/src/lib.rs
+21
-327
crates/buttplug_server_device_config/src/lib.rs
···
137
#[macro_use]
138
extern crate strum_macros;
139
140
mod specifier;
141
pub use specifier::*;
142
mod identifiers;
···
145
pub use device_definitions::*;
146
mod device_feature;
147
pub use device_feature::*;
148
-
mod device_configuration;
149
-
pub use device_configuration::*;
150
mod endpoint;
151
pub use endpoint::*;
152
153
-
use buttplug_core::errors::ButtplugDeviceError;
154
-
use dashmap::DashMap;
155
-
use getset::Getters;
156
-
use std::{
157
-
collections::HashMap,
158
-
fmt::{self, Debug},
159
-
};
160
161
-
#[macro_use]
162
-
extern crate log;
163
-
164
-
#[derive(Default, Clone)]
165
-
pub struct DeviceConfigurationManagerBuilder {
166
-
communication_specifiers: HashMap<String, Vec<ProtocolCommunicationSpecifier>>,
167
-
user_communication_specifiers: DashMap<String, Vec<ProtocolCommunicationSpecifier>>,
168
-
base_device_definitions: HashMap<BaseDeviceIdentifier, BaseDeviceDefinition>,
169
-
user_device_definitions: DashMap<UserDeviceIdentifier, DeviceDefinition>,
170
-
}
171
-
172
-
impl DeviceConfigurationManagerBuilder {
173
-
pub fn communication_specifier(
174
-
&mut self,
175
-
protocol_name: &str,
176
-
specifier: &[ProtocolCommunicationSpecifier],
177
-
) -> &mut Self {
178
-
self
179
-
.communication_specifiers
180
-
.entry(protocol_name.to_owned())
181
-
.or_default()
182
-
.extend(specifier.iter().cloned());
183
-
self
184
-
}
185
-
186
-
pub fn protocol_features(
187
-
&mut self,
188
-
identifier: &BaseDeviceIdentifier,
189
-
features: &BaseDeviceDefinition,
190
-
) -> &mut Self {
191
-
self
192
-
.base_device_definitions
193
-
.insert(identifier.clone(), features.clone());
194
-
self
195
-
}
196
-
197
-
pub fn user_communication_specifier(
198
-
&mut self,
199
-
protocol_name: &str,
200
-
specifier: &[ProtocolCommunicationSpecifier],
201
-
) -> &mut Self {
202
-
self
203
-
.user_communication_specifiers
204
-
.entry(protocol_name.to_owned())
205
-
.or_default()
206
-
.extend(specifier.iter().cloned());
207
-
self
208
-
}
209
-
210
-
pub fn user_protocol_features(
211
-
&mut self,
212
-
identifier: &UserDeviceIdentifier,
213
-
features: &UserDeviceDefinition,
214
-
) -> &mut Self {
215
-
if let Some((_, base_definition)) = self
216
-
.base_device_definitions
217
-
.iter()
218
-
.find(|(_, x)| x.id() == features.base_id())
219
-
{
220
-
self.user_device_definitions.insert(
221
-
identifier.clone(),
222
-
DeviceDefinition::new(base_definition, features),
223
-
);
224
-
} else {
225
-
error!(
226
-
"Cannot find protocol with base id {} for user id {}",
227
-
features.base_id(),
228
-
features.id()
229
-
)
230
-
}
231
-
self
232
-
}
233
-
234
-
pub fn finish(&mut self) -> Result<DeviceConfigurationManager, ButtplugDeviceError> {
235
-
// Build and validate the protocol attributes tree.
236
-
let mut attribute_tree_map = HashMap::new();
237
-
238
-
// Add all the defaults first, they won't have parent attributes.
239
-
for (ident, attr) in &self.base_device_definitions {
240
-
/*
241
-
for feature in attr.features() {
242
-
if let Err(e) = feature.is_valid() {
243
-
error!("Feature {attr:?} for ident {ident:?} is not valid, skipping addition: {e:?}");
244
-
continue;
245
-
}
246
-
}
247
-
*/
248
-
attribute_tree_map.insert(ident.clone(), attr.clone());
249
-
}
250
-
251
-
let user_attribute_tree_map = DashMap::new();
252
-
// Finally, add in user configurations, which will have an address.
253
-
for kv in &self.user_device_definitions {
254
-
let (ident, attr) = (kv.key(), kv.value());
255
-
for feature in attr.features() {
256
-
if let Err(e) = feature.is_valid() {
257
-
error!("Feature {attr:?} for ident {ident:?} is not valid, skipping addition: {e:?}");
258
-
continue;
259
-
}
260
-
}
261
-
user_attribute_tree_map.insert(kv.key().clone(), kv.value().clone());
262
-
}
263
-
264
-
Ok(DeviceConfigurationManager {
265
-
base_communication_specifiers: self.communication_specifiers.clone(),
266
-
user_communication_specifiers: self.user_communication_specifiers.clone(),
267
-
base_device_definitions: attribute_tree_map,
268
-
user_device_definitions: user_attribute_tree_map,
269
-
//protocol_map,
270
-
})
271
-
}
272
-
}
273
-
274
-
/// Correlates information about protocols and which devices they support.
275
-
///
276
-
/// The [DeviceConfigurationManager] handles stores information about which device protocols the
277
-
/// library supports, as well as which devices can use those protocols. When a
278
-
/// [DeviceCommunicationManager](crate::server::device::communication_manager) finds a device during scanning,
279
-
/// device information is given to the [DeviceConfigurationManager] to decide whether Buttplug
280
-
/// should try to connect to and communicate with the device.
281
-
///
282
-
/// Assuming the device is supported by the library, the [DeviceConfigurationManager] also stores
283
-
/// information about what commands can be sent to the device (Vibrate, Rotate, etc...), and the
284
-
/// parameters for those commands (number of power levels, stroke distances, etc...).
285
-
#[derive(Getters)]
286
-
#[getset(get = "pub")]
287
-
pub struct DeviceConfigurationManager {
288
-
/// Communication specifiers from the base device config, mapped from protocol name to vector of
289
-
/// specifiers. Should not change/update during a session.
290
-
base_communication_specifiers: HashMap<String, Vec<ProtocolCommunicationSpecifier>>,
291
-
/// Device definitions from the base device config. Should not change/update during a session.
292
-
base_device_definitions: HashMap<BaseDeviceIdentifier, BaseDeviceDefinition>,
293
-
/// Communication specifiers provided by the user, mapped from protocol name to vector of
294
-
/// specifiers. Loaded at session start, may change over life of session.
295
-
user_communication_specifiers: DashMap<String, Vec<ProtocolCommunicationSpecifier>>,
296
-
/// Device definitions from the user device config. Loaded at session start, may change over life
297
-
/// of session.
298
-
user_device_definitions: DashMap<UserDeviceIdentifier, DeviceDefinition>,
299
-
}
300
-
301
-
impl Debug for DeviceConfigurationManager {
302
-
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
303
-
f.debug_struct("DeviceConfigurationManager").finish()
304
-
}
305
-
}
306
-
307
-
impl Default for DeviceConfigurationManager {
308
-
fn default() -> Self {
309
-
// Unwrap allowed here because we assume our built in device config will
310
-
// always work. System won't pass tests or possibly even build otherwise.
311
-
DeviceConfigurationManagerBuilder::default()
312
-
.finish()
313
-
.expect("Default creation of a DCM should always work.")
314
-
}
315
-
}
316
-
317
-
impl DeviceConfigurationManager {
318
-
pub fn add_user_communication_specifier(
319
-
&self,
320
-
protocol: &str,
321
-
specifier: &ProtocolCommunicationSpecifier,
322
-
) -> Result<(), ButtplugDeviceError> {
323
-
//self.protocol_map.contains_key(protocol);
324
-
self
325
-
.user_communication_specifiers
326
-
.entry(protocol.to_owned())
327
-
.or_default()
328
-
.push(specifier.clone());
329
-
Ok(())
330
-
}
331
-
332
-
pub fn remove_user_communication_specifier(
333
-
&self,
334
-
protocol: &str,
335
-
specifier: &ProtocolCommunicationSpecifier,
336
-
) {
337
-
if let Some(mut specifiers) = self.user_communication_specifiers.get_mut(protocol) {
338
-
let specifier_vec = specifiers.value_mut();
339
-
*specifier_vec = specifier_vec
340
-
.iter()
341
-
.filter(|s| *specifier != **s)
342
-
.cloned()
343
-
.collect();
344
-
}
345
-
}
346
-
347
-
pub fn add_user_device_definition(
348
-
&self,
349
-
identifier: &UserDeviceIdentifier,
350
-
definition: &DeviceDefinition,
351
-
) -> Result<(), ButtplugDeviceError> {
352
-
//self.protocol_map.contains_key(identifier.protocol());
353
-
// Check validity of device
354
-
let mut index = definition.user_config().index();
355
-
let indexes: Vec<u32> = self.user_device_definitions().iter().map(|x| x.value().user_config().index()).collect();
356
-
// If we just added 1 to the maximum value of the current indexes, someone decides to set an
357
-
// index to u32::MAX-1, then we'd have a problem. This is kind of a shit solution but it'll work
358
-
// quickly for anyone that's not actively fucking with us by manually playing with user config files.
359
-
while indexes.contains(&index) {
360
-
index = index.wrapping_add(1);
361
-
}
362
-
let mut def = definition.clone();
363
-
*def.user_device_mut().user_config_mut().index_mut() = index;
364
-
self
365
-
.user_device_definitions
366
-
.entry(identifier.clone())
367
-
.insert(def);
368
-
Ok(())
369
-
}
370
-
371
-
pub fn remove_user_device_definition(&self, identifier: &UserDeviceIdentifier) {
372
-
self.user_device_definitions.remove(identifier);
373
-
}
374
-
375
-
pub fn address_allowed(&self, address: &str) -> bool {
376
-
// Make sure the device isn't on the deny list
377
-
if self
378
-
.user_device_definitions
379
-
.iter()
380
-
.any(|kv| kv.key().address() == address && kv.value().user_config().deny())
381
-
{
382
-
// If device is outright denied, deny
383
-
info!(
384
-
"Device {} denied by configuration, not connecting.",
385
-
address
386
-
);
387
-
false
388
-
} else if self
389
-
.user_device_definitions
390
-
.iter()
391
-
.any(|kv| kv.value().user_config().allow())
392
-
&& !self
393
-
.user_device_definitions
394
-
.iter()
395
-
.any(|kv| kv.key().address() == address && kv.value().user_config().allow())
396
-
{
397
-
// If device is not on allow list and allow list isn't empty, deny
398
-
info!(
399
-
"Device {} not on allow list and allow list not empty, not connecting.",
400
-
address
401
-
);
402
-
false
403
-
} else {
404
-
true
405
-
}
406
-
}
407
-
408
-
fn device_index(&self, identifier: &UserDeviceIdentifier) -> u32 {
409
-
// See if we have a reserved or reusable device index here.
410
-
if let Some(config) = self.user_device_definitions.get(identifier) {
411
-
let index = config.user_config().index();
412
-
debug!("Found index {index} for device {identifier:?}");
413
-
return index;
414
-
}
415
-
416
-
let current_indexes: Vec<u32> = self
417
-
.user_device_definitions
418
-
.iter()
419
-
.map(|x| x.user_config().index())
420
-
.collect();
421
-
422
-
// Someone is gonna make a max device index in their config file just to fuck with me, therefore
423
-
// we don't do "max + 1", we fill in holes (lol) in sequences. To whomever has 4 billion sex toys:
424
-
// sorry your index finding for new devices is slow and takes 16GB of allocation every time we
425
-
// want to search the index space.
426
-
427
-
let mut index = 0;
428
-
while current_indexes.contains(&index) {
429
-
index += 1;
430
-
}
431
-
debug!("Generating and assigning index {index:?} for device {identifier:?}");
432
-
index
433
-
}
434
435
-
/// Provides read-only access to the internal protocol/identifier map. Mainly
436
-
/// used for WebBluetooth filter construction, but could also be handy for
437
-
/// listing capabilities in UI, etc.
438
-
pub fn protocol_device_configurations(
439
-
&self,
440
-
) -> HashMap<String, Vec<ProtocolCommunicationSpecifier>> {
441
-
self.base_communication_specifiers.clone()
442
-
}
443
-
444
-
pub fn device_definition(&self, identifier: &UserDeviceIdentifier) -> Option<DeviceDefinition> {
445
-
let features = if let Some(attrs) = self.user_device_definitions.get(identifier) {
446
-
debug!("User device config found for {:?}", identifier);
447
-
attrs.clone()
448
-
} else if let Some(attrs) = self.base_device_definitions.get(&BaseDeviceIdentifier::new(
449
-
identifier.protocol(),
450
-
identifier.identifier(),
451
-
)) {
452
-
debug!(
453
-
"Protocol + Identifier device config found for {:?}",
454
-
identifier
455
-
);
456
-
DeviceDefinition::new_from_base_definition(attrs, self.device_index(identifier))
457
-
} else if let Some(attrs) = self
458
-
.base_device_definitions
459
-
.get(&BaseDeviceIdentifier::new(identifier.protocol(), &None))
460
-
{
461
-
debug!("Protocol device config found for {:?}", identifier);
462
-
DeviceDefinition::new_from_base_definition(attrs, self.device_index(identifier))
463
-
} else {
464
-
return None;
465
-
};
466
-
467
-
// If this is a new device, it needs to be added to the user device definition map.
468
-
//
469
-
// Device definitions are looked up before we fully initialize a device, mostly for algorithm
470
-
// preparation. There is a very small chance we may save the device config then error out when
471
-
// we connect to the device, but we'll assume we may connect successfully later.
472
-
if self.user_device_definitions.get(identifier).is_none() {
473
-
self
474
-
.user_device_definitions
475
-
.insert(identifier.clone(), features.clone());
476
-
}
477
-
478
-
Some(features)
479
-
}
480
}
···
137
#[macro_use]
138
extern crate strum_macros;
139
140
+
#[macro_use]
141
+
extern crate log;
142
+
143
+
mod device_config_file;
144
+
pub use device_config_file::{load_protocol_configs, save_user_config};
145
+
mod device_config_manager;
146
+
pub use device_config_manager::*;
147
mod specifier;
148
pub use specifier::*;
149
mod identifiers;
···
152
pub use device_definitions::*;
153
mod device_feature;
154
pub use device_feature::*;
155
mod endpoint;
156
pub use endpoint::*;
157
158
159
+
use std::ops::RangeInclusive;
160
+
use serde::Serializer;
161
+
use thiserror::Error;
162
163
+
#[derive(Error, Debug)]
164
+
pub enum ButtplugDeviceConfigError<T> {
165
+
/// Conversion to client type not possible with requested property type
166
+
#[error("Conversion of {0} to client type not possible with requested property type")]
167
+
InvalidOutputTypeConversion(String),
168
+
/// User set range exceeds bounds of possible configuration range
169
+
#[error("User set range {0} exceeds bounds of possible configuration range {1}")]
170
+
InvalidUserRange(RangeInclusive<T>, RangeInclusive<T>),
171
+
/// Base range required
172
+
#[error("Base range required for all feature outputs")]
173
+
BaseRangeRequired,
174
}
-6
crates/buttplug_server_device_config/src/specifier.rs
-6
crates/buttplug_server_device_config/src/specifier.rs
···
11
use std::collections::{HashMap, HashSet};
12
use uuid::Uuid;
13
14
-
// Note: There's a ton of extra structs in here just to deserialize the json
15
-
// file. Just leave them and build extras (for instance,
16
-
// DeviceProtocolConfiguration) if needed elsewhere in the codebase. It's not
17
-
// gonna hurt anything and making a ton of serde attributes is just going to get
18
-
// confusing (see the messages impl).
19
-
20
#[derive(Serialize, Deserialize, Debug, Clone, Getters, MutGetters, Setters, Eq)]
21
#[getset(get = "pub", set = "pub", get_mut = "pub(crate)")]
22
pub struct BluetoothLEManufacturerData {