RBLE

gem 'rble'

install_if -> { RUBY_PLATFORM.include?('linux') } do
  gem 'ruby-dbus', '~> 0.25'
end

require 'rble'

RBLE.scan(timeout: 5) do |device|
  puts "Found: #{device.name || 'Unknown'} (#{device.address})"
end

require 'rble/tasks'

require 'rble'

# Scan for 10 seconds, callback for each unique device
RBLE.scan(timeout: 10) do |device|
  puts "#{device.name || 'Unknown'} - #{device.address}"
  puts "  RSSI: #{device.rssi} dBm"
  puts "  Services: #{device.service_uuids.join(', ')}" unless device.service_uuids.empty?
end

RBLE.scan(timeout: 10, service_uuids: ['180d']) do |device|
  puts "Heart rate monitor: #{device.name}"
end

RBLE.scan(timeout: 60, allow_duplicates: true) do |device|
  puts "#{device.address}: RSSI #{device.rssi} dBm"
end

scanner = RBLE.scan do |device|
  puts device.name
  scanner.stop if device.name == "MyDevice"
end

device = RBLE.find_device("AA:BB:CC:DD:EE:FF", timeout: 10)

if device
  puts "Found: #{device.name}"
else
  puts "Device not found"
end

# First, find the device to ensure it's advertising
device = RBLE.find_device("AA:BB:CC:DD:EE:FF", timeout: 10)
raise "Device not found" unless device

# Connect to the device
connection = RBLE.connect(device.address, timeout: 30)
puts "Connected!"

# Discover GATT services
services = connection.discover_services
puts "Found #{services.length} services:"

services.each do |service|
  puts "  Service: #{service.short_uuid}"
  service.characteristics.each do |char|
    puts "    Characteristic: #{char.short_uuid} [#{char.flags.join(', ')}]"
  end
end

# Always disconnect when done
connection.disconnect

device = RBLE.find_device("AA:BB:CC:DD:EE:FF", timeout: 10)
raise "Device not found" unless device

connection = RBLE.connect(device.address)
connection.discover_services

# Get Device Information service (standard UUID: 0x180a)
device_info = connection.service('180a')

# Read Model Number characteristic (standard UUID: 0x2a24)
model_char = device_info.characteristic('2a24')
model_number = model_char.read
puts "Model: #{model_number}"

# Read as byte array instead
bytes = model_char.read_bytes
puts "Bytes: #{bytes.inspect}"

connection.disconnect

device = RBLE.find_device("AA:BB:CC:DD:EE:FF", timeout: 10)
raise "Device not found" unless device

connection = RBLE.connect(device.address)
connection.discover_services

# Find your service and characteristic
service = connection.service('your-service-uuid')
char = service.characteristic('your-characteristic-uuid')

# Write with response (waits for acknowledgment)
char.write([0x01, 0x02, 0x03])

# Write without response (faster, no acknowledgment)
char.write([0x01, 0x02, 0x03], response: false)

# Write a string (converted to bytes)
char.write("hello".bytes)

connection.disconnect

device = RBLE.find_device("AA:BB:CC:DD:EE:FF", timeout: 10)
raise "Device not found" unless device

connection = RBLE.connect(device.address)
connection.discover_services

# Subscribe to Heart Rate Measurement notifications
hr_service = connection.service('180d')
hr_measurement = hr_service.characteristic('2a37')

hr_measurement.subscribe do |value|
  # Heart Rate Measurement format: first byte contains flags,
  # heart rate value follows (8-bit or 16-bit based on flags)
  bytes = value.bytes
  flags = bytes[0]
  hr_value = (flags & 0x01) == 0 ? bytes[1] : (bytes[1] | (bytes[2] << 8))
  puts "Heart Rate: #{hr_value} BPM"
end

# Keep the connection open to receive notifications
puts "Listening for heart rate updates... Press Ctrl+C to stop"
sleep(60)

# Clean up
hr_measurement.unsubscribe
connection.disconnect

device = RBLE.find_device("AA:BB:CC:DD:EE:FF", timeout: 10)
raise "Device not found" unless device

connection = RBLE.connect(device.address)

# Register disconnect callback before doing other operations
connection.on_disconnect do |reason|
  puts "Disconnected! Reason: #{reason}"
  # reason is a symbol: :user_requested, :link_loss, :timeout, :remote_disconnect, etc.
end

# Optional: track all state changes
connection.on_state_change do |old_state, new_state|
  puts "Connection state: #{old_state} -> #{new_state}"
end

connection.discover_services
# ... use the connection ...

# When you disconnect intentionally, callback receives :user_requested
connection.disconnect

RBLE.scan(adapter: 'hci1') { |d| puts d.name }
RBLE.connect(address, adapter: 'hci1')

RBLE.adapters.each do |adapter|
  puts "#{adapter[:name]}: #{adapter[:address]} (powered: #{adapter[:powered]})"
end

# macOS device addresses look like UUIDs
RBLE.find_device("E621E1F8-C36C-495A-93FC-0C247A3E6E5F")

begin
  connection = RBLE.connect(address, timeout: 10)
  connection.discover_services
  # ...
rescue RBLE::AdapterNotFoundError
  puts "No Bluetooth adapter found"
rescue RBLE::AdapterDisabledError
  puts "Bluetooth is turned off"
rescue RBLE::ConnectionTimeoutError
  puts "Could not connect - device may be out of range"
rescue RBLE::NotConnectedError
  puts "Connection lost during operation"
rescue RBLE::ServiceNotFoundError => e
  puts "Service not available: #{e.message}"
rescue RBLE::CharacteristicNotFoundError => e
  puts "Characteristic not available: #{e.message}"
rescue RBLE::NotSupportedError => e
  puts "Operation not supported: #{e.message}"
rescue RBLE::ReadError, RBLE::WriteError => e
  puts "GATT operation failed: #{e.message}"
end