diff --git a/src/connectivity/bluetooth/profiles/bt-hfp-audio-gateway/BUILD.gn b/src/connectivity/bluetooth/profiles/bt-hfp-audio-gateway/BUILD.gn
index f0527e9..8428786 100644
--- a/src/connectivity/bluetooth/profiles/bt-hfp-audio-gateway/BUILD.gn
+++ b/src/connectivity/bluetooth/profiles/bt-hfp-audio-gateway/BUILD.gn
@@ -66,6 +66,7 @@
     "src/procedure/ring.rs",
     "src/procedure/slc_initialization.rs",
     "src/procedure/subscriber_number_information.rs",
+    "src/procedure/transfer_hf_indicator.rs",
     "src/procedure/volume_synchronization.rs",
     "src/profile.rs",
     "src/protocol.rs",
diff --git a/src/connectivity/bluetooth/profiles/bt-hfp-audio-gateway/src/peer/service_level_connection.rs b/src/connectivity/bluetooth/profiles/bt-hfp-audio-gateway/src/peer/service_level_connection.rs
index 9aa3295..bf9d895 100644
--- a/src/connectivity/bluetooth/profiles/bt-hfp-audio-gateway/src/peer/service_level_connection.rs
+++ b/src/connectivity/bluetooth/profiles/bt-hfp-audio-gateway/src/peer/service_level_connection.rs
@@ -679,7 +679,7 @@
     /// Expects a message to be received by the peer. If provided, validates the contents
     /// of the received message.
     #[track_caller]
