diff --git a/.claude/skills/turbo-modules/SKILL.md b/.claude/skills/turbo-modules/SKILL.md
index 3c6372582..68257e1e2 100644
--- a/.claude/skills/turbo-modules/SKILL.md
+++ b/.claude/skills/turbo-modules/SKILL.md
@@ -218,7 +218,7 @@ void AudioAPIModule::registerNatives() {
 
 `registerNatives()` is called from `android/src/main/cpp/audioapi/android/OnLoad.cpp` at `.so` load time.
 
-**`invokeHandlerWithEventNameAndEventBody`**: called from Kotlin (MediaSessionManager callbacks) to fire events into JS. Takes a Java `Map<String, Object>` and converts to `std::unordered_map<std::string, EventValue>`.
+**`invokeHandlerWithEventNameAndEventBody`**: called from Kotlin (MediaSessionManager callbacks) to fire events into JS. Takes a Java `Map<String, Object>` and converts it to a typed `AudioEventPayload` in `buildPayloadFromJniMap` (`android/src/main/cpp/audioapi/android/JniEventPayloadParser.cpp`), which switches on the event. An event without a case there falls to `EmptyPayload{}`: the event still reaches JS, but with an empty body. When Kotlin starts sending a new event, add its case, building the same payload type the iOS side dispatches (e.g. `ROUTE_CHANGE` → `StringPayload{.name = "reason", ...}`).
 
 ---
 
diff --git a/apps/common-app/src/demos/Record/Record.tsx b/apps/common-app/src/demos/Record/Record.tsx
index 37ddb0e2b..0b5e97a65 100644
--- a/apps/common-app/src/demos/Record/Record.tsx
+++ b/apps/common-app/src/demos/Record/Record.tsx
@@ -7,10 +7,11 @@ import {
   concatAudioFiles,
   FileFormat,
   RecordingNotificationManager,
+  useAudioInput,
 } from 'react-native-audio-api';
 
 import { Alert, StyleSheet, View } from 'react-native';
-import { Container } from '../../components';
+import { Container, Select } from '../../components';
 
 import { Easing, useSharedValue, withTiming } from 'react-native-reanimated';
 import { audioRecorder as Recorder, audioContext } from '../../singletons';
@@ -37,6 +38,28 @@ const Record: FC = () => {
   );
   const currentPositionSV = useSharedValue(0);
   const playbackSourceRef = useRef<AudioBufferSourceNode | null>(null);
+  const { availableInputs, currentInput, onSelectInput } = useAudioInput();
+
+  const inputLabels = availableInputs.map(
+    (device) => `${device.name} · ${device.category} #${device.id}`
+  );
+  const currentInputLabel = currentInput
+    ? inputLabels[availableInputs.indexOf(currentInput)]
+    : 'System default';
+
+  const onSelectInputLabel = async (label: string) => {
+    const input = availableInputs[inputLabels.indexOf(label)];
+
+    if (!input) {
+      return;
+    }
+
+    try {
+      await onSelectInput(input);
+    } catch (error) {
+      Alert.alert('Input Device Error', `${error}`);
+    }
+  };
 
   const stopPlayback = useCallback(() => {
     const source = playbackSourceRef.current;
@@ -284,6 +307,16 @@ const Record: FC = () => {
     })();
   }, []);
 
