GATT — ano ito, Generic Attribute Profile at implementasyon sa Android

Ano ang GATT?

GATT (Generic Attribute Profile) — ay ang Bluetooth Low Energy (BLE) profile na tumutukoy kung paano nagpapalitan ng data ang dalawang BLE device sa pamamagitan ng Attribute Protocol (ATT). Istandardisa ng GATT ang istruktura ng data: lahat ng data ay nakaayos sa hierarchy na “serbisyo → katangian → deskriptor”. Ang profile ay ipinakilala sa Bluetooth 4.0 specification (2010) kasama ng BLE at mula noon ay nananatiling pangunahing mekanismo ng pagpapadala ng data para sa energy-efficient na Bluetooth device. Hindi tulad ng classic Bluetooth, kung saan ang data ay ipinapadala sa pamamagitan ng serial port (SPP), ang GATT ay nagbibigay ng structured na access sa data sa pamamagitan ng read, write at notify operations.

Tungkulin ng GATT sa BLE stack

BLE stack ay binubuo ng ilang layer: Physical Layer (radio), Link Layer (pamamahala ng koneksyon), L2CAP (logical channel transmission), ATT (Attribute Protocol — access sa mga attribute) at GATT (profile batay sa ATT). Ang GATT ay ang pinakamataas na layer na ginagamit ng developer ng application. Ang ATT sa ibaba ay nagbibigay ng mga pangunahing operasyon: pagbasa, pagsulat, pag-notify at pag-indicate ng mga attribute. Ang GATT ay nagdaragdag ng semantics: tinutukoy nito kung ano ang serbisyo, katangian, kung paano sila naka-grupo at kung anong mga patakaran ang nalalapat sa pagbasa at pagsulat sa kanila. Ayon sa Bluetooth Core Specification 5.4 (2023), sinusuportahan ng GATT ang hanggang 65,535 attribute (serbisyo + katangian + deskriptor) sa isang device.

Arkitektura ng GATT: mga serbisyo, katangian at deskriptor

GATT hierarchy ay binubuo ng tatlong antas. Serbisyo (Service) — lohikal na grupo ng mga katangian na lumulutas ng isang gawain (halimbawa, “Serbisyo ng Baterya” o “Serbisyo ng Heart Rate”). Katangian (Characteristic) — yunit ng data na may kilalang uri: kasalukuyang antas ng charge, pagbasa ng sensor, estado ng switch. Bawat katangian ay may halaga (value) at isa o higit pang deskriptor (Descriptors) na naglalarawan ng metadata: mga unit ng pagsukat, setting ng notipikasyon, saklaw ng halaga. UUID (Universally Unique Identifier) ay natatanging kinikilala ang bawat serbisyo at bawat katangian.

Mga uri ng operasyon sa mga katangian

GATT ay sumusuporta sa apat na uri ng operasyon para sa pakikipag-ugnayan sa mga katangian. Read — humihiling ang client ng kasalukuyang halaga ng katangian mula sa server. Write — nagpapadala ang client ng bagong halaga sa server. Notify — nagpapadala ang server ng halaga sa client nang walang kumpirmasyon (mas mabilis ngunit hindi gaanong maaasahan). Indicate — nagpapadala ang server ng halaga na may kumpirmasyon ng pagtanggap (mas maaasahan ngunit mas mabagal). Pinipili ng developer ang uri batay sa sitwasyon: para sa pagbasa ng pulse sensor, sapat na ang Notify; para sa pagsulat ng configuration ng smart lock — Write na may kumpirmasyon.

// Istraktura ng GATT data sa Android code
data class BleService(
    val uuid: UUID,
    val characteristics: List<BleCharacteristic>
)

data class BleCharacteristic(
    val uuid: UUID,
    val properties: Int, // BASA, SULAT, NOTIPIKASYON, INDIKASYON
    val descriptors: List<BleDescriptor>,
    var value: ByteArray?
)

GATT at GAP: pagkakaiba ng mga BLE profile

Sa BLE specification ay tinukoy ang dalawang pangunahing profile: GAP (Generic Access Profile) at GATT (Generic Attribute Profile). Ang GAP ay responsable para sa pag-detect ng device, pagtatatag ng koneksyon at pamamahala ng visibility — ito ang “network layer” ng BLE. Ang GATT — para sa pagpapalitan ng data pagkatapos ng koneksyon, iyon ay ang “application layer”. Ginagamit ng developer ang GAP para sa pag-scan at pagkonekta sa device, at GATT — para sa pagbasa, pagsulat at pagtanggap ng mga notipikasyon mula sa nakakonektang device.

