try making an app; commiting for highseas

linux.old/aln/AirPods/Pro2.py

@@ -0,0 +1,30 @@
+# AirPods like Normal (ALN) - Bringing Apple-only features to Linux and Android for seamless AirPods functionality!
+#
+# Copyright (C) 2024 Kavish Devar
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published
+# by the Free Software Foundation, either version 3 of the License.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+from ..Capabilites import Capabilites
+class Pro2:
+    def __init__(self):
+        self.name = 'AirPods Pro 2'
+        self.capabilites = {
+            Capabilites.NOISE_CANCELLATION: [
+                Capabilites.NoiseCancellation.OFF,
+                Capabilites.NoiseCancellation.ON,
+                Capabilites.NoiseCancellation.TRANSPARENCY,
+                Capabilites.NoiseCancellation.ADAPTIVE,
+            ],
+            Capabilites.CONVERSATION_AWARENESS: True,
+            Capabilites.CUSTOMIZABLE_ADAPTIVE_TRANSPARENCY: True
+        }

linux.old/aln/AirPods/__init__.py

@@ -0,0 +1,20 @@
+# AirPods like Normal (ALN) - Bringing Apple-only features to Linux and Android for seamless AirPods functionality!
+#
+# Copyright (C) 2024 Kavish Devar
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published
+# by the Free Software Foundation, either version 3 of the License.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+
+from . import Pro2
+
+Pro2 = Pro2.Pro2

linux.old/aln/Capabilites/__init__.py

@@ -0,0 +1,34 @@
+# AirPods like Normal (ALN) - Bringing Apple-only features to Linux and Android for seamless AirPods functionality!
+#
+# Copyright (C) 2024 Kavish Devar
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published
+# by the Free Software Foundation, either version 3 of the License.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+class NoiseCancellation:
+    OFF = b"\x01"
+    ON = b"\x02"
+    TRANSPARENCY = b"\x03"
+    ADAPTIVE = b"\x04"
+
+class ConversationAwareness:
+    OFF = b"\x02"
+    ON = b"\x01"
+
+class Capabilites:
+    NOISE_CANCELLATION = b"\x0d"
+    CONVERSATION_AWARENESS = b"\x28"
+    CUSTOMIZABLE_ADAPTIVE_TRANSPARENCY = b"\x01\x02"
+    EAR_DETECTION = b"\x06"
+    
+    NoiseCancellation = NoiseCancellation
+    ConversationAwareness = ConversationAwareness

linux.old/aln/Notifications/ANC.py

@@ -0,0 +1,41 @@
+# AirPods like Normal (ALN) - Bringing Apple-only features to Linux and Android for seamless AirPods functionality!
+#
+# Copyright (C) 2024 Kavish Devar
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published
+# by the Free Software Foundation, either version 3 of the License.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+from ..enums import enums
+from ..Capabilites import Capabilites
+class ANCNotification:
+    NOTIFICATION_PREFIX = enums.NOISE_CANCELLATION_PREFIX
+    OFF = Capabilites.NoiseCancellation.OFF
+    ON = Capabilites.NoiseCancellation.ON
+    TRANSPARENCY = Capabilites.NoiseCancellation.TRANSPARENCY
+    ADAPTIVE = Capabilites.NoiseCancellation.ADAPTIVE
+    
+    def __init__(self):
+        pass
+    
+    def isANCData(self, data: bytes):
+        # 04 00 04 00 09 00 0D 01 00 00 00
+        if len(data) != 11:
+            return False
+        
+        if data.hex().startswith(self.NOTIFICATION_PREFIX.hex()):
+            return True
+        else:
+            return False
+        
+    def setData(self, data: bytes):
+        self.status = data[7]
+        pass

linux.old/aln/Notifications/Battery.py

