Struct linux_info::network::modem_manager::Modem

source · 
pub struct Modem { /* private fields */ }

Implementations§

The equipment manufacturer, as reported by the modem.

Examples found in repository?
examples/network.rs (line 39)
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

fn main() {

	let dbus = NetworkManager::connect().unwrap();

	for device in dbus.devices().unwrap() {
		let state = device.state().unwrap();
		let kind = device.kind().unwrap();
		let interface = device.interface().unwrap();

		println!("{:?} {:?} {:?}", interface, kind, state);
		if let Ok(apn) = device.modem_apn() {
			println!("- has apn {:?}", apn);
		}

		if matches!(state, DeviceState::Activated) {
			let ipv4 = device.ipv4_config().unwrap()
				.addresses().unwrap();
			println!("- addresses {:?}", ipv4);
		}
	}

	let dbus = ModemManager::connect().unwrap();

	for modem in dbus.modems().unwrap() {
		println!(
			"modem {:?} {:?} {:?}",
			modem.model().unwrap(),
			modem.manufacturer().unwrap(),
			modem.device().unwrap()
		);

		println!(
			"- carrier configuration: {:?}",
			modem.carrier_configuration().unwrap()
		);

		println!(
			"- state: {:?}, signal: {:?}",
			modem.state().unwrap(),
			modem.signal_quality().unwrap()
		);

		let (allowed_modes, preffered_modes) = modem.current_modes().unwrap();
		println!(
			"- allowed modes: 2g: {} 3g: {} 4g: {} 5g: {}",
			allowed_modes.has_2g(),
			allowed_modes.has_3g(),
			allowed_modes.has_4g(),
			allowed_modes.has_5g()
		);

		println!(
			"- prefered modes: 2g: {} 3g: {} 4g: {} 5g: {}",
			preffered_modes.has_2g(),
			preffered_modes.has_3g(),
			preffered_modes.has_4g(),
			preffered_modes.has_5g()
		);

		println!(
			"- bands: {:?}",
			modem.current_bands().unwrap()
		);

		modem.signal_setup(10).unwrap();
		thread::sleep(Duration::from_secs(1));

		if let Ok(cdma) = modem.signal_cdma() {
			println!("- cdma: {:?}", cdma);
		}

		if let Ok(evdo) = modem.signal_evdo() {
			println!("- evdo: {:?}", evdo);
		}

		if let Ok(gsm) = modem.signal_gsm() {
			println!("- gsm: {:?}", gsm);
		}

		if let Ok(umts) = modem.signal_umts() {
			println!("- umts: {:?}", umts);
		}

		if let Ok(lte) = modem.signal_lte() {
			println!("- lte: {:?}", lte);
		}

		if let Ok(nr5g) = modem.signal_nr5g() {
			println!("- nr5g: {:?}", nr5g);
		}
	}

}

The equipment model, as reported by the modem.

Examples found in repository?
examples/network.rs (line 38)
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

fn main() {

	let dbus = NetworkManager::connect().unwrap();

	for device in dbus.devices().unwrap() {
		let state = device.state().unwrap();
		let kind = device.kind().unwrap();
		let interface = device.interface().unwrap();

		println!("{:?} {:?} {:?}", interface, kind, state);
		if let Ok(apn) = device.modem_apn() {
			println!("- has apn {:?}", apn);
		}

		if matches!(state, DeviceState::Activated) {
			let ipv4 = device.ipv4_config().unwrap()
				.addresses().unwrap();
			println!("- addresses {:?}", ipv4);
		}
	}

	let dbus = ModemManager::connect().unwrap();

	for modem in dbus.modems().unwrap() {
		println!(
			"modem {:?} {:?} {:?}",
			modem.model().unwrap(),
			modem.manufacturer().unwrap(),
			modem.device().unwrap()
		);

		println!(
			"- carrier configuration: {:?}",
			modem.carrier_configuration().unwrap()
		);

		println!(
			"- state: {:?}, signal: {:?}",
			modem.state().unwrap(),
			modem.signal_quality().unwrap()
		);

		let (allowed_modes, preffered_modes) = modem.current_modes().unwrap();
		println!(
			"- allowed modes: 2g: {} 3g: {} 4g: {} 5g: {}",
			allowed_modes.has_2g(),
			allowed_modes.has_3g(),
			allowed_modes.has_4g(),
			allowed_modes.has_5g()
		);

		println!(
			"- prefered modes: 2g: {} 3g: {} 4g: {} 5g: {}",
			preffered_modes.has_2g(),
			preffered_modes.has_3g(),
			preffered_modes.has_4g(),
			preffered_modes.has_5g()
		);

		println!(
			"- bands: {:?}",
			modem.current_bands().unwrap()
		);

		modem.signal_setup(10).unwrap();
		thread::sleep(Duration::from_secs(1));

		if let Ok(cdma) = modem.signal_cdma() {
			println!("- cdma: {:?}", cdma);
		}

		if let Ok(evdo) = modem.signal_evdo() {
			println!("- evdo: {:?}", evdo);
		}

		if let Ok(gsm) = modem.signal_gsm() {
			println!("- gsm: {:?}", gsm);
		}

		if let Ok(umts) = modem.signal_umts() {
			println!("- umts: {:?}", umts);
		}

		if let Ok(lte) = modem.signal_lte() {
			println!("- lte: {:?}", lte);
		}

		if let Ok(nr5g) = modem.signal_nr5g() {
			println!("- nr5g: {:?}", nr5g);
		}
	}

}

