The three mute states map perfectly to a hotel “Do Not Disturb” sign:

The Disabled state represents a physical hardware privacy switch (like a laptop privacy shutter). The device locks the mic mute at hardware level — no BLE command can override it.

No AICS included. Just a global mute switch. Best for headsets or speakers that only need ON/OFF mute with no individual gain control.

One AICS is included inside MICS. MICS = device-wide mute. AICS = individual input gain (volume) and mute for that one microphone. Together they give you fine-grained control.

Multiple AICS instances, one per microphone. Each mic gets its own independent gain and mute. MICS still provides the single device-wide master mute. Perfect for TWS earbuds (left + right mic) or conference room speakerphones.

MICS has exactly one characteristic: the Mute characteristic. It’s a single byte that tells the current mute state of the device’s audio.

The mute state transitions follow strict rules. The most important: only the device itself (server) can enter or exit the Disabled state.

When a client does something invalid, the server returns an ATT error response. MICS defines one custom application-level error:

Both errors tell the client: “you can’t do that.” The difference is the reason — one is about the current locked state, the other is about writing an invalid value.

To implement MICS, your BLE server and client code must support these four GATT operations:

Once the client writes 0x0001 to the CCCD (Client Characteristic Configuration Descriptor), it subscribes to mute change notifications. Every time the mute state changes — whether by the client, server, or a hardware switch — all subscribed clients get notified.

Start by defining the UUIDs and mute state constants. In BlueZ, GATT services are registered through D-Bus using the GATT Manager API.

/* ===== mics.h — MICS Constants ===== */

/* MICS Service UUID (Bluetooth SIG Assigned Numbers) */
#define MICS_UUID           "0000184d-0000-1000-8000-00805f9b34fb"

/* Mute Characteristic UUID */
#define MUTE_CHAR_UUID      "00002bc3-0000-1000-8000-00805f9b34fb"

/* Mute characteristic values */
#define MUTE_NOT_MUTED      0x00   /* Mic active, audio flowing */
#define MUTE_MUTED          0x01   /* Mic silenced by software  */
#define MUTE_DISABLED       0x02   /* Mute locked by hardware   */

/* ATT Application Error Code — defined by MICS spec */
#define ATT_ERR_MUTE_DISABLED    0x80
/* Standard ATT error (BT Core Spec) */
#define ATT_ERR_VALUE_NOT_ALLOWED 0x13

/* MICS service state structure */
struct mics_service {
    uint8_t  mute_state;           /* Current mute value        */
    bool     notify_enabled;       /* Client subscribed?         */
};

/* Initialize with default Not Muted state */
static struct mics_service *mics_init(void)
{
    struct mics_service *svc = g_new0(struct mics_service, 1);
    svc->mute_state    = MUTE_NOT_MUTED;
    svc->notify_enabled = false;
    return svc;
}

After pairing with a BLE device that exposes MICS, use BlueZ’s interactive tool to explore the service. The UUID 0x184D identifies MICS; the Mute characteristic UUID is 0x2BC3.

# Step 1: Power on and scan
bluetoothctl power on
bluetoothctl scan on

# Step 2: Connect to your MICS device
bluetoothctl connect AA:BB:CC:DD:EE:FF

# Step 3: List all GATT attributes (services + characteristics)
bluetoothctl list-attributes AA:BB:CC:DD:EE:FF

# Look for output like:
# Service    /org/bluez/hci0/dev_AA_BB_CC_DD_EE_FF/service000c
#            0000184d-0000-1000-8000-00805f9b34fb (MICS)
# Characteristic /org/.../service000c/char000d
#            00002bc3-0000-1000-8000-00805f9b34fb (Mute)
#            Flags: read write notify

# Step 4: Select the Mute characteristic
bluetoothctl select-attribute /org/bluez/hci0/dev_AA_BB_CC_DD_EE_FF/service000c/char000d

# Step 5: Read the current mute state
bluetoothctl read-attribute

