diff --git a/rust/bt-mcs/src/server.rs b/rust/bt-mcs/src/server.rs
index f666070..be7e567 100644
--- a/rust/bt-mcs/src/server.rs
+++ b/rust/bt-mcs/src/server.rs
@@ -35,87 +35,64 @@
 const TRACK_DURATION_HANDLE: Handle = Handle(4);
 /// Handle assigned to the Track Position characteristic.
 const TRACK_POSITION_HANDLE: Handle = Handle(5);
-/// Handle assigned to the Playback Speed characteristic.
-const PLAYBACK_SPEED_HANDLE: Handle = Handle(6);
-/// Handle assigned to the Seeking Speed characteristic.
-const SEEKING_SPEED_HANDLE: Handle = Handle(7);
-/// Handle assigned to the Playing Order characteristic.
-const PLAYING_ORDER_HANDLE: Handle = Handle(8);
-/// Handle assigned to the Playing Orders Supported characteristic.
-const PLAYING_ORDERS_SUPPORTED_HANDLE: Handle = Handle(9);
 /// Handle assigned to the Media State characteristic.
-const MEDIA_STATE_HANDLE: Handle = Handle(10);
-/// Handle assigned to the Media Control Point characteristic.
-const MEDIA_CONTROL_POINT_HANDLE: Handle = Handle(11);
-/// Handle assigned to the Media Control Point Opcodes Supported characteristic.
-const MEDIA_CONTROL_POINT_OPCODES_SUPPORTED_HANDLE: Handle = Handle(12);
+const MEDIA_STATE_HANDLE: Handle = Handle(6);
 /// Handle assigned to the Content Control ID (CCID) characteristic.
-const CONTENT_CONTROL_ID_HANDLE: Handle = Handle(13);
+const CONTENT_CONTROL_ID_HANDLE: Handle = Handle(7);
 