Mga tungkulin sa GATT

Tinutukoy ng GATT ang dalawang tungkulin: GATT Server at GATT Client. Server — device na nagbibigay ng data (halimbawa, fitness tracker na nagpapadala ng pulse reading). Client — device na humihiling ng data (halimbawa, smartphone na nagbabasa ng mga sukat). Sa karamihan ng mga sitwasyon, ang Android app ay gumaganap bilang GATT Client, at ang BLE peripheral ay GATT Server. Gayunpaman, ang Android ay maaari ding maging GATT Server — halimbawa, kung ang app ay gumagaya ng BLE device para sa iba pang device. Ang tungkulin ay tinutukoy sa yugto ng pagtatatag ng GATT connection at hindi nagbabago sa buong session.

Paano gumagana ang GATT communication sa BLE

Ang proseso ng GATT communication ay nagsisimula pagkatapos maitatag ang BLE connection sa pagitan ng mga device. Una, dini-detect ng GATT Client ang mga serbisyo sa GATT Server sa pamamagitan ng Service Discovery operation — awtomatikong ginagawa ito ng Android kapag kumokonekta sa pamamagitan ng BluetoothGatt.discoverServices(). Pagkatapos ng detection, natatanggap ng client ang listahan ng mga available na serbisyo, katangian at deskriptor. Pagkatapos ay maaaring basahin ng client ang mga halaga ng katangian (Read), sumulat ng mga bagong halaga (Write) o mag-subscribe sa mga notipikasyon (Set Notify/Indicate). Ang GATT Server ay maaaring magpadala ng Notify/Indicate sa client anumang oras pagkatapos maitatag ang koneksyon.

MTU — maximum na laki ng packet

Bilang default, ang laki ng isang GATT packet (MTU, Maximum Transmission Unit) sa BLE ay 23 bytes, kung saan 3 bytes ay ATT header at 20 bytes ay kapaki-pakinabang na data. Kung kailangan ng application na magpadala ng mas maraming data (halimbawa, OTA firmware update), maaaring humiling ng pagtaas ng MTU sa 517 bytes sa pamamagitan ng requestMtu() sa Android. Ang pinalaking MTU ay nagbabawas ng bilang ng mga packet na kailangan para magpadala ng isang block ng data — sa halip na 50 maliliit na packet, maaaring magpadala ng 2 malalaking packet, na nagbabawas ng konsumo ng kuryente at nagpapabilis ng transmisyon. Ang maximum na MTU ay depende sa bersyon ng BLE at kakayahan ng chip — Bluetooth 5.0 ay sumusuporta hanggang 517 bytes, mas lumang bersyon hanggang 247 bytes.

// Mag-subscribe sa mga notipikasyon ng katangian
fun enableNotifications(gatt: BluetoothGatt, characteristic: BluetoothGattCharacteristic) {
    gatt.setCharacteristicNotification(characteristic, true)

    // Paganahin ang CCCD (Client Characteristic Configuration Descriptor)
    val cccdUuid = UUID.fromString("00002902-0000-1000-8000-00805f9b34fb")
    val descriptor = characteristic.getDescriptor(cccdUuid)
    descriptor?.let {
        it.setValue(BluetoothGattDescriptor.ENABLE_NOTIFICATION_VALUE)
        gatt.writeDescriptor(it)
    }
}

Pamamahala ng mga notipikasyon

Para makatanggap ng mga notipikasyon mula sa GATT Server sa Android, kailangang i-implement ang callback na BluetoothGattCallback.onCharacteristicChanged(). Sa pamamaraang ito, natatanggap ng application ang updated na halaga ng katangian tuwing nagpapadala ang server ng Notify o Indicate. Para sa real-time na pagproseso ng data, gumamit ng buffer at Kotlin coroutines — ito ay pipigil sa pag-block ng UI thread sa panahon ng matinding notipikasyon (halimbawa, 100+ pulse reading bawat segundo). Sa mga indikasyon (Indicate), palaging tawagan ang gatt.sendResponse() sa panig ng server — sa Android client, ito ay awtomatikong pinamamahalaan.

Implementasyon ng GATT sa Android