The description of the carrier-specific configuration (MCFG) in use by the modem.

Examples found in repository?
examples/network.rs (line 45)
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

fn main() {

	let dbus = NetworkManager::connect().unwrap();

	for device in dbus.devices().unwrap() {
		let state = device.state().unwrap();
		let kind = device.kind().unwrap();
		let interface = device.interface().unwrap();

		println!("{:?} {:?} {:?}", interface, kind, state);
		if let Ok(apn) = device.modem_apn() {
			println!("- has apn {:?}", apn);
		}

		if matches!(state, DeviceState::Activated) {
			let ipv4 = device.ipv4_config().unwrap()
				.addresses().unwrap();
			println!("- addresses {:?}", ipv4);
		}
	}

	let dbus = ModemManager::connect().unwrap();

	for modem in dbus.modems().unwrap() {
		println!(
			"modem {:?} {:?} {:?}",
			modem.model().unwrap(),
			modem.manufacturer().unwrap(),
			modem.device().unwrap()
		);

		println!(
			"- carrier configuration: {:?}",
			modem.carrier_configuration().unwrap()
		);

		println!(
			"- state: {:?}, signal: {:?}",
			modem.state().unwrap(),
			modem.signal_quality().unwrap()
		);

		let (allowed_modes, preffered_modes) = modem.current_modes().unwrap();
		println!(
			"- allowed modes: 2g: {} 3g: {} 4g: {} 5g: {}",
			allowed_modes.has_2g(),
			allowed_modes.has_3g(),
			allowed_modes.has_4g(),
			allowed_modes.has_5g()
		);

		println!(
			"- prefered modes: 2g: {} 3g: {} 4g: {} 5g: {}",
			preffered_modes.has_2g(),
			preffered_modes.has_3g(),
			preffered_modes.has_4g(),
			preffered_modes.has_5g()
		);

		println!(
			"- bands: {:?}",
			modem.current_bands().unwrap()
		);

		modem.signal_setup(10).unwrap();
		thread::sleep(Duration::from_secs(1));

		if let Ok(cdma) = modem.signal_cdma() {
			println!("- cdma: {:?}", cdma);
		}

		if let Ok(evdo) = modem.signal_evdo() {
			println!("- evdo: {:?}", evdo);
		}

		if let Ok(gsm) = modem.signal_gsm() {
			println!("- gsm: {:?}", gsm);
		}

		if let Ok(umts) = modem.signal_umts() {
			println!("- umts: {:?}", umts);
		}

		if let Ok(lte) = modem.signal_lte() {
			println!("- lte: {:?}", lte);
		}

		if let Ok(nr5g) = modem.signal_nr5g() {
			println!("- nr5g: {:?}", nr5g);
		}
	}

}

The physical modem device reference (ie, USB, PCI, PCMCIA device), which may be dependent upon the operating system.

In Linux for example, this points to a sysfs path of the usb_device object.

This value may also be set by the user using the MM_ID_PHYSDEV_UID udev tag (e.g. binding the tag to a specific sysfs path).

Examples found in repository?
examples/network.rs (line 40)
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

fn main() {

	let dbus = NetworkManager::connect().unwrap();

	for device in dbus.devices().unwrap() {
		let state = device.state().unwrap();
		let kind = device.kind().unwrap();
		let interface = device.interface().unwrap();

		println!("{:?} {:?} {:?}", interface, kind, state);
		if let Ok(apn) = device.modem_apn() {
			println!("- has apn {:?}", apn);
		}

		if matches!(state, DeviceState::Activated) {
			let ipv4 = device.ipv4_config().unwrap()
				.addresses().unwrap();
			println!("- addresses {:?}", ipv4);
		}
	}

	let dbus = ModemManager::connect().unwrap();

	for modem in dbus.modems().unwrap() {
		println!(
			"modem {:?} {:?} {:?}",
			modem.model().unwrap(),
			modem.manufacturer().unwrap(),
			modem.device().unwrap()
		);

		println!(
			"- carrier configuration: {:?}",
			modem.carrier_configuration().unwrap()
		);

		println!(
			"- state: {:?}, signal: {:?}",
			modem.state().unwrap(),
			modem.signal_quality().unwrap()
		);

		let (allowed_modes, preffered_modes) = modem.current_modes().unwrap();
		println!(
			"- allowed modes: 2g: {} 3g: {} 4g: {} 5g: {}",
			allowed_modes.has_2g(),
			allowed_modes.has_3g(),
			allowed_modes.has_4g(),
			allowed_modes.has_5g()
		);

		println!(
			"- prefered modes: 2g: {} 3g: {} 4g: {} 5g: {}",
			preffered_modes.has_2g(),
			preffered_modes.has_3g(),
			preffered_modes.has_4g(),
			preffered_modes.has_5g()
		);

		println!(
			"- bands: {:?}",
			modem.current_bands().unwrap()
		);

		modem.signal_setup(10).unwrap();
		thread::sleep(Duration::from_secs(1));

		if let Ok(cdma) = modem.signal_cdma() {
			println!("- cdma: {:?}", cdma);
		}

		if let Ok(evdo) = modem.signal_evdo() {
			println!("- evdo: {:?}", evdo);
		}

		if let Ok(gsm) = modem.signal_gsm() {
			println!("- gsm: {:?}", gsm);
		}

		if let Ok(umts) = modem.signal_umts() {
			println!("- umts: {:?}", umts);
		}

		if let Ok(lte) = modem.signal_lte() {
			println!("- lte: {:?}", lte);
		}

		if let Ok(nr5g) = modem.signal_nr5g() {
			println!("- nr5g: {:?}", nr5g);
		}
	}

}