@@ -0,0 +1,80 @@
+# AirPods like Normal (ALN) - Bringing Apple-only features to Linux and Android for seamless AirPods functionality!
+#
+# Copyright (C) 2024 Kavish Devar
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published
+# by the Free Software Foundation, either version 3 of the License.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+class BatteryComponent:
+    LEFT = 4
+    RIGHT = 2
+    CASE = 8
+    pass
+class BatteryStatus:
+    CHARGING = 1
+    NOT_CHARGING = 2
+    DISCONNECTED = 4
+    pass
+
+class Battery:
+
+    def get_name(self, cls, value):
+        for key, val in cls.__dict__.items():
+            if val == value:
+                return key
+        return None
+    
+    def get_component(self):
+        return self.get_name(BatteryComponent, self.component)
+    
+    def get_level(self):
+        return self.level
+    
+    def get_status(self):
+        return self.get_name(BatteryStatus, self.status)
+    
+    def __init__(self, component: int, level: int, status: int):
+        self.component = component
+        self.level = level
+        self.status = status
+        pass
+    
+class BatteryNotification:
+    def __init__(self):
+        self.first = Battery(BatteryComponent.LEFT, 0, BatteryStatus.DISCONNECTED)
+        self.second = Battery(BatteryComponent.RIGHT, 0, BatteryStatus.DISCONNECTED)
+        self.case = Battery(BatteryComponent.CASE, 0, BatteryStatus.DISCONNECTED)
+        pass
+    
+    def isBatteryData(self, data):
+        if len(data) != 22:
+            return False
+        if data[0] == 0x04 and data[1] == 0x00 and data[2] == 0x04 and data[3] == 0x00 and data[4] == 0x04 and data[5] == 0x00:
+            return True
+        else:
+            return False
+    def setBattery(self, data):
+        self.count = data[6]
+        self.first = Battery(data[7], data[9], data[10])
+        self.second = Battery(data[12], data[14], data[15])
+        self.case = Battery(data[17], data[19], data[20])
+        pass
+    
+    def getBattery(self):
+        if self.first.component == BatteryComponent.LEFT:
+            self.left = self.first
+            self.right = self.second
+        else:
+            self.left = self.second
+            self.right = self.first
+        self.case = self.case
+        return [self.left, self.right, self.case]

linux.old/aln/Notifications/ConversationalAwareness.py

@@ -0,0 +1,33 @@
+# AirPods like Normal (ALN) - Bringing Apple-only features to Linux and Android for seamless AirPods functionality!
+#
+# Copyright (C) 2024 Kavish Devar
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published
+# by the Free Software Foundation, either version 3 of the License.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+from ..enums import enums
+
+class ConversationalAwarenessNotification:
+    NOTIFICATION_PREFIX = enums.CONVERSATION_AWARENESS_RECEIVE_PREFIX
+    
+    def __init__(self):
+        pass
+    
+    def isConversationalAwarenessData(self, data: bytes):
+        if len(data) != 10:
+            return False
+        if data.hex().startswith(self.NOTIFICATION_PREFIX.hex()):
+            return True
+    
+    def setData(self, data: bytes):
+        self.status = data[9]
+        pass

linux.old/aln/Notifications/EarDetection.py

@@ -0,0 +1,42 @@
+# AirPods like Normal (ALN) - Bringing Apple-only features to Linux and Android for seamless AirPods functionality!
+#
+# Copyright (C) 2024 Kavish Devar
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published
+# by the Free Software Foundation, either version 3 of the License.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+from ..Capabilites import Capabilites
+from ..enums import enums
+from typing import Literal
+
+class EarDetectionNotification:
+    NOTIFICATION_BIT = Capabilites.EAR_DETECTION
+    NOTIFICATION_PREFIX = enums.PREFIX + NOTIFICATION_BIT
+    IN_EAR = 0x00
+    OUT_OF_EAR = 0x01
+    def __init__(self):
+        pass
+    
+    def isEarDetectionData(self, data: bytes):
+        if len(data) != 8:
+            return False
+        if data.hex().startswith(self.NOTIFICATION_PREFIX.hex()):
+            return True
+    
+    def setEarDetection(self, data: bytes):
+        self.first = data[6]
+        self.second = data[7]
+
+    def getEarDetection(self):
+        return [self.first, self.second]
+        pass
+        

linux.old/aln/Notifications/Listener.py