# Example responses:
# Attribute Value (1):  00          -> Not Muted
# Attribute Value (1):  01          -> Muted
# Attribute Value (1):  02          -> Disabled (hardware lock)

To programmatically mute or unmute over BLE in C, call WriteValue on the Mute characteristic proxy. The link must be encrypted (bonded) or the ATT operation will be rejected.

#include <glib.h>
#include <gio/gio.h>

/*
 * mics_write_mute() — send mute or unmute command to MICS server
 *
 * @char_proxy : D-Bus proxy for the Mute characteristic
 * @mute_val   : MUTE_NOT_MUTED (0x00) or MUTE_MUTED (0x01)
 *
 * Returns 0 on success, negative errno on failure.
 */
static int mics_write_mute(GDBusProxy *char_proxy, uint8_t mute_val)
{
    GVariant      *params;
    GVariantBuilder opts_builder;
    GError        *error = NULL;

    /* Validate: client can only write 0x00 or 0x01 */
    if (mute_val != MUTE_NOT_MUTED && mute_val != MUTE_MUTED) {
        g_printerr("[MICS] Invalid value 0x%02x — only 0x00/0x01 allowed\n",
                   mute_val);
        return -EINVAL;
    }

    /* Build WriteValue call: (ay, a{sv}) */
    g_variant_builder_init(&opts_builder, G_VARIANT_TYPE_VARDICT);

    params = g_variant_new(
        "(ay@a{sv})",
        g_variant_new_fixed_array(G_VARIANT_TYPE_BYTE,
                                  &mute_val, 1, sizeof(uint8_t)),
        g_variant_builder_end(&opts_builder));

    g_dbus_proxy_call_sync(char_proxy, "WriteValue", params,
                           G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);

    if (error) {
        /*
         * If the server is in Disabled state it returns
         * application error 0x80 (Mute Disabled).
         */
        g_printerr("[MICS] WriteValue failed: %s\n", error->message);
        g_error_free(error);
        return -EIO;
    }

    g_print("[MICS] Mute set to: %s\n",
            mute_val == MUTE_MUTED ? "MUTED 🔇" : "NOT MUTED ✅");
    return 0;
}

Subscribe to the Mute characteristic via StartNotify. Connect a GObject signal to handle incoming notifications — the callback fires whenever the mute state changes on the server side.

/*
 * mics_notify_cb() — called whenever Mute characteristic value changes
 * Triggered by: BLE notification from MICS server
 */
static void mics_notify_cb(GDBusProxy *proxy,
                            GVariant   *changed_props,
                            GStrv       invalidated,
                            gpointer    user_data)
{
    GVariant       *val;
    const uint8_t  *data;
    gsize           len;

    val = g_variant_lookup_value(changed_props,
                                 "Value",
                                 G_VARIANT_TYPE_BYTESTRING);
    if (!val)
        return;

    data = g_variant_get_fixed_array(val, &len, sizeof(uint8_t));
    if (len < 1) {
        g_variant_unref(val);
        return;
    }

    /* Decode and print the new mute state */
    switch (data[0]) {
    case MUTE_NOT_MUTED:
        g_print("[MICS Notify] 🎤 Microphone: NOT MUTED (0x00)\n");
        break;
    case MUTE_MUTED:
        g_print("[MICS Notify] 🔇 Microphone: MUTED (0x01)\n");
        break;
    case MUTE_DISABLED:
        g_print("[MICS Notify] 🔒 Mute control: DISABLED by hardware (0x02)\n");
        break;
    default:
        g_printerr("[MICS Notify] ⚠️  Unknown value: 0x%02x\n", data[0]);
    }

    g_variant_unref(val);
}

