End the phone call.
        
        Does nothing if the call is already inactive.
507006
def hangup(self):
        
        if self.active:
            self._gsmModem.write('ATH')
            self.answered = False
            self.active = False
        if self.id in self._gsmModem.activeCalls:
            del self._gsmModem.activeCalls[self.id]
1119915
def stop(self):
        
        self.stopping = True
        # Cancel any outstanding request to our client
        if self._batch_send_d:
            self._batch_send_d.cancel()
        # Do we have to worry about our looping call?
        if self.batch_every_t is not None:
            # Stop our looping call, and wait for the deferred to be called
            if self._sendLooper is not None:
                self._sendLooper.stop()
        # Make sure requests that wasn't cancelled above are now
        self._cancel_outstanding()
        return self._sendLooperD or succeed(None)
793358
def stop(self):
        
        self.__end.set()
        if self.__recv_thread:
            self.__recv_thread.join()
            self.__recv_thread = None
        if self.__send_thread:
            self.__send_thread.join()
            self.__send_thread = None
403912
public synchronized void stop() {
        if (!monitorActive) {
            return;
        }
        monitorActive = false;
        resetAccounting(milliSecondFromNano());
        if (trafficShapingHandler != null) {
            trafficShapingHandler.doAccounting(this);
        }
        if (scheduledFuture != null) {
            scheduledFuture.cancel(true);
        }
    }
699664
def stop(self):
        
        if self.is_run:
            self._service.shutdown()
            self._service.server_close()
478014
def quit(self, message=None):
        """"""
        if message is None:
            message = 'Quit'

        if self.connected:
            self.send('QUIT', params=[message])
583364
@Override
    public CallEvent drain() {
        CallEvent callEvent = delayedEvents.drain();
        if (callEvent == null) {
            validate();
            return null;
        }

        // double check this is an end event
        assert(callEvent.startTS == null);
        assert(callEvent.endTS != null);

        // return the agent/phone for this event to the available lists
        agentsAvailable.add(callEvent.agentId);
        phoneNumbersAvailable.add(callEvent.phoneNo);

        validate();
        return callEvent;
    }
373879
public synchronized void stop() {
        if (isRunning()) {
            socket.get().close();
            socket.set(null);
            deliverLifecycleAnnouncement(logger, false);
        }
    }
381037
async def stop(self):
        
        if self.__started:
            self.__transport._unregister_rtp_receiver(self)
            self.__stop_decoder()
            self.__rtcp_task.cancel()
            await self.__rtcp_exited.wait()
1020308
def stop(self):
        
        with self.__receiver_thread_exit_condition:
            while not self.__receiver_thread_exited and self.is_connected():
                self.__receiver_thread_exit_condition.wait()
819829
def stop(self):
        
        self._cease.set()
        time.sleep(0.1)  # let the thread closing correctly.
        self._isRunning = False
497908
def close(self):
        """"""
        if self.call is None:
            return

        self._request_queue.put(None)
        self.call.cancel()
        self._request_generator = None
1110841
def end(self, n=1, interval=0, pre_dl=None, post_dl=None):
        
        self.delay(pre_dl)
        self.k.tap_key(self.k.end_key, n, interval)
        self.delay(post_dl)
320778
public function stop()
    {
        if ($this->isExternal())
        {
            $this->communicator->getLoop()->stop();
        }
        else
        {
            $this->asyncCallOnChild(__FUNCTION__, func_get_args());
        }
    }
517760
public synchronized void stop() {
        try {
            this.kill();
        } finally {
            this.killed = false;
            this.restartCondition.setUseless(false);
            this.restartCondition.setActive(false);
        }

    }
648877
public void finished() {
    final ScheduledFuture<?> scheduled = nextCall.getAndSet(null);

    if (scheduled != null) {
      scheduled.cancel(true);
    }
  }
845856
def terminate(self):
        
        rs = self.connection.terminate_instances([self.id])
        if len(rs) > 0:
            self._update(rs[0])