@@ -0,0 +1,73 @@
+# AirPods like Normal (ALN) - Bringing Apple-only features to Linux and Android for seamless AirPods functionality!
+#
+# Copyright (C) 2024 Kavish Devar
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published
+# by the Free Software Foundation, either version 3 of the License.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program. If not, see <https://www.gnu.org/licenses/>.
+from bluetooth import BluetoothSocket
+import threading
+from .Battery import BatteryNotification
+from .EarDetection import EarDetectionNotification
+from .ConversationalAwareness import ConversationalAwarenessNotification
+from .ANC import ANCNotification
+import logging
+
+logging = logging.getLogger(__name__)
+
+class NotificationListener:
+    BATTERY_UPDATED = 0x01
+    ANC_UPDATED = 0x02
+    EAR_DETECTION_UPDATED = 0x03
+    CA_UPDATED = 0x04
+    UNKNOWN = 0x00
+
+    def __init__(self, socket: BluetoothSocket, callback: callable):
+        self.socket = socket
+        self.BatteryNotification = BatteryNotification()
+        self.EarDetectionNotification = EarDetectionNotification()
+        self.ANCNotification = ANCNotification()
+        self.ConversationalAwarenessNotification = ConversationalAwarenessNotification()
+        self.callback = callback
+        pass
+    
+    def __start(self):
+        while True:
+            data = self.socket.recv(1024)
+            if len(data) == 0:
+                break
+            if self.BatteryNotification.isBatteryData(data):
+                self.BatteryNotification.setBattery(data)
+                self.callback(self.BATTERY_UPDATED, data)
+                pass
+            if self.EarDetectionNotification.isEarDetectionData(data):
+                self.EarDetectionNotification.setEarDetection(data)
+                self.callback(self.EAR_DETECTION_UPDATED, data)
+            if self.ANCNotification.isANCData(data):
+                self.ANCNotification.setData(data)
+                self.callback(self.ANC_UPDATED, data)
+            if self.ConversationalAwarenessNotification.isConversationalAwarenessData(data):
+                self.ConversationalAwarenessNotification.setData(data)
+                self.callback(self.CA_UPDATED, data)
+            else:
+                self.callback(self.UNKNOWN, data)
+                pass
+            pass
+        pass
+    
+    def start(self):
+        threading.Thread(target=self.__start).start()
+        pass
+    
+    def stop(self):
+        self.socket.close()
+        pass
+        

linux.old/aln/Notifications/__init__.py

@@ -0,0 +1,56 @@
+# AirPods like Normal (ALN) - Bringing Apple-only features to Linux and Android for seamless AirPods functionality!
+#
+# Copyright (C) 2024 Kavish Devar
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published
+# by the Free Software Foundation, either version 3 of the License.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+from .Listener import NotificationListener
+from ..enums import enums
+import bluetooth
+import logging
+
+logging = logging.getLogger(__name__)
+
+enums = enums()
+
+class Notifications:
+    BATTERY_UPDATED = NotificationListener.BATTERY_UPDATED
+    ANC_UPDATED = NotificationListener.ANC_UPDATED
+    CA_UPDATED = NotificationListener.CA_UPDATED
+    EAR_DETECTION_UPDATED = NotificationListener.EAR_DETECTION_UPDATED
+    UNKNOWN = NotificationListener.UNKNOWN
+    def __init__(self, socket: bluetooth.BluetoothSocket, callback: callable):
+        self.socket = socket
+        self.notificationListener = NotificationListener(self.socket, callback)
+        self.BatteryNotification = self.notificationListener.BatteryNotification
+        self.EarDetectionNotification = self.notificationListener.EarDetectionNotification
+        self.ANCNotification = self.notificationListener.ANCNotification
+        self.ConversationalAwarenessNotification = self.notificationListener.ConversationalAwarenessNotification
+        pass
+
+    def initialize(self):
+        try:
+            self.socket.send(enums.SET_SPECIFIC_FEATURES)
+            self.socket.send(enums.REQUEST_NOTIFICATIONS)
+            self.notificationListener.start()
+            
+        except bluetooth.btcommon.BluetoothError as e:
+            logging.error(f'Failed to send data to {self.mac_address}: {e}')
+            return False
+        return True
+
+    def __del__(self):
+        self.notificationListener.stop()
+        self.socket.close()
+        pass
+    pass

linux.old/aln/__init__.py

