Resume your app stream by app name and stream name

@param app app name
@param stream stream name
@return the response
196141
public ResumeAppStreamResponse resumeAppStream(String app, String stream) {
        ResumeAppStreamRequest request = new ResumeAppStreamRequest();
        request.setApp(app);
        request.setStream(stream);
        return resumeAppStream(request);
    }
225729
public ResumeSessionResponse resumeSession(String sessionId) {
        ResumeSessionRequest request = new ResumeSessionRequest();
        request.setSessionId(sessionId);
        return resumeSession(request);
    }
323525
private static synchronized void createStream(Http2Connection conn, int streamId) throws Http2Exception {
        conn.local().createStream(streamId, false);
        if (LOG.isDebugEnabled()) {
            LOG.debug("Stream created streamId: {}", streamId);
        }
    }
1167713
public InputStream getURLStream(String path) throws NoSuchPathException, IOException {
		URL url = null;
		try {
			url = new URL(path);
		} catch (MalformedURLException e) {
			throw new NoSuchPathException(e);
		}

		return url.openStream();
		
	}
1372761
public Observable<ApplicationInfoResponse> getAsync(UUID appId) {
        return getWithServiceResponseAsync(appId).map(new Func1<ServiceResponse<ApplicationInfoResponse>, ApplicationInfoResponse>() {
            @Override
            public ApplicationInfoResponse call(ServiceResponse<ApplicationInfoResponse> response) {
                return response.body();
            }
        });
    }
1264732
public void shutdownApplication( String applicationName ) throws ManagementWsException {
		this.logger.finer( "Removing application " + applicationName + "..." );

		WebResource path = this.resource
					.path( UrlConstants.APPLICATIONS )
					.path( applicationName )
					.path( "shutdown" );

		ClientResponse response = this.wsClient.createBuilder( path ).post( ClientResponse.class );
		String text = response.getEntity( String.class );
		this.logger.finer( text );
		if( Family.SUCCESSFUL != response.getStatusInfo().getFamily())
			throw new ManagementWsException( response.getStatusInfo().getStatusCode(), text );
	}
1085611
public ListAppStreamsResponse listAppStreams(ListAppStreamsRequest request) {
        checkNotNull(request, "The parameter request should NOT be null.");
        checkStringNotEmpty(request.getApp(), "The parameter app should NOT be null or empty string.");
        InternalRequest internalRequest = createRequest(HttpMethodName.GET, request, LIVE_APP,
                request.getApp(), LIVE_SESSION);
        if (request.getStatus() != null) {
            internalRequest.addParameter("status", request.getStatus());
        }
        return invokeHttpClient(internalRequest, ListAppStreamsResponse.class);
    }
808452
<RequestT, ResponseT> ApiStreamObserver<RequestT> streamRequest(
      ApiStreamObserver<ResponseT> responseObserverT,
      BidiStreamingCallable<RequestT, ResponseT> callable) {
    Preconditions.checkState(!closed, "Firestore client has already been closed");
    return callable.bidiStreamingCall(responseObserverT);
  }
1212601
public CreateStreamResponse createStream(CreateStreamRequest request) {
        checkNotNull(request, "The parameter request should NOT be null.");

        checkStringNotEmpty(request.getPlayDomain(), "playDomain should NOT be empty.");
        checkStringNotEmpty(request.getApp(), "app should NOT be empty.");
        checkNotNull(request.getPublish(), "publish should NOT be null.");
        checkStringNotEmpty(request.getPublish().getPushStream(), "pushStream should NOT be empty.");

        InternalRequest internalRequest = createRequest(HttpMethodName.POST,
                request, LIVE_DOMAIN, request.getPlayDomain(), LIVE_STREAM);
        return invokeHttpClient(internalRequest, CreateStreamResponse.class);
    }
1160266
public Observable<InputStream> downloadQueryLogsAsync(UUID appId) {
        return downloadQueryLogsWithServiceResponseAsync(appId).map(new Func1<ServiceResponse<InputStream>, InputStream>() {
            @Override
            public InputStream call(ServiceResponse<InputStream> response) {
                return response.body();
            }
        });
    }
184940
public App named(String name) {
        App newApp = copy();
        newApp.name = name;
        return newApp;
    }
1147136
public Observable<ApplicationSettings> getSettingsAsync(UUID appId) {
        return getSettingsWithServiceResponseAsync(appId).map(new Func1<ServiceResponse<ApplicationSettings>, ApplicationSettings>() {
            @Override
            public ApplicationSettings call(ServiceResponse<ApplicationSettings> response) {
                return response.body();
            }
        });
    }