Sa Android, ang paggawa sa GATT ay naipapatupad sa pamamagitan ng mga klase ng android.bluetooth package: BluetoothGatt (koneksyon), BluetoothGattService (serbisyo), BluetoothGattCharacteristic (katangian) at BluetoothGattDescriptor (deskriptor). Ang pagkonekta sa BLE device ay nagsisimula sa pagtawag ng BluetoothDevice.connectGatt() — ang pamamaraang ito ay nagbabalik ng BluetoothGatt, kung saan isinasagawa ang lahat ng kasunod na operasyon. Lahat ng GATT callback ay dumarating sa BluetoothGattCallback — ito ay isang asynchronous na interface na tinatawag sa parehong thread kung saan ginawa ang BluetoothGatt. Mahalaga: lahat ng GATT operation ay dapat isagawa nang sunud-sunod — ang sabay na pagtawag ng maraming operasyon sa iisang BluetoothGatt ay nagdudulot ng mga error.

Lifecycle ng GATT connection

Ang tamang pamamahala ng lifecycle ng GATT connection ay kritikal para sa stability ng BLE application. Pagkatapos tumawag ng connectGatt(), naghihintay ang application ng callback na onConnectionStateChange() na may STATE_CONNECTED. Pagkatapos ay awtomatikong sinisimulan ng system ang Service Discovery, pagkatapos nito ay tinatawag ang onServicesDiscovered(). Pagkatapos lamang nito maaaring isagawa ang pagbasa, pagsulat at pag-subscribe. Pagkatapos ng trabaho, palaging tawagan ang gatt.close() sa onDestroy() o onPause() — ang mga hindi saradong GATT connection ay kumokonsumo ng baterya at maaaring harangan ang muling pagkonekta sa parehong device sa Android.

// Kumonekta sa BLE device sa pamamagitan ng GATT
private val gattCallback = object : BluetoothGattCallback() {
    override fun onConnectionStateChange(
        gatt: BluetoothGatt, status: Int, newState: Int
    ) {
        if (newState == BluetoothProfile.STATE_CONNECTED) {
            gatt.discoverServices()
        }
    }

    override fun onServicesDiscovered(gatt: BluetoothGatt, status: Int) {
        val service = gatt.getService(UUID.fromString("180D"))
        val characteristic = service?.getCharacteristic(
            UUID.fromString("2A37")
        )
        characteristic?.let { enableNotifications(gatt, it) }
    }
}

Standard na GATT profile at serbisyo

Bluetooth SIG (Special Interest Group) ay tumutukoy ng dose-dosenang standard na GATT profile at serbisyo na may fixed na 16-bit na UUID. Ang pinakakaraniwan: serbisyong Battery Service (UUID 180F, katangiang Battery Level 2A19), serbisyong Heart Rate (UUID 180D, katangiang Heart Rate Measurement 2A37), serbisyong Device Information (UUID 180A, katangiang Manufacturer Name, Serial Number). Ang paggamit ng standard na serbisyo ay ginagarantiyahan ang compatibility sa pagitan ng mga device mula sa iba't ibang manufacturer — anumang fitness bracelet na may Heart Rate service ay dapat gumana sa anumang Android app na sumusuporta dito.

Pagdidisenyo ng custom na GATT services

Kung hindi sasaklawin ng standard na serbisyo ang gawain, ang developer ay maaaring lumikha ng sariling GATT services na may 128-bit na UUID (custom na UUID). Sa pagdidisenyo ng custom na serbisyo, kailangan: tukuyin ang lohikal na grupo ng mga katangian (halimbawa, “Serbisyo ng Pamamahala ng Lock”), bigyan ang bawat katangian ng tamang properties (Read, Write, Notify), tukuyin ang mga pinapayagang halaga at unit ng pagsukat sa pamamagitan ng descriptor na Characteristic Presentation Format. Para sa mga kumplikadong protokol, inirerekomenda na isama sa serbisyo ang Command na katangian na may Write property at Status na katangian na may Notify — ito ay tumutugma sa Command/Status pattern na tinanggap sa industrial na BLE application.

// Gumawa ng custom na GATT service (Android bilang GATT Server)
private fun createCustomService(): BluetoothGattService {
    val serviceUuid = UUID.fromString("12345678-1234-5678-1234-56789abcdef0")
    val service = BluetoothGattService(
        serviceUuid, BluetoothGattService.SERVICE_TYPE_PRIMARY
    )

    val charUuid = UUID.fromString("12345678-1234-5678-1234-56789abcdef1")
    val characteristic = BluetoothGattCharacteristic(
        charUuid,
        BluetoothGattCharacteristic.PROPERTY_READ or
        BluetoothGattCharacteristic.PROPERTY_NOTIFY,
        BluetoothGattCharacteristic.PERMISSION_READ
    )
    service.addCharacteristic(characteristic)
    return service
}