@@ -0,0 +1,87 @@
+# AirPods like Normal (ALN) - Bringing Apple-only features to Linux and Android for seamless AirPods functionality!
+#
+# Copyright (C) 2024 Kavish Devar
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published
+# by the Free Software Foundation, either version 3 of the License.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+from .Notifications import Notifications
+import bluetooth
+import logging
+
+logging = logging.getLogger("Connection Handler")
+
+class Connection:
+    def __init__(self, mac_address: str):
+        self.mac_address = mac_address
+        self.socket = bluetooth.BluetoothSocket(bluetooth.L2CAP)
+    def connect(self):
+        try:
+            self.socket.connect((self.mac_address, 0x1001))
+        except bluetooth.btcommon.BluetoothError as e:
+            logging.error(f'Failed to connect to {self.mac_address}: {e}')
+            return False
+        return True
+    
+    def initialize_notifications(self, callback: callable = None):
+        if callback is None:
+            callback = self.notification_callback
+        self.notifications = Notifications(self.socket, callback)
+        self.notificationListener = self.notifications.notificationListener
+        self.BatteryNotification = self.notifications.BatteryNotification
+        self.ANCNotification = self.notifications.ANCNotification
+        self.EarDetectionNotification = self.notifications.EarDetectionNotification
+        self.ConversationalAwarenessNotification = self.notifications.ConversationalAwarenessNotification
+        self.notifications.initialize()
+
+    def send(self, data: bytes):
+        try:
+            logging.info(f"Sending data to {self.mac_address}: {data}")
+            self.socket.send(data)
+        except bluetooth.btcommon.BluetoothError as e:
+            logging.error(f'Failed to send data to {self.mac_address}: {e}')
+            return False
+        return True
+    
+    def notification_callback(self, notification_type: int, data: bytes):
+        import logging
+        if notification_type == Notifications.BATTERY_UPDATED:
+            logging = logging.getLogger("Battery Status")
+            for i in self.notificationListener.BatteryNotification.getBattery():
+                logging.debug(f'{i.get_component()} - {i.get_status()}: {i.get_level()}')
+            pass
+        elif notification_type == Notifications.EAR_DETECTION_UPDATED:
+            logging = logging.getLogger("In-Ear Status")
+            logging.debug(f'{self.notificationListener.EarDetectionNotification.getEarDetection()}')
+            pass
+        elif notification_type == Notifications.ANC_UPDATED:
+            logging = logging.getLogger("ANC Status")
+            logging.debug(f'{self.notificationListener.ANCNotification.status}')
+            pass
+        elif notification_type == Notifications.CA_UPDATED:
+            logging = logging.getLogger("Conversational Awareness Status")
+            logging.debug(f'{self.notificationListener.ConversationalAwarenessNotification.status}')
+            pass
+        elif notification_type == Notifications.UNKNOWN:
+            logging = logging.getLogger("Unknown Notification")
+            hex_data = ' '.join(f'{byte:02x}' for byte in data)
+            logging.debug(f'{hex_data}')
+            pass
+        pass
+
+    def disconnect(self):
+        self.socket.close()
+        pass
+
+    def __del__(self):
+        self.socket.close()
+        pass

linux.old/aln/__main__.py