1066240
public ListAppStreamsResponse listAppStreams(String app, String status) {
        ListAppStreamsRequest request = new ListAppStreamsRequest();
        request.setApp(app);
        request.setStatus(status);
        return listAppStreams(request);
    }
354640
public PauseAppStreamResponse pauseAppStream(PauseAppStreamRequest request) {
        checkNotNull(request, "The parameter request should NOT be null.");
        checkStringNotEmpty(request.getApp(), "The parameter app should NOT be null or empty string.");
        checkStringNotEmpty(request.getStream(), "The parameter stream should NOT be null or empty string.");
        InternalRequest internalRequest = createRequest(HttpMethodName.PUT, request, LIVE_APP,
                request.getApp(), LIVE_SESSION, request.getStream());
        internalRequest.addParameter(PAUSE, null);
        return invokeHttpClient(internalRequest, PauseAppStreamResponse.class);
    }
1172054
public final synchronized void initEVCache(String app) {
        if (app == null || (app = app.trim()).length() == 0) throw new IllegalArgumentException(
                "param app name null or space");
        final String APP = getAppName(app);
        if (poolMap.containsKey(APP)) return;
        final EVCacheNodeList provider;
        if (EVCacheConfig.getInstance().getChainedBooleanProperty(APP + ".use.simple.node.list.provider", "evcache.use.simple.node.list.provider", Boolean.FALSE, null).get()) {
            provider = new SimpleNodeListProvider();
        } else {
            provider = new DiscoveryNodeListProvider(applicationInfoManager, discoveryClient, APP);
        }

        final EVCacheClientPool pool = new EVCacheClientPool(APP, provider, asyncExecutor, this);
        scheduleRefresh(pool);
        poolMap.put(APP, pool);
    }
159765
public final void stopApp() throws IOException {
        Application runningApp = getRunningApp();
        if (runningApp == null) {
            throw new ChromeCastException("No application is running in ChromeCast");
        }
        channel().stop(runningApp.sessionId);
    }
784084
private void processStreamUpload(final UploadStream req) {
    assert (req.body() == null);
    try {
      RpcResponseCallback callback = new RpcResponseCallback() {
        @Override
        public void onSuccess(ByteBuffer response) {
          respond(new RpcResponse(req.requestId, new NioManagedBuffer(response)));
        }

        @Override
        public void onFailure(Throwable e) {
          respond(new RpcFailure(req.requestId, Throwables.getStackTraceAsString(e)));
        }
      };
      TransportFrameDecoder frameDecoder = (TransportFrameDecoder)
          channel.pipeline().get(TransportFrameDecoder.HANDLER_NAME);
      ByteBuffer meta = req.meta.nioByteBuffer();
      StreamCallbackWithID streamHandler = rpcHandler.receiveStream(reverseClient, meta, callback);
      if (streamHandler == null) {
        throw new NullPointerException("rpcHandler returned a null streamHandler");
      }
      StreamCallbackWithID wrappedCallback = new StreamCallbackWithID() {
        @Override
        public void onData(String streamId, ByteBuffer buf) throws IOException {
          streamHandler.onData(streamId, buf);
        }

        @Override
        public void onComplete(String streamId) throws IOException {
           try {
             streamHandler.onComplete(streamId);
             callback.onSuccess(ByteBuffer.allocate(0));
           } catch (Exception ex) {
             IOException ioExc = new IOException("Failure post-processing complete stream;" +
               " failing this rpc and leaving channel active", ex);
             callback.onFailure(ioExc);
             streamHandler.onFailure(streamId, ioExc);
           }
        }

        @Override
        public void onFailure(String streamId, Throwable cause) throws IOException {
          callback.onFailure(new IOException("Destination failed while reading stream", cause));
          streamHandler.onFailure(streamId, cause);
        }

        @Override
        public String getID() {
          return streamHandler.getID();
        }
      };
      if (req.bodyByteCount > 0) {
        StreamInterceptor<RequestMessage> interceptor = new StreamInterceptor<>(
          this, wrappedCallback.getID(), req.bodyByteCount, wrappedCallback);
        frameDecoder.setInterceptor(interceptor);
      } else {
        wrappedCallback.onComplete(wrappedCallback.getID());
      }
    } catch (Exception e) {
      logger.error("Error while invoking RpcHandler#receive() on RPC id " + req.requestId, e);
      respond(new RpcFailure(req.requestId, Throwables.getStackTraceAsString(e)));
      // We choose to totally fail the channel, rather than trying to recover as we do in other
      // cases.  We don't know how many bytes of the stream the client has already sent for the
      // stream, it's not worth trying to recover.
      channel.pipeline().fireExceptionCaught(e);
    } finally {
      req.meta.release();
    }
  }