notification from root to modification point.
Normaly for internal use.
160579
function(space, type, path, value, index) {
		// console.log('context.notifyUpstream : ', space, type, path, value, index);
		for (var i = 0, len = space._upstreams.length; i < len; ++i) {
			var upstream = space._upstreams[i];
			if (!upstream) {
				// maybe it's because upstreams length has change so update it
				// (probably a (or more) previous listener has removed some listeners through cascade)
				len = space._upstreams.length;
				continue;
			}
			// path is local to notified node. value is the modified value. index is the one from modification point.
			upstream.call(this, value, type, path, index);
		}
	}
931787
def set_notification_callback(self, notification_cb):
    """"""
    self._notification_cb = notification_cb
    if not notification_cb and self.dimensions:
      self.measured_value.notify_value_set = None
    return self
896218
def notify(self, method, params=None):
        
        log.debug('Sending notification: %s %s', method, params)

        message = {
            'jsonrpc': JSONRPC_VERSION,
            'method': method,
        }
        if params is not None:
            message['params'] = params

        self._consumer(message)
104005
def new_style_notification(notify)
      # Given `notifies :restart, "service[foo]"` the target is the
      # `"service[foo]"` string portion.
      target_path = 'args_add_block/args_add/descendant::
        tstring_content[count(ancestor::dyna_symbol) = 0]/@value'
      target = notify.xpath("arg_paren/#{target_path} | #{target_path}").to_s

      # Test the target string against the standard syntax for a new-style
      # notification: `resource_type[resource_name]`.
      match = target.match(/^([^\[]+)\[(.*)\]$/)
      return nil unless match

      # Convert the captured resource type and name to symbols.
      resource_type, resource_name =
        match.captures.tap { |m| m[0] = m[0].to_sym }

      # Normally the `resource_name` will be a simple string. However in the
      # case where it has an embedded sub-expression then we will return the
      # AST to the caller to handle.
      if notify.xpath("descendant::string_embexpr").empty?
        return nil if resource_name.empty?
      else
        resource_name =
          notify.xpath("args_add_block/args_add/string_literal")
      end
      { resource_name: resource_name, resource_type: resource_type }
    end
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
317110
public synchronized void postNotification(final String name, final Map<String, Object> userInfo) {
		ApptentiveLog.v(NOTIFICATIONS, "Post notification: name=%s userInfo={%s}", name, StringUtils.toString(userInfo));

		final ApptentiveNotificationObserverList list = findObserverList(name);
		if (list != null) {
			list.notifyObservers(new ApptentiveNotification(name, userInfo));
		}
	}
217567
protected void updateProgressNotification(@NonNull final NotificationCompat.Builder builder, final int progress) {
		// Add Abort action to the notification
		if (progress != PROGRESS_ABORTED && progress != PROGRESS_COMPLETED) {
			final Intent abortIntent = new Intent(BROADCAST_ACTION);
			abortIntent.putExtra(EXTRA_ACTION, ACTION_ABORT);
			final PendingIntent pendingAbortIntent = PendingIntent.getBroadcast(this, 1, abortIntent, PendingIntent.FLAG_UPDATE_CURRENT);
			builder.addAction(R.drawable.ic_action_notify_cancel, getString(R.string.dfu_action_abort), pendingAbortIntent);
		}
	}
733522
@Override
    public void notificationCreated(RuntimeUpdateManager updateManager, RuntimeUpdateNotification notification) {
        if (TraceComponent.isAnyTracingEnabled() && tc.isDebugEnabled())
            Tr.debug(this, tc, "GPCL: RuntimeUpdate notification " + notification.getName() + ", apps in service = " + appsInService);

        if (this.appsInService > 0 && notification.getName().equals(RuntimeUpdateNotification.CONFIG_UPDATES_DELIVERED)) {
            setFutureGeneratePluginTask();
            notification.onCompletion(new ConfigUpdateListener());
        }
    }
1306957
function notify(message) {
	if (Mix.isUsing('notifications')) {
		let contentImage = path.join(__dirname, '../img/sunshine.png');
		notifier.notify({
			title: 'The Extension of Laravel Mix',
			message: message,
			contentImage: contentImage,
			icon: (os.platform() === 'win32' || os.platform() === 'linux') ? contentImage : undefined
		});
	}
}
1219682
public void notice(SourcePosition pos, String key, Object... args) {
        printNotice(pos, getText(key, args));
    }
758664
def notify(args):
    
    from jcvi.utils.iter import flatten

    valid_notif_methods.extend(available_push_api.keys())

    fromaddr = get_email_address(whoami="notifier")

    p = OptionParser(notify.__doc__)
    p.add_option("--method", default="email", choices=valid_notif_methods,
                 help="Specify the mode of notification [default: %default]")
    p.add_option("--subject", default="JCVI: job monitor",
                 help="Specify the subject of the notification message")
    p.set_email()

    g1 = OptionGroup(p, "Optional `push` parameters")
    g1.add_option("--api", default="pushover", \
                  choices=list(flatten(available_push_api.values())),
                  help="Specify API used to send the push notification")
    g1.add_option("--priority", default=0, type="int",
                  help="Message priority (-1 <= p <= 2) [default: %default]")
    g1.add_option("--timestamp", default=None, type="int", \
                  dest="timestamp", \
                  help="Message timestamp in unix format [default: %default]")
    p.add_option_group(g1)

    opts, args = p.parse_args(args)

    if len(args) == 0:
        logging.error("Please provide a brief message to be sent")
        sys.exit(not p.print_help())

    subject = opts.subject
    message = " ".join(args).strip()

    if opts.method == "email":
        toaddr = opts.email.split(",")   # TO address should be in a list
        for addr in toaddr:
            if not is_valid_email(addr):
                logging.debug("Email address `{0}` is not valid!".format(addr))
                sys.exit()
        send_email(fromaddr, toaddr, subject, message)
    else:
        pushnotify(subject, message, api=opts.api, priority=opts.priority, \
                   timestamp=opts.timestamp)
1247733
def notify(self, msgtype, method, params):
        """"""
        self.dispatch.call(method, params)
1302082
def WriteUserNotification(self, notification):
    """"""
    if notification.username not in self.users:
      raise db.UnknownGRRUserError(notification.username)

    cloned_notification = notification.Copy()
    if not cloned_notification.timestamp:
      cloned_notification.timestamp = rdfvalue.RDFDatetime.Now()

    self.notifications_by_username.setdefault(cloned_notification.username,
                                              []).append(cloned_notification)
503065
def handle_notification(self, data):
        """"""
        if data.get('method') in self._callbacks:
            self._callbacks.get(data.get('method'))(data.get('params'))
1222062
public void showNotification(Context context, Bundle extras) {
        // parse the title and message from the extras
        String title = getTitle(context, extras);
        String message = getMessage(context, extras);

        // if the message is empty, bail
        if (message == null)
            return;

        // create the notification
        NotificationManager mNotificationManager = (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
        long when = System.currentTimeMillis();

        NotificationCompat.Builder mBuilder = new NotificationCompat.Builder(context)
                .setAutoCancel(true)
                .setSmallIcon(getIcon(context))
                .setContentTitle(title)
                .setContentText(message)
                .setContentIntent(getContentIntent(context, extras, when))
                .setStyle(new NotificationCompat.BigTextStyle().bigText(message));

        // display the notification
        mNotificationManager.notify((int) when, mBuilder.build());
    }
713517
protected void ensureNotifications() {

        I_CmsNotificationWidget oldWidget = CmsNotification.get().getWidget();
        if (oldWidget == null) {
            CmsNotificationWidget newWidget = new CmsNotificationWidget();
            CmsNotification.get().setWidget(newWidget);
            RootPanel.get().add(newWidget);
        }
    }
281574
def normal_notification(text, options = {})
      base = {
        aps: {
          alert: {
            title: nil,
            subtitle: nil,
            body: text
          },
          sound: options.delete(:sound),
          badge: 1,
          'mutable-content': 1,
          'content-available': 1
        }
      }
      base.merge(options)
    end