@@ -0,0 +1,265 @@
+# AirPods like Normal (ALN) - Bringing Apple-only features to Linux and Android for seamless AirPods functionality!
+#
+# Copyright (C) 2024 Kavish Devar
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published
+# by the Free Software Foundation, either version 3 of the License.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+import logging.handlers
+import socket
+import threading
+import signal
+import sys
+import logging
+from . import Connection
+import enums
+from aln.Notifications import Notifications
+from aln.Notifications.Battery import Battery
+import os
+import bluetooth
+from aln.enums import enums
+connection = None
+
+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')
+
+# RotatingFileHandler
+
+formatter = logging.Formatter('%(asctime)s - %(levelname)s - %(message)s')
+handler = logging.handlers.RotatingFileHandler(LOG_FILE, maxBytes=2**20)
+handler.setFormatter(formatter)
+handler.setLevel(logging.DEBUG)
+
+l = logging.getLogger()
+l.setLevel(logging.DEBUG)
+l.addHandler(handler)
+
+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":
+                                # noinspection PyTypeChecker
+                                data: list[int] = data
+                                earDetectionJSON = {
+                                    "type": "ear_detection",
+                                    "primary": data[0],
+                                    "secondary": data[1]
+                                }
+                                data: str = JSONEncoder().encode(earDetectionJSON)
+                            elif notif_key == "notif_anc":
+                                data: int = data
+                                ancJSON = {
+                                    "type": "anc",
+                                    "mode": data,
+                                }
+                                data: str = JSONEncoder().encode(ancJSON)
+                            elif notif_key == "notif_ca":
+                                data: int = data
+                                caJSON = {
+                                    "type": "ca",
+                                    "status": data,
+                                }
+                                data: str = JSONEncoder().encode(caJSON)
+                            elif notif_key == "notif_unknown":
+                                logging.debug(f"Unhandled notification type: {notif_key}")
+                                logging.debug(f"Data: {data}")
+                                data: str = JSONEncoder().encode({"type": "unknown", "data": data})
+                            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(_, __):
+    """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, data: bytes):
+    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)
+    elif notification_type == Notifications.ANC_UPDATED:
+        logger = logging.getLogger("ANC Status")
+        anc = connection.notificationListener.ANCNotification.status
+        globals()["notif_anc"] = anc
+        logger.debug(anc)
+    elif notification_type == Notifications.CA_UPDATED:
+        logger = logging.getLogger("Conversational Awareness Status")
+        ca = connection.notificationListener.ConversationalAwarenessNotification.status
+        globals()["notif_ca"] = ca
+        logger.debug(ca)
+    elif notification_type == Notifications.UNKNOWN:
+        logger = logging.getLogger("Unknown Notification")
+        hex_data = ' '.join(f'{byte:02x}' for byte in data)
+        globals()["notif_unknown"] = hex_data
+        logger.debug(hex_data)
+
+def main():
+    global running
+    logging.info("Starting AirPods daemon")
+    
+    connection = Connection(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 {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()

linux.old/aln/enums.py

@@ -0,0 +1,43 @@
+# AirPods like Normal (ALN) - Bringing Apple-only features to Linux and Android for seamless AirPods functionality!
+#
+# Copyright (C) 2024 Kavish Devar
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published
+# by the Free Software Foundation, either version 3 of the License.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+from .Capabilites import Capabilites
+
+class enums:
+    NOISE_CANCELLATION = Capabilites.NOISE_CANCELLATION
+    CONVERSATION_AWARENESS = Capabilites.CONVERSATION_AWARENESS
+    CUSTOMIZABLE_ADAPTIVE_TRANSPARENCY = Capabilites.CUSTOMIZABLE_ADAPTIVE_TRANSPARENCY
+    PREFIX = b'\x04\x00\x04\x00'
+    SETTINGS = b"\x09\x00"
+    SUFFIX = b'\x00\x00\x00'
+    NOTIFICATION_FILTER = b'\x0f'
+    SPECIFIC_FEATURES = b'\x4d'
+    SET_SPECIFIC_FEATURES = PREFIX + SPECIFIC_FEATURES + b"\x00\xff\x00\x00\x00\x00\x00\x00\x00"
+    REQUEST_NOTIFICATIONS = PREFIX + NOTIFICATION_FILTER + b"\x00\xff\xff\xff\xff"
+    HANDSHAKE = b"\x00\x00\x04\x00\x01\x00\x02\x00\x00\x00\x00\x00\x00\x00\x00\x00"
+    NOISE_CANCELLATION_PREFIX = PREFIX + SETTINGS + NOISE_CANCELLATION
+    NOISE_CANCELLATION_OFF = NOISE_CANCELLATION_PREFIX + Capabilites.NoiseCancellation.OFF + SUFFIX
+    NOISE_CANCELLATION_ON = NOISE_CANCELLATION_PREFIX + Capabilites.NoiseCancellation.ON + SUFFIX
+    NOISE_CANCELLATION_TRANSPARENCY = NOISE_CANCELLATION_PREFIX + Capabilites.NoiseCancellation.TRANSPARENCY + SUFFIX
+    NOISE_CANCELLATION_ADAPTIVE = NOISE_CANCELLATION_PREFIX + Capabilites.NoiseCancellation.ADAPTIVE + SUFFIX
+    
+    SET_CONVERSATION_AWARENESS_OFF = PREFIX + SETTINGS + CONVERSATION_AWARENESS + Capabilites.ConversationAwareness.OFF + SUFFIX
+    SET_CONVERSATION_AWARENESS_ON = PREFIX + SETTINGS + CONVERSATION_AWARENESS + Capabilites.ConversationAwareness.ON + SUFFIX
+    
+    CONVERSATION_AWARENESS_RECEIVE_PREFIX = PREFIX + b"\x4b\x00\x02\00"
+    
+    class longPress:
+        PREFIX = b'\x04\x00\x04\x00\x09\x00\x1A'

linux.old/aln/listener.py

@@ -0,0 +1,47 @@
+# AirPods like Normal (ALN) - Bringing Apple-only features to Linux and Android for seamless AirPods functionality!
+#
+# Copyright (C) 2024 Kavish Devar
+#
+# This program is free software: you can redistribute it and/or modify
+# it under the terms of the GNU Affero General Public License as published
+# by the Free Software Foundation, either version 3 of the License.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU Affero General Public License for more details.
+#
+# You should have received a copy of the GNU Affero General Public License
+# along with this program. If not, see <https://www.gnu.org/licenses/>.
+
+import bluetooth
+import time
+
+class BluetoothListener:
+    def __init__(self):
+        self.connected_devices = set()
+
+    def scan_devices(self):
+        nearby_devices = bluetooth.discover_devices(lookup_names=True, lookup_class=True, device_id=-1, duration=8, flush_cache=True)
+        return nearby_devices
+
+    def start_listening(self):
+        print("Listening for Bluetooth devices")
+        while True:
+            nearby_devices = self.scan_devices()
+            current_devices = set()
+
+            for addr, name, device_class in nearby_devices:
+                current_devices.add(addr)
+                if addr not in self.connected_devices:
+                    print(f"Device connected: {name} [{addr}]")
+            
+            for addr in self.connected_devices - current_devices:
+                print(f"Device disconnected: [{addr}]")
+
+            self.connected_devices = current_devices
+            time.sleep(5)
+
+if __name__ == "__main__":
+    listener = BluetoothListener()
+    listener.start_listening()