Overall state of the modem, given as a MMModemState value.

If the device’s state cannot be determined, MM_MODEM_STATE_UNKNOWN will be reported.

Examples found in repository?
examples/network.rs (line 50)
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

fn main() {

	let dbus = NetworkManager::connect().unwrap();

	for device in dbus.devices().unwrap() {
		let state = device.state().unwrap();
		let kind = device.kind().unwrap();
		let interface = device.interface().unwrap();

		println!("{:?} {:?} {:?}", interface, kind, state);
		if let Ok(apn) = device.modem_apn() {
			println!("- has apn {:?}", apn);
		}

		if matches!(state, DeviceState::Activated) {
			let ipv4 = device.ipv4_config().unwrap()
				.addresses().unwrap();
			println!("- addresses {:?}", ipv4);
		}
	}

	let dbus = ModemManager::connect().unwrap();

	for modem in dbus.modems().unwrap() {
		println!(
			"modem {:?} {:?} {:?}",
			modem.model().unwrap(),
			modem.manufacturer().unwrap(),
			modem.device().unwrap()
		);

		println!(
			"- carrier configuration: {:?}",
			modem.carrier_configuration().unwrap()
		);

		println!(
			"- state: {:?}, signal: {:?}",
			modem.state().unwrap(),
			modem.signal_quality().unwrap()
		);

		let (allowed_modes, preffered_modes) = modem.current_modes().unwrap();
		println!(
			"- allowed modes: 2g: {} 3g: {} 4g: {} 5g: {}",
			allowed_modes.has_2g(),
			allowed_modes.has_3g(),
			allowed_modes.has_4g(),
			allowed_modes.has_5g()
		);

		println!(
			"- prefered modes: 2g: {} 3g: {} 4g: {} 5g: {}",
			preffered_modes.has_2g(),
			preffered_modes.has_3g(),
			preffered_modes.has_4g(),
			preffered_modes.has_5g()
		);

		println!(
			"- bands: {:?}",
			modem.current_bands().unwrap()
		);

		modem.signal_setup(10).unwrap();
		thread::sleep(Duration::from_secs(1));

		if let Ok(cdma) = modem.signal_cdma() {
			println!("- cdma: {:?}", cdma);
		}

		if let Ok(evdo) = modem.signal_evdo() {
			println!("- evdo: {:?}", evdo);
		}

		if let Ok(gsm) = modem.signal_gsm() {
			println!("- gsm: {:?}", gsm);
		}

		if let Ok(umts) = modem.signal_umts() {
			println!("- umts: {:?}", umts);
		}

		if let Ok(lte) = modem.signal_lte() {
			println!("- lte: {:?}", lte);
		}

		if let Ok(nr5g) = modem.signal_nr5g() {
			println!("- nr5g: {:?}", nr5g);
		}
	}

}

Signal quality in percent (0 - 100) of the dominant access technology the device is using to communicate with the network. Always 0 for POTS devices.
The additional boolean value indicates if the quality value given was recently taken.

Examples found in repository?
examples/network.rs (line 51)
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

fn main() {

	let dbus = NetworkManager::connect().unwrap();

	for device in dbus.devices().unwrap() {
		let state = device.state().unwrap();
		let kind = device.kind().unwrap();
		let interface = device.interface().unwrap();

		println!("{:?} {:?} {:?}", interface, kind, state);
		if let Ok(apn) = device.modem_apn() {
			println!("- has apn {:?}", apn);
		}

		if matches!(state, DeviceState::Activated) {
			let ipv4 = device.ipv4_config().unwrap()
				.addresses().unwrap();
			println!("- addresses {:?}", ipv4);
		}
	}

	let dbus = ModemManager::connect().unwrap();

	for modem in dbus.modems().unwrap() {
		println!(
			"modem {:?} {:?} {:?}",
			modem.model().unwrap(),
			modem.manufacturer().unwrap(),
			modem.device().unwrap()
		);

		println!(
			"- carrier configuration: {:?}",
			modem.carrier_configuration().unwrap()
		);

		println!(
			"- state: {:?}, signal: {:?}",
			modem.state().unwrap(),
			modem.signal_quality().unwrap()
		);

		let (allowed_modes, preffered_modes) = modem.current_modes().unwrap();
		println!(
			"- allowed modes: 2g: {} 3g: {} 4g: {} 5g: {}",
			allowed_modes.has_2g(),
			allowed_modes.has_3g(),
			allowed_modes.has_4g(),
			allowed_modes.has_5g()
		);

		println!(
			"- prefered modes: 2g: {} 3g: {} 4g: {} 5g: {}",
			preffered_modes.has_2g(),
			preffered_modes.has_3g(),
			preffered_modes.has_4g(),
			preffered_modes.has_5g()
		);

		println!(
			"- bands: {:?}",
			modem.current_bands().unwrap()
		);

		modem.signal_setup(10).unwrap();
		thread::sleep(Duration::from_secs(1));

		if let Ok(cdma) = modem.signal_cdma() {
			println!("- cdma: {:?}", cdma);
		}

		if let Ok(evdo) = modem.signal_evdo() {
			println!("- evdo: {:?}", evdo);
		}

		if let Ok(gsm) = modem.signal_gsm() {
			println!("- gsm: {:?}", gsm);
		}

		if let Ok(umts) = modem.signal_umts() {
			println!("- umts: {:?}", umts);
		}

		if let Ok(lte) = modem.signal_lte() {
			println!("- lte: {:?}", lte);
		}

		if let Ok(nr5g) = modem.signal_nr5g() {
			println!("- nr5g: {:?}", nr5g);
		}
	}

}