-/// All 13 mandatory characteristics defined in MCS v1.0.1 Section 3.
-fn mandatory_characteristics() -> [Characteristic; 13] {
+// ============================================================================
+// Optional Characteristic Handle Definitions (MCS v1.0.1 Section 3)
+// ============================================================================
+
+/// Handle assigned to the Media Player Icon URL characteristic.
+const MEDIA_PLAYER_ICON_URL_HANDLE: Handle = Handle(8);
+/// Handle assigned to the Playback Speed characteristic.
+const PLAYBACK_SPEED_HANDLE: Handle = Handle(9);
+/// Handle assigned to the Seeking Speed characteristic.
+const SEEKING_SPEED_HANDLE: Handle = Handle(10);
+/// Handle assigned to the Playing Order characteristic.
+const PLAYING_ORDER_HANDLE: Handle = Handle(11);
+/// Handle assigned to the Playing Orders Supported characteristic.
+const PLAYING_ORDERS_SUPPORTED_HANDLE: Handle = Handle(12);
+/// Handle assigned to the Media Control Point characteristic.
+const MEDIA_CONTROL_POINT_HANDLE: Handle = Handle(13);
+/// Handle assigned to the Media Control Point Opcodes Supported characteristic.
+const MEDIA_CONTROL_POINT_OPCODES_SUPPORTED_HANDLE: Handle = Handle(14);
+
+/// The mandatory characteristics defined in MCS v1.0.1 Section 3, Table 3.1.
+fn mandatory_characteristics() -> [Characteristic; 7] {
     [
-        build_mandatory_characteristic(
+        build_characteristic(
             MEDIA_PLAYER_NAME_HANDLE,
             MEDIA_PLAYER_NAME_UUID,
             CharacteristicProperties::READ_NOTIFY,
         ),
-        build_mandatory_characteristic(
+        build_characteristic(
             TRACK_CHANGED_HANDLE,
             TRACK_CHANGED_UUID,
             CharacteristicProperty::Notify,
         ),
-        build_mandatory_characteristic(
+        build_characteristic(
             TRACK_TITLE_HANDLE,
             TRACK_TITLE_UUID,
             CharacteristicProperties::READ_NOTIFY,
         ),
-        build_mandatory_characteristic(
+        build_characteristic(
             TRACK_DURATION_HANDLE,
             TRACK_DURATION_UUID,
             CharacteristicProperties::READ_NOTIFY,
         ),
-        build_mandatory_characteristic(
+        build_characteristic(
             TRACK_POSITION_HANDLE,
             TRACK_POSITION_UUID,
             CharacteristicProperties::READ_WRITE_NOTIFY,
         ),
-        build_mandatory_characteristic(
-            PLAYBACK_SPEED_HANDLE,
-            PLAYBACK_SPEED_UUID,
-            CharacteristicProperties::READ_WRITE_NOTIFY,
-        ),
-        build_mandatory_characteristic(
-            SEEKING_SPEED_HANDLE,
-            SEEKING_SPEED_UUID,
-            CharacteristicProperties::READ_NOTIFY,
-        ),
-        build_mandatory_characteristic(
-            PLAYING_ORDER_HANDLE,
-            PLAYING_ORDER_UUID,
-            CharacteristicProperties::READ_WRITE_NOTIFY,
-        ),
-        build_mandatory_characteristic(
-            PLAYING_ORDERS_SUPPORTED_HANDLE,
-            PLAYING_ORDERS_SUPPORTED_UUID,
-            CharacteristicProperty::Read,
-        ),
-        build_mandatory_characteristic(
+        build_characteristic(
             MEDIA_STATE_HANDLE,
             MEDIA_STATE_UUID,
             CharacteristicProperties::READ_NOTIFY,
         ),
-        build_mandatory_characteristic(
-            MEDIA_CONTROL_POINT_HANDLE,
-            MEDIA_CONTROL_POINT_UUID,
-            CharacteristicProperties::WRITE_NOTIFY,
-        ),
-        build_mandatory_characteristic(
-            MEDIA_CONTROL_POINT_OPCODES_SUPPORTED_HANDLE,
-            MEDIA_CONTROL_POINT_OPCODES_SUPPORTED_UUID,
-            CharacteristicProperties::READ_NOTIFY,
-        ),
-        build_mandatory_characteristic(
+        build_characteristic(
             CONTENT_CONTROL_ID_HANDLE,
             CONTENT_CONTROL_ID_UUID,
             CharacteristicProperty::Read,
@@ -123,11 +100,10 @@
     ]
 }
 
-/// Specification of a mandatory GATT characteristic for MCS.
 /// Constructs a characteristic definition with the specified handle, UUID,
 /// properties, and encryption-required permissions conforming to MCS v1.0.1
 /// Section 3.
-fn build_mandatory_characteristic(
+fn build_characteristic(
     handle: Handle,
     uuid: Uuid,
     properties: impl Into<CharacteristicProperties>,
@@ -220,7 +196,7 @@
     }
 }
 
-/// Local state of the mandatory characteristics in this server.
+/// Local state of the characteristics in this server.
 #[derive(Debug, Clone, PartialEq, Eq)]
 struct McsLocalState {
     /// Content Control ID (CCID) identifying this media service instance.
@@ -237,6 +213,17 @@
     position_updated_at: Option<std::time::Instant>,
     /// Current player activity state.
     media_state: MediaState,
+    /// URL pointing to media player icon graphic, if supported.
+    icon_url: Option<String>,
+    /// Playback speed multiplier (0 = 1.0x normal speed), if supported.
+    playback_speed: Option<i8>,
+    /// Seeking speed factor (0 = not seeking), if supported.
+    seeking_speed: Option<i8>,
+    /// Playing order and supported playing orders, if supported.
+    playing_orders: Option<PlayingOrderState>,
+    /// Supported media control point opcodes, if Media Control Point is
+    /// supported.
+    supported_opcodes: Option<SupportedOpcodes>,
 }
 
 impl McsLocalState {
@@ -251,6 +238,11 @@
             track_position: TrackPosition::Unavailable,
             position_updated_at: None,
             media_state: MediaState::Inactive,
+            icon_url: None,
+            playback_speed: None,
+            seeking_speed: None,
+            playing_orders: None,
+            supported_opcodes: None,
         }
     }
 
@@ -291,14 +283,12 @@
 
     /// Reads the characteristic bytes for `handle` at `offset`.
     fn handle_read(&self, handle: Handle, offset: usize) -> Result<Vec<u8>, GattError> {
-        // Track Changed is notify-only. Return Error. See MCS v1.0.1 Section 3.4.
-        if handle == TRACK_CHANGED_HANDLE {
-            return Err(GattError::ReadNotPermitted);
-        }
-
         let read_at_offset =
             |bytes: &[u8]| bytes.get(offset..).map(Vec::from).ok_or(GattError::InvalidOffset);
         match handle {
+            // Track Changed and Media Control Point are not readable per MCS v1.0.1 Section 3,
+            // Table 3.1.
+            TRACK_CHANGED_HANDLE | MEDIA_CONTROL_POINT_HANDLE => Err(GattError::ReadNotPermitted),
             MEDIA_PLAYER_NAME_HANDLE => read_at_offset(self.player_name.as_bytes()),
             TRACK_TITLE_HANDLE => read_at_offset(self.track_title.as_bytes()),
             TRACK_DURATION_HANDLE => read_at_offset(&self.track_duration.raw_10ms().to_le_bytes()),
@@ -307,6 +297,30 @@
             }
             MEDIA_STATE_HANDLE => read_at_offset(&[self.media_state.into()]),
             CONTENT_CONTROL_ID_HANDLE => read_at_offset(&[self.ccid]),
+            MEDIA_PLAYER_ICON_URL_HANDLE => {
+                let url = self.icon_url.as_ref().ok_or(GattError::InvalidHandle)?;
+                read_at_offset(url.as_bytes())
+            }
+            PLAYBACK_SPEED_HANDLE => {
+                let speed = self.playback_speed.ok_or(GattError::InvalidHandle)?;
+                read_at_offset(&[speed as u8])
+            }
+            SEEKING_SPEED_HANDLE => {
+                let speed = self.seeking_speed.ok_or(GattError::InvalidHandle)?;
+                read_at_offset(&[speed as u8])
+            }
+            PLAYING_ORDER_HANDLE => {
+                let orders = self.playing_orders.as_ref().ok_or(GattError::InvalidHandle)?;
+                read_at_offset(&[orders.current.into()])
+            }
+            PLAYING_ORDERS_SUPPORTED_HANDLE => {
+                let orders = self.playing_orders.as_ref().ok_or(GattError::InvalidHandle)?;
+                read_at_offset(&orders.supported.bits().to_le_bytes())
+            }
+            MEDIA_CONTROL_POINT_OPCODES_SUPPORTED_HANDLE => {
+                let opcodes = self.supported_opcodes.ok_or(GattError::InvalidHandle)?;
+                read_at_offset(&opcodes.bits().to_le_bytes())
+            }
             _ => Err(GattError::InvalidHandle),
         }
     }
@@ -337,8 +351,34 @@
         Self { service_uuid, state: McsLocalState::new(ccid, player_name) }
     }
 
-    /// Constructs the complete GATT [`ServiceDefinition`] containing all 13
-    /// Mandatory Characteristics defined in MCS v1.0.1 Section 3.
+    /// Enables media player icon URL support.
+    pub fn with_icon_url(mut self, url: impl Into<String>) -> Self {
+        self.state.icon_url = Some(url.into());
+        self
+    }
+
+    /// Enables playback and seeking speed support with default speeds.
+    pub fn with_player_speeds(mut self) -> Self {
+        self.state.playback_speed = Some(0);
+        self.state.seeking_speed = Some(0);
+        self
+    }
+
+    /// Enables playing order support with the given supported playing orders.
+    pub fn with_playing_orders(mut self, supported: SupportedPlayingOrders) -> Self {
+        self.state.playing_orders = Some(PlayingOrderState::new(supported));
+        self
+    }
+
+    /// Enables media control operations with the given supported opcodes.
+    pub fn with_supported_operations(mut self, supported: SupportedOpcodes) -> Self {
+        self.state.supported_opcodes = Some(supported);
+        self
+    }
+
+    /// Constructs the GATT [`ServiceDefinition`] containing the mandatory
+    /// characteristics per MCS v1.0.1 Section 3 and any configured optional
+    /// characteristics.
     pub fn build_service_definition(&self) -> Result<ServiceDefinition, Error> {
         // The local `ServiceId` is derived from the provided `CCID`. This is valid
         // because the CCID must be unique across all MCS/GMCS instances on the
@@ -354,6 +394,52 @@
             service_def.add_characteristic(chrc)?;
         }
 
+        if self.state.icon_url.is_some() {
+            service_def.add_characteristic(build_characteristic(
+                MEDIA_PLAYER_ICON_URL_HANDLE,
+                MEDIA_PLAYER_ICON_URL_UUID,
+                CharacteristicProperty::Read,
+            ))?;
+        }
+        if self.state.playback_speed.is_some() {
+            service_def.add_characteristic(build_characteristic(
+                PLAYBACK_SPEED_HANDLE,
+                PLAYBACK_SPEED_UUID,
+                CharacteristicProperties::READ_WRITE_NOTIFY,
+            ))?;
+        }
+        if self.state.seeking_speed.is_some() {
+            service_def.add_characteristic(build_characteristic(
+                SEEKING_SPEED_HANDLE,
+                SEEKING_SPEED_UUID,
+                CharacteristicProperties::READ_NOTIFY,
+            ))?;
+        }
+        if self.state.playing_orders.is_some() {
+            service_def.add_characteristic(build_characteristic(
+                PLAYING_ORDER_HANDLE,
+                PLAYING_ORDER_UUID,
+                CharacteristicProperties::READ_WRITE_NOTIFY,
+            ))?;
+            service_def.add_characteristic(build_characteristic(
+                PLAYING_ORDERS_SUPPORTED_HANDLE,
+                PLAYING_ORDERS_SUPPORTED_UUID,
+                CharacteristicProperty::Read,
+            ))?;
+        }
+        if self.state.supported_opcodes.is_some() {
+            service_def.add_characteristic(build_characteristic(
+                MEDIA_CONTROL_POINT_HANDLE,
+                MEDIA_CONTROL_POINT_UUID,
+                CharacteristicProperties::WRITE_NOTIFY,
+            ))?;
+            service_def.add_characteristic(build_characteristic(
+                MEDIA_CONTROL_POINT_OPCODES_SUPPORTED_HANDLE,
+                MEDIA_CONTROL_POINT_OPCODES_SUPPORTED_UUID,
+                CharacteristicProperties::READ_NOTIFY,
+            ))?;
+        }
+
         Ok(service_def)
     }
 
@@ -454,7 +540,7 @@
         assert_eq!(service_def.uuid(), GENERIC_MEDIA_CONTROL_SERVICE_UUID);
         assert_eq!(service_def.id(), ServiceId::new(0x42));
         assert_eq!(service_def.kind(), ServiceKind::Primary);
-        assert_eq!(service_def.characteristics().count(), 13);
+        assert_eq!(service_def.characteristics().count(), 7);
     }
 
     #[test]
@@ -466,7 +552,74 @@
         assert_eq!(service_def.uuid(), MEDIA_CONTROL_SERVICE_UUID);
         assert_eq!(service_def.id(), ServiceId::new(0x07));
         assert_eq!(service_def.kind(), ServiceKind::Primary);
-        assert_eq!(service_def.characteristics().count(), 13);
+        assert_eq!(service_def.characteristics().count(), 7);
+    }
+
+    #[test]
+    fn builder_with_optional_characteristics_service_definition() {
+        let builder = McsServerBuilder::generic(0x10, "Full Player")
+            .with_icon_url("https://example.com/icon.png")
+            .with_player_speeds()
+            .with_playing_orders(SupportedPlayingOrders::default())
+            .with_supported_operations(SupportedOpcodes::default());
+
+        let service_def =
+            builder.build_service_definition().expect("service definition builds successfully");
+        assert_eq!(service_def.characteristics().count(), 14);
+
+        let characteristics: Vec<&Characteristic> = service_def.characteristics().collect();
+        let expected_characteristics = [
+            mandatory_characteristics()[0].clone(),
+            mandatory_characteristics()[1].clone(),
+            mandatory_characteristics()[2].clone(),
+            mandatory_characteristics()[3].clone(),
+            mandatory_characteristics()[4].clone(),
+            mandatory_characteristics()[5].clone(),
+            mandatory_characteristics()[6].clone(),
+            build_characteristic(
+                MEDIA_PLAYER_ICON_URL_HANDLE,
+                MEDIA_PLAYER_ICON_URL_UUID,
+                CharacteristicProperty::Read,
+            ),
+            build_characteristic(
+                PLAYBACK_SPEED_HANDLE,
+                PLAYBACK_SPEED_UUID,
+                CharacteristicProperties::READ_WRITE_NOTIFY,
+            ),
+            build_characteristic(
+                SEEKING_SPEED_HANDLE,
+                SEEKING_SPEED_UUID,
+                CharacteristicProperties::READ_NOTIFY,
+            ),
+            build_characteristic(
+                PLAYING_ORDER_HANDLE,
+                PLAYING_ORDER_UUID,
+                CharacteristicProperties::READ_WRITE_NOTIFY,
+            ),
+            build_characteristic(
+                PLAYING_ORDERS_SUPPORTED_HANDLE,
+                PLAYING_ORDERS_SUPPORTED_UUID,
+                CharacteristicProperty::Read,
+            ),
+            build_characteristic(
+                MEDIA_CONTROL_POINT_HANDLE,
+                MEDIA_CONTROL_POINT_UUID,
+                CharacteristicProperties::WRITE_NOTIFY,
+            ),
+            build_characteristic(
+                MEDIA_CONTROL_POINT_OPCODES_SUPPORTED_HANDLE,
+                MEDIA_CONTROL_POINT_OPCODES_SUPPORTED_UUID,
+                CharacteristicProperties::READ_NOTIFY,
+            ),
+        ];
+
+        assert_eq!(characteristics.len(), expected_characteristics.len());
+        for (i, expected) in expected_characteristics.iter().enumerate() {
+            let chrc = characteristics[i];
+            assert_eq!(chrc.handle, expected.handle);
+            assert_eq!(chrc.uuid, expected.uuid);
+            assert_eq!(chrc.properties, expected.properties);
+        }
     }
 
     #[test]
@@ -677,7 +830,7 @@
         let (mut server, fake_gatt_server, mut event_receiver) =
             setup_test_server(McsServerBuilder::generic(0x42, "Test Player"));
 
-        // Media Player Name (0x2B93)
+        // Media Player Name
         assert_read_characteristic(
             &mut server,
             &fake_gatt_server,
@@ -686,7 +839,7 @@
             b"Test Player",
         );
 
-        // Track Title (0x2B97)
+        // Track Title
         assert_read_characteristic(
             &mut server,
             &fake_gatt_server,
@@ -695,7 +848,7 @@
             b"",
         );
 
-        // Track Duration (0x2B98)
+        // Track Duration
         assert_read_characteristic(
             &mut server,
             &fake_gatt_server,
@@ -704,7 +857,7 @@
             &(-1i32).to_le_bytes(),
         );
 
-        // Track Position (0x2B99)
+        // Track Position
         assert_read_characteristic(
             &mut server,
             &fake_gatt_server,
@@ -713,7 +866,7 @@
             &(-1i32).to_le_bytes(),
         );
 
-        // Media State (0x2BA3)
+        // Media State
         assert_read_characteristic(
             &mut server,
             &fake_gatt_server,
@@ -722,7 +875,7 @@
             &[MediaState::Inactive.into()],
         );
 
-        // Content Control ID (0x2BA8)
+        // Content Control ID
         assert_read_characteristic(
             &mut server,
             &fake_gatt_server,
@@ -733,15 +886,121 @@
     }
 
     #[test]
-    fn read_string_characteristics_with_offset() {
-        let mut noop_cx = Context::from_waker(futures::task::noop_waker_ref());
+    fn read_optional_characteristics_configured_values() {
+        let (mut server, fake_gatt_server, mut event_receiver) = setup_test_server(
+            McsServerBuilder::generic(0x42, "Test Player")
+                .with_icon_url("https://example.com/icon.png")
+                .with_player_speeds()
+                .with_playing_orders(
+                    SupportedPlayingOrders::IN_ORDER_ONCE | SupportedPlayingOrders::SHUFFLE_ONCE,
+                )
+                .with_supported_operations(SupportedOpcodes::PLAY | SupportedOpcodes::PAUSE),
+        );
+
+        // Media Player Icon URL
+        assert_read_characteristic(
+            &mut server,
+            &fake_gatt_server,
+            &mut event_receiver,
+            MEDIA_PLAYER_ICON_URL_HANDLE,
+            b"https://example.com/icon.png",
+        );
+
+        // Playback Speed
+        assert_read_characteristic(
+            &mut server,
+            &fake_gatt_server,
+            &mut event_receiver,
+            PLAYBACK_SPEED_HANDLE,
+            &[0],
+        );
+
+        // Seeking Speed
+        assert_read_characteristic(
+            &mut server,
+            &fake_gatt_server,
+            &mut event_receiver,
+            SEEKING_SPEED_HANDLE,
+            &[0],
+        );
+
+        // Playing Order
+        assert_read_characteristic(
+            &mut server,
+            &fake_gatt_server,
+            &mut event_receiver,
+            PLAYING_ORDER_HANDLE,
+            &[PlayingOrder::InOrderOnce.into()],
+        );
+
+        // Playing Orders Supported
+        let expected_orders =
+            SupportedPlayingOrders::IN_ORDER_ONCE | SupportedPlayingOrders::SHUFFLE_ONCE;
+        assert_read_characteristic(
+            &mut server,
+            &fake_gatt_server,
+            &mut event_receiver,
+            PLAYING_ORDERS_SUPPORTED_HANDLE,
+            &expected_orders.bits().to_le_bytes(),
+        );
+
+        // Media Control Point Opcodes Supported
+        let expected_opcodes = SupportedOpcodes::PLAY | SupportedOpcodes::PAUSE;
+        assert_read_characteristic(
+            &mut server,
+            &fake_gatt_server,
+            &mut event_receiver,
+            MEDIA_CONTROL_POINT_OPCODES_SUPPORTED_HANDLE,
+            &expected_opcodes.bits().to_le_bytes(),
+        );
+    }
+
+    #[test]
+    fn read_unconfigured_optional_characteristics_returns_invalid_handle() {
         let (mut server, fake_gatt_server, mut event_receiver) =
-            setup_test_server(McsServerBuilder::generic(0x42, "Long Player Name"));
+            setup_test_server(McsServerBuilder::generic(0x42, "Mandatory Only Player"));
 
+        let mut noop_cx = Context::from_waker(futures::task::noop_waker_ref());
         let peer = PeerId(1);
-        let service_id = ServiceId::new(0x42);
+        let service_id = server.service_def.id();
 
-        // Valid offset slice
+        let unconfigured_handles = [
+            MEDIA_PLAYER_ICON_URL_HANDLE,
+            PLAYBACK_SPEED_HANDLE,
+            SEEKING_SPEED_HANDLE,
+            PLAYING_ORDER_HANDLE,
+            PLAYING_ORDERS_SUPPORTED_HANDLE,
+            MEDIA_CONTROL_POINT_OPCODES_SUPPORTED_HANDLE,
+        ];
+
+        for handle in unconfigured_handles {
+            fake_gatt_server.incoming_read(peer, service_id, handle, 0);
+            let _ = server.next().poll_unpin(&mut noop_cx);
+            let bt_gatt::test_utils::FakeServerEvent::ReadResponded { value, .. } =
+                event_receiver.try_recv().unwrap()
+            else {
+                panic!("expected ReadResponded for handle {:?}", handle);
+            };
+            assert!(
+                matches!(value.unwrap_err(), bt_gatt::types::Error::Gatt(GattError::InvalidHandle)),
+                "handle {:?} should return InvalidHandle when unconfigured",
+                handle
+            );
+        }
+    }
+
+    #[test]
+    fn read_string_characteristics_with_offset() {
+        let (mut server, fake_gatt_server, mut event_receiver) = setup_test_server(
+            McsServerBuilder::generic(0x42, "Long Player Name")
+                .with_icon_url("https://example.com/icon.png"),
+        );
+
+        let mut noop_cx = Context::from_waker(futures::task::noop_waker_ref());
+        let peer = PeerId(1);
+        let service_id = server.service_def.id();
+
+        // Valid offset slice for Player Name
         fake_gatt_server.incoming_read(peer, service_id, MEDIA_PLAYER_NAME_HANDLE, 5);
         let _ = server.next().poll_unpin(&mut noop_cx);
         let bt_gatt::test_utils::FakeServerEvent::ReadResponded { value, .. } =
@@ -751,6 +1010,16 @@
         };
         assert_eq!(value.unwrap(), b"Player Name");
 
+        // Valid offset slice for Icon URL
+        fake_gatt_server.incoming_read(peer, service_id, MEDIA_PLAYER_ICON_URL_HANDLE, 8);
+        let _ = server.next().poll_unpin(&mut noop_cx);
+        let bt_gatt::test_utils::FakeServerEvent::ReadResponded { value, .. } =
+            event_receiver.try_recv().unwrap()
+        else {
+            panic!("expected ReadResponded");
+        };
+        assert_eq!(value.unwrap(), b"example.com/icon.png");
+
         // Exact end offset returns empty slice
         fake_gatt_server.incoming_read(
             peer,
@@ -778,16 +1047,31 @@
             value.unwrap_err(),
             bt_gatt::types::Error::Gatt(GattError::InvalidOffset)
         ));
+
+        // Out-of-bounds offset on Icon URL returns InvalidOffset
+        fake_gatt_server.incoming_read(peer, service_id, MEDIA_PLAYER_ICON_URL_HANDLE, 100);
+        let _ = server.next().poll_unpin(&mut noop_cx);
+        let bt_gatt::test_utils::FakeServerEvent::ReadResponded { value, .. } =
+            event_receiver.try_recv().unwrap()
+        else {
+            panic!("expected ReadResponded");
+        };
+        assert!(matches!(
+            value.unwrap_err(),
+            bt_gatt::types::Error::Gatt(GattError::InvalidOffset)
+        ));
     }
 
     #[test]
     fn read_non_readable_characteristics_returns_error() {
         let mut noop_cx = Context::from_waker(futures::task::noop_waker_ref());
-        let (mut server, fake_gatt_server, mut event_receiver) =
-            setup_test_server(McsServerBuilder::generic(0x42, "Test Player"));
+        let (mut server, fake_gatt_server, mut event_receiver) = setup_test_server(
+            McsServerBuilder::generic(0x42, "Test Player")
+                .with_supported_operations(SupportedOpcodes::default()),
+        );
 
         let peer = PeerId(1);
-        let service_id = ServiceId::new(0x42);
+        let service_id = server.service_def.id();
 
         // Track Changed is notify-only
         fake_gatt_server.incoming_read(peer, service_id, TRACK_CHANGED_HANDLE, 0);
@@ -802,6 +1086,19 @@
             bt_gatt::types::Error::Gatt(GattError::ReadNotPermitted)
         ));
 
+        // Media Control Point is write/notify-only
+        fake_gatt_server.incoming_read(peer, service_id, MEDIA_CONTROL_POINT_HANDLE, 0);
+        let _ = server.next().poll_unpin(&mut noop_cx);
+        let bt_gatt::test_utils::FakeServerEvent::ReadResponded { value, .. } =
+            event_receiver.try_recv().unwrap()
+        else {
+            panic!("expected ReadResponded");
+        };
+        assert!(matches!(
+            value.unwrap_err(),
+            bt_gatt::types::Error::Gatt(GattError::ReadNotPermitted)
+        ));
+
         // Unknown handle returns InvalidHandle
         fake_gatt_server.incoming_read(peer, service_id, Handle(999), 0);
         let _ = server.next().poll_unpin(&mut noop_cx);
diff --git a/rust/bt-mcs/src/types.rs b/rust/bt-mcs/src/types.rs
index 30043ac..1d9d8d0 100644
--- a/rust/bt-mcs/src/types.rs
+++ b/rust/bt-mcs/src/types.rs
@@ -20,6 +20,8 @@
 
 /// Media Player Name characteristic UUID.
 pub(crate) const MEDIA_PLAYER_NAME_UUID: Uuid = Uuid::from_u16(0x2B93);
+/// Media Player Icon URL characteristic UUID.
+pub(crate) const MEDIA_PLAYER_ICON_URL_UUID: Uuid = Uuid::from_u16(0x2B95);
 /// Track Changed characteristic UUID.
 pub(crate) const TRACK_CHANGED_UUID: Uuid = Uuid::from_u16(0x2B96);
 /// Track Title characteristic UUID.
@@ -46,7 +48,7 @@
 pub(crate) const CONTENT_CONTROL_ID_UUID: Uuid = Uuid::from_u16(0x2BBA);
 
 decodable_enum! {
-    /// State of the media player.
+    /// State of the media player (MCS v1.0.1 Section 3.17, Table 3.5).
     pub enum MediaState<u8, PacketError, OutOfRange> {
         /// Media player is inactive.
         Inactive = 0x00,
@@ -87,7 +89,7 @@
 }
 
 decodable_enum! {
-    /// Result code returned in a Media Control Point notification.
+    /// Result code returned in a Media Control Point notification (MCS v1.0.1 Section 3.18.2, Table 3.8).
     pub enum ControlPointResultCode<u8, PacketError, OutOfRange> {
         /// The procedure completed successfully.
         Success = 0x01,
@@ -180,6 +182,30 @@
     }
 }
 
+impl Default for PlayingOrder {
+    /// Returns standard sequential playing order (`InOrderOnce`) by default.
+    fn default() -> Self {
+        Self::InOrderOnce
+    }
+}
+
+/// State of the playing order characteristics when enabled.
+#[derive(Debug, Default, Clone, PartialEq, Eq)]
+pub struct PlayingOrderState {
+    /// Currently selected playing order.
+    pub current: PlayingOrder,
+    /// Bitmask of supported playing orders.
+    pub supported: SupportedPlayingOrders,
+}
+
+impl PlayingOrderState {
+    /// Creates a new `PlayingOrderState` with the default current order
+    /// (`PlayingOrder::InOrderOnce`) and the given supported bitmask.
+    pub fn new(supported: SupportedPlayingOrders) -> Self {
+        Self { current: PlayingOrder::default(), supported }
+    }
+}
+
 bitflags! {
     /// Bitmask representing supported playing orders (MCS v1.0.1 Section 3.16, Table 3.4).
     #[derive(Debug, Clone, Copy, PartialEq, Eq)]
@@ -437,7 +463,7 @@
 }
 
 bitflags! {
-    /// Bitmask representing supported Media Control Point opcodes (MCS v1.0.1 Section 3.19, Table 3.10).
+    /// Bitmask representing supported Media Control Point opcodes (MCS v1.0.1 Section 3.19, Table 3.9).
     #[derive(Debug, Clone, Copy, PartialEq, Eq)]
     pub struct SupportedOpcodes: u32 {
         const PLAY = 0x00000001;
@@ -873,6 +899,17 @@
     }
 
     #[test]
+    fn playing_order_state_defaults() {
+        let default_state = PlayingOrderState::default();
+        assert_eq!(default_state.current, PlayingOrder::InOrderOnce);
+        assert_eq!(default_state.supported, SupportedPlayingOrders::IN_ORDER_ONCE);
+
+        let custom_state = PlayingOrderState::new(SupportedPlayingOrders::all());
+        assert_eq!(custom_state.current, PlayingOrder::InOrderOnce);
+        assert_eq!(custom_state.supported, SupportedPlayingOrders::all());
+    }
+
+    #[test]
     fn media_control_opcode_all_non_parameterized() {
         let opcodes = [
             (MediaControlOpcode::Play, 0x01),