+  useEffect(() => {
+    Recorder.onError((error) => {
+      Alert.alert('Recorder Error', error.message);
+    });
+
+    return () => {
+      Recorder.clearOnError();
+    };
+  }, []);
+
   useEffect(() => {
     const pauseListener = RecordingNotificationManager.addEventListener(
       'recordingNotificationPause',
@@ -344,6 +377,13 @@ const Record: FC = () => {
 
   return (
     <Container disablePadding>
+      <View style={styles.inputPicker}>
+        <Select
+          value={currentInputLabel}
+          options={inputLabels}
+          onChange={onSelectInputLabel}
+        />
+      </View>
       <Status state={state} />
       <View style={styles.spacerM} />
       {[RecordingState.Playing, RecordingState.ReadyToPlay].includes(state) ? (
@@ -372,4 +412,5 @@ export default Record;
 const styles = StyleSheet.create({
   spacerM: { height: 24 },
   spacerS: { height: 12 },
+  inputPicker: { paddingHorizontal: 16, paddingTop: 12 },
 });
diff --git a/apps/common-app/src/examples/Record/Record.tsx b/apps/common-app/src/examples/Record/Record.tsx
index 77da4f5f0..0e5459808 100644
--- a/apps/common-app/src/examples/Record/Record.tsx
+++ b/apps/common-app/src/examples/Record/Record.tsx
@@ -216,11 +216,19 @@ const Record: FC = () => {
   };
 
   const onSelect = useCallback(
-    (id: string) => {
+    async (id: string) => {
       const input = availableInputs.find((d) => d.id === id);
 
-      if (input) {
-        onSelectInput(input);
+      if (!input) {
+        return;
+      }
+
+      try {
+        await onSelectInput(input);
+      } catch (error) {
+        // Android refuses a switch while a recorder is running, and either
+        // platform refuses a device that went away between listing and picking.
+        Alert.alert('Input Device Error', `${error}`);
       }
     },
     [availableInputs, onSelectInput]
diff --git a/packages/audiodocs/docs/hooks/select-input.mdx b/packages/audiodocs/docs/hooks/select-input.mdx
index 743b87485..e683e8f81 100644
--- a/packages/audiodocs/docs/hooks/select-input.mdx
+++ b/packages/audiodocs/docs/hooks/select-input.mdx
@@ -14,7 +14,9 @@ The `useAudioInput` hook provides an interface for:
 - switching between different input devices
 
 :::info Platform support
-Input device selection is currently only supported on iOS. On Android, `useAudioInput` is implemented as a no-op: the hook will not list or switch input devices, and any selection calls will effectively be ignored.
+Input device selection works on iOS and on Android. The two platforms differ in when a selection takes effect: iOS reroutes the running session immediately, while Android binds the device as a capture stream opens, so the selection applies to recorders started afterwards. Calling `onSelectInput` on Android while a recorder is running or paused throws, rather than deferring the switch without saying so.
+
+On Android, `currentInput` is `null` until a device is selected through this hook, because the platform does not report which input it would pick on its own.
 :::
 
 ## Signature
diff --git a/packages/audiodocs/docs/system/audio-manager.mdx b/packages/audiodocs/docs/system/audio-manager.mdx
index b9d3964c7..73e95cfa2 100644
--- a/packages/audiodocs/docs/system/audio-manager.mdx
+++ b/packages/audiodocs/docs/system/audio-manager.mdx
@@ -177,8 +177,26 @@ Checks if notification permissions were previously granted.
 
 Checks currently used and available devices.
 
+On Android, `currentInputs` reports the device selected through [`setInputDevice`](#setinputdevice) and is empty until one is selected, since the platform does not report which input it would pick on its own. `currentOutputs` is always empty on Android.
+
 #### Returns `Promise<AudioDevicesInfo>`, which is resolved after receiving the answer from the system.
 
+### `setInputDevice`
+
+Selects the device that audio is captured from, using an `id` taken from `getDevicesInfo().availableInputs`.
+
+| Name | Type | Description |
+| :----: | :----: | :---- |
+| `deviceId` | `string` | Identifier of the input device to capture from. |
+
+The two platforms differ in when the selection takes effect:
+
+- **iOS** sets the session's preferred input, which reroutes a running session right away.
+- **Android** binds the device while an Oboe capture stream opens, so the selection applies to recorders started afterwards. Calling it while a recorder is running or paused rejects instead of deferring the switch silently: stop the recorder, select the device, then start it again.
+
+#### Returns `Promise<void>`
+resolved once the device is selected and rejected when the device cannot be found, when the system fails to switch to it, or, on Android, when a recorder is running or paused.
+
 ## Remarks
 
 ### `AudioFocusType`
@@ -339,7 +357,7 @@ export type AudioDeviceList = AudioDeviceInfo[];
 export interface AudioDevicesInfo {
   availableInputs: AudioDeviceList;
   availableOutputs: AudioDeviceList;
-  currentInputs: AudioDeviceList; // iOS
+  currentInputs: AudioDeviceList; // iOS, and Android once a device is selected
   currentOutputs: AudioDeviceList; // iOS
 }
 ```
diff --git a/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/AudioAPIModule.cpp b/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/AudioAPIModule.cpp
index 943c42a5c..aa08255de 100644
--- a/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/AudioAPIModule.cpp
+++ b/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/AudioAPIModule.cpp
@@ -1,5 +1,6 @@
 #include <audioapi/android/AudioAPIModule.h>
 #include <audioapi/android/JniEventPayloadParser.h>
+#include <audioapi/android/core/AudioInputSelection.h>
 #include <audioapi/android/system/NativeFileInfo.hpp>
 #include <memory>
 
@@ -32,6 +33,7 @@ void AudioAPIModule::registerNatives() {
       makeNativeMethod(
           "invokeHandlerWithEventNameAndEventBody",
           AudioAPIModule::invokeHandlerWithEventNameAndEventBody),
+      makeNativeMethod("setPreferredInputDeviceId", AudioAPIModule::setPreferredInputDeviceId),
   });
 }
 
@@ -55,4 +57,9 @@ void AudioAPIModule::invokeHandlerWithEventNameAndEventBody(
       event, kBroadcastListenerId, buildPayloadFromJniMap(event, eventBody));
 }
 
+jboolean AudioAPIModule::setPreferredInputDeviceId(jint deviceId) {
+  return static_cast<jboolean>(
+      AudioInputSelection::setPreferredDeviceId(static_cast<int32_t>(deviceId)));
+}
+
 } // namespace audioapi
diff --git a/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/AudioAPIModule.h b/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/AudioAPIModule.h
index b0719a4db..8724fe077 100644
--- a/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/AudioAPIModule.h
+++ b/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/AudioAPIModule.h
@@ -26,6 +26,9 @@ class AudioAPIModule : public jni::HybridClass<AudioAPIModule> {
       jint eventOrdinal,
       jni::alias_ref<jni::JMap<jstring, jobject>> eventBody);
 
+  /// @see AudioInputSelection::setPreferredDeviceId
+  jboolean setPreferredInputDeviceId(jint deviceId);
+
  private:
   friend HybridBase;
 
diff --git a/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/JniEventPayloadParser.cpp b/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/JniEventPayloadParser.cpp
index 5130586e6..5e88f7f26 100644
--- a/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/JniEventPayloadParser.cpp
+++ b/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/JniEventPayloadParser.cpp
@@ -69,6 +69,9 @@ AudioEventPayload buildPayloadFromJniMap(
       return InterruptionPayload{
           .type = jniGetString(map, "type"), .shouldResume = jniGetBool(map, "shouldResume")};
 
+    case AudioEvent::ROUTE_CHANGE:
+      return StringPayload{.name = "reason", .reason = jniGetString(map, "reason")};
+
     case AudioEvent::VOLUME_CHANGE:
     case AudioEvent::PLAYBACK_NOTIFICATION_SKIP_FORWARD:
     case AudioEvent::PLAYBACK_NOTIFICATION_SKIP_BACKWARD:
diff --git a/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/AndroidAudioRecorder.cpp b/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/AndroidAudioRecorder.cpp
index 9a3a4b115..04ae13020 100644
--- a/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/AndroidAudioRecorder.cpp
+++ b/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/AndroidAudioRecorder.cpp
@@ -1,5 +1,6 @@
 #include <android/log.h>
 #include <audioapi/android/core/AndroidAudioRecorder.h>
+#include <audioapi/android/core/AudioInputSelection.h>
 #include <audioapi/android/core/utils/AndroidFileWriterBackend.h>
 #include <audioapi/android/core/utils/AndroidRecorderCallback.h>
 
@@ -51,6 +52,30 @@ std::optional<oboe::InputPreset> inputPresetFromString(const std::string &name)
   }
   return std::nullopt;
 }
+
+/// Runs an action when the scope ends unless dismiss() is called first. Lets a
+/// multi-step operation roll back an early step on every failure path without
+/// repeating the rollback before each return.
+template <typename Action>
+class ScopeExit {
+ public:
+  explicit ScopeExit(Action action) : action_(std::move(action)) {}
+  ~ScopeExit() {
+    if (armed_) {
+      action_();
+    }
+  }
+
+  DELETE_COPY_AND_MOVE(ScopeExit);
+
+  void dismiss() {
+    armed_ = false;
+  }
+
+ private:
+  Action action_;
+  bool armed_ = true;
+};
 } // namespace
 
 AndroidAudioRecorder::AndroidAudioRecorder(
@@ -60,7 +85,8 @@ AndroidAudioRecorder::AndroidAudioRecorder(
       inputPreset_(std::move(options.androidInputPreset)),
       streamSampleRate_(0.0),
       streamChannelCount_(0),
-      streamMaxBufferSizeInFrames_(0) {}
+      streamMaxBufferSizeInFrames_(0),
+      streamDeviceId_(AudioInputSelection::kSystemDefaultDeviceId) {}
 
 /// @brief Destructor ensures that the audio stream and each output type are closed and flushed up remaining data.
 /// callable from the JS thread or handled by audio thread (if js dropped recorder first).
@@ -87,12 +113,24 @@ AndroidAudioRecorder::~AndroidAudioRecorder() {
 /// @brief Creates and opens the Oboe audio input stream for recording.
 /// calculates the "native" or hardware stream parameters for other interfaces
 /// to use.
-/// Callable from the JS thread only.
+/// Called from start() on the promise thread pool and from onErrorAfterClose()
+/// on the Oboe error thread.
+/// An already open stream bound to a device other than the current
+/// AudioInputSelection is closed and reopened.
 /// @returns Success status or Error status with message.
 Result<NoneType, std::string> AndroidAudioRecorder::openAudioStream() {
   std::scoped_lock streamLock(streamMutex_);
+
+  const int32_t preferredDeviceId = AudioInputSelection::getPreferredDeviceId();
+
   if (mStream_ != nullptr) {
-    return Result<NoneType, std::string>::Ok(None);
+    if (streamDeviceId_ == preferredDeviceId) {
+      return Result<NoneType, std::string>::Ok(None);
+    }
+
+    mStream_->requestStop();
+    mStream_->close();
+    mStream_.reset();
   }
 
   oboe::AudioStreamBuilder builder;
@@ -109,6 +147,10 @@ Result<NoneType, std::string> AndroidAudioRecorder::openAudioStream() {
     builder.setInputPreset(*preset);
   }
 
+  if (preferredDeviceId != AudioInputSelection::kSystemDefaultDeviceId) {
+    builder.setDeviceId(preferredDeviceId);
+  }
+
   auto result = builder.openStream(mStream_);
 
   if (result != oboe::Result::OK || mStream_ == nullptr) {
@@ -116,6 +158,20 @@ Result<NoneType, std::string> AndroidAudioRecorder::openAudioStream() {
         "Failed to open audio stream: " + std::string(oboe::convertToText(result)));
   }
 
+  // The selection is a preference, as on iOS: when the platform routes elsewhere
+  // (the device is gone, or OpenSL ES, which ignores setDeviceId and reports
+  // kUnspecified), recording continues on the routed device instead of failing.
+  if (preferredDeviceId != AudioInputSelection::kSystemDefaultDeviceId &&
+      mStream_->getDeviceId() != preferredDeviceId) {
+    __android_log_print(
+        ANDROID_LOG_WARN,
+        "AndroidAudioRecorder",
+        "Input device %d was requested, but the capture stream opened on device %d",
+        preferredDeviceId,
+        mStream_->getDeviceId());
+  }
+
+  streamDeviceId_ = preferredDeviceId;
   streamSampleRate_ = static_cast<float>(mStream_->getSampleRate());
   streamChannelCount_ = mStream_->getChannelCount();
   streamMaxBufferSizeInFrames_ = mStream_->getBufferSizeInFrames();
@@ -138,6 +194,9 @@ Result<NoneType, std::string> AndroidAudioRecorder::start(const std::string &fil
     return Result<NoneType, std::string>::Err("Recorder is already recording");
   }
 
+  setRunningCapture(true);
+  ScopeExit releaseCapture([this] { setRunningCapture(false); });
+
   auto streamResult = openAudioStream();
 
   if (!streamResult.is_ok()) {
@@ -187,10 +246,27 @@ Result<NoneType, std::string> AndroidAudioRecorder::start(const std::string &fil
         "Failed to start stream: " + std::string(oboe::convertToText(result)));
   }
 
+  releaseCapture.dismiss();
   state_.store(RecorderState::Recording, std::memory_order_release);
   return Result<NoneType, std::string>::Ok(None);
 }
 
+void AndroidAudioRecorder::setRunningCapture(bool running) {
+  std::scoped_lock streamLock(streamMutex_);
+
+  if (countedAsRunningCapture_ == running) {
+    return;
+  }
+
+  countedAsRunningCapture_ = running;
+
+  if (running) {
+    AudioInputSelection::captureStarted();
+  } else {
+    AudioInputSelection::captureStopped();
+  }
+}
+
 /// @brief Stops the audio stream and finalizes any output (file writing, callback, adapter node).
 /// This method should be called from the JS thread only.
 /// @returns On success, returns the file URI, size in MB and duration in seconds of the recorded file (if file output is enabled).
@@ -220,6 +296,7 @@ AndroidAudioRecorder::stop() {
     }
 
     state_.store(RecorderState::Idle, std::memory_order_release);
+    setRunningCapture(false);
     lastCallbackFrameCount_.store(0, std::memory_order_release);
     mStream_->requestStop();
 
@@ -566,6 +643,7 @@ bool AndroidAudioRecorder::isIdle() const {
 void AndroidAudioRecorder::cleanup() {
   std::scoped_lock streamLock(streamMutex_);
   state_.store(RecorderState::Idle, std::memory_order_release);
+  setRunningCapture(false);
 
   if (mStream_ != nullptr) {
     mStream_->requestStop();
@@ -596,6 +674,11 @@ void AndroidAudioRecorder::onErrorAfterClose(oboe::AudioStream *stream, oboe::Re
       return;
     }
 
+    // cleanup() released the claim; take it again before the replacement stream
+    // reads the selection.
+    setRunningCapture(true);
+    ScopeExit releaseCapture([this] { setRunningCapture(false); });
+
     auto streamResult = openAudioStream();
 
     if (!streamResult.is_ok()) {
@@ -616,6 +699,7 @@ void AndroidAudioRecorder::onErrorAfterClose(oboe::AudioStream *stream, oboe::Re
     if (stateBeforeTeardown == RecorderState::Recording) {
       mStream_->requestStart();
     }
+    releaseCapture.dismiss();
     state_.store(stateBeforeTeardown, std::memory_order_release);
   }
 }
diff --git a/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/AndroidAudioRecorder.h b/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/AndroidAudioRecorder.h
index d30318d75..d6a1de99c 100644
--- a/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/AndroidAudioRecorder.h
+++ b/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/AndroidAudioRecorder.h
@@ -68,12 +68,25 @@ class AndroidAudioRecorder : public oboe::AudioStreamCallback,
   std::atomic<float> streamSampleRate_;
   int32_t streamChannelCount_;
   int32_t streamMaxBufferSizeInFrames_;
+  /// The device mStream_ was opened for, guarded by streamMutex_.
+  int32_t streamDeviceId_;
 
   std::shared_ptr<oboe::AudioStream> mStream_;
   std::vector<std::string> recordingSegmentPaths_;
   /// Updated on the audio thread from each input callback `numFrames`.
   std::atomic<int32_t> lastCallbackFrameCount_{0};
+  /// Whether this recorder is counted among AudioInputSelection's running
+  /// captures. Guarded by streamMutex_.
+  bool countedAsRunningCapture_{false};
   Result<NoneType, std::string> openAudioStream();
+  /// @brief Counts this recorder among AudioInputSelection's running captures
+  /// (`true`) or removes it (`false`). Idempotent.
+  ///
+  /// The claim must be taken before openAudioStream() reads the selection and
+  /// held until the stream is running.
+  ///
+  /// Takes streamMutex_, which is recursive, so callers may already hold it.
+  void setRunningCapture(bool running);
   std::shared_ptr<AudioFileWriter> createFileWriter(
       const std::shared_ptr<AudioFileProperties> &props);
   Result<NoneType, std::string> setupFileWriter(
diff --git a/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/AudioInputSelection.cpp b/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/AudioInputSelection.cpp
new file mode 100644
index 000000000..aea94cbd9
--- /dev/null
+++ b/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/AudioInputSelection.cpp
@@ -0,0 +1,45 @@
+#include <audioapi/android/core/AudioInputSelection.h>
+
+#include <mutex>
+
+namespace audioapi::AudioInputSelection {
+
+namespace {
+/// Guards both values together, so setPreferredDeviceId decides and writes
+/// without a window in which a recorder could claim the selection in between.
+std::mutex selectionMutex;
+int32_t preferredDeviceId = kSystemDefaultDeviceId;
+int32_t runningCaptureCount = 0;
+} // namespace
+
+bool setPreferredDeviceId(int32_t deviceId) {
+  std::scoped_lock selectionLock(selectionMutex);
+
+  if (deviceId == preferredDeviceId) {
+    return true;
+  }
+
+  if (runningCaptureCount > 0) {
+    return false;
+  }
+
+  preferredDeviceId = deviceId;
+  return true;
+}
+
+int32_t getPreferredDeviceId() {
+  std::scoped_lock selectionLock(selectionMutex);
+  return preferredDeviceId;
+}
+
+void captureStarted() {
+  std::scoped_lock selectionLock(selectionMutex);
+  ++runningCaptureCount;
+}
+
+void captureStopped() {
+  std::scoped_lock selectionLock(selectionMutex);
+  --runningCaptureCount;
+}
+
+} // namespace audioapi::AudioInputSelection
diff --git a/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/AudioInputSelection.h b/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/AudioInputSelection.h
new file mode 100644
index 000000000..4e3565533
--- /dev/null
+++ b/packages/react-native-audio-api/android/src/main/cpp/audioapi/android/core/AudioInputSelection.h
@@ -0,0 +1,33 @@
+#pragma once
+
+#include <oboe/Oboe.h>
+#include <cstdint>
+
+namespace audioapi::AudioInputSelection {
+
+/// @brief Process-wide choice of the capture device every AndroidAudioRecorder
+/// opens its input stream on, set by the Kotlin AudioAPIModule.setInputDevice.
+///
+/// Kept process-wide because the public API is AudioManager.setInputDevice,
+/// which selects the input for the whole app to match iOS's session-wide
+/// preferred input; a recorder reads it when its stream opens.
+
+/// @brief Leaves the capture device to the platform, which is Oboe's default.
+constexpr int32_t kSystemDefaultDeviceId = oboe::kUnspecified;
+
+/// @param deviceId An Android AudioDeviceInfo id, or kSystemDefaultDeviceId to
+/// hand the choice back to the platform.
+/// @returns false when a capture stream is running and the requested device
+/// differs from the current selection. The selection is then left unchanged,
+/// because a running stream cannot be moved onto it.
+bool setPreferredDeviceId(int32_t deviceId);
+
+int32_t getPreferredDeviceId();
+
+/// @brief Reports that a recorder holds the selection: it is about to read it,
+/// or is already feeding audio from it. Every call must be balanced by
+/// captureStopped(), including on teardown.
+void captureStarted();
+void captureStopped();
+
+} // namespace audioapi::AudioInputSelection
diff --git a/packages/react-native-audio-api/android/src/main/java/com/swmansion/audioapi/AudioAPIModule.kt b/packages/react-native-audio-api/android/src/main/java/com/swmansion/audioapi/AudioAPIModule.kt
index 5411f005d..b8ec22ba6 100644
--- a/packages/react-native-audio-api/android/src/main/java/com/swmansion/audioapi/AudioAPIModule.kt
+++ b/packages/react-native-audio-api/android/src/main/java/com/swmansion/audioapi/AudioAPIModule.kt
@@ -31,6 +31,7 @@ class AudioAPIModule(
   companion object {
     const val NAME = NativeAudioAPIModuleSpec.NAME
     private const val TAG = "AudioAPIModule"
+    private const val INPUT_DEVICE_ERROR = "E_INPUT_DEVICE"
   }
 
   val reactContext: WeakReference<ReactApplicationContext> = WeakReference(reactContext)
@@ -51,6 +52,8 @@ class AudioAPIModule(
     eventBody: Map<String, Any>,
   )
 
+  private external fun setPreferredInputDeviceId(deviceId: Int): Boolean
+
   init {
     try {
       System.loadLibrary("react-native-audio-api")
@@ -93,8 +96,8 @@ class AudioAPIModule(
 
   override fun invalidate() {
     reactContext.get()?.removeLifecycleEventListener(this)
-    // Cleanup foreground service manager
     ForegroundServiceManager.cleanup()
+    MediaSessionManager.cleanup()
   }
 
   override fun getDevicePreferredSampleRate(): Double = MediaSessionManager.getDevicePreferredSampleRate()
@@ -115,7 +118,7 @@ class AudioAPIModule(
     allowHaptics: Boolean,
     notifyOthersOnDeactivation: Boolean,
   ) {
-    // noting to do here
+    // nothing to do here
   }
 
   override fun disableSessionManagement() {
@@ -172,12 +175,28 @@ class AudioAPIModule(
     promise.resolve(MediaSessionManager.getDevicesInfo())
   }
 
+  @RequiresApi(Build.VERSION_CODES.M)
   override fun setInputDevice(
     deviceId: String?,
     promise: Promise?,
   ) {
-    // TODO: noop for now, but it should be moved to upcoming
-    // audio engine implementation for android (duplex stream)
+    val device = deviceId?.let { MediaSessionManager.findInputDevice(it) }
+
+    if (device == null) {
+      promise?.reject(INPUT_DEVICE_ERROR, "Input device with id $deviceId not found", null)
+      return
+    }
+
+    if (!setPreferredInputDeviceId(device.id)) {
+      promise?.reject(
+        INPUT_DEVICE_ERROR,
+        "Cannot change the input device while a recorder is running or paused. Stop the recorder, select the device, then start it again.",
+        null,
+      )
+      return
+    }
+
+    MediaSessionManager.setPreferredInputDevice(device)
     promise?.resolve(null)
   }
 
diff --git a/packages/react-native-audio-api/android/src/main/java/com/swmansion/audioapi/system/DeviceChangeListener.kt b/packages/react-native-audio-api/android/src/main/java/com/swmansion/audioapi/system/DeviceChangeListener.kt
new file mode 100644
index 000000000..a7c903784
--- /dev/null
+++ b/packages/react-native-audio-api/android/src/main/java/com/swmansion/audioapi/system/DeviceChangeListener.kt
@@ -0,0 +1,32 @@
+package com.swmansion.audioapi.system
+
+import android.media.AudioDeviceCallback
+import android.media.AudioDeviceInfo
+import com.swmansion.audioapi.AudioAPIModule
+import java.lang.ref.WeakReference
+import java.util.HashMap
+
+class DeviceChangeListener(
+  private val audioAPIModule: WeakReference<AudioAPIModule>,
+) : AudioDeviceCallback() {
+  /** Registration replays every connected device as added; that snapshot is not a change. */
+  private var receivedInitialDevices = false
+
+  override fun onAudioDevicesAdded(addedDevices: Array<out AudioDeviceInfo>) {
+    if (!receivedInitialDevices) {
+      receivedInitialDevices = true
+      return
+    }
+
+    dispatchRouteChange("NewDeviceAvailable")
+  }
+
+  override fun onAudioDevicesRemoved(removedDevices: Array<out AudioDeviceInfo>) {
+    dispatchRouteChange("OldDeviceUnavailable")
+  }
+
+  private fun dispatchRouteChange(reason: String) {
+    val body = HashMap<String, Any>().apply { put("reason", reason) }
+    audioAPIModule.get()?.invokeHandlerWithEventNameAndEventBody(AudioEvent.ROUTE_CHANGE.ordinal, body)
+  }
+}
diff --git a/packages/react-native-audio-api/android/src/main/java/com/swmansion/audioapi/system/MediaSessionManager.kt b/packages/react-native-audio-api/android/src/main/java/com/swmansion/audioapi/system/MediaSessionManager.kt
index d29d8c360..605ab933e 100644
--- a/packages/react-native-audio-api/android/src/main/java/com/swmansion/audioapi/system/MediaSessionManager.kt
+++ b/packages/react-native-audio-api/android/src/main/java/com/swmansion/audioapi/system/MediaSessionManager.kt
@@ -9,6 +9,9 @@ import android.content.pm.PackageManager
 import android.media.AudioDeviceInfo
 import android.media.AudioManager
 import android.os.Build
+import android.os.Handler
+import android.os.Looper
+import android.util.Log
 import androidx.annotation.RequiresApi
 import androidx.annotation.RequiresPermission
 import androidx.core.app.ActivityCompat
@@ -17,6 +20,7 @@ import androidx.core.content.ContextCompat
 import com.facebook.react.bridge.Arguments
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReadableMap
+import com.facebook.react.bridge.WritableMap
 import com.facebook.react.modules.core.PermissionAwareActivity
 import com.facebook.react.modules.core.PermissionListener
 import com.swmansion.audioapi.AudioAPIModule
@@ -30,11 +34,13 @@ import java.lang.ref.WeakReference
 object MediaSessionManager {
   private lateinit var audioAPIModule: WeakReference<AudioAPIModule>
   private lateinit var reactContext: WeakReference<ReactApplicationContext>
+  private const val TAG = "MediaSessionManager"
   const val CHANNEL_ID = "react-native-audio-api"
 
   private lateinit var audioManager: AudioManager
   private lateinit var audioFocusListener: AudioFocusListener
   private lateinit var volumeChangeListener: VolumeChangeListener
+  private lateinit var deviceChangeListener: DeviceChangeListener
   private lateinit var playbackNotificationReceiver: PlaybackNotificationReceiver
 
   // New notification system
@@ -79,6 +85,8 @@ object MediaSessionManager {
     this.audioFocusListener =
       AudioFocusListener(WeakReference(this.audioManager), this.audioAPIModule)
     this.volumeChangeListener = VolumeChangeListener(WeakReference(this.audioManager), this.audioAPIModule)
+    this.deviceChangeListener = DeviceChangeListener(this.audioAPIModule)
+    this.audioManager.registerAudioDeviceCallback(deviceChangeListener, Handler(Looper.getMainLooper()))
 
     // Initialize new notification system
     this.notificationRegistry = NotificationRegistry(this.reactContext, this.audioAPIModule)
@@ -97,6 +105,12 @@ object MediaSessionManager {
     return sampleRate.toDouble()
   }
 
+  fun cleanup() {
+    if (::deviceChangeListener.isInitialized) {
+      audioManager.unregisterAudioDeviceCallback(deviceChangeListener)
+    }
+  }
+
   fun requestAudioFocus(focus: Int) {
     audioFocusListener.requestAudioFocus(focus)
   }
@@ -211,32 +225,119 @@ object MediaSessionManager {
     notificationManager.createNotificationChannel(mChannel)
   }
 
+  /**
+   * Capture device selected through `AudioAPIModule.setInputDevice`, reported
+   * back by [getDevicesInfo]. Mirrors the selection held natively by
+   * `AudioInputSelection`.
+   *
+   * Null means the platform picks the device. Android does not say which one
+   * before a stream opens, so `currentInputs` stays empty.
+   *
+   * Written on the React Native module thread, read by any `getDevicesInfo` caller.
+   */
+  @Volatile
+  private var preferredInputDeviceId: Int? = null
+
+  @RequiresApi(Build.VERSION_CODES.M)
+  fun findInputDevice(deviceId: String): AudioDeviceInfo? = recordableInputs().firstOrNull { it.id.toString() == deviceId }
+
+  @RequiresApi(Build.VERSION_CODES.M)
+  private fun recordableInputs(): List<AudioDeviceInfo> =
+    this.audioManager
+      .getDevices(AudioManager.GET_DEVICES_INPUTS)
+      .filter { it.type !in systemOnlyInputTypes }
+
+  private val systemOnlyInputTypes =
+    setOf(
+      AudioDeviceInfo.TYPE_TELEPHONY,
+      AudioDeviceInfo.TYPE_REMOTE_SUBMIX,
+      AudioDeviceInfo.TYPE_FM_TUNER,
+      AudioDeviceInfo.TYPE_TV_TUNER,
+    )
+
+  /** Whether this manager started the Bluetooth SCO link, so it only tears down its own. */
+  private var startedBluetoothSco = false
+
+  @RequiresApi(Build.VERSION_CODES.M)
+  fun setPreferredInputDevice(device: AudioDeviceInfo) {
+    this.preferredInputDeviceId = device.id
+
+    if (device.type == AudioDeviceInfo.TYPE_BLUETOOTH_SCO) {
+      startBluetoothSco(device)
+    } else {
+      stopBluetoothSco()
+    }
+  }
+
+  /**
+   * A Bluetooth headset mic carries audio only over the SCO link, and the platform
+   * brings that link up for the communication device, never for a capture stream's
+   * preferred device. Without it the stream opens on the headset and receives no frames.
+   * Output to the same headset moves from A2DP to SCO while the link is up.
+   */
+  @RequiresApi(Build.VERSION_CODES.M)
+  private fun startBluetoothSco(input: AudioDeviceInfo) {
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+      val scoOutputs =
+        audioManager.availableCommunicationDevices.filter {
+          it.type == AudioDeviceInfo.TYPE_BLUETOOTH_SCO
+        }
+      val headset = scoOutputs.firstOrNull { it.address == input.address } ?: scoOutputs.firstOrNull()
+
+      if (headset == null || !audioManager.setCommunicationDevice(headset)) {
+        Log.w(TAG, "Cannot route communication to the Bluetooth headset, its mic stays silent")
+        return
+      }
+    } else {
+      @Suppress("DEPRECATION")
+      audioManager.startBluetoothSco()
+      @Suppress("DEPRECATION")
+      audioManager.isBluetoothScoOn = true
+    }
+
+    startedBluetoothSco = true
+  }
+
+  private fun stopBluetoothSco() {
+    if (!startedBluetoothSco) {
+      return
+    }
+
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+      audioManager.clearCommunicationDevice()
+    } else {
+      @Suppress("DEPRECATION")
+      audioManager.isBluetoothScoOn = false
+      @Suppress("DEPRECATION")
+      audioManager.stopBluetoothSco()
+    }
+
+    startedBluetoothSco = false
+  }
+
   @RequiresApi(Build.VERSION_CODES.O)
   fun getDevicesInfo(): ReadableMap {
     val availableInputs = Arguments.createArray()
+    val currentInputs = Arguments.createArray()
     val availableOutputs = Arguments.createArray()
 
-    for (inputDevice in this.audioManager.getDevices(AudioManager.GET_DEVICES_INPUTS)) {
-      val deviceInfo = Arguments.createMap()
-      deviceInfo.putString("id", inputDevice.getId().toString())
-      deviceInfo.putString("name", inputDevice.productName.toString())
-      deviceInfo.putString("category", parseDeviceCategory(inputDevice))
+    val selectedInputDeviceId = this.preferredInputDeviceId
+
+    for (inputDevice in recordableInputs()) {
+      availableInputs.pushMap(describeDevice(inputDevice))
 
-      availableInputs.pushMap(deviceInfo)
+      if (inputDevice.id == selectedInputDeviceId) {
+        currentInputs.pushMap(describeDevice(inputDevice))
+      }
     }
 
     for (outputDevice in this.audioManager.getDevices(AudioManager.GET_DEVICES_OUTPUTS)) {
-      val deviceInfo = Arguments.createMap()
-      deviceInfo.putString("id", outputDevice.getId().toString())
-      deviceInfo.putString("name", outputDevice.productName.toString())
-      deviceInfo.putString("category", parseDeviceCategory(outputDevice))
-
-      availableOutputs.pushMap(deviceInfo)
+      availableOutputs.pushMap(describeDevice(outputDevice))
     }
 
     val devicesInfo = Arguments.createMap()
 
-    devicesInfo.putArray("currentInputs", Arguments.createArray())
+    devicesInfo.putArray("currentInputs", currentInputs)
     devicesInfo.putArray("currentOutputs", Arguments.createArray())
     devicesInfo.putArray("availableInputs", availableInputs)
     devicesInfo.putArray("availableOutputs", availableOutputs)
@@ -244,6 +345,27 @@ object MediaSessionManager {
     return devicesInfo
   }
 
+  @RequiresApi(Build.VERSION_CODES.O)
+  private fun describeDevice(device: AudioDeviceInfo): WritableMap {
+    val deviceInfo = Arguments.createMap()
+    deviceInfo.putString("id", device.id.toString())
+    deviceInfo.putString("name", deviceName(device))
+    deviceInfo.putString("category", parseDeviceCategory(device))
+
+    return deviceInfo
+  }
+
+  @RequiresApi(Build.VERSION_CODES.O)
+  private fun deviceName(device: AudioDeviceInfo): String {
+    val productName = device.productName.toString()
+
+    if (device.type != AudioDeviceInfo.TYPE_BUILTIN_MIC || device.address.isEmpty()) {
+      return productName
+    }
+
+    return "$productName (${device.address})"
+  }
+
   @RequiresApi(Build.VERSION_CODES.O)
   fun parseDeviceCategory(device: AudioDeviceInfo): String =
     when (device.type) {
@@ -254,6 +376,9 @@ object MediaSessionManager {
       AudioDeviceInfo.TYPE_WIRED_HEADPHONES -> "Wired Headphones"
       AudioDeviceInfo.TYPE_BLUETOOTH_A2DP -> "Bluetooth A2DP"
       AudioDeviceInfo.TYPE_BLUETOOTH_SCO -> "Bluetooth SCO"
+      AudioDeviceInfo.TYPE_USB_DEVICE -> "USB Device"
+      AudioDeviceInfo.TYPE_USB_HEADSET -> "USB Headset"
+      AudioDeviceInfo.TYPE_USB_ACCESSORY -> "USB Accessory"
       else -> "Other (${device.type})"
     }
 
diff --git a/packages/react-native-audio-api/src/hooks/useAudioInput.ts b/packages/react-native-audio-api/src/hooks/useAudioInput.ts
index c3a1fc374..0ad49503a 100644
--- a/packages/react-native-audio-api/src/hooks/useAudioInput.ts
+++ b/packages/react-native-audio-api/src/hooks/useAudioInput.ts
@@ -18,9 +18,14 @@ const meaningfulReasons: RouteChangeReason[] = [
 
 /**
  * A hook that provides basic information and selection capabilities for audio
- * input devices on the system. (iOS only currently). The hook will
- * automatically listen for configuration changes and updates its state. If you
- * need more granular control, consider using the AudioManager API directly.
+ * input devices on the system. The hook will automatically listen for
+ * configuration changes and updates its state. If you need more granular
+ * control, consider using the AudioManager API directly.
+ *
+ * On Android the selection is bound while a capture stream opens, so
+ * `onSelectInput` throws while a recorder is running or paused, and
+ * `currentInput` stays null until a device is picked. See
+ * `AudioManager.setInputDevice`.
  *
  * @returns An object containing audio input information and selection
  *   capabilities
diff --git a/packages/react-native-audio-api/src/system/AudioManager.ts b/packages/react-native-audio-api/src/system/AudioManager.ts
index ace424da3..e87ccc094 100644
--- a/packages/react-native-audio-api/src/system/AudioManager.ts
+++ b/packages/react-native-audio-api/src/system/AudioManager.ts
@@ -125,6 +125,11 @@ class AudioManager implements IAudioManager {
    *
    * Resolves when the input device was set successfully and rejects when the
    * device cannot be found or the system fails to switch to it.
+   *
+   * On iOS the running session is rerouted right away. On Android the device is
+   * bound while a capture stream opens, so the selection applies to recorders
+   * started afterwards, and calling this while a recorder is running or paused
+   * rejects rather than deferring the switch silently.
    */
   async setInputDevice(deviceId: string): Promise<void> {
     await NativeAudioAPIModule.setInputDevice(deviceId);
diff --git a/packages/react-native-audio-api/src/system/types.ts b/packages/react-native-audio-api/src/system/types.ts
index d010ed95e..74dfa69ab 100644
--- a/packages/react-native-audio-api/src/system/types.ts
+++ b/packages/react-native-audio-api/src/system/types.ts
@@ -68,8 +68,14 @@ export type AudioDeviceList = AudioDeviceInfo[];
 export interface AudioDevicesInfo {
   availableInputs: AudioDeviceList;
   availableOutputs: AudioDeviceList;
-  currentInputs: AudioDeviceList; // iOS only
-  currentOutputs: AudioDeviceList; // iOS only
+  /**
+   * On iOS, the inputs of the current route. On Android, the device selected
+   * through `setInputDevice`, and empty until one is selected: the platform
+   * does not report which input it would pick on its own.
+   */
+  currentInputs: AudioDeviceList;
+  /** Outputs of the current route. Always empty on Android. */
+  currentOutputs: AudioDeviceList;
 }
 
 export interface IAudioManager {