docs: def start(self, **kwargs):
          """Start listening to command queue, process commands in main loop,
          set status, etc...
          This function is most likely called by the frontend in a separate
          process."""
  
          # Keep a copy of keyword arguments for use in subclasses
          self.start_kwargs.update(kwargs)
          try:
              self.initialize_logging()
  
              self.__update_service_status(self.SERVICE_STATUS_STARTING)
  
              self.start_transport()
  
              self.initializing()
              self._register("command", self.__process_command)
  
              if self.__pipe_commands is None:
                  # can only listen to commands if command queue is defined
                  self.__shutdown = True
              else:
                  # start listening to command queue in separate thread
                  self.__start_command_queue_listener()
  
              while not self.__shutdown:  # main loop
                  self.__update_service_status(self.SERVICE_STATUS_IDLE)
  
                  if self._idle_time is None:
                      task = self.__queue.get()
                  else:
                      try:
                          task = self.__queue.get(True, self._idle_time)
                      except queue.Empty:
                          self.__update_service_status(self.SERVICE_STATUS_TIMER)
                          if self._idle_callback:
                              self._idle_callback()
                          continue
  
                  self.__update_service_status(self.SERVICE_STATUS_PROCESSING)
  
                  if task[0] == Priority.COMMAND:
                      message = task[2]
                      if message and "band" in message:
                          processor = self.__callback_register.get(message["band"])
                          if processor is None:
                              self.log.warning(
                                  "received message on unregistered band\n%s", message
                              )
                          else:
                              processor(message.get("payload"))
                      else:
                          self.log.warning(
                              "received message without band information\n%s", message
                          )
                  elif task[0] == Priority.TRANSPORT:
                      callback, header, message = task[2]
                      callback(header, message)
                  else:
                      self.log.warning("Unknown item on main service queue\n%r", task)
  
          except KeyboardInterrupt:
              self.log.warning("Ctrl+C detected. Shutting down.")
  
          except Exception as e:
              self.process_uncaught_exception(e)
              self.__update_service_status(self.SERVICE_STATUS_ERROR)
              self.in_shutdown()
              return
  
          try:
              self.__update_service_status(self.SERVICE_STATUS_SHUTDOWN)
              self.in_shutdown()
              self.__update_service_status(self.SERVICE_STATUS_END)
          except Exception as e:
              self.process_uncaught_exception(e)
              self.__update_service_status(self.SERVICE_STATUS_ERROR)