updated

Author: GvozdevLeonid

python_hackrf/pyhackrf_tools/pyhackrf_info.py

@@ -62,24 +62,25 @@ def pyhackrf_info(print_to_console: bool = True, initialize: bool = True) -> Non
     else:
         print_info += 'No HackRF boards found.'
 
+    if initialize:
+        pyhackrf.pyhackrf_exit()
+
     if print_to_console:
         print(print_info)
     else:
         return print_info
 
-    if initialize:
-        pyhackrf.pyhackrf_exit()
-
 
 def pyhackrf_serial_numbers_list_info(print_to_console: bool = True, initialize: bool = True) -> None | tuple[int, list]:
     if initialize:
         pyhackrf.pyhackrf_init()
 
     device_list = pyhackrf.pyhackrf_device_list()
 
+    if initialize:
+        pyhackrf.pyhackrf_exit()
+
     if print_to_console:
         print(f'Serial numbers [{device_list.device_count}]: {device_list.serial_numbers}')
     else:
         return device_list.device_count, device_list.serial_numbers
-    if initialize:
-        pyhackrf.pyhackrf_exit()

python_hackrf/pyhackrf_tools/pyhackrf_sweep.pyx

@@ -115,7 +115,7 @@ def init_signals():
         pass
 
 
-cdef sweep_callback(buffer: np.ndarray[:], buffer_length: int, valid_length: int):
+cdef sweep_callback(device: pyhackrf.PyHackrfDevice, buffer: np.ndarray[:], buffer_length: int, valid_length: int):
     global fftSize, window, pwr_1_start, pwr_1_stop, pwr_2_start, pwr_2_stop, norm_factor, data_length, SAMPLE_RATE
     global start_frequency, sweep_count, sweep_started, max_num_sweeps, check_max_num_sweeps, accepted_bytes, one_shot_mode, run_available
     global binary_output_mode, file_object, queue_mode, SWEEP_STYLE

python_hackrf/pylibhackrf/__android.py

@@ -0,0 +1,92 @@
+from threading import Event
+
+try:
+    from jnius import autoclass
+except ImportError:
+    def autoclass(item):
+        raise RuntimeError('autoclass not available')
+
+try:
+    from android.broadcast import BroadcastReceiver
+except ImportError:
+    def BroadcastReceiver(item):
+        raise RuntimeError('BroadcastReceiver not available')
+
+hackrf_usb_vid = 0x1d50
+hackrf_usb_pids = (0x604b, 0x6089, 0xcc15)
+
+class USBBroadcastReceiver:
+    def __init__(self, events):
+        self.events = events
+
+    def start(self):
+        self.br = BroadcastReceiver(self.on_broadcast, actions=['libusb.android.USB_PERMISSION'])
+        self.br.start()
+
+    def stop(self):
+        self.br.stop()
+
+    def on_broadcast(self, context, intent):
+        action = intent.getAction()
+        if action == 'libusb.android.USB_PERMISSION':
+            UsbManager = autoclass('android.hardware.usb.UsbManager')
+            usb_device = intent.getParcelableExtra(UsbManager.EXTRA_DEVICE)
+            granted = intent.getBooleanExtra(autoclass('android.content.Intent').EXTRA_PERMISSION_GRANTED, False)
+            device_name = usb_device.getDeviceName()
+            print(device_name, granted)
+            if device_name in self.events:
+                self.events[device_name]['granted'] = granted
+                self.events[device_name]['device'] = usb_device
+                self.events[device_name]['event'].set()
+
+
+def get_usb_devices_info(num_devices: int = None):
+    events = {}
+    device_file_descriptors = []
+
+    usb_broadcast_receiver = USBBroadcastReceiver(events)
+
+    Context = autoclass('android.content.Context')
+    PendingIntent = autoclass('android.app.PendingIntent')
+
+    activity = autoclass('org.kivy.android.PythonActivity').mActivity
+    usb_manager = activity.getSystemService(Context.USB_SERVICE)
+    permission_intent = 'libusb.android.USB_PERMISSION'
+
+    flags = PendingIntent.FLAG_IMMUTABLE
+    mPermissionIntent = PendingIntent.getBroadcast(activity, 0, autoclass('android.content.Intent')(permission_intent), flags)
+
+    device_list = usb_manager.getDeviceList()
+    if device_list:
+        for idx, usb_device in enumerate(device_list.values()):
+            device_name = usb_device.getDeviceName()
+            if (
+                usb_device.getVendorId() == hackrf_usb_vid
+                and usb_device.getProductId() in hackrf_usb_pids
+            ):
+
+                if usb_manager.hasPermission(usb_device):
+                    usb_device_connection = usb_manager.openDevice(usb_device)
+                    file_descriptor = usb_device_connection.getFileDescriptor()
+                    device_file_descriptors.append((file_descriptor, usb_device.getProductId(), usb_device.getSerialNumber()))
+                else:
+                    events[device_name] = {'event': Event(), 'granted': False, 'device': None}
+                    usb_manager.requestPermission(usb_device, mPermissionIntent)
+                
+                if num_devices is not None and idx + 1 == num_devices:
+                    break
+
+        if len(events):
+            usb_broadcast_receiver.start()
+            for device_name, info in events.items():
+                info['event'].wait()
+            usb_broadcast_receiver.stop()
+
+            for device_name, info in events.items():
+                if info['granted']:
+                    usb_device = info['device']
+                    usb_device_connection = usb_manager.openDevice(usb_device)
+                    file_descriptor = usb_device_connection.getFileDescriptor()
+                    device_file_descriptors.append((file_descriptor, usb_device.getProductId(), usb_device.getSerialNumber()))
+
+    return device_file_descriptors

