Tetap teratur dengan koleksi Simpan dan kategorikan konten berdasarkan preferensi Anda.
Sinyal Iklan Penyedia
Iklan: Saat dapat ditemukan
Jika perangkat Penyedia dapat ditemukan BR/EDR (yaitu, dalam mode penyambungan), perangkat tersebut akan mengiklankan Data ID Model Sambungan Cepat melalui BLE, dan alamat BLE tidak boleh diputar.
Interval iklan: Saat dapat ditemukan
Interval antar-iklan tidak boleh lebih besar dari 100 md (10 Hz). Kecepatan cepat memungkinkan Pencari menemukan Penyedia dengan cepat, bahkan saat memindai dalam mode daya rendah.
Payload iklan: Data ID Model Sambungan Cepat
Iklan harus berisi jenis data Data Layanan, ibid., § 1.11. UUID akan berupa UUID Layanan Sambungan Cepat dari 0xFE2C. Data layanan harus berisi hal berikut:
Oktet
Jenis data
Deskripsi
Nilai
0-2
uint24
ID model 24-bit
bervariasi
Iklan: Jika tidak dapat ditemukan
Jika tidak dapat ditemukan (yaitu, tidak dalam mode penyambungan), perangkat Penyedia harus mengumumkan Data Akun Sambungan Cepat, menggunakan panduan berikut.
Dengan mengiklankan data akun, Pencari di sekitar dapat mengenali saat penyedia milik akun mereka dan memulai penyambungan tanpa harus memaksa penyedia kembali ke mode penyambungan terlebih dahulu, yang merupakan penyebab umum keluhan pengguna. Pencari akan memberikan kesempatan bagi pengguna untuk dapat mengabaikan siaran ini jika mereka tidak menunggu untuk disambungkan dengan penyedia atau siaran tidak relevan (misalnya, jika mereka sudah disambungkan). Pencari juga akan otomatis memfilter siaran yang jelas-jelas buruk, seperti saat data akun salah dikonfigurasi.
Interval iklan: Jika tidak dapat ditemukan
Interval antara iklan tidak boleh lebih dari 250 md (4 Hz).
Payload iklan: Data Akun Sambungan Cepat
Iklan harus berisi jenis data Data Layanan, Ibid., § 1.11. UUID akan berupa UUID Layanan Sambungan Cepat dari 0xFE2C. Data layanan harus berisi hal berikut:
Oktet
Jenis data
Deskripsi
Nilai
0
uint8
Versi dan tanda 0bVVVVFFFF
V = versi
F = flag
0x00 (disimpan untuk penggunaan di masa mendatang)
1 - bervariasi
Data Kunci Akun
bervariasi
Data Kunci Akun berisi:
Oktet
Jenis data
Deskripsi
Nilai
0
uint8
Panjang dan jenis kolom 0bLLLLTTTT
L = panjang filter kunci akun dalam byte
T = jenis
0bLLLL0000
length = 0bLLLL = bervariasi
type = 0b0000 (tampilkan indikasi UI) atau 0b0010 (sembunyikan indikasi UI), Filter Kunci Akun
Filter Kunci Akun yang diiklankan memungkinkan Pencari memeriksa dengan cepat apakah Penyedia mungkin memiliki kunci akun tertentu (dengan probabilitas positif palsu yang rendah, rata-rata jauh di bawah 0,5%), sebelum interaksi lebih lanjut. Pencari dapat otomatis terhubung dan mencoba memulai prosedur saat melihat filter yang disiarkan dengan jenis 0, yaitu menunjukkan indikasi UI, yang berpotensi berisi salah satu kunci akunnya, sehingga dapat mengurangi tingkat positif palsu lebih lanjut. Dalam beberapa situasi, Penyedia mungkin ingin dikenali oleh Pencari saat belum siap untuk penyambungan. Salah satu contohnya adalah saat bud dimasukkan kembali ke dalam casing, kita ingin berhenti menampilkan notifikasi penyambungan berikutnya karena penyambungan tersebut dapat ditolak oleh headset.
Filter Kunci Akun adalah filter Bloom berpanjang variabel yang dibuat sebagai berikut:
Misalkan n adalah jumlah kunci akun (n >= 1) dalam Daftar Kunci Akun yang dipertahankan.
Misalkan s, ukuran filter dalam byte, adalah (1,2*n + 3) yang terpotong. Misalnya, jika 1 kunci dipertahankan, s = 4 byte. uint8_t s = (((uint8_t)(( float )1.2 * n)) + 3);
Lakukan inisialisasi filter F sebagai array byte s, yang masing-masing ditetapkan ke 0. uint8_t F[s] = {0};
Untuk setiap kunci akun K dalam Daftar Kunci Akun yang dipertahankan: a. Misalkan V adalah concat(K, Salt).
// In the sample code, the size of salt is 2 bytes.#define SALT_SIZE 2uint8_tV[FASTPAIR_ACCOUNT_KEY_SIZE+SALT_SIZE];for(uint8_tkeyIndex=0;keyIndex < n;keyIndex++){// concat (K, Salt)fastpair_get_account_key_by_index(keyIndex,V);uint8_trandomSalt=(uint8_t)rand();V[FASTPAIR_ACCOUNT_KEY_SIZE]=randomSalt;...}
b. Buat hash V menggunakan SHA256, yang menghasilkan nilai 32 byte H = {H0, …, H31}.
uint8_tH[32]={0};SHA256_hash_function(V,H);
c. Bagi H menjadi delapan bilangan bulat tanpa tanda tangan 4 byte dalam big-endian, X = {X0, …, X7}, dengan X0 = 0xH0H1H2H3.
d. Untuk setiap Xi: i. Misalkan M adalah Xi modulo jumlah bit dalam filter, (s * 8). ii. Dapatkan byte dalam F pada indeks (M / 8), dibulatkan ke bawah. iii. Dalam byte, tetapkan bit pada indeks (M % 8) ke 1. iv. Dengan kata lain:
// M = Xi % (s * 8)// F[M/8] = F[M/8] | (1 << (M % 8))for(index=0;index < 8;index++){uint32_tM=X[index]%(s*8);F[M/8]=F[M/8]|(1 << (M%8));}
Sertakan filter F sebagai kolom Filter Kunci Akun, dalam data iklan. Perhatikan bahwa tidak ada "endianness" untuk nilai ini, karena tidak ada byte yang lebih atau kurang signifikan—jangan ubah urutan byte.
Ladang garam
Salt adalah nilai acak yang ditambahkan ke kunci akun saat membuat filter bloom. Salt ini harus dibuat ulang setiap kali RPA diperbarui untuk Penyedia guna menghindari pelacakan di seluruh rotasi alamat.
Untuk membuat Filter Kunci Akun menggunakan salt:
Buat S 2 byte acak. Perhatikan bahwa tidak ada "endianness" untuk nilai ini, karena tidak ada byte yang lebih atau kurang signifikan — jangan ubah urutan byte.
Gunakan S 2 byte sebagai Salt.
Dalam Data Akun Sambungan Cepat yang diiklankan, sertakan filter yang dihasilkan di kolom Filter Kunci Akun, dan S di kolom Salt.
[[["Mudah dipahami","easyToUnderstand","thumb-up"],["Memecahkan masalah saya","solvedMyProblem","thumb-up"],["Lainnya","otherUp","thumb-up"]],[["Informasi yang saya butuhkan tidak ada","missingTheInformationINeed","thumb-down"],["Terlalu rumit/langkahnya terlalu banyak","tooComplicatedTooManySteps","thumb-down"],["Sudah usang","outOfDate","thumb-down"],["Masalah terjemahan","translationIssue","thumb-down"],["Masalah kode / contoh","samplesCodeIssue","thumb-down"],["Lainnya","otherDown","thumb-down"]],["Terakhir diperbarui pada 2025-08-13 UTC."],[[["\u003cp\u003eProvider devices advertise Fast Pair Model ID Data over BLE when in pairing mode to enable quick discovery by Seeker devices.\u003c/p\u003e\n"],["\u003cp\u003eWhen not discoverable, Provider devices advertise Fast Pair Account Data, allowing Seekers to recognize them and initiate pairing without requiring the Provider to re-enter pairing mode.\u003c/p\u003e\n"],["\u003cp\u003eThe Account Key Filter, a Bloom filter included in the Account Key Data, helps Seekers quickly assess the potential presence of a specific account key on the Provider, reducing false positives and unnecessary pairing attempts.\u003c/p\u003e\n"],["\u003cp\u003eThe salt, a random value appended to account keys during Bloom filter construction, is regenerated with each Provider RPA update to prevent tracking across address rotations, enhancing privacy.\u003c/p\u003e\n"]]],[],null,["Provider Advertising signal\n\nAdvertising: When discoverable\n\nWhen the Provider device is BR/EDR discoverable (that is, in pairing mode), it\nshall advertise Fast Pair Model ID Data over BLE, and the BLE address shall not\nbe rotated.\n\nAdvertising interval: When discoverable\n\nThe interval between advertisements should be no larger than 100ms (10Hz). A\nfast rate allows the Seeker to quickly find the Provider, even when scanning in\nlow-power mode.\n\nAdvertising payload: Fast Pair Model ID Data\n\nThe advertisement shall contain the Service Data data type, ibid., § 1.11. The\nUUID shall be the Fast Pair Service UUID of `0xFE2C`. The service data shall\ncontain the following:\n\n| Octet | Data type | Description | Value |\n|-------|-----------|-----------------|----------|\n| 0-2 | `uint24` | 24-bit model ID | *varies* |\n\nAdvertising: When not discoverable\n\nWhen not discoverable (that is, not in pairing mode), the Provider device shall\nadvertise Fast Pair Account Data, using the following guidelines.\n\nAdvertising the account data allows Seekers nearby to recognize when a provider\nbelongs to their account and initiate pairing without having to force the\nprovider back into pairing mode first, which is a common cause for user\ncomplaint. Seekers will provide the opportunity for users to be able to ignore\nthis broadcast in the case where they do not wait to pair with the provider or\nthe broadcast is not relevant (for example, if they have already paired).\nSeekers will also filter out obviously bad broadcasts automatically, such as\nwhen the account data is misconfigured.\n\nAdvertising interval: When not discoverable\n\nThe interval between advertisements should be at most 250ms (4Hz).\n\nAdvertising payload: Fast Pair Account Data\n\nThe advertisement shall contain the Service Data data type, Ibid., § 1.11. The\nUUID shall be the Fast Pair Service UUID of `0xFE2C`. The service data shall\ncontain the following:\n\n| Octet | Data type | Description | Value |\n|--------------|-----------|--------------------------------------------------------|----------------------------------|\n| 0 | `uint8` | Version and flags 0bVVVVFFFF - V = version - F = flags | `0x00` (reserved for future use) |\n| 1 - *varies* | | Account Key Data | *varies* |\n\n| **Note:** The provider shall advertise its Fast PairAccount Data only if the Account Key List has one or more entries.\n\nThe Account Key Data contains:\n\n| Octet | Data type | Description | Value |\n|-------------------|-----------|-----------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------|\n| 0 | `uint8` | Field length and type 0bLLLLTTTT - L = length of account key filter in bytes - T = type | 0bLLLL0000 - length = 0bLLLL = *varies* - type = 0b0000 (show UI indication) or 0b0010 (hide UI indication), Account Key Filter |\n| 1 - *s* | | Account Key Filter | *varies* |\n| *s* + 1 | `uint8` | Field length and type 0bLLLLTTTT - L = length in bytes - T = type | 0b00100001 - length = 0b0010 = 2 - type = 0b0001, [Salt](#SaltField) |\n| *s* + 2 - *s* + 3 | `uint16` | Salt | *varies* |\n\nAccount Key Filter **Note:** Google recommends implementing the [Cryptographic Test Cases](/nearby/fast-pair/specifications/appendix/cryptotestcases \"Link to the Cryptographic Test Cases.\") to ease verification of these requirements.\n\nThe advertised Account Key Filter allows a Seeker to quickly check whether a\nProvider might possess a certain account key (with a low false-positive\nprobability, on average much less than 0.5%), before further interactions. The\nSeeker may automatically connect and attempt to start the procedure when it sees\na filter being broadcast with type 0, i.e. showing UI indication, that\npotentially contains one of its account keys, so as to reduce the rate of false\npositives further. In some situations, the Provider may want to be recognized\nby the Seeker while not ready for pairing. One example is that when buds get put\nback into case, we want to stop showing the subsequent pairing notification\nsince that pairing could be rejected by the headset.\n\nThe Account Key Filter is a variable-length\n[Bloom filter](https://en.wikipedia.org/wiki/Bloom_filter) constructed as\nfollows:\n\n1. Let *n* be the number of account keys (*n* \\\u003e= 1) in the persisted [Account Key list](/nearby/fast-pair/specifications/configuration#AccountKeyList \"Account Key List\").\n2. Let *s* , the size of the filter in bytes, be (1.2\\**n* + 3) truncated. For example, if 1 key is persisted, *s* = 4 bytes. \n `uint8_t s = (((uint8_t)(( float )1.2 * n)) + 3);`\n3. Initialize the filter *F* as an array of *s* bytes, each set to 0. \n `uint8_t F[s] = {0};`\n4. For each account key *K* in the persisted [Account Key list](/nearby/fast-pair/specifications/configuration#AccountKeyList \"Account Key List\"): \n\n a. Let *V* be concat(*K* , [Salt](#SaltField)). \n\n // In the sample code, the size of salt is 2 bytes.\n #define SALT_SIZE 2\n\n uint8_t V[FASTPAIR_ACCOUNT_KEY_SIZE + SALT_SIZE];\n for (uint8_t keyIndex = 0; keyIndex \u003c n; keyIndex++)\n {\n // concat (K, Salt)\n fastpair_get_account_key_by_index(keyIndex, V);\n\n uint8_t randomSalt = (uint8_t)rand();\n V[FASTPAIR_ACCOUNT_KEY_SIZE] = randomSalt;\n ... }\n\n b. Hash *V* using SHA256, obtaining a 32-byte value *H* =\n {H~0~, ..., H~31~}. \n\n uint8_t H[32] = {0};\n SHA256_hash_function(V, H);\n\n c. Divide *H* into eight 4-byte unsigned integers in big-endian,\n X = {X~0~, ..., X~7~}, where\n X~0~ = 0xH~0~H~1~H~2~H~3~. \n\n uint32_t X[8];\n for (index = 0; index \u003c 8; index++)\n {\n X[index] = (((uint32_t)(H[index * 4])) \u003c\u003c 24) |\n (((uint32_t)(H[index * 4 + 1])) \u003c\u003c 16) |\n (((uint32_t)(H[index * 4 + 2])) \u003c\u003c 8) |\n (((uint32_t)(H[index * 4 + 3])) \u003c\u003c 0);\n }\n\n d. For each X~i~: \n\n i. Let *M* be *X~i~* modulo the number of bits in the filter,\n (*s* \\* 8). \n\n ii. Get the byte in *F* at index (*M* / 8), rounded down. \n\n iii. Within the byte, set the bit at index (*M* % 8) to 1. \n\n iv. In other words: \n\n // M = Xi % (s * 8)\n // F[M/8] = F[M/8] | (1 \u003c\u003c (M % 8))\n for (index = 0; index \u003c 8; index++)\n {\n uint32_t M = X[index] % (s * 8);\n F[M / 8] = F[M / 8] | (1 \u003c\u003c (M % 8));\n }\n\nInclude the filter *F* as the Account Key Filter field, in the advertising data.\nNote that there is no \"endianness\" to this value, since there is no more or less\nsignificant byte---don't alter the byte order.\n\nSalt field\n\nThe salt is a random value that is appended to account keys when building the\nbloom filter. This salt should be regenerated every time the RPA is updated for\nthe Provider to avoid tracking across address rotation.\n\nTo generate the Account Key Filter using the salt:\n\n1. Generate a random 2-byte *S*. Note that there is no \"endianness\" to this value, since there is no more or less significant byte --- don't alter the byte order.\n2. Use the 2-byte *S* as the Salt.\n3. In the advertised Fast Pair Account Data, include the generated filter in the Account Key Filter field, and *S* in the Salt field."]]