/* Enable notifications for the Mute characteristic */
static int mics_enable_notify(GDBusProxy *char_proxy)
{
    GError *error = NULL;

    /* Wire up the PropertiesChanged signal BEFORE calling StartNotify */
    g_signal_connect(char_proxy, "g-properties-changed",
                     G_CALLBACK(mics_notify_cb), NULL);

    /* Tell BlueZ to subscribe (writes CCCD = 0x0001 under the hood) */
    g_dbus_proxy_call_sync(char_proxy, "StartNotify", NULL,
                           G_DBUS_CALL_FLAGS_NONE, -1, NULL, &error);
    if (error) {
        g_printerr("[MICS] StartNotify failed: %s\n", error->message);
        g_error_free(error);
        return -EIO;
    }

    g_print("[MICS] ✅ Subscribed to Mute notifications\n");
    return 0;
}

On the peripheral (server) side, when a remote client sends a Write request to the Mute characteristic, you must validate it and return the correct ATT error when needed. This is the critical guard logic the spec mandates.

/*
 * mics_server_write_handler()
 * Called by BlueZ GATT server when client writes Mute characteristic.
 *
 * Returns NULL on success, or a D-Bus error message on failure.
 */
static DBusMessage *mics_server_write_handler(DBusConnection *conn,
                                               DBusMessage    *msg,
                                               void           *user_data)
{
    struct mics_service *svc = user_data;
    DBusMessageIter     iter, array_iter;
    uint8_t             new_val = 0;

    /* Parse the incoming byte value */
    dbus_message_iter_init(msg, &iter);
    if (dbus_message_iter_get_arg_type(&iter) == DBUS_TYPE_ARRAY) {
        dbus_message_iter_recurse(&iter, &array_iter);
        dbus_message_iter_get_basic(&array_iter, &new_val);
    }

    /*
     * Rule 1 (MICS spec §3.1.1):
     * Client must NOT write Disabled (0x02) or any RFU value.
     * Return standard ATT error: Value Not Allowed (0x13)
     */
    if (new_val >= MUTE_DISABLED) {
        g_print("[MICS Server] ❌ Rejected write 0x%02x — Value Not Allowed\n",
                new_val);
        return g_dbus_create_error(msg,
                   "org.bluez.Error.NotPermitted",
                   "ATT Error 0x13: Value Not Allowed");
    }

    /*
     * Rule 2 (MICS spec §3.1.1):
     * If current state is Disabled, reject ALL client writes.
     * Return application error: Mute Disabled (0x80)
     */
    if (svc->mute_state == MUTE_DISABLED) {
        g_print("[MICS Server] 🔒 Rejected write — Mute is hardware-disabled\n");
        return g_dbus_create_error(msg,
                   "org.bluez.Error.NotPermitted",
                   "ATT App Error 0x80: Mute Disabled");
    }

    /* ✅ Valid write — apply new mute state */
    svc->mute_state = new_val;
    g_print("[MICS Server] ✅ Mute state updated to: 0x%02x (%s)\n",
            new_val, new_val == MUTE_MUTED ? "MUTED" : "NOT MUTED");

    /* Notify all subscribed clients */
    mics_send_notification(conn, svc, new_val);

    return dbus_message_new_method_return(msg);
}

/*
 * mics_hardware_disable()
 * Called locally when a physical privacy switch is engaged.
 * ONLY the server can call this — clients cannot trigger it.
 */
static void mics_hardware_disable(struct mics_service *svc,
                                   DBusConnection      *conn)
{
    svc->mute_state = MUTE_DISABLED;
    g_print("[MICS Server] 🔒 Hardware privacy switch engaged — Disabled\n");

    /* Notify all connected clients about the state change */
    mics_send_notification(conn, svc, MUTE_DISABLED);
}

Although MICS is a GATT/BLE service, it can also run over Bluetooth Classic (BR/EDR). When it does, the device must register an SDP record so Classic Bluetooth clients can discover it.

C.1 — EATT condition: The Additional Protocol Descriptor List (with PSM = EATT) is mandatory if Enhanced Attribute Protocol is supported, and excluded otherwise.