A pair of MMModemMode values, where the first one is a bitmask specifying the access technologies (eg 2G/3G/4G) the device is currently allowed to use when connecting to a network, and the second one is the preferred mode of those specified as allowed.

Examples found in repository?
examples/network.rs (line 54)
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

fn main() {

	let dbus = NetworkManager::connect().unwrap();

	for device in dbus.devices().unwrap() {
		let state = device.state().unwrap();
		let kind = device.kind().unwrap();
		let interface = device.interface().unwrap();

		println!("{:?} {:?} {:?}", interface, kind, state);
		if let Ok(apn) = device.modem_apn() {
			println!("- has apn {:?}", apn);
		}

		if matches!(state, DeviceState::Activated) {
			let ipv4 = device.ipv4_config().unwrap()
				.addresses().unwrap();
			println!("- addresses {:?}", ipv4);
		}
	}

	let dbus = ModemManager::connect().unwrap();

	for modem in dbus.modems().unwrap() {
		println!(
			"modem {:?} {:?} {:?}",
			modem.model().unwrap(),
			modem.manufacturer().unwrap(),
			modem.device().unwrap()
		);

		println!(
			"- carrier configuration: {:?}",
			modem.carrier_configuration().unwrap()
		);

		println!(
			"- state: {:?}, signal: {:?}",
			modem.state().unwrap(),
			modem.signal_quality().unwrap()
		);

		let (allowed_modes, preffered_modes) = modem.current_modes().unwrap();
		println!(
			"- allowed modes: 2g: {} 3g: {} 4g: {} 5g: {}",
			allowed_modes.has_2g(),
			allowed_modes.has_3g(),
			allowed_modes.has_4g(),
			allowed_modes.has_5g()
		);

		println!(
			"- prefered modes: 2g: {} 3g: {} 4g: {} 5g: {}",
			preffered_modes.has_2g(),
			preffered_modes.has_3g(),
			preffered_modes.has_4g(),
			preffered_modes.has_5g()
		);

		println!(
			"- bands: {:?}",
			modem.current_bands().unwrap()
		);

		modem.signal_setup(10).unwrap();
		thread::sleep(Duration::from_secs(1));

		if let Ok(cdma) = modem.signal_cdma() {
			println!("- cdma: {:?}", cdma);
		}

		if let Ok(evdo) = modem.signal_evdo() {
			println!("- evdo: {:?}", evdo);
		}

		if let Ok(gsm) = modem.signal_gsm() {
			println!("- gsm: {:?}", gsm);
		}

		if let Ok(umts) = modem.signal_umts() {
			println!("- umts: {:?}", umts);
		}

		if let Ok(lte) = modem.signal_lte() {
			println!("- lte: {:?}", lte);
		}

		if let Ok(nr5g) = modem.signal_nr5g() {
			println!("- nr5g: {:?}", nr5g);
		}
	}

}

List of MMModemBand values, specifying the radio frequency and technology bands the device is currently using when connecting to a network.

It must be a subset of “SupportedBands”.

Examples found in repository?
examples/network.rs (line 73)
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

