code: async def _worker_process(self) -> None:
          
          state = self.STATE_DETECT
          timeout = self._time_duration
  
          self._loop.call_soon(self._callback, False)
  
          re_start = re.compile("silence_start")
          re_end = re.compile("silence_end")
  
          # process queue data
          while True:
              try:
                  _LOGGER.debug("Reading State: %d, timeout: %s", state, timeout)
                  with async_timeout.timeout(timeout, loop=self._loop):
                      data = await self._que.get()
                  timeout = None
                  if data is None:
                      self._loop.call_soon(self._callback, None)
                      return
              except asyncio.TimeoutError:
                  _LOGGER.debug("Blocking timeout")
                  # noise
                  if state == self.STATE_DETECT:
                      # noise detected
                      self._loop.call_soon(self._callback, True)
                      state = self.STATE_NOISE
  
                  elif state == self.STATE_END:
                      # no noise
                      self._loop.call_soon(self._callback, False)
                      state = self.STATE_NONE
  
                  timeout = None
                  continue
  
              if re_start.search(data):
                  if state == self.STATE_NOISE:
                      # stop noise detection
                      state = self.STATE_END
                      timeout = self._time_reset
                  elif state == self.STATE_DETECT:
                      # reset if only a peak
                      state = self.STATE_NONE
                  continue
  
              if re_end.search(data):
                  if state == self.STATE_NONE:
                      # detect noise begin
                      state = self.STATE_DETECT
                      timeout = self._time_duration
                  elif state == self.STATE_END:
                      # back to noise status
                      state = self.STATE_NOISE
                  continue
  
              _LOGGER.warning("Unknown data from queue!")
docs: This function processing data.