mirror of
https://github.com/kavishdevar/librepods.git
synced 2026-02-11 12:12:26 +00:00
organize and improve examples
This commit is contained in:
Kavish Devar
@@ -1,51 +1,56 @@
|
||||
import socket
|
||||
import pickle
|
||||
import json
|
||||
import subprocess
|
||||
from aln.Notifications import Battery
|
||||
import threading
|
||||
import time
|
||||
import os
|
||||
import logging
|
||||
|
||||
|
||||
# Configure logging
|
||||
logging.basicConfig(level=logging.DEBUG, format='%(asctime)s - %(levelname)s - %(message)s')
|
||||
|
||||
# Colorful logging
|
||||
logging.addLevelName(logging.DEBUG, "\033[1;34m%s\033[1;0m" % logging.getLevelName(logging.DEBUG))
|
||||
logging.addLevelName(logging.INFO, "\033[1;32m%s\033[1;0m" % logging.getLevelName(logging.INFO))
|
||||
logging.addLevelName(logging.WARNING, "\033[1;33m%s\033[1;0m" % logging.getLevelName(logging.WARNING))
|
||||
logging.addLevelName(logging.ERROR, "\033[1;31m%s\033[1;0m" % logging.getLevelName(logging.ERROR))
|
||||
logging.addLevelName(logging.CRITICAL, "\033[1;41m%s\033[1;0m" % logging.getLevelName(logging.CRITICAL))
|
||||
|
||||
SOCKET_PATH = "/tmp/airpods_daemon.sock"
|
||||
|
||||
class MediaController:
|
||||
def __init__(self):
|
||||
self.wasMusicPlaying = False
|
||||
self.earStatus = "Both out"
|
||||
self.status = "Stopped"
|
||||
self.stop_thread_event = threading.Event()
|
||||
self.wasMusicPlayingInSingle = False
|
||||
self.wasMusicPlayingInBoth = False
|
||||
self.firstEarOutTime = 0
|
||||
self.stop_thread_event = threading.Event()
|
||||
|
||||
def playMusic(self):
|
||||
print("Playing music")
|
||||
subprocess.call(("playerctl", "play", "--ignore-player", "OnePlus_7"))
|
||||
|
||||
def pauseMusic(self):
|
||||
print("Pausing music")
|
||||
subprocess.call(("playerctl", "pause", "--player", "spotify"))
|
||||
subprocess.call(("playerctl", "pause", "--ignore-player", "OnePlus_7"))
|
||||
|
||||
def isPlaying(self):
|
||||
status = subprocess.check_output(["playerctl", "status", "--player", "spotify"]).decode("utf-8").strip()
|
||||
print(f"Music status: {status}")
|
||||
return status == "Playing"
|
||||
return subprocess.check_output(["playerctl", "status", "--player", "spotify"]).decode("utf-8").strip() == "Playing"
|
||||
|
||||
def handlePlayPause(self, data):
|
||||
primary_status = data[0]
|
||||
secondary_status = data[1]
|
||||
|
||||
print(f"Handle play/pause called with data: {data}, previousStatus: {self.status}, wasMusicPlaying: {self.wasMusicPlaying}")
|
||||
logging.debug(f"Handle play/pause called with data: {data}, previousStatus: {self.earStatus}, wasMusicPlaying: {self.wasMusicPlayingInSingle or self.wasMusicPlayingInBoth}")
|
||||
|
||||
def delayed_action(s):
|
||||
if not self.stop_thread_event.is_set():
|
||||
print("Delayed action")
|
||||
if self.wasMusicPlayingInSingle:
|
||||
self.playMusic()
|
||||
self.wasMusicPlayingInBoth = False
|
||||
elif self.wasMusicPlayingInBoth or s:
|
||||
self.wasMusicPlayingInBoth = True
|
||||
self.wasMusicPlayingInSingle = False
|
||||
print(self.wasMusicPlayingInSingle, self.wasMusicPlayingInBoth)
|
||||
|
||||
if primary_status and secondary_status:
|
||||
if self.earStatus != "Both out":
|
||||
@@ -54,7 +59,6 @@ class MediaController:
|
||||
os.system("pacmd set-card-profile bluez_card.28_2D_7F_C2_05_5B off")
|
||||
if self.earStatus == "Only one in":
|
||||
if self.firstEarOutTime != 0 and time.time() - self.firstEarOutTime < 0.3:
|
||||
print("Only one in called with both out")
|
||||
self.wasMusicPlayingInSingle = True
|
||||
self.wasMusicPlayingInBoth = True
|
||||
self.stop_thread_event.set()
|
||||
@@ -106,7 +110,7 @@ def read():
|
||||
try:
|
||||
# Create a socket connection to the daemon
|
||||
client_socket = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
|
||||
print("Connecting to daemon...")
|
||||
logging.info("Connecting to daemon...")
|
||||
client_socket.connect(SOCKET_PATH)
|
||||
|
||||
media_controller = MediaController()
|
||||
@@ -116,28 +120,21 @@ def read():
|
||||
d = client_socket.recv(1024)
|
||||
if d:
|
||||
try:
|
||||
data = pickle.loads(d)
|
||||
if isinstance(data, str):
|
||||
print(f"Received data: {data}")
|
||||
elif isinstance(data, list) and all(isinstance(b, Battery.Battery) for b in data):
|
||||
for b in data:
|
||||
print(f"Received battery status: {b.get_component()} is {b.get_status()} at {b.get_level()}%")
|
||||
elif isinstance(data, list) and len(data) == 2 and all(isinstance(i, int) for i in data):
|
||||
print(f"Received ear detection status: Is in-ear? Primary: {data[0] == 0}, Secondary: {data[1] == 0}")
|
||||
media_controller.handlePlayPause(data)
|
||||
else:
|
||||
print(f"Received unknown data: {data}")
|
||||
except pickle.UnpicklingError as e:
|
||||
print(f"Error deserializing data: {e}")
|
||||
data: dict = json.loads(d.decode('utf-8'))
|
||||
if data["type"] == "ear_detection":
|
||||
logging.debug(f"Ear detection: {data['primary']} - {data['secondary']}")
|
||||
media_controller.handlePlayPause([data['primary'], data['secondary']])
|
||||
except json.JSONDecodeError as e:
|
||||
logging.error(f"Error deserializing data: {e}")
|
||||
else:
|
||||
break
|
||||
|
||||
except Exception as e:
|
||||
print(f"Error communicating with daemon: {e}")
|
||||
logging.error(f"Error communicating with daemon: {e}")
|
||||
finally:
|
||||
if client_socket:
|
||||
client_socket.close()
|
||||
print("Socket closed")
|
||||
logging.warning("Socket closed")
|
||||
|
||||
if __name__ == "__main__":
|
||||
read()
|
||||
@@ -1,5 +1,5 @@
|
||||
import socket
|
||||
import pickle
|
||||
import json
|
||||
from aln.Notifications import Battery
|
||||
|
||||
SOCKET_PATH = "/tmp/airpods_daemon.sock"
|
||||
@@ -18,18 +18,15 @@ def read():
|
||||
d = client_socket.recv(1024)
|
||||
if d:
|
||||
try:
|
||||
data = pickle.loads(d)
|
||||
if isinstance(data, str):
|
||||
print(f"Received data: {data}")
|
||||
elif isinstance(data, list) and all(isinstance(b, Battery.Battery) for b in data):
|
||||
for b in data:
|
||||
print(f"Received battery status: {b.get_component()} is {b.get_status()} at {b.get_level()}%")
|
||||
elif isinstance(data, list) and len(data) == 2 and all(isinstance(i, int) for i in data):
|
||||
print(f"Received ear detection status: Is in-ear? Primary: {data[0] == 0}, Secondary: {data[1] == 0}")
|
||||
data: dict = json.loads(d.decode('utf-8'))
|
||||
if data["type"] == "battery":
|
||||
for b in data.keys():
|
||||
print(f"Received battery status: {b} - {data[b]}")
|
||||
elif data["type"] == "ear_detection":
|
||||
print(f"Ear detection: {data['primary']} - {data['secondary']}")
|
||||
else:
|
||||
print(f"Received unknown data: {data}")
|
||||
all(isinstance(b, Battery.Battery) for b in data)
|
||||
except pickle.UnpicklingError as e:
|
||||
print(f"Received data: {data}")
|
||||
except json.JSONDecodeError as e:
|
||||
print(f"Error deserializing data: {e}")
|
||||
else:
|
||||
break
|
||||
|
||||
205
examples/daemon/start.py
Normal file
205
examples/daemon/start.py
Normal file
@@ -0,0 +1,205 @@
|
||||
import socket
|
||||
import threading
|
||||
import signal
|
||||
import sys
|
||||
import logging
|
||||
from aln import Connection, enums
|
||||
from aln.Notifications import Notifications
|
||||
import os
|
||||
from aln.Notifications.Battery import Battery
|
||||
import bluetooth
|
||||
|
||||
connection = None
|
||||
|
||||
AIRPODS_MAC = '28:2D:7F:C2:05:5B'
|
||||
SOCKET_PATH = '/tmp/airpods_daemon.sock'
|
||||
LOG_FOLDER = '.'
|
||||
LOG_FILE = os.path.join(LOG_FOLDER, 'airpods_daemon.log')
|
||||
|
||||
# Global flag to control the server loop
|
||||
running = True
|
||||
|
||||
# Configure logging to write to a file
|
||||
logging.basicConfig(filename=LOG_FILE, level=logging.DEBUG, format='%(asctime)s %(levelname)s : %(message)s')
|
||||
# logging.basicConfig(level=logging.DEBUG, format='%(asctime)s %(levelname)s : %(message)s')
|
||||
|
||||
from json import JSONEncoder
|
||||
|
||||
def handle_client(connection, client_socket):
|
||||
"""Handle client requests by forwarding all received data to aln.Connection, send data back to the client."""
|
||||
|
||||
def send_status():
|
||||
while running:
|
||||
try:
|
||||
for notif_key in list(globals().keys()):
|
||||
if notif_key.startswith("notif_"):
|
||||
data = globals().get(notif_key)
|
||||
if data:
|
||||
if notif_key == "notif_battery":
|
||||
data: list[Battery] = data
|
||||
batteryJSON = {"type": "battery"}
|
||||
for i in data:
|
||||
batteryJSON[i.get_component()] = {
|
||||
"status": i.get_status(),
|
||||
"level": i.get_level()
|
||||
}
|
||||
data: str = JSONEncoder().encode(batteryJSON)
|
||||
elif notif_key == "notif_ear_detection":
|
||||
data: list[int] = data
|
||||
earDetectionJSON = {
|
||||
"type": "ear_detection",
|
||||
"primary": data[0],
|
||||
"secondary": data[1]
|
||||
}
|
||||
data: str = JSONEncoder().encode(earDetectionJSON)
|
||||
else:
|
||||
logging.warning(f"Unhandled notification type: {notif_key}")
|
||||
continue
|
||||
|
||||
if not client_socket or not isinstance(client_socket, socket.socket):
|
||||
logging.error("Invalid client socket")
|
||||
break
|
||||
logging.info(f'Sending {notif_key} status: {data}')
|
||||
client_socket.sendall(data.encode('utf-8'))
|
||||
logging.info(f'Sent {notif_key} status: {data}')
|
||||
globals()[notif_key] = None
|
||||
except socket.error as e:
|
||||
logging.error(f"Socket error sending status: {e}")
|
||||
break
|
||||
except Exception as e:
|
||||
logging.error(f"Error sending status: {e}")
|
||||
break
|
||||
|
||||
def receive_commands():
|
||||
while running:
|
||||
try:
|
||||
data = client_socket.recv(1024)
|
||||
if not data:
|
||||
break
|
||||
logging.info(f'Received command: {data}')
|
||||
connection.send(data)
|
||||
except Exception as e:
|
||||
logging.error(f"Error receiving command: {e}")
|
||||
break
|
||||
|
||||
# Start two threads to handle sending and receiving data
|
||||
send_thread = threading.Thread(target=send_status)
|
||||
send_thread.start()
|
||||
receive_thread = threading.Thread(target=receive_commands)
|
||||
receive_thread.start()
|
||||
|
||||
send_thread.join()
|
||||
receive_thread.join()
|
||||
|
||||
client_socket.close()
|
||||
logging.info("Client socket closed")
|
||||
|
||||
def start_socket_server(connection):
|
||||
"""Start a UNIX domain socket server."""
|
||||
global running
|
||||
|
||||
# Set up the socket
|
||||
server_socket = socket.socket(socket.AF_UNIX, socket.SOCK_STREAM)
|
||||
try:
|
||||
server_socket.bind(SOCKET_PATH)
|
||||
except OSError:
|
||||
logging.error(f"Socket already in use or unavailable: {SOCKET_PATH}")
|
||||
sys.exit(1)
|
||||
|
||||
server_socket.listen(1)
|
||||
logging.info(f"Socket server listening on {SOCKET_PATH}")
|
||||
|
||||
while running:
|
||||
try:
|
||||
client_socket, _ = server_socket.accept()
|
||||
logging.info("Client connected")
|
||||
|
||||
# Handle the client connection in a separate thread
|
||||
client_thread = threading.Thread(target=handle_client, args=(connection, client_socket))
|
||||
client_thread.start()
|
||||
except Exception as e:
|
||||
logging.error(f"Error accepting connection: {e}")
|
||||
|
||||
# Close the server socket when stopped
|
||||
server_socket.close()
|
||||
logging.info("Socket server stopped")
|
||||
|
||||
def stop_daemon(signum, frame):
|
||||
"""Signal handler to stop the daemon."""
|
||||
global running
|
||||
logging.info("Received termination signal. Stopping daemon...")
|
||||
running = False # Set running flag to False to stop the loop
|
||||
|
||||
# Close the socket gracefully by removing the file path
|
||||
try:
|
||||
socket.socket(socket.AF_UNIX, socket.SOCK_STREAM).connect(SOCKET_PATH)
|
||||
except socket.error:
|
||||
pass
|
||||
finally:
|
||||
# Remove the socket file
|
||||
if os.path.exists(SOCKET_PATH):
|
||||
os.remove(SOCKET_PATH)
|
||||
|
||||
sys.exit(0)
|
||||
|
||||
def notification_handler(notification_type: int):
|
||||
global connection
|
||||
|
||||
logging.debug(f"Received notification: {notification_type}")
|
||||
if notification_type == Notifications.BATTERY_UPDATED:
|
||||
logger = logging.getLogger("Battery Status")
|
||||
battery = connection.notificationListener.BatteryNotification.getBattery()
|
||||
globals()["notif_battery"] = battery
|
||||
for i in battery:
|
||||
logger.debug(f'{i.get_component()} - {i.get_status()}: {i.get_level()}')
|
||||
elif notification_type == Notifications.EAR_DETECTION_UPDATED:
|
||||
logger = logging.getLogger("In-Ear Status")
|
||||
earDetection = connection.notificationListener.EarDetectionNotification.getEarDetection()
|
||||
globals()["notif_ear_detection"] = earDetection
|
||||
logger.debug(earDetection)
|
||||
|
||||
def main():
|
||||
global running
|
||||
logging.info("Starting AirPods daemon")
|
||||
connection = Connection(AIRPODS_MAC)
|
||||
globals()['connection'] = connection
|
||||
|
||||
# Connect to the AirPods and send the handshake
|
||||
try:
|
||||
connection.connect()
|
||||
except bluetooth.btcommon.BluetoothError as e:
|
||||
logging.error(f"Failed to connect to {AIRPODS_MAC}: {e}")
|
||||
sys.exit(1)
|
||||
|
||||
connection.send(enums.HANDSHAKE)
|
||||
logging.info("Handshake sent")
|
||||
connection.initialize_notifications(notification_handler)
|
||||
|
||||
# Start the socket server to listen for client connections
|
||||
start_socket_server(connection)
|
||||
|
||||
# Set up signal handlers to handle termination signals
|
||||
signal.signal(signal.SIGINT, stop_daemon) # Handle Ctrl+C
|
||||
signal.signal(signal.SIGTERM, stop_daemon) # Handle kill signal
|
||||
|
||||
if __name__ == "__main__":
|
||||
# Daemonize the process
|
||||
if os.fork():
|
||||
sys.exit()
|
||||
|
||||
os.setsid()
|
||||
|
||||
if os.fork():
|
||||
sys.exit()
|
||||
|
||||
sys.stdout.flush()
|
||||
sys.stderr.flush()
|
||||
|
||||
with open('/dev/null', 'r') as devnull:
|
||||
os.dup2(devnull.fileno(), sys.stdin.fileno())
|
||||
|
||||
with open(LOG_FILE, 'a+') as logfile:
|
||||
os.dup2(logfile.fileno(), sys.stdout.fileno())
|
||||
os.dup2(logfile.fileno(), sys.stderr.fileno())
|
||||
|
||||
main()
|
||||
105
examples/logger-and-anc.py
Normal file
105
examples/logger-and-anc.py
Normal file
@@ -0,0 +1,105 @@
|
||||
from aln import Connection
|
||||
from aln import enums
|
||||
import logging
|
||||
import threading
|
||||
import time
|
||||
import sys
|
||||
import shutil
|
||||
|
||||
AIRPODS_MAC = '28:2D:7F:C2:05:5B'
|
||||
|
||||
class CustomFormatter(logging.Formatter):
|
||||
def format(self, record):
|
||||
# Format the log message with spaces around colons without altering the original message
|
||||
formatted_message = record.getMessage().replace(':', ': ')
|
||||
record.message = formatted_message
|
||||
return super().format(record)
|
||||
|
||||
class ConsoleHandler(logging.StreamHandler):
|
||||
def __init__(self, stream=None):
|
||||
super().__init__(stream)
|
||||
self.terminator = '\n'
|
||||
self.log_lines = []
|
||||
|
||||
def emit(self, record):
|
||||
try:
|
||||
msg = self.format(record)
|
||||
self.log_lines.append(msg)
|
||||
self.display_logs()
|
||||
except Exception:
|
||||
self.handleError(record)
|
||||
|
||||
def display_logs(self):
|
||||
sys.stdout.write('\033[H\033[J') # Clear the screen
|
||||
terminal_height, _ = shutil.get_terminal_size()
|
||||
log_display_lines = self.log_lines[-(terminal_height - 5):] # Display the last terminal_height - 5 log lines
|
||||
empty_lines = terminal_height - 5 - len(log_display_lines)
|
||||
|
||||
for _ in range(empty_lines):
|
||||
sys.stdout.write('\n') # Fill empty space with new lines
|
||||
|
||||
for line in log_display_lines:
|
||||
sys.stdout.write(line + self.terminator)
|
||||
|
||||
sys.stdout.write('1: ANC Off\n')
|
||||
sys.stdout.write('2: Transparency\n')
|
||||
sys.stdout.write('3: Adaptive Transparency\n')
|
||||
sys.stdout.write('4: ANC On\n')
|
||||
sys.stdout.write('Select ANC Mode: ')
|
||||
sys.stdout.flush()
|
||||
|
||||
def input_thread(connection: Connection):
|
||||
while True:
|
||||
anc_mode = input()
|
||||
if anc_mode == '1':
|
||||
connection.send(enums.SET_NOISE_CANCELLATION_OFF)
|
||||
logging.info('ANC Off')
|
||||
elif anc_mode == '2':
|
||||
connection.send(enums.SET_NOISE_CANCELLATION_TRANSPARENCY)
|
||||
logging.info('Transparency On')
|
||||
elif anc_mode == '3':
|
||||
connection.send(enums.SET_NOISE_CANCELLATION_ADAPTIVE)
|
||||
logging.info('Adaptive Transparency On')
|
||||
elif anc_mode == '4':
|
||||
connection.send(enums.SET_NOISE_CANCELLATION_ON)
|
||||
logging.info('ANC On')
|
||||
else:
|
||||
logging.error('Invalid ANC Mode')
|
||||
|
||||
def main():
|
||||
# Set up logging
|
||||
handler = ConsoleHandler()
|
||||
|
||||
logging.addLevelName(logging.DEBUG, "\033[1;34m%s\033[1;0m" % logging.getLevelName(logging.DEBUG))
|
||||
logging.addLevelName(logging.INFO, "\033[1;32m%s\033[1;0m" % logging.getLevelName(logging.INFO))
|
||||
logging.addLevelName(logging.WARNING, "\033[1;33m%s\033[1;0m" % logging.getLevelName(logging.WARNING))
|
||||
logging.addLevelName(logging.ERROR, "\033[1;31m%s\033[1;0m" % logging.getLevelName(logging.ERROR))
|
||||
logging.addLevelName(logging.CRITICAL, "\033[1;41m%s\033[1;0m" % logging.getLevelName(logging.CRITICAL))
|
||||
|
||||
formatter = CustomFormatter('%(asctime)s - %(levelname)s - %(name)s - %(message)s')
|
||||
handler.setFormatter(formatter)
|
||||
logging.basicConfig(level=logging.DEBUG, handlers=[handler])
|
||||
|
||||
connection = Connection(AIRPODS_MAC)
|
||||
connection.connect()
|
||||
logging.info('Sending Handshake')
|
||||
connection.send(enums.HANDSHAKE)
|
||||
logging.info('Initializing Notifications')
|
||||
connection.initialize_notifications()
|
||||
logging.info('Initialized Notifications')
|
||||
|
||||
# Start the input thread
|
||||
thread = threading.Thread(target=input_thread, args=(connection,))
|
||||
thread.daemon = True
|
||||
thread.start()
|
||||
|
||||
try:
|
||||
# Keep the main thread alive to handle logging
|
||||
while True:
|
||||
time.sleep(1)
|
||||
except KeyboardInterrupt:
|
||||
logging.info('Program interrupted. Exiting...')
|
||||
connection.disconnect() # Ensure the connection is properly closed
|
||||
|
||||
if __name__ == "__main__":
|
||||
main()
|
||||
323
examples/standalone.py
Normal file
323
examples/standalone.py
Normal file
@@ -0,0 +1,323 @@
|
||||
import threading
|
||||
import bluetooth
|
||||
import subprocess
|
||||
import time
|
||||
import threading
|
||||
import os
|
||||
|
||||
# Bluetooth MAC address of AirPods
|
||||
AIRPODS_MAC = "28:2D:7F:C2:05:5B"
|
||||
|
||||
class initL2CAP():
|
||||
lastEarStatus = ""
|
||||
earStatus = ""
|
||||
wasMusicPlayingInBoth = False
|
||||
wasMusicPlayingInSingle = False
|
||||
|
||||
def pauseMusic(self):
|
||||
subprocess.call(("playerctl", "pause", "--ignore-player", "OnePlus_7"))
|
||||
|
||||
def playMusic(self):
|
||||
subprocess.call(("playerctl", "play", "--ignore-player", "OnePlus_7"))
|
||||
|
||||
def getMusicStatus(self):
|
||||
return subprocess.check_output(("playerctl", "status", "--ignore-player", "OnePlus_7")).decode("utf-8").strip()
|
||||
|
||||
# Change to MAC address of your AirPods
|
||||
|
||||
connected = False
|
||||
|
||||
cmd_off = b"\x04\x00\x04\x00\x09\x00\x0d\x01\x00\x00\x00"
|
||||
cmd_on = b"\x04\x00\x04\x00\x09\x00\x0d\x02\x00\x00\x00"
|
||||
cmd_transparency = b"\x04\x00\x04\x00\x09\x00\x0d\x03\x00\x00\x00"
|
||||
cmd_adaptive = b"\x04\x00\x04\x00\x09\x00\x0d\x04\x00\x00\x00"
|
||||
cmd_ca_off = b"\x04\x00\x04\x00\x09\x00\x28\x02\x00\x00\x00"
|
||||
cmd_ca_on = b"\x04\x00\x04\x00\x09\x00\x28\x01\x00\x00\x00"
|
||||
|
||||
def start(self):
|
||||
cmd_handshake = b"\x00\x00\x04\x00\x01\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00"
|
||||
# cmd_smth0 = b"\x04\x00\x04\x00\x0f\x00\xff\xff\xfe\xff"
|
||||
cmd_smth1 = b"\x04\x00\x04\x00\x0f\x00\xff\xff\xff\xff"
|
||||
|
||||
address = "28:2D:7F:C2:05:5B"
|
||||
|
||||
aap_service = "74EC2172-0BAD-4D01-8F77-997B2BE0722A"
|
||||
aap_port = 0x1001
|
||||
|
||||
services = bluetooth.find_service(address=address)
|
||||
|
||||
service = [s for s in services if s["service-classes"] == [aap_service]]
|
||||
|
||||
if not service:
|
||||
print("Device does not have AAP service")
|
||||
exit()
|
||||
|
||||
self.sock = bluetooth.BluetoothSocket(bluetooth.L2CAP)
|
||||
sock = self.sock
|
||||
sock.connect((address, aap_port))
|
||||
|
||||
print("Connected to AirPods")
|
||||
self.connected = True
|
||||
print("Sending handshake...")
|
||||
print(sock.type)
|
||||
|
||||
sock.send(cmd_handshake)
|
||||
# sock.send(cmd_smth0)
|
||||
sock.send(cmd_smth1)
|
||||
|
||||
threading.Thread(target=self.listen).start()
|
||||
|
||||
# battery info: 04 00 04 00 04 00 03 02 01 64 01 01 04 01 64 01 01 08 01 34 02 01
|
||||
|
||||
def parse_battery_status(self, data):
|
||||
if len(data) != 22:
|
||||
return
|
||||
self.left_bud_level = data[9]
|
||||
self.left_bud_status = data[10]
|
||||
|
||||
self.right_bud_level = data[14]
|
||||
self.right_bud_status = data[15]
|
||||
|
||||
self.case_level = data[19]
|
||||
self.case_status = data[20]
|
||||
|
||||
# Interpret the status
|
||||
def interpret_status(status):
|
||||
if status == 1:
|
||||
return "Charging"
|
||||
elif status == 2:
|
||||
return "Not charging"
|
||||
elif status == 4:
|
||||
return "Disconnected"
|
||||
else:
|
||||
return "Unknown"
|
||||
|
||||
# Print the results
|
||||
print(f"Left Bud: {self.left_bud_level}% - {interpret_status(self.left_bud_status)}")
|
||||
print(f"Right Bud: {self.right_bud_level}% - {interpret_status(self.right_bud_status)}")
|
||||
print(f"Case: {self.case_level}% - {interpret_status(self.case_status)}")
|
||||
|
||||
|
||||
def parse_anc_status(self, data):
|
||||
# 04 00 04 00 09 00 0d 03 00 00 00
|
||||
if len(data) != 11 and data.hex().startswith("040004000600"):
|
||||
return
|
||||
if data[7] == 1:
|
||||
return "Off"
|
||||
elif data[7] == 2:
|
||||
return "On"
|
||||
elif data[7] == 3:
|
||||
return "Transparency"
|
||||
elif data[7] == 4:
|
||||
return "Adaptive"
|
||||
|
||||
firstEarOutTime = 0
|
||||
stop_thread_event = threading.Event()
|
||||
|
||||
def parse_inear_status(self, data):
|
||||
if len(data) != 8:
|
||||
return
|
||||
|
||||
second_status = data[6]
|
||||
first_status = data[7]
|
||||
|
||||
def delayed_action(self, s):
|
||||
print(s)
|
||||
if not self.stop_thread_event.is_set():
|
||||
print("Delayed action")
|
||||
if self.wasMusicPlayingInSingle:
|
||||
self.playMusic()
|
||||
self.wasMusicPlayingInBoth = False
|
||||
elif self.wasMusicPlayingInBoth or s == "Playing":
|
||||
self.wasMusicPlayingInBoth = True
|
||||
self.wasMusicPlayingInSingle = False
|
||||
|
||||
if first_status and second_status:
|
||||
if self.earStatus != "Both out":
|
||||
s = self.getMusicStatus()
|
||||
self.pauseMusic()
|
||||
os.system("pacmd set-card-profile bluez_card.28_2D_7F_C2_05_5B off")
|
||||
if self.earStatus == "Only one in":
|
||||
if self.firstEarOutTime != 0 and time.time() - self.firstEarOutTime < 0.3:
|
||||
print("Only one in called with both out")
|
||||
self.wasMusicPlayingInSingle = True
|
||||
self.wasMusicPlayingInBoth = True
|
||||
self.stop_thread_event.set()
|
||||
else:
|
||||
if s == "Playing":
|
||||
self.wasMusicPlayingInSingle = True
|
||||
else:
|
||||
self.wasMusicPlayingInSingle = False
|
||||
# wasMusicPlayingInSingle = True
|
||||
elif self.earStatus == "Both in":
|
||||
# should be unreachable
|
||||
s = self.getMusicStatus()
|
||||
if s == "Playing":
|
||||
self.wasMusicPlayingInBoth = True
|
||||
self.wasMusicPlayingInSingle = False
|
||||
else:
|
||||
self.wasMusicPlayingInSingle = False
|
||||
self.earStatus = "Both out"
|
||||
return "Both out"
|
||||
elif not first_status and not second_status:
|
||||
if self.earStatus != "Both in":
|
||||
if self.earStatus == "Both out":
|
||||
os.system("pacmd set-card-profile bluez_card.28_2D_7F_C2_05_5B a2dp_sink")
|
||||
elif self.earStatus == "Only one in":
|
||||
self.stop_thread_event.set()
|
||||
s = self.getMusicStatus()
|
||||
if s == "Playing":
|
||||
self.wasMusicPlayingInBoth = True
|
||||
if self.wasMusicPlayingInSingle or self.wasMusicPlayingInBoth:
|
||||
self.playMusic()
|
||||
self.wasMusicPlayingInBoth = True
|
||||
self.wasMusicPlayingInSingle = False
|
||||
self.earStatus = "Both in"
|
||||
return "Both in"
|
||||
elif (first_status and not second_status) or (not first_status and second_status):
|
||||
if self.earStatus != "Only one in":
|
||||
self.stop_thread_event.clear()
|
||||
s = self.getMusicStatus()
|
||||
self.pauseMusic()
|
||||
delayed_thread = threading.Timer(0.3, delayed_action, args=[self, s])
|
||||
delayed_thread.start()
|
||||
self.firstEarOutTime = time.time()
|
||||
if self.earStatus == "Both out":
|
||||
os.system("pacmd set-card-profile bluez_card.28_2D_7F_C2_05_5B a2dp_sink")
|
||||
self.earStatus = "Only one in"
|
||||
|
||||
return "Only one in"
|
||||
|
||||
def listen(self):
|
||||
while True:
|
||||
res = self.sock.recv(1024)
|
||||
print(f"Response: {res.hex()}")
|
||||
self.battery_status = self.parse_battery_status(res)
|
||||
self.inear_status = self.parse_inear_status(res)
|
||||
# anc_status = parse_anc_status(res)
|
||||
# if anc_status:
|
||||
# print("ANC: ", anc_status)
|
||||
if self.battery_status:
|
||||
print(self.battery_status)
|
||||
if self.inear_status:
|
||||
print(self.inear_status)
|
||||
|
||||
|
||||
# while True:
|
||||
# print("Select command:")
|
||||
# print("1. Turn off")
|
||||
# print("2. Turn on")
|
||||
# print("3. Toggle transparency")
|
||||
# print("4. Toggle Adaptive")
|
||||
# print("5. Conversational Awareness On")
|
||||
# print("6. Conversational Awareness Off")
|
||||
# print("0. Exit")
|
||||
|
||||
# cmd = input("Enter command: ")
|
||||
|
||||
# if cmd == "0":
|
||||
# break
|
||||
# elif cmd == "1":
|
||||
# self.sock.send(cmd_off)
|
||||
# elif cmd == "2":
|
||||
# self.sock.send(cmd_on)
|
||||
# elif cmd == "3":
|
||||
# self.sock.send(cmd_transparency)
|
||||
# elif cmd == "4":
|
||||
# self.sock.send(cmd_adaptive)
|
||||
# elif cmd == "5":
|
||||
# self.sock.send(cmd_ca_on)
|
||||
# elif cmd == "6":
|
||||
# self.sock.send(cmd_ca_off)
|
||||
|
||||
def stop(self):
|
||||
self.connected = False
|
||||
self.sock.close()
|
||||
|
||||
|
||||
|
||||
def is_bluetooth_connected():
|
||||
try:
|
||||
result = subprocess.run(["bluetoothctl", "info", AIRPODS_MAC], capture_output=True, text=True)
|
||||
return "Connected: yes" in result.stdout
|
||||
except Exception as e:
|
||||
print(f"Error checking Bluetooth connection status: {e}")
|
||||
return False
|
||||
|
||||
# Connect to Bluetooth device using bluetoothctl if not already connected
|
||||
def connect_bluetooth_device():
|
||||
if is_bluetooth_connected():
|
||||
print("AirPods are already connected.")
|
||||
return
|
||||
|
||||
print("Checking if AirPods are available...")
|
||||
result = subprocess.run(["bluetoothctl", "devices"], capture_output=True, text=True)
|
||||
if AIRPODS_MAC in result.stdout:
|
||||
print("AirPods are available. Connecting...")
|
||||
subprocess.run(["bluetoothctl", "connect", AIRPODS_MAC])
|
||||
else:
|
||||
print("AirPods are not available.")
|
||||
|
||||
time.sleep(2) # Wait for the connection to establish
|
||||
|
||||
# Switch audio output to AirPods (PulseAudio)
|
||||
try:
|
||||
result = subprocess.run(["pactl", "list", "short", "sinks"], capture_output=True, text=True)
|
||||
sink_name = next((line.split()[1] for line in result.stdout.splitlines() if "bluez_sink" in line), None)
|
||||
if sink_name:
|
||||
subprocess.run(["pactl", "set-default-sink", sink_name])
|
||||
print(f"Switched audio to AirPods: {sink_name}")
|
||||
|
||||
else:
|
||||
print("Failed to switch audio to AirPods.")
|
||||
except Exception as e:
|
||||
print(f"Error switching audio: {e}")
|
||||
|
||||
# Disconnect from Bluetooth device if connected
|
||||
def disconnect_bluetooth_device():
|
||||
if not is_bluetooth_connected():
|
||||
print("AirPods are already disconnected.")
|
||||
return
|
||||
|
||||
print("Disconnecting from AirPods...")
|
||||
subprocess.run(["bluetoothctl", "disconnect", AIRPODS_MAC])
|
||||
|
||||
l2cap = initL2CAP()
|
||||
|
||||
# Function to listen to `playerctl --follow` and react to status changes
|
||||
def mediaListener():
|
||||
try:
|
||||
# Run playerctl --follow in a subprocess
|
||||
process = subprocess.Popen(
|
||||
["playerctl", "--follow", "status"], stdout=subprocess.PIPE, stderr=subprocess.PIPE, text=True
|
||||
)
|
||||
|
||||
# Continuously read from the subprocess stdout
|
||||
for line in process.stdout:
|
||||
if line: # Make sure the line is not empty
|
||||
line = line.strip() # Remove any extraneous whitespace
|
||||
print(f"Received event from playerctl: {line}")
|
||||
|
||||
if "Playing" in line:
|
||||
print("Media started playing")
|
||||
connect_bluetooth_device()
|
||||
if not l2cap.connected:
|
||||
l2cap.start()
|
||||
elif "Paused" in line or "Stopped" in line:
|
||||
print("Media paused or stopped")
|
||||
# disconnect_bluetooth_device()
|
||||
|
||||
# Check for any errors in stderr
|
||||
stderr = process.stderr.read()
|
||||
if stderr:
|
||||
print(f"Error: {stderr}")
|
||||
|
||||
except Exception as e:
|
||||
print(f"An error occurred in mediaListener: {e}")
|
||||
|
||||
mediaListener()
|
||||
|
||||
# thread = threading.Thread(target=mediaListener)
|
||||
# thread.start()
|
||||
|
||||
# thread.stop()
|
||||
Reference in New Issue
Block a user