fn main() {

	let dbus = NetworkManager::connect().unwrap();

	for device in dbus.devices().unwrap() {
		let state = device.state().unwrap();
		let kind = device.kind().unwrap();
		let interface = device.interface().unwrap();

		println!("{:?} {:?} {:?}", interface, kind, state);
		if let Ok(apn) = device.modem_apn() {
			println!("- has apn {:?}", apn);
		}

		if matches!(state, DeviceState::Activated) {
			let ipv4 = device.ipv4_config().unwrap()
				.addresses().unwrap();
			println!("- addresses {:?}", ipv4);
		}
	}

	let dbus = ModemManager::connect().unwrap();

	for modem in dbus.modems().unwrap() {
		println!(
			"modem {:?} {:?} {:?}",
			modem.model().unwrap(),
			modem.manufacturer().unwrap(),
			modem.device().unwrap()
		);

		println!(
			"- carrier configuration: {:?}",
			modem.carrier_configuration().unwrap()
		);

		println!(
			"- state: {:?}, signal: {:?}",
			modem.state().unwrap(),
			modem.signal_quality().unwrap()
		);

		let (allowed_modes, preffered_modes) = modem.current_modes().unwrap();
		println!(
			"- allowed modes: 2g: {} 3g: {} 4g: {} 5g: {}",
			allowed_modes.has_2g(),
			allowed_modes.has_3g(),
			allowed_modes.has_4g(),
			allowed_modes.has_5g()
		);

		println!(
			"- prefered modes: 2g: {} 3g: {} 4g: {} 5g: {}",
			preffered_modes.has_2g(),
			preffered_modes.has_3g(),
			preffered_modes.has_4g(),
			preffered_modes.has_5g()
		);

		println!(
			"- bands: {:?}",
			modem.current_bands().unwrap()
		);

		modem.signal_setup(10).unwrap();
		thread::sleep(Duration::from_secs(1));

		if let Ok(cdma) = modem.signal_cdma() {
			println!("- cdma: {:?}", cdma);
		}

		if let Ok(evdo) = modem.signal_evdo() {
			println!("- evdo: {:?}", evdo);
		}

		if let Ok(gsm) = modem.signal_gsm() {
			println!("- gsm: {:?}", gsm);
		}

		if let Ok(umts) = modem.signal_umts() {
			println!("- umts: {:?}", umts);
		}

		if let Ok(lte) = modem.signal_lte() {
			println!("- lte: {:?}", lte);
		}

		if let Ok(nr5g) = modem.signal_nr5g() {
			println!("- nr5g: {:?}", nr5g);
		}
	}

}
Examples found in repository?
examples/network.rs (line 76)
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

fn main() {

	let dbus = NetworkManager::connect().unwrap();

	for device in dbus.devices().unwrap() {
		let state = device.state().unwrap();
		let kind = device.kind().unwrap();
		let interface = device.interface().unwrap();

		println!("{:?} {:?} {:?}", interface, kind, state);
		if let Ok(apn) = device.modem_apn() {
			println!("- has apn {:?}", apn);
		}

		if matches!(state, DeviceState::Activated) {
			let ipv4 = device.ipv4_config().unwrap()
				.addresses().unwrap();
			println!("- addresses {:?}", ipv4);
		}
	}

	let dbus = ModemManager::connect().unwrap();

	for modem in dbus.modems().unwrap() {
		println!(
			"modem {:?} {:?} {:?}",
			modem.model().unwrap(),
			modem.manufacturer().unwrap(),
			modem.device().unwrap()
		);

		println!(
			"- carrier configuration: {:?}",
			modem.carrier_configuration().unwrap()
		);

		println!(
			"- state: {:?}, signal: {:?}",
			modem.state().unwrap(),
			modem.signal_quality().unwrap()
		);

		let (allowed_modes, preffered_modes) = modem.current_modes().unwrap();
		println!(
			"- allowed modes: 2g: {} 3g: {} 4g: {} 5g: {}",
			allowed_modes.has_2g(),
			allowed_modes.has_3g(),
			allowed_modes.has_4g(),
			allowed_modes.has_5g()
		);

		println!(
			"- prefered modes: 2g: {} 3g: {} 4g: {} 5g: {}",
			preffered_modes.has_2g(),
			preffered_modes.has_3g(),
			preffered_modes.has_4g(),
			preffered_modes.has_5g()
		);

		println!(
			"- bands: {:?}",
			modem.current_bands().unwrap()
		);

		modem.signal_setup(10).unwrap();
		thread::sleep(Duration::from_secs(1));

		if let Ok(cdma) = modem.signal_cdma() {
			println!("- cdma: {:?}", cdma);
		}

		if let Ok(evdo) = modem.signal_evdo() {
			println!("- evdo: {:?}", evdo);
		}

		if let Ok(gsm) = modem.signal_gsm() {
			println!("- gsm: {:?}", gsm);
		}

		if let Ok(umts) = modem.signal_umts() {
			println!("- umts: {:?}", umts);
		}

		if let Ok(lte) = modem.signal_lte() {
			println!("- lte: {:?}", lte);
		}

		if let Ok(nr5g) = modem.signal_nr5g() {
			println!("- nr5g: {:?}", nr5g);
		}
	}

}

Available signal information for the CDMA1x access technology.

Examples found in repository?
examples/network.rs (line 79)
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

