Sets the notification channel URI that the registered callback message
will be sent to.

When using an authenticated web service, this parameter is required.

@param callbackUri   the notification channel URI
@return  this
323967
public A callbackUri(String callbackUri) {
        this.headers.add(Pair.of("X-CallbackURI", callbackUri));
        return (A)this;
    }
246266
public static Condition uri(final String uri) {
        return new Condition(input -> input.getUri().equals(uri));
    }
624000
public static final NodeUri decode(final PravegaNodeUri uri) {
        Preconditions.checkNotNull(uri, "uri");
        return NodeUri.newBuilder().setEndpoint(uri.getEndpoint()).setPort(uri.getPort()).build();
    }
1009874
public void setChannels(String uri, Set<WebSocketChannel> channels) {
        Objects.requireNonNull(uri, Required.URI.toString());
        Objects.requireNonNull(channels, Required.URI_CONNECTIONS.toString());

        this.cache.put(Default.WSS_CACHE_PREFIX.toString() + uri, channels);
    }
705579
public void proxyTo(final URI uri) {
		if(uri == null) {
			throw new NullPointerException("URI can't be null");
		}
		if(!JainSipUtils.checkScheme(uri.toString())) {
			// Fix for Issue http://code.google.com/p/mobicents/issues/detail?id=2327, checking the route header
			RouteHeader routeHeader = (RouteHeader) originalRequest.getMessage().getHeader(RouteHeader.NAME);
			if(routeHeader == null || (routeHeader != null && !JainSipUtils.checkScheme(routeHeader.getAddress().getURI().toString()))) {
				throw new IllegalArgumentException("Scheme " + uri.getScheme() + " is not supported");
			}			
		}
		final ProxyBranchImpl branch = new ProxyBranchImpl(uri, this);
		branch.setRecordRoute(recordRoutingEnabled);
		branch.setRecurse(recurse);
		this.proxyBranches.put(uri, branch);
		startProxy();

	}
1362779
public void setImageURI(@Nullable String uriString, @Nullable Object callerContext) {
    Uri uri = (uriString != null) ? Uri.parse(uriString) : null;
    setImageURI(uri, callerContext);
  }
1167209
public function setProxy($proxyUri, $requestFullUri = false)
    {
        $this->proxyUri = $proxyUri;
        $this->requestFullUri = $requestFullUri;

        $this->socketClient->setContext($this->getContext());
    }
887507
public static String getCallbackUri(@NonNull String scheme, @NonNull String packageName, @NonNull String domain) {
        if (!URLUtil.isValidUrl(domain)) {
            Log.e(TAG, "The Domain is invalid and the Callback URI will not be set. You used: " + domain);
            return null;
        }

        Uri uri = Uri.parse(domain)
                .buildUpon()
                .scheme(scheme)
                .appendPath("android")
                .appendPath(packageName)
                .appendPath("callback")
                .build();

        Log.v(TAG, "The Callback URI is: " + uri);
        return uri.toString();
    }
877132
@Override
    public void setCallback(SourceCallback callback) {
        try {
            mCallbackLock.lock();
            mCallback = callback;
            mCallbackChanged.signal();
        } finally {
            mCallbackLock.unlock();
        }
    }
544198
public void setURI(URI uri) throws URIException {

        if (uri.getScheme() == null || uri.getScheme().equals("")) {
            mUri = new URI(HTTP + "://" + getHeader(HOST) + "/" + mUri.toString(), true);
            
        } else {
            mUri = uri;
        }

        if (uri.getScheme().equalsIgnoreCase(HTTPS)) {
            mIsSecure = true;
            
        } else {
            mIsSecure = false;
        }

        setHostPort(mUri.getPort());
    }
1264132
protected String toSignMessageURI(String uri) {
    LoaEnum loa = LoaEnum.parse(uri);
    if (loa == null) {
      return null;
    }
    if (loa.isSignatureMessageUri()) {
      return uri;
    }
    for (LoaEnum l : LoaEnum.values()) {
      if (l.getBaseUri().equals(loa.getBaseUri()) && l.isSignatureMessageUri() && l.isNotified() == loa.isNotified()) {
        return l.getUri();
      }
    }
    return null;
  }
1209871
@TargetApi(Build.VERSION_CODES.O)
  public static void setDefaultChannelId(Context context, String channelId) {
    DefaultChannelId = channelId;
    if (Build.VERSION.SDK_INT <= Build.VERSION_CODES.N_MR1) {
      // do nothing for Android versions before Ore
      return;
    }

    try {
      NotificationManager notificationManager = (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
      CharSequence name = context.getPackageName();
      String description = "PushNotification";
      int importance = NotificationManager.IMPORTANCE_DEFAULT;
      android.app.NotificationChannel channel = new android.app.NotificationChannel(channelId, name, importance);
      channel.setDescription(description);
      notificationManager.createNotificationChannel(channel);
    } catch (Exception ex) {
      LOGGER.w("failed to create NotificationChannel, then perhaps PushNotification doesn't work well on Android O and newer version.");
    }
  }
138324
@Override
  @Deprecated
  public void setImageURI(Uri uri) {
    init(getContext());
    mDraweeHolder.setController(null);
    super.setImageURI(uri);
  }
567602
public function getAuthorizeUrl($request_token, $callback_uri = NULL, $state = NULL) {
    $request_token = array(
      'oauth_token' => is_array($request_token) ? $request_token['oauth_token'] : $request_token,
    );
    // authorize
    $url = Url::factory($this->getConfig('base_url'));
    $url->addPath($this->getConfig('authorize_path'));
    $url->setQuery($request_token);
    return (string)$url;
  }
1200944
private URI addAuthInterceptorIfRequired(URI uri) {

        String uriProtocol = uri.getScheme();
        String uriHost = uri.getHost();
        String uriPath = uri.getRawPath();

        int uriPort = getDefaultPort(uri);
        setUserInfo(uri);
        setAuthInterceptor(uriHost, uriPath, uriProtocol, uriPort);
        return scrubUri(uri, uriHost, uriPath, uriProtocol, uriPort);
    }
691564
public HttpClient setURI(final String uri) throws HibiscusException {

        try {
            setURI(new URI(uri));
        } catch (URISyntaxException e) {
            throw new HibiscusException(e);
        }

        return this;
    }
1291456
public void updateServiceInstanceUri(String serviceName, String instanceId, String uri, final RegistrationCallback cb, Object context){
        ProtocolHeader header = new ProtocolHeader();
        header.setType(ProtocolType.UpdateServiceInstanceUri);

        UpdateServiceInstanceUriProtocol p = new UpdateServiceInstanceUriProtocol(serviceName, instanceId, uri);
        ProtocolCallback pcb = new ProtocolCallback(){

            @Override
            public void call(boolean result, Response response,
                    ErrorCode error, Object ctx) {
                cb.call(result, error, ctx);
            }

        };
        connection.submitCallbackRequest(header, p, pcb, context);
    }