Correct way to implement long polling using OkHttp3 and ReactiveX Java

How do I implement long polling using OkHttp3 (v4.4.1) to get RxJava (v2.2.11) Observable<String> for each line of the response? Can it be done without blocking a thread to keep reading lines? If I need to block some thread then which thread do I block? Any general examples on implementation of long polling using OkHttp3? Google's been very shy with me on this topic...

TL;DR

I am using OKHttp3 as a HTTP client and got it wrapped in makeGetObservable method call which returns Observable Response using the newCall callback to emit events to Observable. Now I am trying to add support for long polling service and I am concerned about threading.

Below code demonstrates what I am attempting to do (and seems to work) but I am pretty sure it is not OK.

// return Observable<Response>
makeGetObservable("http://my.service.com/api/events")
  // check for error and map to Observable<ResponseBody>
  .map(this::mapRespBodyOrError)
  // flat map to Observable<String> representing line of long polling response
  .flatMap(respBody -> Observable.create(emitter -> {
    // open reader on response body stream
    try (BufferedReader reader = new BufferedReader(respBody.charStream())) {
      String line;
      // block and wait to read a line from input
      while((line = reader.readLine()) !=null) {
        // once line was read from response body input stream emit it as observable event
        emitter.onNext(line);
      }
    }
  }));

After some research I found that the thread which is being blocked is OkHttp client thread. This is due to my implementation of makeGetObservable which emits from newCall..enqueue callback of OkHttp client.
OkHttp client by default has pool of 5 threads for 5 concurrent connections for a resource. So I was blocking one of those threads every time I subscribed to another long-polling resource. After 5 blocked threads OkHttp client stopped working as it had no threads to process responses.

As suggested by @Progman I went with subscribeOn using IO scheduler which spawns new thread for every blocking IO operation. One has to be careful and properly dispose of resources with this scheduler.

My implementation currently looks as follows (added scheduler, completion and error events)

// return Observable<Response>
makeGetObservable("http://my.service.com/api/events")
  // check for error and map to Observable<ResponseBody>
  .map(this::mapRespBodyOrError)
  // use IO scheduler that spawns new threads to take care of blocking operations
  .observeOn(Schedulers.io())
  // flat map to Observable<String> representing line of long polling response
  .flatMap(respBody -> Observable.create(emitter -> {
    try (BufferedReader reader = new BufferedReader(respBody.charStream())) {
      // blocking read lines while available
      String line;
      while ((line = reader.readLine()) != null) {
        // emit event for every line
        emitter.onNext(line);
      }
      // emit the completion event to indicate we are done
      emitter.onComplete();
    } catch (IOException | RuntimeException err) {
      // emit any error that might have occurred
      emitter.onError(err);
    }
  }));