fn main() {

	let dbus = NetworkManager::connect().unwrap();

	for device in dbus.devices().unwrap() {
		let state = device.state().unwrap();
		let kind = device.kind().unwrap();
		let interface = device.interface().unwrap();

		println!("{:?} {:?} {:?}", interface, kind, state);
		if let Ok(apn) = device.modem_apn() {
			println!("- has apn {:?}", apn);
		}

		if matches!(state, DeviceState::Activated) {
			let ipv4 = device.ipv4_config().unwrap()
				.addresses().unwrap();
			println!("- addresses {:?}", ipv4);
		}
	}

	let dbus = ModemManager::connect().unwrap();

	for modem in dbus.modems().unwrap() {
		println!(
			"modem {:?} {:?} {:?}",
			modem.model().unwrap(),
			modem.manufacturer().unwrap(),
			modem.device().unwrap()
		);

		println!(
			"- carrier configuration: {:?}",
			modem.carrier_configuration().unwrap()
		);

		println!(
			"- state: {:?}, signal: {:?}",
			modem.state().unwrap(),
			modem.signal_quality().unwrap()
		);

		let (allowed_modes, preffered_modes) = modem.current_modes().unwrap();
		println!(
			"- allowed modes: 2g: {} 3g: {} 4g: {} 5g: {}",
			allowed_modes.has_2g(),
			allowed_modes.has_3g(),
			allowed_modes.has_4g(),
			allowed_modes.has_5g()
		);

		println!(
			"- prefered modes: 2g: {} 3g: {} 4g: {} 5g: {}",
			preffered_modes.has_2g(),
			preffered_modes.has_3g(),
			preffered_modes.has_4g(),
			preffered_modes.has_5g()
		);

		println!(
			"- bands: {:?}",
			modem.current_bands().unwrap()
		);

		modem.signal_setup(10).unwrap();
		thread::sleep(Duration::from_secs(1));

		if let Ok(cdma) = modem.signal_cdma() {
			println!("- cdma: {:?}", cdma);
		}

		if let Ok(evdo) = modem.signal_evdo() {
			println!("- evdo: {:?}", evdo);
		}

		if let Ok(gsm) = modem.signal_gsm() {
			println!("- gsm: {:?}", gsm);
		}

		if let Ok(umts) = modem.signal_umts() {
			println!("- umts: {:?}", umts);
		}

		if let Ok(lte) = modem.signal_lte() {
			println!("- lte: {:?}", lte);
		}

		if let Ok(nr5g) = modem.signal_nr5g() {
			println!("- nr5g: {:?}", nr5g);
		}
	}

}

Available signal information for the CDMA EV-DO access technology.

Examples found in repository?
examples/network.rs (line 83)
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

fn main() {

	let dbus = NetworkManager::connect().unwrap();

	for device in dbus.devices().unwrap() {
		let state = device.state().unwrap();
		let kind = device.kind().unwrap();
		let interface = device.interface().unwrap();

		println!("{:?} {:?} {:?}", interface, kind, state);
		if let Ok(apn) = device.modem_apn() {
			println!("- has apn {:?}", apn);
		}

		if matches!(state, DeviceState::Activated) {
			let ipv4 = device.ipv4_config().unwrap()
				.addresses().unwrap();
			println!("- addresses {:?}", ipv4);
		}
	}

	let dbus = ModemManager::connect().unwrap();

	for modem in dbus.modems().unwrap() {
		println!(
			"modem {:?} {:?} {:?}",
			modem.model().unwrap(),
			modem.manufacturer().unwrap(),
			modem.device().unwrap()
		);

		println!(
			"- carrier configuration: {:?}",
			modem.carrier_configuration().unwrap()
		);

		println!(
			"- state: {:?}, signal: {:?}",
			modem.state().unwrap(),
			modem.signal_quality().unwrap()
		);

		let (allowed_modes, preffered_modes) = modem.current_modes().unwrap();
		println!(
			"- allowed modes: 2g: {} 3g: {} 4g: {} 5g: {}",
			allowed_modes.has_2g(),
			allowed_modes.has_3g(),
			allowed_modes.has_4g(),
			allowed_modes.has_5g()
		);

		println!(
			"- prefered modes: 2g: {} 3g: {} 4g: {} 5g: {}",
			preffered_modes.has_2g(),
			preffered_modes.has_3g(),
			preffered_modes.has_4g(),
			preffered_modes.has_5g()
		);

		println!(
			"- bands: {:?}",
			modem.current_bands().unwrap()
		);

		modem.signal_setup(10).unwrap();
		thread::sleep(Duration::from_secs(1));

		if let Ok(cdma) = modem.signal_cdma() {
			println!("- cdma: {:?}", cdma);
		}

		if let Ok(evdo) = modem.signal_evdo() {
			println!("- evdo: {:?}", evdo);
		}

		if let Ok(gsm) = modem.signal_gsm() {
			println!("- gsm: {:?}", gsm);
		}

		if let Ok(umts) = modem.signal_umts() {
			println!("- umts: {:?}", umts);
		}

		if let Ok(lte) = modem.signal_lte() {
			println!("- lte: {:?}", lte);
		}

		if let Ok(nr5g) = modem.signal_nr5g() {
			println!("- nr5g: {:?}", nr5g);
		}
	}

}

Available signal information for the GSM/GPRS access technology.

Examples found in repository?
examples/network.rs (line 87)
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

