@jjlmoya/utils-hardware 1.24.0 → 1.25.0

package/src/tool/webBluetoothBleScanner/component.astro

@@ -0,0 +1,339 @@
+---
+import { Icon } from 'astro-icon/components';
+import type { KnownLocale } from '../../types';
+import type { WebBluetoothBleScannerUI } from './ui';
+
+interface Props {
+  locale?: KnownLocale;
+  ui?: Record<string, unknown>;
+}
+
+const { ui } = Astro.props;
+const t = (ui ?? {}) as WebBluetoothBleScannerUI;
+---
+
+<div
+  class="wbb-root"
+  data-config={JSON.stringify({
+    unsupportedTitle: t.unsupportedTitle,
+    unsupportedBody: t.unsupportedBody,
+    secureContext: t.secureContext,
+    scanning: t.scanning,
+    reconnect: t.reconnect,
+    disconnect: t.disconnect,
+    deviceLabel: t.deviceLabel,
+    nameFallback: t.nameFallback,
+    idLabel: t.idLabel,
+    servicesLabel: t.servicesLabel,
+    noServices: t.noServices,
+    statusIdle: t.statusIdle,
+    statusPermission: t.statusPermission,
+    statusConnecting: t.statusConnecting,
+    statusConnected: t.statusConnected,
+    statusDisconnected: t.statusDisconnected,
+    statusCancelled: t.statusCancelled,
+    statusUnavailable: t.statusUnavailable,
+    statusError: t.statusError,
+    signalUnknown: t.signalUnknown,
+    gattUnavailable: t.gattUnavailable,
+    customServiceName: t.customServiceName,
+    serviceGenericAccess: t.serviceGenericAccess,
+    serviceGenericAttribute: t.serviceGenericAttribute,
+    serviceDeviceInformation: t.serviceDeviceInformation,
+    serviceHeartRate: t.serviceHeartRate,
+    serviceBattery: t.serviceBattery,
+    serviceHumanInterfaceDevice: t.serviceHumanInterfaceDevice,
+    serviceCyclingSpeedCadence: t.serviceCyclingSpeedCadence,
+    serviceEnvironmentalSensing: t.serviceEnvironmentalSensing,
+    serviceUserData: t.serviceUserData,
+    serviceFitnessMachine: t.serviceFitnessMachine,
+    uuidHelp: t.uuidHelp,
+    serviceCountSingular: t.serviceCountSingular,
+    serviceCountPlural: t.serviceCountPlural,
+  })}
+>
+  <section class="wbb-shell">
+    <div class="wbb-radar" aria-hidden="true">
+      <span><Icon name="mdi:bluetooth" /></span>
+      <i></i>
+      <b></b>
+      <em></em>
+    </div>
+
+    <div class="wbb-console">
+      <div class="wbb-status">
+        <span data-status-dot></span>
+        <strong data-status>{t.statusIdle}</strong>
+      </div>
+
+      <button type="button" class="wbb-scan" data-scan>
+        <Icon name="mdi:bluetooth-searching" />
+        <span>{t.scanButton}</span>
+      </button>
+
+      <aside class="wbb-privacy">
+        <Icon name="mdi:shield-lock-outline" />
+        <span>
+          <strong>{t.privacyTitle}</strong>
+          <small>{t.privacyBody}</small>
+        </span>
+      </aside>
+
+      <div class="wbb-device-list" data-device-list aria-live="polite"></div>
+
+      <p class="wbb-hint">{t.compatibilityHint}</p>
+    </div>
+  </section>
+</div>
+
+<link rel="stylesheet" href="./web-bluetooth-ble-scanner.css" />
+
+<script>
+  interface Config {
+    unsupportedTitle: string;
+    unsupportedBody: string;
+    secureContext: string;
+    scanning: string;
+    reconnect: string;
+    disconnect: string;
+    deviceLabel: string;
+    nameFallback: string;
+    idLabel: string;
+    servicesLabel: string;
+    noServices: string;
+    statusIdle: string;
+    statusPermission: string;
+    statusConnecting: string;
+    statusConnected: string;
+    statusDisconnected: string;
+    statusCancelled: string;
+    statusUnavailable: string;
+    statusError: string;
+    signalUnknown: string;
+    gattUnavailable: string;
+    customServiceName: string;
+    serviceGenericAccess: string;
+    serviceGenericAttribute: string;
+    serviceDeviceInformation: string;
+    serviceHeartRate: string;
+    serviceBattery: string;
+    serviceHumanInterfaceDevice: string;
+    serviceCyclingSpeedCadence: string;
+    serviceEnvironmentalSensing: string;
+    serviceUserData: string;
+    serviceFitnessMachine: string;
+    uuidHelp: string;
+    serviceCountSingular: string;
+    serviceCountPlural: string;
+  }
+
+  type BluetoothRequestDeviceFilter = { services?: BluetoothServiceUUID[]; name?: string; namePrefix?: string };
+  interface BluetoothRemoteGATTServiceLike {
+    uuid: string;
+  }
+  interface BluetoothRemoteGATTServerLike {
+    connected: boolean;
+    connect: () => Promise<BluetoothRemoteGATTServerLike>;
+    disconnect: () => void;
+    getPrimaryServices: () => Promise<BluetoothRemoteGATTServiceLike[]>;
+  }
+  interface BluetoothDeviceLike extends EventTarget {
+    id: string;
+    name?: string;
+    gatt?: BluetoothRemoteGATTServerLike;
+  }
+  interface BluetoothNavigator {
+    bluetooth?: {
+      getAvailability?: () => Promise<boolean>;
+      requestDevice: (options: {
+        acceptAllDevices?: boolean;
+        filters?: BluetoothRequestDeviceFilter[];
+        optionalServices?: BluetoothServiceUUID[];
+      }) => Promise<BluetoothDeviceLike>;
+    };
+  }
+
+  const root = document.querySelector<HTMLElement>('.wbb-root');
+  const config = JSON.parse(root?.dataset.config ?? '{}') as Config;
+  const button = root?.querySelector<HTMLButtonElement>('[data-scan]');
+  const status = root?.querySelector<HTMLElement>('[data-status]');
+  const statusDot = root?.querySelector<HTMLElement>('[data-status-dot]');
+  const list = root?.querySelector<HTMLElement>('[data-device-list]');
+  const optionalServices: BluetoothServiceUUID[] = [
+    'generic_access',
+    'generic_attribute',
+    'device_information',
+    'battery_service',
+    'heart_rate',
+    'human_interface_device',
+    'cycling_speed_and_cadence',
+    'environmental_sensing',
+    'user_data',
+    'fitness_machine',
+  ];
+  const serviceNames: Record<string, string> = {
+    '00001800-0000-1000-8000-00805f9b34fb': config.serviceGenericAccess,
+    '00001801-0000-1000-8000-00805f9b34fb': config.serviceGenericAttribute,
+    '0000180a-0000-1000-8000-00805f9b34fb': config.serviceDeviceInformation,
+    '0000180d-0000-1000-8000-00805f9b34fb': config.serviceHeartRate,
+    '0000180f-0000-1000-8000-00805f9b34fb': config.serviceBattery,
+    '00001812-0000-1000-8000-00805f9b34fb': config.serviceHumanInterfaceDevice,
+    '00001816-0000-1000-8000-00805f9b34fb': config.serviceCyclingSpeedCadence,
+    '0000181a-0000-1000-8000-00805f9b34fb': config.serviceEnvironmentalSensing,
+    '0000181c-0000-1000-8000-00805f9b34fb': config.serviceUserData,
+    '00001826-0000-1000-8000-00805f9b34fb': config.serviceFitnessMachine,
+  };
+  let activeDevice: BluetoothDeviceLike | undefined;
+
+  function hasBluetoothSupport() {
+    return Boolean((navigator as BluetoothNavigator).bluetooth?.requestDevice);
+  }
+
+  async function hasAvailableBluetoothAdapter() {
+    const bluetooth = (navigator as BluetoothNavigator).bluetooth;
+    if (!bluetooth?.getAvailability) return true;
+    return bluetooth.getAvailability();
+  }
+
+  function setStatus(message: string, state: 'idle' | 'busy' | 'ok' | 'warn' | 'error' = 'idle') {
+    if (status) status.textContent = message;
+    statusDot?.setAttribute('data-state', state);
+    root?.setAttribute('data-state', state);
+  }
+
+  function serviceName(uuid: string) {
+    return serviceNames[uuid.toLowerCase()] ?? config.customServiceName;
+  }
+
+  function renderSupportWarning(title: string, body: string) {
+    if (!list) return;
+    list.innerHTML = `
+      <article class="wbb-card wbb-warning">
+        <div>
+          <strong>${title}</strong>
+          <p>${body}</p>
+        </div>
+      </article>
+    `;
+  }
+
+  function renderServiceRows(services: BluetoothRemoteGATTServiceLike[]) {
+    if (services.length === 0) return `<li class="wbb-empty">${config.noServices}</li>`;
+
+    return services.map((service) => `
+      <li>
+        <span>${serviceName(service.uuid)}</span>
+        <code>${service.uuid}</code>
+      </li>
+    `).join('');
+  }
+
+  function renderDeviceCard(device: BluetoothDeviceLike, services: BluetoothRemoteGATTServiceLike[], connected: boolean) {
+    const name = device.name || config.nameFallback;
+    const countLabel = services.length === 1 ? config.serviceCountSingular : config.serviceCountPlural;
+
+    return `
+      <article class="wbb-card">
+        <div class="wbb-card-head">
+          <span>${config.deviceLabel}</span>
+          <strong>${name}</strong>
+        </div>
+        <dl>
+          <div>
+            <dt>${config.idLabel}</dt>
+            <dd><code>${device.id}</code></dd>
+          </div>
+          <div>
+            <dt>${config.servicesLabel}</dt>
+            <dd>${services.length} ${countLabel}</dd>
+          </div>
+        </dl>
+        <ul>${renderServiceRows(services)}</ul>
+        <p>${config.uuidHelp}</p>
+        <button type="button" data-disconnect>${connected ? config.disconnect : config.reconnect}</button>
+      </article>
+    `;
+  }
+
+  function renderDevice(device: BluetoothDeviceLike, services: BluetoothRemoteGATTServiceLike[], connected: boolean) {
+    if (!list) return;
+    list.innerHTML = renderDeviceCard(device, services, connected);
+
+    list.querySelector<HTMLButtonElement>('[data-disconnect]')?.addEventListener('click', () => {
+      if (activeDevice?.gatt?.connected) {
+        activeDevice.gatt.disconnect();
+        setStatus(config.statusDisconnected, 'warn');
+        renderDevice(activeDevice, services, false);
+      } else {
+        scan();
+      }
+    });
+  }
+
+  async function canStartScan() {
+    if (!hasBluetoothSupport()) {
+      setStatus(config.statusError, 'error');
+      renderSupportWarning(config.unsupportedTitle, config.unsupportedBody);
+      return false;
+    }
+    if (!window.isSecureContext) {
+      setStatus(config.statusError, 'error');
+      renderSupportWarning(config.unsupportedTitle, config.secureContext);
+      return false;
+    }
+    if (!(await hasAvailableBluetoothAdapter())) {
+      setStatus(config.statusUnavailable, 'error');
+      renderSupportWarning(config.unsupportedTitle, config.statusUnavailable);
+      return false;
+    }
+
+    return true;
+  }
+
+  async function requestSelectedDevice() {
+    setStatus(config.statusPermission, 'busy');
+    return (navigator as BluetoothNavigator).bluetooth!.requestDevice({
+      acceptAllDevices: true,
+      optionalServices,
+    });
+  }
+
+  async function connectDevice(device: BluetoothDeviceLike) {
+    activeDevice = device;
+    device.addEventListener('gattserverdisconnected', () => {
+      setStatus(config.statusDisconnected, 'warn');
+    });
+    setStatus(config.statusConnecting, 'busy');
+    const server = await device.gatt?.connect();
+    if (!server) {
+      setStatus(config.gattUnavailable, 'warn');
+      renderDevice(device, [], false);
+      return;
+    }
+    const services = await server.getPrimaryServices();
+    renderDevice(device, services, server.connected);
+    setStatus(config.statusConnected, 'ok');
+  }
+
+  function handleScanError(error: unknown) {
+    const isNotFound = error instanceof DOMException && error.name === 'NotFoundError';
+    setStatus(isNotFound ? config.statusCancelled : config.statusError, isNotFound ? 'warn' : 'error');
+  }
+
+  async function scan() {
+    if (!(await canStartScan())) return;
+    try {
+      if (button) button.disabled = true;
+      await connectDevice(await requestSelectedDevice());
+    } catch (error) {
+      handleScanError(error);
+    } finally {
+      if (button) button.disabled = false;
+    }
+  }
+
+  button?.addEventListener('click', scan);
+  if (!hasBluetoothSupport()) {
+    renderSupportWarning(config.unsupportedTitle, config.unsupportedBody);
+  }
+</script>