python_hackrf/pylibhackrf/pyhackrf.pyx

@@ -74,18 +74,18 @@ cdef dict operacake_ports = {
 cdef int __rx_callback(chackrf.hackrf_transfer* transfer) nogil:
     global global_callbacks
     with gil:
-        np_buffer = np.asarray(<uint8_t[:transfer.buffer_length]>transfer.buffer)  # type: ignore
+        np_buffer = np.asarray(<uint8_t[:transfer.buffer_length]> transfer.buffer)  # type: ignore
         if global_callbacks[<size_t> transfer.device]['__rx_callback'] is not None:
-            result = global_callbacks[<size_t> transfer.device]['__rx_callback'](np_buffer, transfer.buffer_length, transfer.valid_length)
+            result = global_callbacks[<size_t> transfer.device]['__rx_callback'](global_callbacks[<size_t> transfer.device]['device'], np_buffer, transfer.buffer_length, transfer.valid_length)
             return result
     return -1
 
 cdef int __tx_callback(chackrf.hackrf_transfer* transfer) nogil:
     global global_callbacks
     with gil:
-        np_buffer = np.asarray(<uint8_t[:transfer.buffer_length]>transfer.buffer)  # type: ignore
+        np_buffer = np.asarray(<uint8_t[:transfer.buffer_length]> transfer.buffer)  # type: ignore
         if global_callbacks[<size_t> transfer.device]['__tx_callback'] is not None:
-            result, buffer, valid_length = global_callbacks[<size_t> transfer.device]['__tx_callback'](np_buffer, transfer.buffer_length, transfer.valid_length)
+            result, buffer, valid_length = global_callbacks[<size_t> transfer.device]['__tx_callback'](global_callbacks[<size_t> transfer.device]['device'], np_buffer, transfer.buffer_length, transfer.valid_length)
 
             for i in range(valid_length):
                 transfer.buffer[i] = buffer[i]
@@ -97,24 +97,25 @@ cdef int __tx_callback(chackrf.hackrf_transfer* transfer) nogil:
 cdef int __sweep_callback(chackrf.hackrf_transfer* transfer) nogil:
     global global_callbacks
     with gil:
-        np_buffer = np.asarray(<uint8_t[:transfer.buffer_length]>transfer.buffer)  # type: ignore
+        np_buffer = np.asarray(<uint8_t[:transfer.buffer_length]> transfer.buffer)  # type: ignore
         if global_callbacks[<size_t> transfer.device]['__sweep_callback'] is not None:
-            result = global_callbacks[<size_t> transfer.device]['__sweep_callback'](np_buffer, transfer.buffer_length, transfer.valid_length)
+            result = global_callbacks[<size_t> transfer.device]['__sweep_callback'](global_callbacks[<size_t> transfer.device]['device'], np_buffer, transfer.buffer_length, transfer.valid_length)
             return result
     return -1
 
 cdef void __tx_complete_callback(chackrf.hackrf_transfer* transfer, int success) nogil:
     global global_callbacks
     with gil:
-        np_buffer = np.asarray(<uint8_t[:transfer.buffer_length]>transfer.buffer)  # type: ignore
+        np_buffer = np.asarray(<uint8_t[:transfer.buffer_length]> transfer.buffer)  # type: ignore
         if global_callbacks[<size_t> transfer.device]['__tx_complete_callback'] is not None:
-            global_callbacks[<size_t> transfer.device]['__tx_complete_callback'](np_buffer, transfer.buffer_length, transfer.valid_length, success)
+            global_callbacks[<size_t> transfer.device]['__tx_complete_callback'](global_callbacks[<size_t> transfer.device]['device'], np_buffer, transfer.buffer_length, transfer.valid_length, success)
 
 cdef void __tx_flush_callback(void* flush_ctx, int success) nogil:
     global global_callbacks
+    cdef size_t device_ptr = <size_t> flush_ctx
     with gil:
-        if global_callbacks['__tx_flush_callback'] is not None:
-            global_callbacks['__tx_flush_callback'](success)
+        if global_callbacks[device_ptr]['__tx_flush_callback'] is not None:
+            global_callbacks[device_ptr]['__tx_flush_callback'](global_callbacks[device_ptr]['device'], success)
 
 
 cdef class PyHackRFDeviceList:
@@ -182,13 +183,14 @@ cdef class PyHackrfDevice:
         global global_callbacks
 
         if self.__hackrf_device is not NULL:
-            global_callbacks[<size_t>self.__hackrf_device] = {
+            global_callbacks[<size_t> self.__hackrf_device] = {
                 '__rx_callback': None,
                 '__tx_callback': None,
                 '__sweep_callback': None,
                 '__tx_complete_callback': None,
+                '__tx_flush_callback': None,
+                'device': self,
             }
-            global_callbacks['__tx_flush_callback'] = None
             return
 
         raise RuntimeError(f'_setup_callbacks() failed: Device not initialized!')
@@ -342,7 +344,7 @@ cdef class PyHackrfDevice:
                             ) -> None:
 
         cdef uint16_t* frequencies
-        frequencies = <uint16_t*>malloc(chackrf.MAX_SWEEP_RANGES * 2 * sizeof(uint16_t))
+        frequencies = <uint16_t*> malloc(chackrf.MAX_SWEEP_RANGES * 2 * sizeof(uint16_t))
 
         for index, frequency in enumerate(frequency_list):
             frequencies[index] = frequency
@@ -392,7 +394,7 @@ cdef class PyHackrfDevice:
             raise RuntimeError(f'pyhackrf_set_tx_block_complete_callback() failed: {chackrf.hackrf_error_name(result).decode("utf-8")} ({result})')
 
     def pyhackrf_enable_tx_flush(self) -> None:
-        result = chackrf.hackrf_enable_tx_flush(self.__hackrf_device, __tx_flush_callback, NULL)
+        result = chackrf.hackrf_enable_tx_flush(self.__hackrf_device, __tx_flush_callback, <void*> self.__hackrf_device)
         if result != chackrf.hackrf_error.HACKRF_SUCCESS:
             raise RuntimeError(f'pyhackrf_enable_tx_flush() failed: {chackrf.hackrf_error_name(result).decode("utf-8")} ({result})')
 
@@ -459,74 +461,74 @@ cdef class PyHackrfDevice:
     def set_rx_callback(self, rx_callback_function) -> None:
         global global_callbacks
         """
-        Accept a 3 args that contains the buffer, the maximum length and the length of the buffer data.
-        buffer: numpy.array(dtype=numpy.uint8), buffer_length: int, valid_length: int
+        Accept a 4 args that contains the device, buffer, the maximum length and the length of the buffer data.
+        device: PyHackrfDevice, buffer: numpy.array(dtype=numpy.uint8), buffer_length: int, valid_length: int
 
-        Should copy/process the contents of the transfer buffer's valid part.
+        Should copy/process the contents of the buffer's valid part.
 
         The callback should return 0 if it wants to be called again, and any other value otherwise.
         """
         if self.__hackrf_device is not NULL:
-            global_callbacks[<size_t>self.__hackrf_device]['__rx_callback'] = rx_callback_function
+            global_callbacks[<size_t> self.__hackrf_device]['__rx_callback'] = rx_callback_function
             return
 
         raise RuntimeError(f'set_rx_callback() failed: Device not initialized!')
 
     def set_tx_callback(self, tx_callback_function) -> None:
         global global_callbacks
         """
-        Accept a 3 args that contains the buffer, the maximum length and the length of the buffer data.
-        buffer: numpy.array(dtype=numpy.uint8), buffer_length: int, valid_length: int
+        Accept a 4 args that contains the device, buffer, the maximum length and the length of the buffer data.
+        device: PyHackrfDevice, buffer: numpy.array(dtype=numpy.uint8), buffer_length: int, valid_length: int
 
 
         The callback should return 0 if it wants to be called again, and any other value otherwise, numpy array(buffer) and new valid_length
         """
         if self.__hackrf_device is not NULL:
-            global_callbacks[<size_t>self.__hackrf_device]['__tx_callback'] = tx_callback_function
+            global_callbacks[<size_t> self.__hackrf_device]['__tx_callback'] = tx_callback_function
             return
 
         raise RuntimeError(f'set_tx_callback() failed: Device not initialized!')
 
     def set_sweep_callback(self, sweep_callback_function) -> None:
         global global_callbacks
         """
-        Accept a 3 args that contains the buffer, the maximum length and the length of the buffer data.
-        buffer: numpy.array(dtype=numpy.uint8), buffer_length: int, valid_length: int
+        Accept a 4 args that contains the device, buffer, the maximum length and the length of the buffer data.
+        device: PyHackrfDevice, buffer: numpy.array(dtype=numpy.uint8), buffer_length: int, valid_length: int
 
-        Must copy/process the contents of a valid portion of the send buffer.
+        Should copy/process the contents of the buffer's valid part.
 
         The callback should return 0 if it wants to be called again, and any other value otherwise.
         * In this mode, with one data transfer (one callback call)
         """
         if self.__hackrf_device is not NULL:
-            global_callbacks[<size_t>self.__hackrf_device]['__sweep_callback'] = sweep_callback_function
+            global_callbacks[<size_t> self.__hackrf_device]['__sweep_callback'] = sweep_callback_function
             return
 
         raise RuntimeError(f'set_sweep_callback() failed: Device not initialized!')
 
     def set_tx_complete_callback(self, tx_complete_callback_function) -> None:
         global global_callbacks
         """
-        Accept a 4 args that contains the buffer, the maximum length and the length of the buffer data.
-        buffer: numpy.array(dtype=numpy.uint8), buffer_length: int, valid_length: int
+        Accept a 5 args that contains the device, buffer, the maximum length and the length of the buffer data.
+        device: PyHackrfDevice, buffer: numpy.array(dtype=numpy.uint8), buffer_length: int, valid_length: int
         and
         success: int # if the transfer was successful or not
         """
         if self.__hackrf_device is not NULL:
-            global_callbacks[<size_t>self.__hackrf_device]['__tx_complete_callback'] = tx_complete_callback_function
+            global_callbacks[<size_t> self.__hackrf_device]['__tx_complete_callback'] = tx_complete_callback_function
             return
 
         raise RuntimeError(f'set_tx_complete_callback() failed: Device not initialized!')
 
     def set_tx_flush_callback(self, tx_flush_callback_function) -> None:
         global global_callbacks
         """
-        Accept one argument of type int.
+        Accept 2 args that contains device and success flag
+        device: PyHackrfDevice, success: int
         This callback will be called when all the data was transmitted and all data transfers were completed.
-        Prameter is success flag.
         """
 
-        global_callbacks['__tx_flush_callback'] = tx_flush_callback_function
+        global_callbacks[<size_t> self.__hackrf_device]['__tx_flush_callback'] = tx_flush_callback_function
 
     # ---- library ---- #
     def pyhackrf_get_transfer_buffer_size(self) -> int:
@@ -538,7 +540,7 @@ cdef class PyHackrfDevice:
     # ---- operacake ---- #
     def pyhackrf_get_operacake_boards(self) -> list:
         self.pyoperacakes.clear()
-        cdef uint8_t* operacakes = <uint8_t*>malloc(8 * sizeof(uint8_t))
+        cdef uint8_t* operacakes = <uint8_t*> malloc(8 * sizeof(uint8_t))
         result = chackrf.hackrf_get_operacake_boards(self.__hackrf_device, &operacakes[0])
 
         if result != chackrf.hackrf_error.HACKRF_SUCCESS:
@@ -577,7 +579,7 @@ cdef class PyHackrfDevice:
             raise RuntimeError(f'pyhackrf_set_operacake_ports() failed: {chackrf.hackrf_error_name(result).decode("utf-8")} ({result})')
 
     def pyhackrf_set_operacake_dwell_times(self, dwell_times: list) -> None:
-        cdef chackrf.hackrf_operacake_dwell_time* _dwell_times = <chackrf.hackrf_operacake_dwell_time*>malloc(PY_HACKRF_OPERACAKE_MAX_DWELL_TIMES * sizeof(chackrf.hackrf_operacake_dwell_time))
+        cdef chackrf.hackrf_operacake_dwell_time* _dwell_times = <chackrf.hackrf_operacake_dwell_time*> malloc(PY_HACKRF_OPERACAKE_MAX_DWELL_TIMES * sizeof(chackrf.hackrf_operacake_dwell_time))
         for index, (dwell, port) in enumerate(dwell_times):
             _dwell_times[index].dwell = dwell
             _dwell_times[index].port = <uint8_t> operacake_ports[port]
@@ -589,7 +591,7 @@ cdef class PyHackrfDevice:
             raise RuntimeError(f'pyhackrf_set_operacake_dwell_times() failed: {chackrf.hackrf_error_name(result).decode("utf-8")} ({result})')
 
     def pyhackrf_set_operacake_freq_ranges(self, freq_ranges: list) -> None:
-        cdef chackrf.hackrf_operacake_freq_range* _freq_ranges = <chackrf.hackrf_operacake_freq_range*>malloc(PY_HACKRF_OPERACAKE_MAX_FREQ_RANGES * sizeof(chackrf.hackrf_operacake_freq_range))
+        cdef chackrf.hackrf_operacake_freq_range* _freq_ranges = <chackrf.hackrf_operacake_freq_range*> malloc(PY_HACKRF_OPERACAKE_MAX_FREQ_RANGES * sizeof(chackrf.hackrf_operacake_freq_range))
         for index, (port, freq_min, freq_max) in enumerate(freq_ranges):
             _freq_ranges[index].freq_min = freq_min
             _freq_ranges[index].freq_max = freq_max