Remove all of the audio sources from the audio manager.
This will stop all sound from playing.
554345
public void clearSources()
    {
        synchronized (mAudioSources)
        {
            for (GVRAudioSource source : mAudioSources)
            {
                source.setListener(null);
            }
            mAudioSources.clear();
        }
    }
934198
def stop(self):
        
        log.debug("Stopping listeners")
        self.queue_lock.acquire()
        for s in self.listeners:
            log.debug("Stopping {}".format(s))
            s.shutdown()
            s.socket.close()
        self.cancel_queue()
        for t in self.threads:
            t.join()
        self.listeners = []
        self.threads = []
        self.is_running = False
        self.queue_lock.release()
        log.debug("Listeners stopped and threads joined")
1177657
function _removeListeners() {
        DocumentModule.off("documentChange", _documentChangeHandler);
        FileSystem.off("change", _debouncedFileSystemChangeHandler);
        DocumentManager.off("fileNameChange", _fileNameChangeHandler);
    }
216184
private void closeAll() {
	getModalPanel().removeAll();
	components.clear();
	depths.clear();
	listeners.clear();
	restoreRootPane();
  }
120441
function() {
        sound._paused = false;
        sound._seek = seek;
        sound._start = start;
        sound._stop = stop;
        sound._loop = loop;
      }
481702
function mute (conn) {
  if (!conn.db) throw new Error('missing db');
  conn.db.removeAllListeners("close");
  conn.db.removeAllListeners("error");
  conn.db.removeAllListeners("timeout");
  conn.db.removeAllListeners("open");
  conn.db.removeAllListeners("fullsetup");
  conn._listening = false;
}
861772
def close(self):
        """"""
        if not self.closed:
            check(_coreaudio.ExtAudioFileDispose(self._obj))
            self.closed = True
1114837
def stop_everything(self):
        """"""
        for x in range(118):
            for c in range(16):
                self.stop_Note(x, c)
759455
def off(self):
        
        spotifyconnect._session_instance.player.off(
            spotifyconnect.PlayerEvent.MUSIC_DELIVERY, self._on_music_delivery)
        assert spotifyconnect._session_instance.player.num_listeners(
            spotifyconnect.PlayerEvent.MUSIC_DELIVERY) == 0
        self._close()
1018757
private void stop() {
        //unregister and free all resources;
        if (updateTask != null)
            updateTask.cancel();
        for (GenericStatsProducer producer : producers) {
            producer.genericStats.destroy();
            ProducerRegistryFactory.getProducerRegistryInstance().unregisterProducer(producer);
        }
        producers.clear();
    }
116713
def close(self) -> None:
        
        self.__data_channel_buffer.stop()
        self.__data_channel_buffer.close()
        self.__data_channel_buffer = None
        if not self.__was_playing:
            self.__hardware_source.stop_playing()
578340
function() {
      var self = this;
      var limit = self._pool;
      var cnt = 0;
      var i = 0;

      // If there are less sounds than the max pool size, we are done.
      if (self._sounds.length < limit) {
        return;
      }

      // Count the number of inactive sounds.
      for (i=0; i<self._sounds.length; i++) {
        if (self._sounds[i]._ended) {
          cnt++;
        }
      }

      // Remove excess inactive sounds, going in reverse order.
      for (i=self._sounds.length - 1; i>=0; i--) {
        if (cnt <= limit) {
          return;
        }

        if (self._sounds[i]._ended) {
          // Disconnect the audio source when using Web Audio.
          if (self._webAudio && self._sounds[i]._node) {
            self._sounds[i]._node.disconnect(0);
          }

          // Remove sounds until we have the pool size.
          self._sounds.splice(i, 1);
          cnt--;
        }
      }
    }
716805
public function clearAllListeners()
    {
        foreach ($this->raw_listeners as $eventName => $data) {
            foreach ($data as $listeners) {
                foreach ($listeners as $listener) {
                    $this->removeListener($eventName, $listener);
                }
            }
        }

        $this->raw_listeners = [];
    }
773835
def stop_listening(self):
        """"""
        self._halt_threads = True
        # wake them up so that they can die
        for name, queue_waker in self.recieved_signals.items():
            q, wake_event = queue_waker
            wake_event.set()
510464
function () {
            var map = this._getAdditionalListenersList();
            for (var i = 0; i < map.length; i++) {
                this._removeListener(map[i].evt, map[i].cb);
            }
        }
211946
function() {
        annotationsDiv.children().remove();
        container.find('.kelmu-arrow-handle').remove();
        container.children('svg').first().remove();
        container.find('audio.kelmu-annotation-sound').each(function() {
          try {
            this.pause();
          } catch (err) {
            // Ignore if stopping sounds raised any errors
          }
        });
      }
325735
public void stopAllPlugins() {
        synchronized (pluginMap) {
            // remove the listener for this repository
            loggerRepository.removeLoggerRepositoryEventListener(listener);

            Iterator iter = pluginMap.values().iterator();

            while (iter.hasNext()) {
                Plugin plugin = (Plugin) iter.next();
                plugin.shutdown();
                firePluginStopped(plugin);
            }
        }
    }