package/src/tool/webBluetoothBleScanner/entry.ts

@@ -0,0 +1,29 @@
+import type { HardwareToolEntry, ToolLocaleContent } from '../../types';
+import type { WebBluetoothBleScannerUI } from './ui';
+
+export type WebBluetoothBleScannerLocaleContent = ToolLocaleContent<WebBluetoothBleScannerUI>;
+
+export const webBluetoothBleScanner: HardwareToolEntry<WebBluetoothBleScannerUI> = {
+  id: 'web-bluetooth-ble-scanner',
+  icons: {
+    bg: 'mdi:bluetooth',
+    fg: 'mdi:access-point-network',
+  },
+  i18n: {
+    de: () => import('./i18n/de').then((m) => m.content),
+    en: () => import('./i18n/en').then((m) => m.content),
+    es: () => import('./i18n/es').then((m) => m.content),
+    fr: () => import('./i18n/fr').then((m) => m.content),
+    id: () => import('./i18n/id').then((m) => m.content),
+    it: () => import('./i18n/it').then((m) => m.content),
+    ja: () => import('./i18n/ja').then((m) => m.content),
+    ko: () => import('./i18n/ko').then((m) => m.content),
+    nl: () => import('./i18n/nl').then((m) => m.content),
+    pl: () => import('./i18n/pl').then((m) => m.content),
+    pt: () => import('./i18n/pt').then((m) => m.content),
+    ru: () => import('./i18n/ru').then((m) => m.content),
+    sv: () => import('./i18n/sv').then((m) => m.content),
+    tr: () => import('./i18n/tr').then((m) => m.content),
+    zh: () => import('./i18n/zh').then((m) => m.content),
+  },
+};