-    fn expect_peer_ready(
+    pub fn expect_peer_ready(
         exec: &mut fasync::Executor,
         remote: &mut Channel,
         expected: Option<Vec<u8>>,
@@ -710,7 +710,7 @@
 
     /// Serializes the AT Response into a byte buffer.
     #[track_caller]
-    fn serialize_at_response(response: at::Response) -> Vec<u8> {
+    pub fn serialize_at_response(response: at::Response) -> Vec<u8> {
         let mut buf = Vec::new();
         response.serialize(&mut buf).expect("serialization is ok");
         buf
diff --git a/src/connectivity/bluetooth/profiles/bt-hfp-audio-gateway/src/peer/task.rs b/src/connectivity/bluetooth/profiles/bt-hfp-audio-gateway/src/peer/task.rs
index 58f8592..28cae83 100644
--- a/src/connectivity/bluetooth/profiles/bt-hfp-audio-gateway/src/peer/task.rs
+++ b/src/connectivity/bluetooth/profiles/bt-hfp-audio-gateway/src/peer/task.rs
@@ -36,7 +36,7 @@
     error::Error,
     procedure::{AgUpdate, InformationRequest, ProcedureMarker},
     profile::ProfileEvent,
-    protocol::indicators::{AgIndicator, AgIndicators},
+    protocol::indicators::{AgIndicator, AgIndicators, HfIndicator},
 };
 
 pub(super) struct PeerTask {
@@ -233,6 +233,10 @@
                 self.calls.send_dtmf_code(code).await;
                 self.connection.receive_ag_request(marker, response()).await;
             }
+            InformationRequest::SendHfIndicator { indicator, response } => {
+                self.hf_indicator_update(indicator);
+                self.connection.receive_ag_request(marker, response()).await;
+            }
             InformationRequest::SetNrec { enable, response } => {
                 let result = if let Some(handler) = &mut self.handler {
                     if let Ok(Ok(())) = handler.set_nrec_mode(enable).await {
@@ -335,6 +339,22 @@
         self
     }
 
+    /// Sends an HF Indicator update to the client.
+    fn hf_indicator_update(&mut self, indicator: HfIndicator) {
+        match indicator {
+            ind @ HfIndicator::EnhancedSafety(_) => {
+                debug!("Received EnhancedSafety HF Indicator update: {:?}", ind);
+            }
+            HfIndicator::BatteryLevel(v) => {
+                if let Some(handler) = &mut self.handler {
+                    if let Err(e) = handler.report_headset_battery_level(v) {
+                        log::warn!("Couldn't report headset battery level: {:?}", e);
+                    }
+                }
+            }
+        }
+    }
+
     /// Request to send the phone `status` by initiating the Phone Status Indicator
     /// procedure.
     async fn ring_update(&mut self, call: Call) {
@@ -403,6 +423,7 @@
     use {
         super::*,
         async_utils::PollExt,
+        at_commands::{self as at, SerDe},
         fidl_fuchsia_bluetooth_bredr::{ProfileMarker, ProfileRequestStream},
         fidl_fuchsia_bluetooth_hfp::{
             CallState, PeerHandlerMarker, PeerHandlerRequest, SignalStrength,
@@ -415,10 +436,16 @@
 
     use crate::{
         peer::service_level_connection::{
-            tests::{create_and_initialize_slc, expect_data_received_by_peer},
+            tests::{
+                create_and_initialize_slc, expect_data_received_by_peer, expect_peer_ready,
+                serialize_at_response,
+            },
             SlcState,
         },
-        protocol::{features::HfFeatures, indicators::AgIndicatorsReporting},
+        protocol::{
+            features::HfFeatures,
+            indicators::{AgIndicatorsReporting, HfIndicators},
+        },
     };
 
     fn arb_signal() -> impl Strategy<Value = Option<SignalStrength>> {
@@ -788,4 +815,77 @@
         // Check that the task's ringer has an active call with the expected call index.
         assert!(task.ringer.ringing());
     }
+
+    #[test]
+    fn incoming_hf_indicator_battery_level_is_propagated_to_peer_handler_stream() {
+        // Set up the executor, peer, and background call manager task
+        let mut exec = fasync::Executor::new().unwrap();
+
+        // Setup the peer task with the specified SlcState to enable the battery level HF indicator.
+        let mut hf_indicators = HfIndicators::default();
+        hf_indicators.enable_indicators(vec![at::BluetoothHFIndicator::BatteryLevel]);
+        let state = SlcState { hf_indicators, ..SlcState::default() };
+        let (connection, mut remote) = create_and_initialize_slc(state);
+        let (peer, mut sender, receiver, _profile) = setup_peer_task(Some(connection));
+
+        let (proxy, mut stream) =
+            fidl::endpoints::create_proxy_and_stream::<PeerHandlerMarker>().unwrap();
+        // The battery level that will be reported by the peer.
+        let expected_level = 79;
+
+        fasync::Task::local(async move {
+            // First request is always the network info.
+            match stream.next().await {
+                Some(Ok(PeerHandlerRequest::WatchNetworkInformation { responder })) => {
+                    responder
+                        .send(NetworkInformation::EMPTY)
+                        .expect("Successfully send network information");
+                }
+                x => panic!("Expected watch network information request: {:?}", x),
+            };
+            // A vec to hold all the stream items we don't care about for this test.
+            let mut junk_drawer = vec![];
+
+            // Filter out all items that are irrelevant to this particular test, placing them in
+            // the junk_drawer.
+            let mut stream = stream.filter_map(move |item| {
+                let item = match item {
+                    Ok(PeerHandlerRequest::ReportHeadsetBatteryLevel { level, .. }) => Some(level),
+                    x => {
+                        junk_drawer.push(x);
+                        None
+                    }
+                };
+                ready(item)
+            });
+            let actual_battery_level = stream.next().await.unwrap();
+            assert_eq!(actual_battery_level, expected_level);
+            // Call manager should collect all further requests, without responding.
+            stream.collect::<Vec<_>>().await;
+        })
+        .detach();
+
+        // Pass in the client end connected to the call manager
+        let result = exec.run_singlethreaded(sender.send(PeerRequest::Handle(proxy)));
+        assert!(result.is_ok());
+
+        // Run the PeerTask.
+        let run_fut = peer.run(receiver);
+        pin_mut!(run_fut);
+        assert!(exec.run_until_stalled(&mut run_fut).is_pending());
+
+        // Peer sends us a battery level HF indicator update.
+        let battery_level_cmd = at::Command::Biev {
+            anum: at::BluetoothHFIndicator::BatteryLevel,
+            value: expected_level as i64,
+        };
+        let mut buf = Vec::new();
+        battery_level_cmd.serialize(&mut buf).expect("serialization is ok");
+        remote.as_ref().write(&buf[..]).expect("channel write is ok");
+        // Run the main future - the spawned task should receive the HF indicator and report it.
+        assert!(exec.run_until_stalled(&mut run_fut).is_pending());
+
+        // Since we (the AG) received a valid HF indicator, we expect to send an OK back to the peer.
+        expect_peer_ready(&mut exec, &mut remote, Some(serialize_at_response(at::Response::Ok)));
+    }
 }
diff --git a/src/connectivity/bluetooth/profiles/bt-hfp-audio-gateway/src/procedure.rs b/src/connectivity/bluetooth/profiles/bt-hfp-audio-gateway/src/procedure.rs
index 928eabe..2742f45 100644
--- a/src/connectivity/bluetooth/profiles/bt-hfp-audio-gateway/src/procedure.rs
+++ b/src/connectivity/bluetooth/profiles/bt-hfp-audio-gateway/src/procedure.rs
@@ -16,7 +16,7 @@
     },
     protocol::{
         features::AgFeatures,
-        indicators::{AgIndicator, AgIndicators, HfIndicators},
+        indicators::{AgIndicator, AgIndicators, HfIndicator, HfIndicators},
     },
 };
 
@@ -62,6 +62,9 @@
 /// Defines the implementation of the Phone Status Procedures.
 pub mod phone_status;
 
+/// Defines the implementation of the Transfer of HF Indicator Values Procedure.
+pub mod transfer_hf_indicator;
+
 /// Defines the implementation of the Volume Level Synchronization Procedure.
 pub mod volume_synchronization;
 
@@ -79,6 +82,7 @@
 use ring::RingProcedure;
 use slc_initialization::SlcInitProcedure;
 use subscriber_number_information::{build_cnum_response, SubscriberNumberInformationProcedure};
+use transfer_hf_indicator::TransferHfIndicatorProcedure;
 use volume_synchronization::VolumeSynchronizationProcedure;
 
 const THREE_WAY_SUPPORT: &[&str] = &["0", "1", "1X", "2", "2X", "3", "4"];
@@ -172,6 +176,8 @@
     Answer,
     /// The Hang Up procedure as defined in HFP v1.8 Sections 4.14 - 4.15
     HangUp,
+    /// The Transfer of HF Indicator Values procedure as defined in HFP v1.8 Section 4.36.1.5.
+    TransferHfIndicator,
 }
 
 impl ProcedureMarker {
@@ -197,6 +203,7 @@
             Self::Ring => Box::new(RingProcedure::new()),
             Self::Answer => Box::new(AnswerProcedure::new()),
             Self::HangUp => Box::new(HangUpProcedure::new()),
+            Self::TransferHfIndicator => Box::new(TransferHfIndicatorProcedure::new()),
         }
     }
 
@@ -225,6 +232,7 @@
             at::Command::Vts { .. } => Ok(Self::Dtmf),
             at::Command::Answer { .. } => Ok(Self::Answer),
             at::Command::Chup { .. } => Ok(Self::HangUp),
+            at::Command::Biev { .. } => Ok(Self::TransferHfIndicator),
             _ => Err(ProcedureError::NotImplemented),
         }
     }
@@ -243,6 +251,8 @@
 
     SetNrec { enable: bool, response: Box<dyn FnOnce(Result<(), ()>) -> AgUpdate> },
 
+    SendHfIndicator { indicator: HfIndicator, response: Box<dyn FnOnce() -> AgUpdate> },
+
     SendDtmf { code: DtmfCode, response: Box<dyn FnOnce() -> AgUpdate> },
 
     SpeakerVolumeSynchronization { level: Gain, response: Box<dyn FnOnce() -> AgUpdate> },
@@ -265,6 +275,7 @@
             GetSubscriberNumberInformation { .. } => Self::SubscriberNumberInformation,
             SetNrec { .. } => Self::Nrec,
             SendDtmf { .. } => Self::Dtmf,
+            SendHfIndicator { .. } => Self::TransferHfIndicator,
             SpeakerVolumeSynchronization { .. } | MicrophoneVolumeSynchronization { .. } => {
                 Self::VolumeSynchronization
             }
@@ -288,6 +299,10 @@
             Self::QueryCurrentCalls { .. } => "QueryCurrentCalls ",
             // DTFM Code values are not displayed in Debug representation
             Self::SendDtmf { .. } => "SendDtmf",
+            Self::SendHfIndicator { indicator, .. } => {
+                s = format!("SendHfIndicator({:?})", indicator);
+                &s
+            }
             Self::SpeakerVolumeSynchronization { level, .. } => {
                 s = format!("SpeakerVolumeSynchronization({:?})", level);
                 &s
diff --git a/src/connectivity/bluetooth/profiles/bt-hfp-audio-gateway/src/procedure/slc_initialization.rs b/src/connectivity/bluetooth/profiles/bt-hfp-audio-gateway/src/procedure/slc_initialization.rs
index db150e9..6fa04dd 100644
--- a/src/connectivity/bluetooth/profiles/bt-hfp-audio-gateway/src/procedure/slc_initialization.rs
+++ b/src/connectivity/bluetooth/profiles/bt-hfp-audio-gateway/src/procedure/slc_initialization.rs
@@ -333,7 +333,7 @@
 
         match update {
             at::Command::Bind { indicators } => {
-                state.hf_indicators.set(indicators);
+                state.hf_indicators.enable_indicators(indicators);
                 Box::new(HfSupportedIndicatorsReceived)
             }
             m => SlcErrorState::unexpected_hf(m),
diff --git a/src/connectivity/bluetooth/profiles/bt-hfp-audio-gateway/src/procedure/transfer_hf_indicator.rs b/src/connectivity/bluetooth/profiles/bt-hfp-audio-gateway/src/procedure/transfer_hf_indicator.rs
new file mode 100644
index 0000000..4f80035
--- /dev/null
+++ b/src/connectivity/bluetooth/profiles/bt-hfp-audio-gateway/src/procedure/transfer_hf_indicator.rs
@@ -0,0 +1,210 @@
+// Copyright 2021 The Fuchsia Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style license that can be
+// found in the LICENSE file.
+
+use super::{
+    AgUpdate, InformationRequest, Procedure, ProcedureError, ProcedureMarker, ProcedureRequest,
+};
+
+use crate::peer::service_level_connection::SlcState;
+use at_commands as at;
+
+/// Represents the current state of the HF request to transmit an HF Indicator value as
+/// defined in HFP v1.8 Section 4.36.1.5.
+#[derive(Debug, PartialEq, Clone, Copy)]
+enum State {
+    /// Initial state of the Procedure.
+    Start,
+    /// A request has been received from the HF to transmit the indicator via the AG.
+    SendRequest,
+    /// Terminal state of the procedure.
+    Terminated,
+}
+
+impl State {
+    /// Transition to the next state in the procedure.
+    fn transition(&mut self) {
+        match *self {
+            Self::Start => *self = Self::SendRequest,
+            Self::SendRequest => *self = Self::Terminated,
+            Self::Terminated => *self = Self::Terminated,
+        }
+    }
+}
+
+/// The Hf may send an updated HF Indicator value via this procedure. Defined in
+/// HFP v1.8 Section 4.36.1.5.
+///
+/// This procedure is implemented from the perspective of the AG. Namely, outgoing `requests`
+/// typically request information about the current state of the AG, to be sent to the remote
+/// peer acting as the HF.
+#[derive(Debug)]
+pub struct TransferHfIndicatorProcedure {
+    /// The current state of the procedure
+    state: State,
+}
+
+impl Default for TransferHfIndicatorProcedure {
+    fn default() -> Self {
+        Self { state: State::Start }
+    }
+}
+
+impl TransferHfIndicatorProcedure {
+    /// Create a new Transfer HF Indicator procedure in the Start state.
+    pub fn new() -> Self {
+        Self::default()
+    }
+}
+
+impl Procedure for TransferHfIndicatorProcedure {
+    fn marker(&self) -> ProcedureMarker {
+        ProcedureMarker::TransferHfIndicator
+    }
+
+    fn hf_update(&mut self, update: at::Command, state: &mut SlcState) -> ProcedureRequest {
+        match (self.state, update) {
+            (State::Start, at::Command::Biev { anum, value }) => {
+                self.state.transition();
+                // Per HFP v1.8 Section 4.36.1.5, we should send Error if the request `anum` is
+                // disabled, or the `value` is out of bounds.
+                if let Ok(indicator) = state.hf_indicators.update_indicator_value(anum, value) {
+                    InformationRequest::SendHfIndicator {
+                        indicator,
+                        response: Box::new(|| AgUpdate::Ok),
+                    }
+                    .into()
+                } else {
+                    self.state.transition();
+                    AgUpdate::Error.into()
+                }
+            }
+            (_, update) => ProcedureRequest::Error(ProcedureError::UnexpectedHf(update)),
+        }
+    }
+
+    fn ag_update(&mut self, update: AgUpdate, _state: &mut SlcState) -> ProcedureRequest {
+        match (self.state, update) {
+            (State::SendRequest, update @ AgUpdate::Ok) => {
+                self.state.transition();
+                update.into()
+            }
+            (_, update) => ProcedureRequest::Error(ProcedureError::UnexpectedAg(update)),
+        }
+    }
+
+    fn is_terminated(&self) -> bool {
+        self.state == State::Terminated
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::protocol::indicators::HfIndicator;
+    use matches::assert_matches;
+
+    #[test]
+    fn correct_marker() {
+        let marker = TransferHfIndicatorProcedure::new().marker();
+        assert_eq!(marker, ProcedureMarker::TransferHfIndicator);
+    }
+
+    #[test]
+    fn procedure_handles_invalid_messages() {
+        let mut proc = TransferHfIndicatorProcedure::new();
+        let req = proc.hf_update(at::Command::CindRead {}, &mut SlcState::default());
+        assert_matches!(req, ProcedureRequest::Error(ProcedureError::UnexpectedHf(_)));
+
+        let req = proc.ag_update(AgUpdate::ThreeWaySupport, &mut SlcState::default());
+        assert_matches!(req, ProcedureRequest::Error(ProcedureError::UnexpectedAg(_)));
+    }
+
+    #[test]
+    fn procedure_with_invalid_battery_value_sends_error_message() {
+        let mut proc = TransferHfIndicatorProcedure::new();
+        let mut state = SlcState::default();
+        state.hf_indicators.enable_indicators(vec![
+            at::BluetoothHFIndicator::BatteryLevel,
+            at::BluetoothHFIndicator::EnhancedSafety,
+        ]);
+
+        // Battery level is not within the range [0,100].
+        let cmd = at::Command::Biev { anum: at::BluetoothHFIndicator::BatteryLevel, value: 164 };
+        let req = proc.hf_update(cmd, &mut state);
+        let expected = vec![at::Response::Error];
+        assert_matches!(req, ProcedureRequest::SendMessages(m) if m == expected);
+        assert!(proc.is_terminated());
+    }
+
+    #[test]
+    fn procedure_with_valid_battery_value_sends_ok() {
+        let mut proc = TransferHfIndicatorProcedure::new();
+        let mut state = SlcState::default();
+        state.hf_indicators.enable_indicators(vec![
+            at::BluetoothHFIndicator::BatteryLevel,
+            at::BluetoothHFIndicator::EnhancedSafety,
+        ]);
+
+        let cmd = at::Command::Biev { anum: at::BluetoothHFIndicator::BatteryLevel, value: 76 };
+        let req = proc.hf_update(cmd, &mut state);
+        let update = match req {
+            ProcedureRequest::Info(InformationRequest::SendHfIndicator {
+                indicator: HfIndicator::BatteryLevel(76),
+                response,
+            }) => response(),
+            x => panic!("Expected SendHFInd request but got: {:?}", x),
+        };
+
+        let req = proc.ag_update(update, &mut state);
+        assert_matches!(
+            req,
+            ProcedureRequest::SendMessages(msgs) if msgs == vec![at::Response::Ok]
+        );
+        assert!(proc.is_terminated());
+    }
+
+    #[test]
+    fn procedure_with_invalid_safety_value_sends_error_message() {
+        let mut proc = TransferHfIndicatorProcedure::new();
+        let mut state = SlcState::default();
+        state.hf_indicators.enable_indicators(vec![
+            at::BluetoothHFIndicator::BatteryLevel,
+            at::BluetoothHFIndicator::EnhancedSafety,
+        ]);
+
+        // Enhanced Safety can only be 0 or 1.
+        let cmd = at::Command::Biev { anum: at::BluetoothHFIndicator::EnhancedSafety, value: 7 };
+        let req = proc.hf_update(cmd, &mut state);
+        let expected = vec![at::Response::Error];
+        assert_matches!(req, ProcedureRequest::SendMessages(m) if m == expected);
+        assert!(proc.is_terminated());
+    }
+
+    #[test]
+    fn procedure_with_valid_safety_value_sends_ok() {
+        let mut proc = TransferHfIndicatorProcedure::new();
+        let mut state = SlcState::default();
+        state.hf_indicators.enable_indicators(vec![
+            at::BluetoothHFIndicator::BatteryLevel,
+            at::BluetoothHFIndicator::EnhancedSafety,
+        ]);
+
+        let cmd = at::Command::Biev { anum: at::BluetoothHFIndicator::EnhancedSafety, value: 1 };
+        let req = proc.hf_update(cmd, &mut state);
+        let update = match req {
+            ProcedureRequest::Info(InformationRequest::SendHfIndicator {
+                indicator: HfIndicator::EnhancedSafety(true),
+                response,
+            }) => response(),
+            x => panic!("Expected SendHFInd request but got: {:?}", x),
+        };
+
+        let req = proc.ag_update(update, &mut state);
+        assert_matches!(
+            req,
+            ProcedureRequest::SendMessages(msgs) if msgs == vec![at::Response::Ok]
+        );
+        assert!(proc.is_terminated());
+    }
+}
diff --git a/src/connectivity/bluetooth/profiles/bt-hfp-audio-gateway/src/protocol/indicators.rs b/src/connectivity/bluetooth/profiles/bt-hfp-audio-gateway/src/protocol/indicators.rs
index 8ffc78a..39582a0 100644
--- a/src/connectivity/bluetooth/profiles/bt-hfp-audio-gateway/src/protocol/indicators.rs
+++ b/src/connectivity/bluetooth/profiles/bt-hfp-audio-gateway/src/protocol/indicators.rs
@@ -16,16 +16,23 @@
 pub(crate) const ROAM_INDICATOR_INDEX: usize = 6;
 pub(crate) const BATT_CHG_INDICATOR_INDEX: usize = 7;
 
-/// A single HF Indicator status + value.
+/// The supported HF indicators.
+#[derive(Clone, Copy, Debug, PartialEq)]
+pub enum HfIndicator {
+    EnhancedSafety(bool),
+    BatteryLevel(u8),
+}
+
+/// A single indicator status + value.
 #[derive(Clone, Copy, Debug)]
-pub struct HfIndicator<T: Clone + Copy + Debug> {
+struct Indicator<T: Clone + Copy + Debug> {
     /// Whether this indicator is enabled or not.
     enabled: bool,
     /// The value of the indicator.
     value: Option<T>,
 }
 
-impl<T: Clone + Copy + Debug> Default for HfIndicator<T> {
+impl<T: Clone + Copy + Debug> Default for Indicator<T> {
     fn default() -> Self {
         Self { enabled: false, value: None }
     }
@@ -36,14 +43,18 @@
 #[derive(Clone, Copy, Debug, Default)]
 pub struct HfIndicators {
     /// The Enhanced Safety HF indicator. There are only two potential values (enabled, disabled).
-    enhanced_safety: HfIndicator<bool>,
+    enhanced_safety: Indicator<bool>,
     /// The Battery Level HF indicator. Can be any integer value between [0, 100].
-    battery_level: HfIndicator<u8>,
+    battery_level: Indicator<u8>,
 }
 
 impl HfIndicators {
-    /// Sets the HF indicators based on the provided AT `indicators`.
-    pub fn set(&mut self, indicators: Vec<at::BluetoothHFIndicator>) {
+    /// The Maximum Battery Level value for the `battery_level` indicator.
+    /// Defined in HFP v1.8 Section 4.35.
+    const MAX_BATTERY_LEVEL: u8 = 100;
+
+    /// Enables the supported HF indicators based on the provided AT `indicators`.
+    pub fn enable_indicators(&mut self, indicators: Vec<at::BluetoothHFIndicator>) {
         for ind in indicators {
             if ind == at::BluetoothHFIndicator::EnhancedSafety {
                 self.enhanced_safety.enabled = true;
@@ -54,6 +65,39 @@
         }
     }
 
+    /// Updates the `indicator` with the provided `value`.
+    /// Returns Error if the indicator is disabled or if the `value` is out of bounds.
+    /// Returns a valid HfIndicator on success.
+    pub fn update_indicator_value(
+        &mut self,
+        indicator: at::BluetoothHFIndicator,
+        value: i64,
+    ) -> Result<HfIndicator, ()> {
+        let ind = match indicator {
+            at::BluetoothHFIndicator::EnhancedSafety if self.enhanced_safety.enabled => {
+                if value != 0 && value != 1 {
+                    return Err(());
+                }
+                let v = value != 0;
+                self.enhanced_safety.value = Some(v);
+                HfIndicator::EnhancedSafety(v)
+            }
+            at::BluetoothHFIndicator::BatteryLevel if self.battery_level.enabled => {
+                if value < 0 || value > Self::MAX_BATTERY_LEVEL.into() {
+                    return Err(());
+                }
+                let v = value as u8;
+                self.battery_level.value = Some(v);
+                HfIndicator::BatteryLevel(v)
+            }
+            ind => {
+                log::warn!("Received HF indicator update for disabled indicator: {:?}", ind);
+                return Err(());
+            }
+        };
+        Ok(ind)
+    }
+
     /// Returns the +BIND response for the current HF indicator status.
     pub fn bind_response(&self) -> Vec<at::Response> {
         vec![
@@ -431,6 +475,94 @@
 #[cfg(test)]
 mod tests {
     use super::*;
+    use matches::assert_matches;
+
+    #[test]
+    fn update_hf_indicators_with_invalid_values_is_error() {
+        let mut hf_indicators = HfIndicators::default();
+        hf_indicators.enable_indicators(vec![
+            at::BluetoothHFIndicator::BatteryLevel,
+            at::BluetoothHFIndicator::EnhancedSafety,
+        ]);
+
+        let battery_too_low = -18;
+        assert_matches!(
+            hf_indicators
+                .update_indicator_value(at::BluetoothHFIndicator::BatteryLevel, battery_too_low),
+            Err(())
+        );
+        let battery_too_high = 1243;
+        assert_matches!(
+            hf_indicators
+                .update_indicator_value(at::BluetoothHFIndicator::BatteryLevel, battery_too_high),
+            Err(())
+        );
+
+        let negative_safety = -1;
+        assert_matches!(
+            hf_indicators
+                .update_indicator_value(at::BluetoothHFIndicator::EnhancedSafety, negative_safety),
+            Err(())
+        );
+        let large_safety = 8;
+        assert_matches!(
+            hf_indicators
+                .update_indicator_value(at::BluetoothHFIndicator::EnhancedSafety, large_safety),
+            Err(())
+        );
+    }
+
+    #[test]
+    fn update_disabled_hf_indicators_with_valid_values_is_error() {
+        // Default is no indicators set. Therefore any updates are errors.
+        let mut hf_indicators = HfIndicators::default();
+
+        let valid_battery = 32;
+        assert_matches!(
+            hf_indicators
+                .update_indicator_value(at::BluetoothHFIndicator::BatteryLevel, valid_battery),
+            Err(())
+        );
+
+        let valid_safety = 0;
+        assert_matches!(
+            hf_indicators
+                .update_indicator_value(at::BluetoothHFIndicator::EnhancedSafety, valid_safety),
+            Err(())
+        );
+    }
+
+    #[test]
+    fn update_hf_indicators_with_valid_values_is_ok() {
+        let mut hf_indicators = HfIndicators::default();
+        // Default values.
+        assert_eq!(hf_indicators.enhanced_safety.value, None);
+        assert_eq!(hf_indicators.enhanced_safety.enabled, false);
+        assert_eq!(hf_indicators.battery_level.value, None);
+        assert_eq!(hf_indicators.battery_level.enabled, false);
+
+        // Enable both.
+        hf_indicators.enable_indicators(vec![
+            at::BluetoothHFIndicator::BatteryLevel,
+            at::BluetoothHFIndicator::EnhancedSafety,
+        ]);
+
+        let valid_battery = 83;
+        assert_matches!(
+            hf_indicators
+                .update_indicator_value(at::BluetoothHFIndicator::BatteryLevel, valid_battery),
+            Ok(HfIndicator::BatteryLevel(83))
+        );
+        assert_eq!(hf_indicators.battery_level.value, Some(valid_battery as u8));
+
+        let valid_safety = 0;
+        assert_matches!(
+            hf_indicators
+                .update_indicator_value(at::BluetoothHFIndicator::EnhancedSafety, valid_safety),
+            Ok(HfIndicator::EnhancedSafety(false))
+        );
+        assert_eq!(hf_indicators.enhanced_safety.value, Some(false));
+    }
 
     #[test]
     fn default_indicators_reporting_is_disabled_with_all_indicators_enabled() {
diff --git a/src/connectivity/lib/at-commands/definitions/hfp.at b/src/connectivity/lib/at-commands/definitions/hfp.at
index 5fed5cd..345b3ce 100644
--- a/src/connectivity/lib/at-commands/definitions/hfp.at
+++ b/src/connectivity/lib/at-commands/definitions/hfp.at
@@ -81,6 +81,10 @@
 # HFP 1.8 4.36.1.3
 response BindStatus { +BIND:anum:BluetoothHFIndicator,state:BoolAsInt }
 
+# Bluetooth HF Indicator value command
+# HFP 1.8 4.36.1.5
+command { AT+BIEV=anum:BluetoothHFIndicator,value:Integer}
+
 # Standard Call hold read command.
 # HFP 1.8 4.34.2
 command { AT+CHLD=? }