// デバイスをフィルター
    const options: RequestDeviceOptions = {
      filters: [
        {
          namePrefix: "デバイス名のPrefix",
        },
      ],
    };

    // デバイスを探す & 接続
    const device = await navigator.bluetooth
      .requestDevice(options)
      .then((device) => {
        return device;
      })
      .catch((error) => {
        console.error(error);
        return null;
      });

    // 通信のためのあれこれ
    const server = await device?.gatt?.connect();
    const service = await server?.getPrimaryService('battery_service'); // PrimaryServiceの指定
    const characteristic = await service?.getCharacteristic(service.uuid);

    console.log(characteristic);

    // 受信時のイベント
    characteristic?.addEventListener('characteristicvaluechanged', (e) => {
      console.log(e);
    })

const service = await server?.getPrimaryService('battery_service');

// サーバー起動
pub fn start_server(app: &mut App) {
    let app_handle = app.app_handle();

    thread::spawn(move || {
        let port_number = 12345;
        let listener = TcpListener::bind(SocketAddr::new(
            IpAddr::V4(Ipv4Addr::new(0, 0, 0, 0)),
            port_number,
        ))
        .expect("Failed to bind to address");

        print!("Server started");
        emit_socket_payload(
            &app_handle,
            SocketState::Started,
            "Server started".to_string(),
        );

        recv(listener, app_handle);
    });

    print!("Server Stop");
}

// 接続待ち
fn recv(listener: TcpListener, app_handle: AppHandle) {
    loop {
        match listener.accept() {
            Ok((mut socket, addr)) => {
                emit_socket_payload(
                    &app_handle,
                    SocketState::Connected,
                    format!("Accepted connection from {:?}", addr),
                );
                read(&mut socket, &app_handle);
            }
            Err(e) => {
                eprintln!("Accept error: {}", e);
                std::process::exit(1);
            }
        }
    }
}

// 受信しまくる
fn read(socket: &mut std::net::TcpStream, app_handle: &AppHandle) {
    loop {
        let mut buffer = [0; 1024];
        match socket.read(&mut buffer) {
            Ok(0) => {
                emit_socket_payload(
                    app_handle,
                    SocketState::Disconnected,
                    "Client disconnected".to_string(),
                );

                break;
            }
            Ok(bytes_read) => {
                let message = String::from_utf8_lossy(&buffer[..bytes_read]);
                emit_socket_payload(app_handle, SocketState::Received, message.to_string());
            }
            Err(ref e) if e.kind() == ErrorKind::WouldBlock => {
                continue;
            }
            Err(e) => {
                emit_socket_payload(
                    app_handle,
                    SocketState::Error,
                    format!("Error reading from client: {}", e).to_string(),
                );
                break;
            }
        }
    }

    // Close the connection if it's still open.
    if let Err(e) = socket.shutdown(Shutdown::Both) {
        emit_socket_payload(
            app_handle,
            SocketState::Error,
            format!("Shutdown failed: {}", e).to_string(),
        );
    }
}

// React(フロント)に送信
fn emit_socket_payload(app_handle: &AppHandle, state: SocketState, data: String) {
    let payload = SocketPayload { state, data };
    app_handle.emit_all("socket", payload.clone()).unwrap();
}

export const useSocket = (handler: recvHandler, event: EventName = 'socket') => {
  const isListening = useRef(false);

  useEffect(() => {
    if (isListening.current) return;
    isListening.current = true;

    (async () => {
      console.log('Listening to socket events');
      const unlisten = await listen(event, (event: SocketEvent) => {
        handler(event.payload.state, event.payload.data);
      });

      return () => {
        unlisten();
        isListening.current = false;
      };
    })();
  }, []);
};

// 接続
const client = TcpSocket.createConnection({ port: portNum, host: ip }, () => {});
// 送信
client?.write(sendData);
// 切断
client?.destroy();

export const useSensor = (handler?: Handler, sampleingRate = 1 / 60) => {
  const [data, setData] = useState<DeviceMotionMeasurement>();
  const [subscription, setSubscription] = useState<Subscription>();

  /**
   * センサーの読み込みを開始する
   */
  const subscribe = () => {
    const deviceMotion = DeviceMotion.addListener((data) => setData(data));
    DeviceMotion.setUpdateInterval(sampleingRate);
    setSubscription(deviceMotion);
  };

  /**
   * センサーの読み込みを停止する
   */
  const unsubscribe = () => {
    subscription?.remove();
    setSubscription(undefined);
  };

  if (handler && data) handler(data);

  return [data, { subscribe, unsubscribe }] as const;
};