fn main() {

	let dbus = NetworkManager::connect().unwrap();

	for device in dbus.devices().unwrap() {
		let state = device.state().unwrap();
		let kind = device.kind().unwrap();
		let interface = device.interface().unwrap();

		println!("{:?} {:?} {:?}", interface, kind, state);
		if let Ok(apn) = device.modem_apn() {
			println!("- has apn {:?}", apn);
		}

		if matches!(state, DeviceState::Activated) {
			let ipv4 = device.ipv4_config().unwrap()
				.addresses().unwrap();
			println!("- addresses {:?}", ipv4);
		}
	}

	let dbus = ModemManager::connect().unwrap();

	for modem in dbus.modems().unwrap() {
		println!(
			"modem {:?} {:?} {:?}",
			modem.model().unwrap(),
			modem.manufacturer().unwrap(),
			modem.device().unwrap()
		);

		println!(
			"- carrier configuration: {:?}",
			modem.carrier_configuration().unwrap()
		);

		println!(
			"- state: {:?}, signal: {:?}",
			modem.state().unwrap(),
			modem.signal_quality().unwrap()
		);

		let (allowed_modes, preffered_modes) = modem.current_modes().unwrap();
		println!(
			"- allowed modes: 2g: {} 3g: {} 4g: {} 5g: {}",
			allowed_modes.has_2g(),
			allowed_modes.has_3g(),
			allowed_modes.has_4g(),
			allowed_modes.has_5g()
		);

		println!(
			"- prefered modes: 2g: {} 3g: {} 4g: {} 5g: {}",
			preffered_modes.has_2g(),
			preffered_modes.has_3g(),
			preffered_modes.has_4g(),
			preffered_modes.has_5g()
		);

		println!(
			"- bands: {:?}",
			modem.current_bands().unwrap()
		);

		modem.signal_setup(10).unwrap();
		thread::sleep(Duration::from_secs(1));

		if let Ok(cdma) = modem.signal_cdma() {
			println!("- cdma: {:?}", cdma);
		}

		if let Ok(evdo) = modem.signal_evdo() {
			println!("- evdo: {:?}", evdo);
		}

		if let Ok(gsm) = modem.signal_gsm() {
			println!("- gsm: {:?}", gsm);
		}

		if let Ok(umts) = modem.signal_umts() {
			println!("- umts: {:?}", umts);
		}

		if let Ok(lte) = modem.signal_lte() {
			println!("- lte: {:?}", lte);
		}

		if let Ok(nr5g) = modem.signal_nr5g() {
			println!("- nr5g: {:?}", nr5g);
		}
	}

}

Available signal information for the UMTS (WCDMA) access technology.

Examples found in repository?
examples/network.rs (line 91)
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

fn main() {

	let dbus = NetworkManager::connect().unwrap();

	for device in dbus.devices().unwrap() {
		let state = device.state().unwrap();
		let kind = device.kind().unwrap();
		let interface = device.interface().unwrap();

		println!("{:?} {:?} {:?}", interface, kind, state);
		if let Ok(apn) = device.modem_apn() {
			println!("- has apn {:?}", apn);
		}

		if matches!(state, DeviceState::Activated) {
			let ipv4 = device.ipv4_config().unwrap()
				.addresses().unwrap();
			println!("- addresses {:?}", ipv4);
		}
	}

	let dbus = ModemManager::connect().unwrap();

	for modem in dbus.modems().unwrap() {
		println!(
			"modem {:?} {:?} {:?}",
			modem.model().unwrap(),
			modem.manufacturer().unwrap(),
			modem.device().unwrap()
		);

		println!(
			"- carrier configuration: {:?}",
			modem.carrier_configuration().unwrap()
		);

		println!(
			"- state: {:?}, signal: {:?}",
			modem.state().unwrap(),
			modem.signal_quality().unwrap()
		);

		let (allowed_modes, preffered_modes) = modem.current_modes().unwrap();
		println!(
			"- allowed modes: 2g: {} 3g: {} 4g: {} 5g: {}",
			allowed_modes.has_2g(),
			allowed_modes.has_3g(),
			allowed_modes.has_4g(),
			allowed_modes.has_5g()
		);

		println!(
			"- prefered modes: 2g: {} 3g: {} 4g: {} 5g: {}",
			preffered_modes.has_2g(),
			preffered_modes.has_3g(),
			preffered_modes.has_4g(),
			preffered_modes.has_5g()
		);

		println!(
			"- bands: {:?}",
			modem.current_bands().unwrap()
		);

		modem.signal_setup(10).unwrap();
		thread::sleep(Duration::from_secs(1));

		if let Ok(cdma) = modem.signal_cdma() {
			println!("- cdma: {:?}", cdma);
		}

		if let Ok(evdo) = modem.signal_evdo() {
			println!("- evdo: {:?}", evdo);
		}

		if let Ok(gsm) = modem.signal_gsm() {
			println!("- gsm: {:?}", gsm);
		}

		if let Ok(umts) = modem.signal_umts() {
			println!("- umts: {:?}", umts);
		}

		if let Ok(lte) = modem.signal_lte() {
			println!("- lte: {:?}", lte);
		}

		if let Ok(nr5g) = modem.signal_nr5g() {
			println!("- nr5g: {:?}", nr5g);
		}
	}

}

Available signal information for the LTE access technology.

Examples found in repository?
examples/network.rs (line 95)
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

