Cancel all notifications.
9917
public void cancelAll() {
        if (DBG) Log.v(TAG, "prepare to cancel all");
        cancelSchedule(ARRIVE);
        schedule(CANCEL_ALL, 0, 0, null, 0);
    }
1216407
public static void dismissAllInteractions() {
		if (!isConversationQueue()) {
			dispatchOnConversationQueue(new DispatchTask() {
				@Override
				protected void execute() {
					dismissAllInteractions();
				}
			});
			return;
		}

		ApptentiveNotificationCenter.defaultCenter().postNotification(NOTIFICATION_INTERACTIONS_SHOULD_DISMISS);
	}
872727
private void cancelSignals() {
        Iterator<String> keys = this.signals.keySet().iterator();
        while (keys.hasNext()) {
            cancelSignal(keys.next());
        }
    }
1019785
public void clearQueue() {
        try {
            mNotificationsLock.lock();
            while(!mNotifications.isEmpty()) {
                mNotificationsChanged.await();
            }
        } catch(InterruptedException e) {
        } finally {
            mNotificationsLock.unlock();
        }
    }
969428
def Flush(self):
    """"""
    DB.DeleteSubjects(self.delete_subject_requests, sync=False)

    for req in self.delete_attributes_requests:
      subject, attributes, start, end = req
      DB.DeleteAttributes(subject, attributes, start=start, end=end, sync=False)

    for req in self.set_requests:
      subject, values, timestamp, replace, to_delete = req
      DB.MultiSet(
          subject,
          values,
          timestamp=timestamp,
          replace=replace,
          to_delete=to_delete,
          sync=False)

    if (self.delete_subject_requests or self.delete_attributes_requests or
        self.set_requests):
      DB.Flush()

    for queue, notifications in self.new_notifications:
      DB.CreateNotifications(queue, notifications)
    self.new_notifications = []

    self.delete_subject_requests = []
    self.set_requests = []
    self.delete_attributes_requests = []
111698
def stop(self):
        """"""
        self.working = False
        for w in self.workers:
            w.join()
        self.workers = []
629439
public void clear() {
        @SuppressWarnings("unchecked") SparseArray<BaseNotificationItem> cloneArray =
                (SparseArray<BaseNotificationItem>) notificationArray.clone();
        notificationArray.clear();

        for (int i = 0; i < cloneArray.size(); i++) {
            final BaseNotificationItem n = cloneArray.get(cloneArray.keyAt(i));
            n.cancel();
        }

    }
158556
def unsubscribe_all(self, callback=False):
        """"""
        futures = ((f, r) for f, r in self._requests.items()
                   if isinstance(r, Subscribe)
                   and f not in self._pending_unsubscribes)
        if futures:
            for future, request in futures:
                if callback:
                    log.warn("Unsubscribing from %s", request.path)
                    cothread.Callback(self.unsubscribe, future)
                else:
                    self.unsubscribe(future)
522985
def delete(self, **kwargs):
        """"""
        url = self.base_url + '/%s' % kwargs['notification_id']
        resp = self.client.delete(url=url)
        return resp
443353
def stop_all(self):
        """"""
        for alias, service in self._service_objects.items():
            if service.is_alive:
                with expects.expect_no_raises(
                        'Failed to stop service "%s".' % alias):
                    service.stop()
1184853
public final void cancel () {
		cancelRunningChildren(0);
		Status previousStatus = status;
		status = Status.CANCELLED;
		if (tree.listeners != null && tree.listeners.size > 0) tree.notifyStatusUpdated(this, previousStatus);
		end();
	}
314486
def delete_notification_rule(self, id, **kwargs):
        """"""
        endpoint = '{0}/{1}/notification_rules/{2}'.format(
            self.endpoint,
            self['id'],
            id,
        )
        return self.request('DELETE', endpoint=endpoint, query_params=kwargs)
978649
void cancelAllSuperToasts() {
        removeMessages(Messages.SHOW_NEXT);
        removeMessages(Messages.DISPLAY_SUPERTOAST);
        removeMessages(Messages.REMOVE_SUPERTOAST);

        // Iterate through the Queue, polling and removing everything
        for (SuperToast superToast : superToastPriorityQueue) {
            if (superToast instanceof SuperActivityToast) {
                if (superToast.isShowing()) {
                    try{
                        ((SuperActivityToast) superToast).getViewGroup().removeView(superToast.getView());
                        ((SuperActivityToast) superToast).getViewGroup().invalidate();
                    } catch (NullPointerException|IllegalStateException exception) {
                        Log.e(getClass().getName(), exception.toString());
                    }
                }
            } else {
                final WindowManager windowManager = (WindowManager) superToast.getContext()
                        .getApplicationContext().getSystemService(Context.WINDOW_SERVICE);
                if (superToast.isShowing()) {
                    try{
                        windowManager.removeView(superToast.getView());
                    } catch (NullPointerException|IllegalArgumentException exception) {
                        Log.e(getClass().getName(), exception.toString());
                    }
                }
            }
        }
        superToastPriorityQueue.clear();
    }
418193
def notifications_dismiss(self, id):
        
        id = self.__unpack_id(id)
        params = self.__generate_params(locals())
        self.__api_request('POST', '/api/v1/notifications/dismiss', params)
824219
def cancel(self):
        '''
        
        '''
        if (not self.cancelled) and (self._fn is not None):
            self._cancelled = True
            self._drop_fn()
427512
public void cancel() {
        final OnCancelListener listener;
        synchronized (this) {
            if (mIsCanceled) {
                return;
            }
            mIsCanceled = true;
            mCancelInProgress = true;
            listener = mOnCancelListener;
        }

        try {
            if (listener != null) {
                listener.onCancel();
            }
        } finally {
            synchronized (this) {
                mCancelInProgress = false;
                notifyAll();
            }
        }
    }
659133
def skip_all(self):
        """"""

        storage, streaming = self.engine.count()

        if self.selector.output:
            self.offset = streaming
        else:
            self.offset = storage

        self._count = 0