package/src/tool/webBluetoothBleScanner/i18n/de.ts

@@ -0,0 +1,233 @@
+import type { WithContext, FAQPage, HowTo, SoftwareApplication } from 'schema-dts';
+import type { ToolLocaleContent } from '../../../types';
+import type { WebBluetoothBleScannerUI } from '../ui';
+import { bibliography } from '../bibliography';
+
+const slug = 'web-bluetooth-ble-suche';
+const title = 'Web Bluetooth BLE Suche';
+const description = 'Scannen Sie Bluetooth Low Energy Geräte in der Nähe aus dem Browser, prüfen Sie die offengelegten GATT-Service-UUIDs und testen Sie, ob Ihre IoT- oder Wearable-Hardware auffindbar ist.';
+
+const faqData = [
+  {
+    question: 'Kann eine Website ohne Erlaubnis Bluetooth-Geräte scannen?',
+    answer: 'Nein. Web Bluetooth erfordert immer eine Nutzergeste und eine Berechtigungsauswahl des Browsers. Dieses Tool sieht nur das Gerät, das Sie ausdrücklich auswählen, und speichert keine MAC-Adressen, Geräte-IDs oder Scanergebnisse.',
+  },
+  {
+    question: 'Warum zeigt der Scanner nicht jedes BLE-Gerät in der Nähe an?',
+    answer: 'Browser stellen Bluetooth bewusst über eine Berechtigungsauswahl bereit, nicht als stillen Hintergrundscanner. Manche Geräte beenden zudem das Advertising, verbergen ihren Namen, erfordern Pairing oder legen Dienste erst nach einer Verbindung offen.',
+  },
+  {
+    question: 'Welche Browser unterstützen Web Bluetooth?',
+    answer: 'Web Bluetooth wird am besten in Chromium-basierten Desktop-Browsern wie Chrome und Edge unterstützt. Es erfordert in der Regel HTTPS oder localhost und ist in vielen Firefox-, Safari- und iOS-Browser-Konfigurationen nicht verfügbar.',
+  },
+  {
+    question: 'Kann dies private Sensordaten von einem Wearable lesen?',
+    answer: 'Nur wenn das Gerät kompatible GATT-Dienste bereitstellt und der Browser den Zugriff gewährt. Viele kommerzielle Wearables benötigen Hersteller-Apps, Verschlüsselung, Bonding oder proprietäre Eigenschaften, die ein generischer Browser-Scanner nicht entschlüsseln kann.',
+  },
+  {
+    question: 'Was sind GATT-Service-UUIDs?',
+    answer: 'Eine GATT-Service-UUID identifiziert eine Gruppe von Bluetooth-Low-Energy-Funktionen wie Batterie-Service, Herzfrequenz, Geräteinformationen oder einen benutzerdefinierten Herstellerdienst, der von Maker- und IoT-Hardware genutzt wird.',
+  },
+];
+
+const howToData = [
+  {
+    name: 'Kompatiblen Browser verwenden',
+    text: 'Öffnen Sie das Tool in Chrome oder Edge über HTTPS oder localhost und stellen Sie sicher, dass Bluetooth am Computer oder Telefon aktiviert ist.',
+  },
+  {
+    name: 'Hardware in den Advertising-Modus versetzen',
+    text: 'Aktivieren Sie das BLE-Gerät, schalten Sie es aus und wieder ein, drücken Sie die Pairing-Taste oder öffnen Sie den Advertising-Modus, damit es in der Berechtigungsauswahl des Browsers erscheint.',
+  },
+  {
+    name: 'Umgebung scannen',
+    text: 'Klicken Sie auf Umgebung scannen und wählen Sie das zu prüfende BLE-Gerät aus. Der Berechtigungsdialog des Browsers steuert genau, welches Gerät für die Seite sichtbar wird.',
+  },
+  {
+    name: 'GATT-Dienste auslesen',
+    text: 'Überprüfen Sie nach der Verbindung die Service-UUID-Karten, um Standard-Bluetooth-Profile, benutzerdefinierte Firmware-Dienste und die Frage zu identifizieren, ob das Gerät den erwarteten Datenpfad bereitstellt.',
+  },
+];
+
+const faqSchema: WithContext<FAQPage> = {
+  '@context': 'https://schema.org',
+  '@type': 'FAQPage',
+  mainEntity: faqData.map((item) => ({
+    '@type': 'Question',
+    name: item.question,
+    acceptedAnswer: { '@type': 'Answer', text: item.answer },
+  })),
+};
+
+const howToSchema: WithContext<HowTo> = {
+  '@context': 'https://schema.org',
+  '@type': 'HowTo',
+  name: title,
+  description,
+  step: howToData.map((step, i) => ({
+    '@type': 'HowToStep',
+    position: i + 1,
+    name: step.name,
+    text: step.text,
+  })),
+};
+
+const appSchema: WithContext<SoftwareApplication> = {
+  '@context': 'https://schema.org',
+  '@type': 'SoftwareApplication',
+  name: title,
+  description,
+  applicationCategory: 'DeveloperApplication',
+  operatingSystem: 'All',
+  offers: { '@type': 'Offer', price: '0', priceCurrency: 'USD' },
+  inLanguage: 'de',
+};
+
+export const content: ToolLocaleContent<WebBluetoothBleScannerUI> = {
+  slug,
+  title,
+  description,
+  faq: faqData,
+  bibliography,
+  howTo: howToData,
+  schemas: [faqSchema, howToSchema, appSchema],
+  seo: [
+    {
+      type: 'title',
+      text: 'BLE-Tester online für IoT, Wearables und Maker-Hardware',
+      level: 2,
+    },
+    {
+      type: 'paragraph',
+      html: 'Dieser Web-Bluetooth-Scanner ermöglicht es Ihnen zu testen, ob ein nahegelegenes Bluetooth-Low-Energy-Gerät aus einem Browser auffindbar ist und welche GATT-Dienste es nach erteilter Berechtigung bereitstellt. Er ist nützlich beim Debuggen von ESP32-Firmware, Arduino-BLE-Sketches, intelligenten Sensoren, Fitness-Wearables, Tastaturen, benutzerdefinierten Beacons, Umweltmonitoren und Prototyp-Hardware, bevor Sie eine native mobile App erstellen.',
+    },
+    {
+      type: 'message',
+      title: 'Datenschutzmodell',
+      html: 'GameBob speichert keine MAC-Adressen, Geräte-IDs, Namen, UUIDs, Signaldaten oder Scanverläufe. Die Berechtigungsauswahl des Browsers bestimmt, auf welches einzelne Gerät die Seite zugreifen darf, und die Ergebnisse verbleiben in Ihrer aktuellen Browser-Sitzung.',
+    },
+    {
+      type: 'table',
+      headers: ['Was Sie sehen', 'Was es bedeutet', 'Was als Nächstes zu prüfen ist'],
+      rows: [
+        ['Gerätename', 'Der per Advertising übertragene Bluetooth-Name, sofern die Hardware einen sendet.', 'Falls leer, überprüfen Sie die Advertising-Daten der Firmware oder nutzen Sie während des Tests ein bekanntes Namenspräfix.'],
+        ['Geräte-ID', 'Eine browserbezogene Kennung, nicht die tatsächliche öffentliche MAC-Adresse.', 'Nur für diese Browser-Sitzung verwenden; nicht als universelle Hardware-Seriennummer behandeln.'],
+        ['GATT-Service-UUIDs', 'Die Dienstgruppen, die nach Annahme der Verbindung offengelegt werden.', 'Vergleichen Sie Standard-UUIDs mit der Bluetooth-SIG-Liste oder Ihrer Firmware-Servicetabelle.'],
+        ['Benutzerdefinierter Dienst', 'Eine hersteller- oder projektspezifische UUID.', 'Öffnen Sie Ihre Firmware, das mobile App-Profil oder die BLE-Dokumentation, um Eigenschaften und Berechtigungen zuzuordnen.'],
+      ],
+    },
+    {
+      type: 'title',
+      text: 'Warum sich browserbasiertes Bluetooth-Scannen unterscheidet',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: 'Native BLE-Scanner-Apps zeigen oft fortlaufende Advertisements vieler nahegelegener Geräte an. Web Bluetooth ist bewusst strenger: Die Seite muss in einem sicheren Kontext geöffnet werden, der Scan muss durch einen Nutzerklick gestartet werden und der Browser zeigt eine Berechtigungsauswahl an. Dies schützt Nutzer vor stillem Tracking und gibt Entwicklern dennoch einen praktischen Weg, um von JavaScript aus eine Verbindung zur ausgewählten BLE-Hardware herzustellen.',
+    },
+    {
+      type: 'comparative',
+      items: [
+        {
+          title: 'Web Bluetooth Scanner',
+          description: 'Am besten für schnelle Firmware-Validierung, Demos, Support-Abläufe, Unterrichtslabore und browserbasierte Diagnose geeignet, wenn Installationshürden eine Rolle spielen.',
+        },
+        {
+          title: 'Native BLE App',
+          description: 'Besser für Hintergrundscans, RSSI-Protokollierung, Pairing-Workflows, verschlüsselte Herstellerprotokolle, große Eigenschaftsbäume und langfristige Felddiagnose.',
+        },
+      ],
+    },
+    {
+      type: 'title',
+      text: 'Häufige Gründe, warum ein BLE-Gerät nicht erscheint',
+      level: 3,
+    },
+    {
+      type: 'list',
+      items: [
+        'Bluetooth ist auf Betriebssystemebene deaktiviert oder der Browser besitzt keine Bluetooth-Berechtigung.',
+        'Das Gerät ist mit einem anderen Telefon, Laptop, einer Hersteller-App oder einem Gateway verbunden und hat das Advertising eingestellt.',
+        'Die Hardware sendet Advertisements nur für ein kurzes Zeitfenster nach dem Start oder nach dem Drücken einer Pairing-Taste.',
+        'Der Browser ist nicht Chromium-basiert, die Seite wird nicht über HTTPS bereitgestellt oder die Plattform blockiert Web Bluetooth.',
+        'Die Firmware überträgt Herstellerdaten, verbirgt aber den lokalen Namen, sodass die Auswahl ein namenloses Gerät anzeigen kann.',
+        'Das Gerät erfordert Bonding, Verschlüsselung oder proprietäre Authentifizierung, bevor Dienste lesbar werden.',
+      ],
+    },
+    {
+      type: 'title',
+      text: 'So verwenden Sie GATT-UUIDs beim Debugging',
+      level: 3,
+    },
+    {
+      type: 'paragraph',
+      html: 'Eine erfolgreiche Verbindung mit Service-UUIDs zeigt Ihnen, dass der Browser das Peripheriegerät erreichen kann und dass das Peripheriegerät zumindest einen Teil seiner GATT-Tabelle offenlegt. Standarddienste wie Batterie-Service, Geräteinformationen, Herzfrequenz, Human Interface Device und Umweltsensorik sind leicht zu erkennen. Benutzerdefinierte UUIDs verweisen meist auf firmwarespezifische Funktionen und benötigen die Eigenschaftstabelle aus Ihrem Quellcode oder der Herstellerdokumentation.',
+    },
+    {
+      type: 'table',
+      headers: ['Symptom', 'Wahrscheinliche Ursache', 'Praktische Abhilfe'],
+      rows: [
+        ['Berechtigungsauswahl ist leer', 'Gerät sendet kein Advertising oder Browser-Unterstützung fehlt.', 'Gerät neu starten, Pairing-Modus aktivieren, näher herangehen oder in Chrome/Edge erneut versuchen.'],
+        ['Verbindung schlägt sofort fehl', 'Gerät ist belegt, außer Reichweite oder lehnt die Browser-Verbindung ab.', 'Hersteller-Apps trennen und das Peripheriegerät in der Nähe des Computers halten.'],
+        ['Keine Dienste aufgelistet', 'GATT ist nicht verfügbar, Dienste sind verborgen oder der Zugriff wurde für diese UUIDs nicht gewährt.', 'Bekannte optionale Dienste in Firmware-Tests hinzufügen oder mit einem nativen BLE-Tool prüfen.'],
+        ['Nur benutzerdefinierte UUIDs erscheinen', 'Die Hardware verwendet herstellerspezifische Firmware-Dienste.', 'UUIDs Quellcode-Konstanten zuordnen und Lese-/Schreibberechtigungen der Eigenschaften dokumentieren.'],
+      ],
+    },
+    {
+      type: 'title',
+      text: 'Sicherheits- und Datenschutzgrenzen',
+      level: 3,
+    },
+    {
+      type: 'list',
+      items: [
+        'Die Seite kann nicht stillschweigend nahegelegene Bluetooth-Geräte im Hintergrund erfassen.',
+        'Der Browser kann echte MAC-Adressen verbergen und stattdessen eine sitzungsbezogene Geräte-ID bereitstellen.',
+        'Der Zugriff beginnt erst, nachdem der Nutzer auf die Scan-Schaltfläche klickt und ein Gerät auswählt.',
+        'Ergebnisse werden von GameBob weder hochgeladen noch gespeichert.',
+        'Sensible kommerzielle Geräte können eine Verschlüsselung oder einen Hersteller-Pairing-Ablauf erfordern, den dieser generische Scanner nicht umgehen kann.',
+      ],
+    },
+  ],
+  ui: {
+    unsupportedTitle: 'Web Bluetooth ist nicht verfügbar',
+    unsupportedBody: 'Versuchen Sie Chrome oder Edge auf dem Desktop oder unter Android, aktivieren Sie Bluetooth und öffnen Sie die Seite über HTTPS oder localhost.',
+    secureContext: 'Web Bluetooth erfordert eine sichere HTTPS-Seite oder localhost. Laden Sie das Tool von einer sicheren Quelle neu und versuchen Sie es erneut.',
+    scanButton: 'Umgebung scannen',
+    scanning: 'Scannen läuft',
+    reconnect: 'Erneut scannen',
+    disconnect: 'Trennen',
+    privacyTitle: 'Datenschutz durch Design',
+    privacyBody: 'GameBob speichert keine MAC-Adressen, Geräte-IDs, Namen, UUIDs oder Scanverläufe. Der Browser legt nur das von Ihnen gewählte Gerät offen.',
+    deviceLabel: 'Ausgewähltes Gerät',
+    nameFallback: 'Unbenanntes BLE-Gerät',
+    idLabel: 'Browser-Geräte-ID',
+    servicesLabel: 'GATT-Dienste',
+    noServices: 'Für diese Verbindung wurden keine lesbaren Primärdienste zurückgegeben.',
+    statusIdle: 'Bereit zum Scannen nahegelegener BLE-Hardware',
+    statusPermission: 'Warten auf die Berechtigungsauswahl des Browsers',
+    statusConnecting: 'Verbinden mit dem ausgewählten BLE-Gerät',
+    statusConnected: 'Verbunden und Dienste geladen',
+    statusDisconnected: 'Gerät getrennt',
+    statusCancelled: 'Kein BLE-Gerät ausgewählt oder Bluetooth ist auf diesem Gerät ausgeschaltet bzw. nicht verfügbar.',
+    statusUnavailable: 'Bluetooth scheint auf diesem Gerät ausgeschaltet, blockiert oder nicht vorhanden zu sein. Aktivieren Sie Bluetooth oder versuchen Sie es mit Hardware, die einen BLE-Adapter besitzt.',
+    statusError: 'Bluetooth-Scan fehlgeschlagen',
+    signalUnknown: 'Die Signalstärke wird durch die Browser-Auswahl gesteuert',
+    gattUnavailable: 'Dieses Gerät hat dem Browser keinen GATT-Server bereitgestellt',
+    customServiceName: 'Benutzerdefinierter oder herstellerspezifischer Dienst',
+    serviceGenericAccess: 'Generic Access',
+    serviceGenericAttribute: 'Generic Attribute',
+    serviceDeviceInformation: 'Geräteinformationen',
+    serviceHeartRate: 'Herzfrequenz',
+    serviceBattery: 'Batterie-Service',
+    serviceHumanInterfaceDevice: 'Human Interface Device',
+    serviceCyclingSpeedCadence: 'Radfahren Geschwindigkeit und Trittfrequenz',
+    serviceEnvironmentalSensing: 'Umweltsensorik',
+    serviceUserData: 'Nutzerdaten',
+    serviceFitnessMachine: 'Fitnessgerät',
+    uuidHelp: 'UUIDs identifizieren Bluetooth-Dienste. Standarddienste werden automatisch benannt; herstellerspezifische UUIDs benötigen Ihre Firmware- oder Gerätedokumentation.',
+    compatibilityHint: 'Funktioniert am besten in Chromium-basierten Browsern mit aktiviertem Bluetooth. Web Bluetooth ist bewusst berechtigungsbeschränkt und zeigt möglicherweise nicht jeden nahegelegenen Advertiser an.',
+    serviceCountSingular: 'Dienst',
+    serviceCountPlural: 'Dienste',
+  },
+};