Emits a notification through this manageable.
344984
@Override
    public void emit(Level level, String message, long sequence) {
        if (_broadcaster != null) _broadcaster.sendNotification(new Notification(
            level.toString(),
            _name != null ? _name : this,
            sequence,
            message
        ));
    }
32912
private void notificationCallback(Notification notification) {
    if (notification instanceof MetricContextCleanupNotification) {
      removedMetricContext(((MetricContextCleanupNotification) notification).getMetricContext());
    }
    if (notification instanceof NewMetricContextNotification) {
      newMetricContext(((NewMetricContextNotification) notification).getMetricContext());
    }
  }
975024
def show_toast(self, title="Notification", msg="Here comes the message",
                    icon_path=None, duration=5, threaded=False):
        
        if not threaded:
            self._show_toast(title, msg, icon_path, duration)
        else:
            if self.notification_active():
                # We have an active notification, let is finish so we don't spam them
                return False

            self._thread = threading.Thread(target=self._show_toast, args=(title, msg, icon_path, duration))
            self._thread.start()
        return True
618936
public void sendNotification(final Notification notification) {

    ContextAwareTimer.Context timer = this.notificationTimer.time();
    if(!this.notificationTargets.isEmpty()) {
        for (final Map.Entry<UUID, Function<Notification, Void>> entry : this.notificationTargets.entrySet()) {
          try {
            entry.getValue().apply(notification);
          } catch (RuntimeException exception) {
            LOG.warn("RuntimeException when running notification target. Skipping.", exception);
          }
        }
    }

    if(getParent().isPresent()) {
      getParent().get().sendNotification(notification);
    }
    timer.stop();
  }
799157
def notifications(self):
        """"""
        self.__init()
        items = []
        for n in self._notifications:
            if "id" in n:
                url = "%s/%s" % (self.root, n['id'])
                items.append(self.Notification(url=url,
                                               securityHandler=self._securityHandler,
                                               proxy_url=self._proxy_url,
                                               proxy_port=self._proxy_port))
        return items
1113387
def notify(message, message_opts = {})
      if _client?
        return unless enabled?
      else
        return unless active?
      end

      @detected.available.each do |notifier|
        notifier.notify(message, message_opts.dup)
      end
    end
149386
private void requestNotification() {
        AndPermission.with(this)
            .notification()
            .permission()
            .rationale(new NotifyRationale())
            .onGranted(new Action<Void>() {
                @Override
                public void onAction(Void data) {
                    toast(R.string.successfully);
                }
            })
            .onDenied(new Action<Void>() {
                @Override
                public void onAction(Void data) {
                    toast(R.string.failure);
                }
            })
            .start();
    }
26208
def create_notification(self):
        
        d = self.declaration
        builder = self.builder = Notification.Builder(self.get_context(),
                                                      d.channel_id)
        d = self.declaration

        # Apply any custom settings
        if d.settings:
            builder.update(**d.settings)

        for k, v in self.get_declared_items():
            handler = getattr(self, 'set_{}'.format(k))
            handler(v)

        builder.setSmallIcon(d.icon or '@mipmap/ic_launcher')
        # app = self.get_context()
        # intent = Intent()
        # intent.setClass(app, )
        # builder.setContentIntent(PendingIntent.getActivity(app, 0, intent, 0))

        #: Set custom content if present
        for view in self.child_widgets():
            builder.setCustomContentView(view)
            break
578710
def send_notification(self, title, message, typ=1, url=None, sender=None):
        
        self.user.send_notification(title=title, message=message, typ=typ, url=url,
                                    sender=sender)
1344866
@Override
    public void step(SimState arg0) {
        logger.finest("Notifying each element of the notifable element list...");
        for(Notifable n: NotificationManager.notifables){
            NotificationManager.addNotification(n);
        }
    }
259081
def send_notification(self, method, *args):
        
        message = self._version.create_request(method, args, notification=True)
        self.send_message(message)
630154
protected void notifyListeners()
   {
      synchronized (listeners)
      {
         Thread notifier = new NotifyThread(listeners.toArray(new BackupJobListener[listeners.size()]), this);
         notifier.start();
      }
   }
648074
def notify(self, msg='', title=None, delay=5000, image=''):
        '''
        '''
        if not msg:
            log.warning('Empty message for notification dialog')
        if title is None:
            title = self.addon.getAddonInfo('name')
        xbmc.executebuiltin('XBMC.Notification("%s", "%s", "%s", "%s")' %
                            (msg, title, delay, image))
1223255
def _update_notification(self, message=None):
        """"""
        if message is None:
            message = ''
        message_label = self._parts['notification label']
        message_label.config(text=message)
        self._base.update()
304806
public function notify() {
		if ( $this->requirements_met() ) {
			return;
		}

		echo '<div class="notice notice-error">';

		foreach ( $this->requirements as $requirement ) {
			if ( $requirement->is_met() ) {
				continue;
			}

			printf(
				'<p>%s deactivated: %s</p>',
				esc_html( $this->name ),
				esc_html( $requirement->get_message() )
			);
		}

		echo '</div>';
	}
891197
def _on_notification(self, name, args):
        """"""
        if IS_PYTHON3:
            name = decode_if_bytes(name)
        handler = self._notification_handlers.get(name, None)
        if not handler:
            msg = self._missing_handler_error(name, 'notification')
            error(msg)
            self._on_async_err(msg + "\n")
            return

        debug('calling notification handler for "%s", args: "%s"', name, args)
        handler(*args)
40554
def _handle_notification(self, method, params):
        """"""
        if method == CANCEL_METHOD:
            self._handle_cancel_notification(params['id'])
            return

        try:
            handler = self._dispatcher[method]
        except KeyError:
            log.warn("Ignoring notification for unknown method %s", method)
            return

        try:
            handler_result = handler(params)
        except Exception:  # pylint: disable=broad-except
            log.exception("Failed to handle notification %s: %s", method, params)
            return

        if callable(handler_result):
            log.debug("Executing async notification handler %s", handler_result)
            notification_future = self._executor_service.submit(handler_result)
            notification_future.add_done_callback(self._notification_callback(method, params))