AVPlayerItem.loadedTimeRanges notifications aren't working with custom AVAssetResourceLoaderDelegate

Question

I use AVAssetResourceLoaderDelegate for video caching but the video plays after it will be fully downloaded. I add KVO observer to loadedTimeRanges property:

[self.player.currentItem addObserver:self
                          forKeyPath:@"loadedTimeRanges"
                             options:NSKeyValueObservingOptionNew
                             context:nil];

Check ranges and start playing:

- (void)checkRanges {
  if (self.player.currentItem.asset) {
    CMTimeRange loadedTimeRange = 
    [[self.player.currentItem.loadedTimeRanges firstObject] CMTimeRangeValue];
    Float64 videoDuration = CMTimeGetSeconds(self.player.currentItem.asset.duration);
    Float64 buffered = CMTimeGetSeconds(loadedTimeRange.duration);
    Float64 percent = buffered / videoDuration;
    if (percent > 0.2) {
      [self.player play];
    }
  }
}

But notifications aren't working, for some reason, I get a notification when the video is almost downloaded. Video downloading is implemented by using AVAssetResourceLoaderDelegate that allow use cache within video playing. The downloading is initialized in the method AVAssetResourceLoaderDelegate:

func resourceLoader(_ resourceLoader: AVAssetResourceLoader,
                  shouldWaitForLoadingOfRequestedResource loadingRequest: AVAssetResourceLoadingRequest) -> Bool {
 if let resourceURL = loadingRequest.request.url, resourceURL.isVCSVideoScheme(),
   let originalURL = resourceURL.vcsRemoteVideoURL() {
   let assetLoader: VideoAssetLoader
   if let loader = assetLoaderForRequest(loadingRequest) {
     assetLoader = loader
   } else {
     assetLoader = VideoAssetLoader(url: originalURL)
     assetLoader.delegate = self
     assetLoaders[keyForAssetLoaderWithURL(resourceURL)] = assetLoader
   }
   assetLoader.addRequest(loadingRequest)
   return true
 }
 return false
}

VideoAssetLoader receives a HEAD request with file information and then updates AVAssetResourceLoadingRequest:

private func fillInContentInformation(_ contentInformationRequest: AVAssetResourceLoadingContentInformationRequest?) {
  guard let contentInformationRequest = contentInformationRequest,
    let contentInformation = self.contentInformation else {
      return
  }
  contentInformationRequest.isByteRangeAccessSupported = contentInformation.byteRangeAccessSupported
  contentInformationRequest.contentType = contentInformation.contentType
  contentInformationRequest.contentLength = Int64(contentInformation.contentLength)
}

Then VideoAssetLoader downloads requested range of bytes and then updates AVAssetResourceLoadingDataRequest:

private func processPendingRequests() {
  for request in pendingRequests {
    fillInContentInformation(request.contentInformationRequest)
    let didRespondCompletely = respondWithDataForRequest(request.dataRequest)
    if didRespondCompletely {
      request.finishLoading()
    }
  }
  pendingRequests = pendingRequests.filter({ !$0.isFinished })
}

private func respondWithDataForRequest(_ dataRequest: AVAssetResourceLoadingDataRequest?) -> Bool {
  guard let dataRequest = dataRequest, let downloadTask = videoDownloadTask else {
    return false
  }
  var startOffset: UInt64 = UInt64(dataRequest.requestedOffset)
  if dataRequest.currentOffset != 0 {
    startOffset = UInt64(dataRequest.currentOffset)
  }
  let numberOfBytesToRespondWith = UInt64(dataRequest.requestedLength)
  var didRespondFully = false
  if let data = downloadTask.readCachedDataWithOffset(startOffset, lenght: numberOfBytesToRespondWith) {
    dataRequest.respond(with: data)
    didRespondFully = data.count >= dataRequest.requestedLength
  }
  return didRespondFully
}

Unfortunately, the video isn't playing while it won't be completely downloaded (AVAssetResourceLoadingRequest.finishLoading()), also not getting notification loadedTimeRanges.

Does anyone have experience with this to point me toward an area where I may be doing something wrong? Thanks!