fn main() {

	let dbus = NetworkManager::connect().unwrap();

	for device in dbus.devices().unwrap() {
		let state = device.state().unwrap();
		let kind = device.kind().unwrap();
		let interface = device.interface().unwrap();

		println!("{:?} {:?} {:?}", interface, kind, state);
		if let Ok(apn) = device.modem_apn() {
			println!("- has apn {:?}", apn);
		}

		if matches!(state, DeviceState::Activated) {
			let ipv4 = device.ipv4_config().unwrap()
				.addresses().unwrap();
			println!("- addresses {:?}", ipv4);
		}
	}

	let dbus = ModemManager::connect().unwrap();

	for modem in dbus.modems().unwrap() {
		println!(
			"modem {:?} {:?} {:?}",
			modem.model().unwrap(),
			modem.manufacturer().unwrap(),
			modem.device().unwrap()
		);

		println!(
			"- carrier configuration: {:?}",
			modem.carrier_configuration().unwrap()
		);

		println!(
			"- state: {:?}, signal: {:?}",
			modem.state().unwrap(),
			modem.signal_quality().unwrap()
		);

		let (allowed_modes, preffered_modes) = modem.current_modes().unwrap();
		println!(
			"- allowed modes: 2g: {} 3g: {} 4g: {} 5g: {}",
			allowed_modes.has_2g(),
			allowed_modes.has_3g(),
			allowed_modes.has_4g(),
			allowed_modes.has_5g()
		);

		println!(
			"- prefered modes: 2g: {} 3g: {} 4g: {} 5g: {}",
			preffered_modes.has_2g(),
			preffered_modes.has_3g(),
			preffered_modes.has_4g(),
			preffered_modes.has_5g()
		);

		println!(
			"- bands: {:?}",
			modem.current_bands().unwrap()
		);

		modem.signal_setup(10).unwrap();
		thread::sleep(Duration::from_secs(1));

		if let Ok(cdma) = modem.signal_cdma() {
			println!("- cdma: {:?}", cdma);
		}

		if let Ok(evdo) = modem.signal_evdo() {
			println!("- evdo: {:?}", evdo);
		}

		if let Ok(gsm) = modem.signal_gsm() {
			println!("- gsm: {:?}", gsm);
		}

		if let Ok(umts) = modem.signal_umts() {
			println!("- umts: {:?}", umts);
		}

		if let Ok(lte) = modem.signal_lte() {
			println!("- lte: {:?}", lte);
		}

		if let Ok(nr5g) = modem.signal_nr5g() {
			println!("- nr5g: {:?}", nr5g);
		}
	}

}

Available signal information for the 5G access technology.

Examples found in repository?
examples/network.rs (line 99)
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104

fn main() {

	let dbus = NetworkManager::connect().unwrap();

	for device in dbus.devices().unwrap() {
		let state = device.state().unwrap();
		let kind = device.kind().unwrap();
		let interface = device.interface().unwrap();

		println!("{:?} {:?} {:?}", interface, kind, state);
		if let Ok(apn) = device.modem_apn() {
			println!("- has apn {:?}", apn);
		}

		if matches!(state, DeviceState::Activated) {
			let ipv4 = device.ipv4_config().unwrap()
				.addresses().unwrap();
			println!("- addresses {:?}", ipv4);
		}
	}

	let dbus = ModemManager::connect().unwrap();

	for modem in dbus.modems().unwrap() {
		println!(
			"modem {:?} {:?} {:?}",
			modem.model().unwrap(),
			modem.manufacturer().unwrap(),
			modem.device().unwrap()
		);

		println!(
			"- carrier configuration: {:?}",
			modem.carrier_configuration().unwrap()
		);

		println!(
			"- state: {:?}, signal: {:?}",
			modem.state().unwrap(),
			modem.signal_quality().unwrap()
		);

		let (allowed_modes, preffered_modes) = modem.current_modes().unwrap();
		println!(
			"- allowed modes: 2g: {} 3g: {} 4g: {} 5g: {}",
			allowed_modes.has_2g(),
			allowed_modes.has_3g(),
			allowed_modes.has_4g(),
			allowed_modes.has_5g()
		);

		println!(
			"- prefered modes: 2g: {} 3g: {} 4g: {} 5g: {}",
			preffered_modes.has_2g(),
			preffered_modes.has_3g(),
			preffered_modes.has_4g(),
			preffered_modes.has_5g()
		);

		println!(
			"- bands: {:?}",
			modem.current_bands().unwrap()
		);

		modem.signal_setup(10).unwrap();
		thread::sleep(Duration::from_secs(1));

		if let Ok(cdma) = modem.signal_cdma() {
			println!("- cdma: {:?}", cdma);
		}

		if let Ok(evdo) = modem.signal_evdo() {
			println!("- evdo: {:?}", evdo);
		}

		if let Ok(gsm) = modem.signal_gsm() {
			println!("- gsm: {:?}", gsm);
		}

		if let Ok(umts) = modem.signal_umts() {
			println!("- umts: {:?}", umts);
		}

		if let Ok(lte) = modem.signal_lte() {
			println!("- lte: {:?}", lte);
		}

		if let Ok(nr5g) = modem.signal_nr5g() {
			println!("- nr5g: {:?}", nr5g);
		}
	}

}

List of numbers (e.g. MSISDN in 3GPP) being currently handled by this modem.

The IMEI of the device.

Note

This interface will only be available once the modem is ready to be registered in the cellular network. 3GPP devices will require a valid unlocked SIM card before any of the features in the interface can be used.

Name of the operator to which the mobile is currently registered.

If the operator name is not known or the mobile is not registered to a mobile network, this property will be an empty string.

Note

This interface will only be available once the modem is ready to be registered in the cellular network. 3GPP devices will require a valid unlocked SIM card before any of the features in the interface can be used.

This SIM object is the one used for network registration and data connection setup.

Auto Trait Implementations§

Blanket Implementations§

Gets the TypeId of self. Read more
Immutably borrows from an owned value. Read more
Mutably borrows from an owned value. Read more

Returns the argument unchanged.

Calls U::from(self).

That is, this conversion is whatever the implementation of From<T> for U chooses to do.

The type returned in the event of a conversion error.
Performs the conversion.
The type returned in the event of a conversion error.
Performs the conversion.