+ * The default is {@link DefaultHttpDataSource#DEFAULT_CONNECT_TIMEOUT_MILLIS}.
+ *
+ *
+ * @param connectTimeoutMsValue The connect timeout, in milliseconds, that will be used.
+ * @return This factory.
+ */
+ public Factory setConnectTimeoutMs(final int connectTimeoutMsValue) {
+ connectTimeoutMs = connectTimeoutMsValue;
+ return this;
+ }
+
+ /**
+ * Sets the read timeout, in milliseconds.
+ *
+ * The default is {@link DefaultHttpDataSource#DEFAULT_READ_TIMEOUT_MILLIS}.
+ *
+ * @param readTimeoutMsValue The connect timeout, in milliseconds, that will be used.
+ * @return This factory.
+ */
+ public Factory setReadTimeoutMs(final int readTimeoutMsValue) {
+ readTimeoutMs = readTimeoutMsValue;
+ return this;
+ }
+
+ /**
+ * Sets whether to allow cross protocol redirects.
+ *
+ *
The default is {@code false}.
+ *
+ * @param allowCrossProtocolRedirectsValue Whether to allow cross protocol redirects.
+ * @return This factory.
+ */
+ public Factory setAllowCrossProtocolRedirects(
+ final boolean allowCrossProtocolRedirectsValue) {
+ allowCrossProtocolRedirects = allowCrossProtocolRedirectsValue;
+ return this;
+ }
+
+ /**
+ * Sets whether the use of the {@code range} parameter instead of the {@code Range} header
+ * to request ranges of streams is enabled.
+ *
+ *
+ * Note that it must be not enabled on streams which are using a {@link
+ * com.google.android.exoplayer2.source.ProgressiveMediaSource}, as it will break playback
+ * for them (some exceptions may be thrown).
+ *
+ *
+ * @param rangeParameterEnabledValue whether the use of the {@code range} parameter instead
+ * of the {@code Range} header (must be only enabled when
+ * non-{@code ProgressiveMediaSource}s)
+ * @return This factory.
+ */
+ public Factory setRangeParameterEnabled(final boolean rangeParameterEnabledValue) {
+ rangeParameterEnabled = rangeParameterEnabledValue;
+ return this;
+ }
+
+ /**
+ * Sets whether the use of the {@code rn}, which stands for request number, parameter is
+ * enabled.
+ *
+ *
+ * Note that it should be not enabled on streams which are using {@code /} to delimit URLs
+ * parameters, such as the streams of HLS manifests.
+ *
+ *
+ * @param rnParameterEnabledValue whether the appending the {@code rn} parameter to
+ * {@code videoplayback} URLs
+ * @return This factory.
+ */
+ public Factory setRnParameterEnabled(final boolean rnParameterEnabledValue) {
+ rnParameterEnabled = rnParameterEnabledValue;
+ return this;
+ }
+
+ /**
+ * Sets a content type {@link Predicate}. If a content type is rejected by the predicate
+ * then a {@link HttpDataSource.InvalidContentTypeException} is thrown from
+ * {@link YoutubeHttpDataSource#open(DataSpec)}.
+ *
+ * contentTypePredicateToSet) {
+ this.contentTypePredicate = contentTypePredicateToSet;
+ return this;
+ }
+
+ /**
+ * Sets the {@link TransferListener} that will be used.
+ *
+ * The default is {@code null}.
+ *
+ *
See {@link DataSource#addTransferListener(TransferListener)}.
+ *
+ * @param transferListenerToUse The listener that will be used.
+ * @return This factory.
+ */
+ public Factory setTransferListener(
+ @Nullable final TransferListener transferListenerToUse) {
+ this.transferListener = transferListenerToUse;
+ return this;
+ }
+
+ /**
+ * Sets whether we should keep the POST method and body when we have HTTP 302 redirects for
+ * a POST request.
+ *
+ * @param keepPostFor302RedirectsValue Whether we should keep the POST method and body when
+ * we have HTTP 302 redirects for a POST request.
+ * @return This factory.
+ */
+ public Factory setKeepPostFor302Redirects(final boolean keepPostFor302RedirectsValue) {
+ this.keepPostFor302Redirects = keepPostFor302RedirectsValue;
+ return this;
+ }
+
+ @NonNull
+ @Override
+ public YoutubeHttpDataSource createDataSource() {
+ final YoutubeHttpDataSource dataSource = new YoutubeHttpDataSource(
+ connectTimeoutMs,
+ readTimeoutMs,
+ allowCrossProtocolRedirects,
+ rangeParameterEnabled,
+ rnParameterEnabled,
+ defaultRequestProperties,
+ contentTypePredicate,
+ keepPostFor302Redirects);
+ if (transferListener != null) {
+ dataSource.addTransferListener(transferListener);
+ }
+ return dataSource;
+ }
+ }
+
+ private static final String TAG = YoutubeHttpDataSource.class.getSimpleName();
+ private static final int MAX_REDIRECTS = 20; // Same limit as okhttp.
+ private static final int HTTP_STATUS_TEMPORARY_REDIRECT = 307;
+ private static final int HTTP_STATUS_PERMANENT_REDIRECT = 308;
+ private static final long MAX_BYTES_TO_DRAIN = 2048;
+
+ private static final String RN_PARAMETER = "&rn=";
+ private static final String YOUTUBE_BASE_URL = "https://www.youtube.com";
+
+ private final boolean allowCrossProtocolRedirects;
+ private final boolean rangeParameterEnabled;
+ private final boolean rnParameterEnabled;
+
+ private final int connectTimeoutMillis;
+ private final int readTimeoutMillis;
+ @Nullable
+ private final RequestProperties defaultRequestProperties;
+ private final RequestProperties requestProperties;
+ private final boolean keepPostFor302Redirects;
+
+ @Nullable
+ private final Predicate contentTypePredicate;
+ @Nullable
+ private DataSpec dataSpec;
+ @Nullable
+ private HttpURLConnection connection;
+ @Nullable
+ private InputStream inputStream;
+ private boolean opened;
+ private int responseCode;
+ private long bytesToRead;
+ private long bytesRead;
+
+ private long requestNumber;
+
+ @SuppressWarnings("checkstyle:ParameterNumber")
+ private YoutubeHttpDataSource(final int connectTimeoutMillis,
+ final int readTimeoutMillis,
+ final boolean allowCrossProtocolRedirects,
+ final boolean rangeParameterEnabled,
+ final boolean rnParameterEnabled,
+ @Nullable final RequestProperties defaultRequestProperties,
+ @Nullable final Predicate contentTypePredicate,
+ final boolean keepPostFor302Redirects) {
+ super(true);
+ this.connectTimeoutMillis = connectTimeoutMillis;
+ this.readTimeoutMillis = readTimeoutMillis;
+ this.allowCrossProtocolRedirects = allowCrossProtocolRedirects;
+ this.rangeParameterEnabled = rangeParameterEnabled;
+ this.rnParameterEnabled = rnParameterEnabled;
+ this.defaultRequestProperties = defaultRequestProperties;
+ this.contentTypePredicate = contentTypePredicate;
+ this.requestProperties = new RequestProperties();
+ this.keepPostFor302Redirects = keepPostFor302Redirects;
+ this.requestNumber = 0;
+ }
+
+ @Override
+ @Nullable
+ public Uri getUri() {
+ return connection == null ? null : Uri.parse(connection.getURL().toString());
+ }
+
+ @Override
+ public int getResponseCode() {
+ return connection == null || responseCode <= 0 ? -1 : responseCode;
+ }
+
+ @NonNull
+ @Override
+ public Map> getResponseHeaders() {
+ if (connection == null) {
+ return ImmutableMap.of();
+ }
+ // connection.getHeaderFields() always contains a null key with a value like
+ // ["HTTP/1.1 200 OK"]. The response code is available from
+ // HttpURLConnection#getResponseCode() and the HTTP version is fixed when establishing the
+ // connection.
+ // DataSource#getResponseHeaders() doesn't allow null keys in the returned map, so we need
+ // to remove it.
+ // connection.getHeaderFields() returns a special unmodifiable case-insensitive Map
+ // so we can't just remove the null key or make a copy without the null key. Instead we
+ // wrap it in a ForwardingMap subclass that ignores and filters out null keys in the read
+ // methods.
+ return new NullFilteringHeadersMap(connection.getHeaderFields());
+ }
+
+ @Override
+ public void setRequestProperty(@NonNull final String name, @NonNull final String value) {
+ checkNotNull(name);
+ checkNotNull(value);
+ requestProperties.set(name, value);
+ }
+
+ @Override
+ public void clearRequestProperty(@NonNull final String name) {
+ checkNotNull(name);
+ requestProperties.remove(name);
+ }
+
+ @Override
+ public void clearAllRequestProperties() {
+ requestProperties.clear();
+ }
+
+ /**
+ * Opens the source to read the specified data.
+ */
+ @Override
+ public long open(@NonNull final DataSpec dataSpecParameter) throws HttpDataSourceException {
+ this.dataSpec = dataSpecParameter;
+ bytesRead = 0;
+ bytesToRead = 0;
+ transferInitializing(dataSpecParameter);
+
+ final HttpURLConnection httpURLConnection;
+ final String responseMessage;
+ try {
+ this.connection = makeConnection(dataSpec);
+ httpURLConnection = this.connection;
+ responseCode = httpURLConnection.getResponseCode();
+ responseMessage = httpURLConnection.getResponseMessage();
+ } catch (final IOException e) {
+ closeConnectionQuietly();
+ throw HttpDataSourceException.createForIOException(e, dataSpec,
+ HttpDataSourceException.TYPE_OPEN);
+ }
+
+ // Check for a valid response code.
+ if (responseCode < 200 || responseCode > 299) {
+ final Map> headers = httpURLConnection.getHeaderFields();
+ if (responseCode == 416) {
+ final long documentSize = HttpUtil.getDocumentSize(
+ httpURLConnection.getHeaderField(HttpHeaders.CONTENT_RANGE));
+ if (dataSpecParameter.position == documentSize) {
+ opened = true;
+ transferStarted(dataSpecParameter);
+ return dataSpecParameter.length != C.LENGTH_UNSET
+ ? dataSpecParameter.length
+ : 0;
+ }
+ }
+
+ final InputStream errorStream = httpURLConnection.getErrorStream();
+ byte[] errorResponseBody;
+ try {
+ errorResponseBody = errorStream != null
+ ? Util.toByteArray(errorStream)
+ : Util.EMPTY_BYTE_ARRAY;
+ } catch (final IOException e) {
+ errorResponseBody = Util.EMPTY_BYTE_ARRAY;
+ }
+
+ closeConnectionQuietly();
+ final IOException cause = responseCode == 416 ? new DataSourceException(
+ PlaybackException.ERROR_CODE_IO_READ_POSITION_OUT_OF_RANGE)
+ : null;
+ throw new InvalidResponseCodeException(responseCode, responseMessage, cause, headers,
+ dataSpec, errorResponseBody);
+ }
+
+ // Check for a valid content type.
+ final String contentType = httpURLConnection.getContentType();
+ if (contentTypePredicate != null && !contentTypePredicate.apply(contentType)) {
+ closeConnectionQuietly();
+ throw new InvalidContentTypeException(contentType, dataSpecParameter);
+ }
+
+ final long bytesToSkip;
+ if (!rangeParameterEnabled) {
+ // If we requested a range starting from a non-zero position and received a 200 rather
+ // than a 206, then the server does not support partial requests. We'll need to
+ // manually skip to the requested position.
+ bytesToSkip = responseCode == 200 && dataSpecParameter.position != 0
+ ? dataSpecParameter.position
+ : 0;
+ } else {
+ bytesToSkip = 0;
+ }
+
+
+ // Determine the length of the data to be read, after skipping.
+ final boolean isCompressed = isCompressed(httpURLConnection);
+ if (!isCompressed) {
+ if (dataSpecParameter.length != C.LENGTH_UNSET) {
+ bytesToRead = dataSpecParameter.length;
+ } else {
+ final long contentLength = HttpUtil.getContentLength(
+ httpURLConnection.getHeaderField(HttpHeaders.CONTENT_LENGTH),
+ httpURLConnection.getHeaderField(HttpHeaders.CONTENT_RANGE));
+ bytesToRead = contentLength != C.LENGTH_UNSET
+ ? (contentLength - bytesToSkip)
+ : C.LENGTH_UNSET;
+ }
+ } else {
+ // Gzip is enabled. If the server opts to use gzip then the content length in the
+ // response will be that of the compressed data, which isn't what we want. Always use
+ // the dataSpec length in this case.
+ bytesToRead = dataSpecParameter.length;
+ }
+
+ try {
+ inputStream = httpURLConnection.getInputStream();
+ if (isCompressed) {
+ inputStream = new GZIPInputStream(inputStream);
+ }
+ } catch (final IOException e) {
+ closeConnectionQuietly();
+ throw new HttpDataSourceException(e, dataSpec,
+ PlaybackException.ERROR_CODE_IO_UNSPECIFIED,
+ HttpDataSourceException.TYPE_OPEN);
+ }
+
+ opened = true;
+ transferStarted(dataSpecParameter);
+
+ try {
+ skipFully(bytesToSkip, dataSpec);
+ } catch (final IOException e) {
+ closeConnectionQuietly();
+ if (e instanceof HttpDataSourceException) {
+ throw (HttpDataSourceException) e;
+ }
+ throw new HttpDataSourceException(e, dataSpec,
+ PlaybackException.ERROR_CODE_IO_UNSPECIFIED,
+ HttpDataSourceException.TYPE_OPEN);
+ }
+
+ return bytesToRead;
+ }
+
+ @Override
+ public int read(@NonNull final byte[] buffer, final int offset, final int length)
+ throws HttpDataSourceException {
+ try {
+ return readInternal(buffer, offset, length);
+ } catch (final IOException e) {
+ throw HttpDataSourceException.createForIOException(e, castNonNull(dataSpec),
+ HttpDataSourceException.TYPE_READ);
+ }
+ }
+
+ @Override
+ public void close() throws HttpDataSourceException {
+ try {
+ final InputStream connectionInputStream = this.inputStream;
+ if (connectionInputStream != null) {
+ final long bytesRemaining = bytesToRead == C.LENGTH_UNSET
+ ? C.LENGTH_UNSET
+ : bytesToRead - bytesRead;
+ maybeTerminateInputStream(connection, bytesRemaining);
+
+ try {
+ connectionInputStream.close();
+ } catch (final IOException e) {
+ throw new HttpDataSourceException(e, castNonNull(dataSpec),
+ PlaybackException.ERROR_CODE_IO_UNSPECIFIED,
+ HttpDataSourceException.TYPE_CLOSE);
+ }
+ }
+ } finally {
+ inputStream = null;
+ closeConnectionQuietly();
+ if (opened) {
+ opened = false;
+ transferEnded();
+ }
+ }
+ }
+
+ @NonNull
+ private HttpURLConnection makeConnection(@NonNull final DataSpec dataSpecToUse)
+ throws IOException {
+ URL url = new URL(dataSpecToUse.uri.toString());
+ @HttpMethod int httpMethod = dataSpecToUse.httpMethod;
+ @Nullable byte[] httpBody = dataSpecToUse.httpBody;
+ final long position = dataSpecToUse.position;
+ final long length = dataSpecToUse.length;
+ final boolean allowGzip = dataSpecToUse.isFlagSet(DataSpec.FLAG_ALLOW_GZIP);
+
+ if (!allowCrossProtocolRedirects && !keepPostFor302Redirects) {
+ // HttpURLConnection disallows cross-protocol redirects, but otherwise performs
+ // redirection automatically. This is the behavior we want, so use it.
+ return makeConnection(url, httpMethod, httpBody, position, length, allowGzip, true,
+ dataSpecToUse.httpRequestHeaders);
+ }
+
+ // We need to handle redirects ourselves to allow cross-protocol redirects or to keep the
+ // POST request method for 302.
+ int redirectCount = 0;
+ while (redirectCount++ <= MAX_REDIRECTS) {
+ final HttpURLConnection httpURLConnection = makeConnection(url, httpMethod, httpBody,
+ position, length, allowGzip, false, dataSpecToUse.httpRequestHeaders);
+ final int httpURLConnectionResponseCode = httpURLConnection.getResponseCode();
+ final String location = httpURLConnection.getHeaderField("Location");
+ if ((httpMethod == DataSpec.HTTP_METHOD_GET || httpMethod == DataSpec.HTTP_METHOD_HEAD)
+ && (httpURLConnectionResponseCode == HttpURLConnection.HTTP_MULT_CHOICE
+ || httpURLConnectionResponseCode == HttpURLConnection.HTTP_MOVED_PERM
+ || httpURLConnectionResponseCode == HttpURLConnection.HTTP_MOVED_TEMP
+ || httpURLConnectionResponseCode == HttpURLConnection.HTTP_SEE_OTHER
+ || httpURLConnectionResponseCode == HTTP_STATUS_TEMPORARY_REDIRECT
+ || httpURLConnectionResponseCode == HTTP_STATUS_PERMANENT_REDIRECT)) {
+ httpURLConnection.disconnect();
+ url = handleRedirect(url, location, dataSpecToUse);
+ } else if (httpMethod == DataSpec.HTTP_METHOD_POST
+ && (httpURLConnectionResponseCode == HttpURLConnection.HTTP_MULT_CHOICE
+ || httpURLConnectionResponseCode == HttpURLConnection.HTTP_MOVED_PERM
+ || httpURLConnectionResponseCode == HttpURLConnection.HTTP_MOVED_TEMP
+ || httpURLConnectionResponseCode == HttpURLConnection.HTTP_SEE_OTHER)) {
+ httpURLConnection.disconnect();
+ final boolean shouldKeepPost = keepPostFor302Redirects
+ && responseCode == HttpURLConnection.HTTP_MOVED_TEMP;
+ if (!shouldKeepPost) {
+ // POST request follows the redirect and is transformed into a GET request.
+ httpMethod = DataSpec.HTTP_METHOD_GET;
+ httpBody = null;
+ }
+ url = handleRedirect(url, location, dataSpecToUse);
+ } else {
+ return httpURLConnection;
+ }
+ }
+
+ // If we get here we've been redirected more times than are permitted.
+ throw new HttpDataSourceException(
+ new NoRouteToHostException("Too many redirects: " + redirectCount),
+ dataSpecToUse,
+ PlaybackException.ERROR_CODE_IO_NETWORK_CONNECTION_FAILED,
+ HttpDataSourceException.TYPE_OPEN);
+ }
+
+ /**
+ * Configures a connection and opens it.
+ *
+ * @param url The url to connect to.
+ * @param httpMethod The http method.
+ * @param httpBody The body data, or {@code null} if not required.
+ * @param position The byte offset of the requested data.
+ * @param length The length of the requested data, or {@link C#LENGTH_UNSET}.
+ * @param allowGzip Whether to allow the use of gzip.
+ * @param followRedirects Whether to follow redirects.
+ * @param requestParameters parameters (HTTP headers) to include in request.
+ * @return the connection opened
+ */
+ @SuppressWarnings("checkstyle:ParameterNumber")
+ @NonNull
+ private HttpURLConnection makeConnection(
+ @NonNull final URL url,
+ @HttpMethod final int httpMethod,
+ @Nullable final byte[] httpBody,
+ final long position,
+ final long length,
+ final boolean allowGzip,
+ final boolean followRedirects,
+ final Map requestParameters) throws IOException {
+ // This is the method that contains breaking changes with respect to DefaultHttpDataSource!
+
+ String requestUrl = url.toString();
+
+ // Don't add the request number parameter if it has been already added (for instance in
+ // DASH manifests) or if that's not a videoplayback URL
+ final boolean isVideoPlaybackUrl = url.getPath().startsWith("/videoplayback");
+ if (isVideoPlaybackUrl && rnParameterEnabled && !requestUrl.contains(RN_PARAMETER)) {
+ requestUrl += RN_PARAMETER + requestNumber;
+ ++requestNumber;
+ }
+
+ if (rangeParameterEnabled && isVideoPlaybackUrl) {
+ final String rangeParameterBuilt = buildRangeParameter(position, length);
+ if (rangeParameterBuilt != null) {
+ requestUrl += rangeParameterBuilt;
+ }
+ }
+
+ final HttpURLConnection httpURLConnection = openConnection(new URL(requestUrl));
+ httpURLConnection.setConnectTimeout(connectTimeoutMillis);
+ httpURLConnection.setReadTimeout(readTimeoutMillis);
+
+ final Map requestHeaders = new HashMap<>();
+ if (defaultRequestProperties != null) {
+ requestHeaders.putAll(defaultRequestProperties.getSnapshot());
+ }
+ requestHeaders.putAll(requestProperties.getSnapshot());
+ requestHeaders.putAll(requestParameters);
+
+ for (final Map.Entry property : requestHeaders.entrySet()) {
+ httpURLConnection.setRequestProperty(property.getKey(), property.getValue());
+ }
+
+ if (!rangeParameterEnabled) {
+ final String rangeHeader = buildRangeRequestHeader(position, length);
+ if (rangeHeader != null) {
+ httpURLConnection.setRequestProperty(HttpHeaders.RANGE, rangeHeader);
+ }
+ }
+
+ if (isWebStreamingUrl(requestUrl)
+ || isTvHtml5SimplyEmbeddedPlayerStreamingUrl(requestUrl)) {
+ httpURLConnection.setRequestProperty(HttpHeaders.ORIGIN, YOUTUBE_BASE_URL);
+ httpURLConnection.setRequestProperty(HttpHeaders.REFERER, YOUTUBE_BASE_URL);
+ httpURLConnection.setRequestProperty(HttpHeaders.SEC_FETCH_DEST, "empty");
+ httpURLConnection.setRequestProperty(HttpHeaders.SEC_FETCH_MODE, "cors");
+ httpURLConnection.setRequestProperty(HttpHeaders.SEC_FETCH_SITE, "cross-site");
+ }
+
+ httpURLConnection.setRequestProperty(HttpHeaders.TE, "trailers");
+
+ final boolean isAndroidStreamingUrl = isAndroidStreamingUrl(requestUrl);
+ final boolean isIosStreamingUrl = isIosStreamingUrl(requestUrl);
+ if (isAndroidStreamingUrl) {
+ // Improvement which may be done: find the content country used to request YouTube
+ // contents to add it in the user agent instead of using the default
+ httpURLConnection.setRequestProperty(HttpHeaders.USER_AGENT,
+ getAndroidUserAgent(null));
+ } else if (isIosStreamingUrl) {
+ httpURLConnection.setRequestProperty(HttpHeaders.USER_AGENT,
+ getIosUserAgent(null));
+ } else {
+ // non-mobile user agent
+ httpURLConnection.setRequestProperty(HttpHeaders.USER_AGENT, DownloaderImpl.USER_AGENT);
+ }
+
+ httpURLConnection.setRequestProperty(HttpHeaders.ACCEPT_ENCODING,
+ allowGzip ? "gzip" : "identity");
+ httpURLConnection.setInstanceFollowRedirects(followRedirects);
+ httpURLConnection.setDoOutput(httpBody != null);
+
+ // Mobile clients uses POST requests to fetch contents
+ httpURLConnection.setRequestMethod(isAndroidStreamingUrl || isIosStreamingUrl
+ ? "POST"
+ : DataSpec.getStringForHttpMethod(httpMethod));
+
+ if (httpBody != null) {
+ httpURLConnection.setFixedLengthStreamingMode(httpBody.length);
+ httpURLConnection.connect();
+ final OutputStream os = httpURLConnection.getOutputStream();
+ os.write(httpBody);
+ os.close();
+ } else {
+ httpURLConnection.connect();
+ }
+ return httpURLConnection;
+ }
+
+ /**
+ * Creates an {@link HttpURLConnection} that is connected with the {@code url}.
+ *
+ * @param url the {@link URL} to create an {@link HttpURLConnection}
+ * @return an {@link HttpURLConnection} created with the {@code url}
+ */
+ private HttpURLConnection openConnection(@NonNull final URL url) throws IOException {
+ return (HttpURLConnection) url.openConnection();
+ }
+
+ /**
+ * Handles a redirect.
+ *
+ * @param originalUrl The original URL.
+ * @param location The Location header in the response. May be {@code null}.
+ * @param dataSpecToHandleRedirect The {@link DataSpec}.
+ * @return The next URL.
+ * @throws HttpDataSourceException If redirection isn't possible.
+ */
+ @NonNull
+ private URL handleRedirect(final URL originalUrl,
+ @Nullable final String location,
+ final DataSpec dataSpecToHandleRedirect)
+ throws HttpDataSourceException {
+ if (location == null) {
+ throw new HttpDataSourceException("Null location redirect", dataSpecToHandleRedirect,
+ PlaybackException.ERROR_CODE_IO_NETWORK_CONNECTION_FAILED,
+ HttpDataSourceException.TYPE_OPEN);
+ }
+
+ // Form the new url.
+ final URL url;
+ try {
+ url = new URL(originalUrl, location);
+ } catch (final MalformedURLException e) {
+ throw new HttpDataSourceException(e, dataSpecToHandleRedirect,
+ PlaybackException.ERROR_CODE_IO_NETWORK_CONNECTION_FAILED,
+ HttpDataSourceException.TYPE_OPEN);
+ }
+
+ // Check that the protocol of the new url is supported.
+ final String protocol = url.getProtocol();
+ if (!"https".equals(protocol) && !"http".equals(protocol)) {
+ throw new HttpDataSourceException("Unsupported protocol redirect: " + protocol,
+ dataSpecToHandleRedirect,
+ PlaybackException.ERROR_CODE_IO_NETWORK_CONNECTION_FAILED,
+ HttpDataSourceException.TYPE_OPEN);
+ }
+
+ if (!allowCrossProtocolRedirects && !protocol.equals(originalUrl.getProtocol())) {
+ throw new HttpDataSourceException(
+ "Disallowed cross-protocol redirect ("
+ + originalUrl.getProtocol()
+ + " to "
+ + protocol
+ + ")",
+ dataSpecToHandleRedirect,
+ PlaybackException.ERROR_CODE_IO_NETWORK_CONNECTION_FAILED,
+ HttpDataSourceException.TYPE_OPEN);
+ }
+
+ return url;
+ }
+
+ /**
+ * Attempts to skip the specified number of bytes in full.
+ *
+ * @param bytesToSkip The number of bytes to skip.
+ * @param dataSpecToUse The {@link DataSpec}.
+ * @throws IOException If the thread is interrupted during the operation, or if the data ended
+ * before skipping the specified number of bytes.
+ */
+ @SuppressWarnings("checkstyle:FinalParameters")
+ private void skipFully(long bytesToSkip, final DataSpec dataSpecToUse) throws IOException {
+ if (bytesToSkip == 0) {
+ return;
+ }
+
+ final byte[] skipBuffer = new byte[4096];
+ while (bytesToSkip > 0) {
+ final int readLength = (int) min(bytesToSkip, skipBuffer.length);
+ final int read = castNonNull(inputStream).read(skipBuffer, 0, readLength);
+ if (Thread.currentThread().isInterrupted()) {
+ throw new HttpDataSourceException(
+ new InterruptedIOException(),
+ dataSpecToUse,
+ PlaybackException.ERROR_CODE_IO_UNSPECIFIED,
+ HttpDataSourceException.TYPE_OPEN);
+ }
+
+ if (read == -1) {
+ throw new HttpDataSourceException(
+ dataSpecToUse,
+ PlaybackException.ERROR_CODE_IO_READ_POSITION_OUT_OF_RANGE,
+ HttpDataSourceException.TYPE_OPEN);
+ }
+
+ bytesToSkip -= read;
+ bytesTransferred(read);
+ }
+ }
+
+ /**
+ * Reads up to {@code length} bytes of data and stores them into {@code buffer}, starting at
+ * index {@code offset}.
+ *
+ *
+ * This method blocks until at least one byte of data can be read, the end of the opened range
+ * is detected, or an exception is thrown.
+ *
+ *
+ * @param buffer The buffer into which the read data should be stored.
+ * @param offset The start offset into {@code buffer} at which data should be written.
+ * @param readLength The maximum number of bytes to read.
+ * @return The number of bytes read, or {@link C#RESULT_END_OF_INPUT} if the end of the opened
+ * range is reached.
+ * @throws IOException If an error occurs reading from the source.
+ */
+ @SuppressWarnings("checkstyle:FinalParameters")
+ private int readInternal(final byte[] buffer, final int offset, int readLength)
+ throws IOException {
+ if (readLength == 0) {
+ return 0;
+ }
+ if (bytesToRead != C.LENGTH_UNSET) {
+ final long bytesRemaining = bytesToRead - bytesRead;
+ if (bytesRemaining == 0) {
+ return C.RESULT_END_OF_INPUT;
+ }
+ readLength = (int) min(readLength, bytesRemaining);
+ }
+
+ final int read = castNonNull(inputStream).read(buffer, offset, readLength);
+ if (read == -1) {
+ return C.RESULT_END_OF_INPUT;
+ }
+
+ bytesRead += read;
+ bytesTransferred(read);
+ return read;
+ }
+
+ /**
+ * On platform API levels 19 and 20, okhttp's implementation of {@link InputStream#close} can
+ * block for a long time if the stream has a lot of data remaining. Call this method before
+ * closing the input stream to make a best effort to cause the input stream to encounter an
+ * unexpected end of input, working around this issue. On other platform API levels, the method
+ * does nothing.
+ *
+ * @param connection The connection whose {@link InputStream} should be terminated.
+ * @param bytesRemaining The number of bytes remaining to be read from the input stream if its
+ * length is known. {@link C#LENGTH_UNSET} otherwise.
+ */
+ private static void maybeTerminateInputStream(@Nullable final HttpURLConnection connection,
+ final long bytesRemaining) {
+ if (connection == null || Util.SDK_INT < 19 || Util.SDK_INT > 20) {
+ return;
+ }
+
+ try {
+ final InputStream inputStream = connection.getInputStream();
+ if (bytesRemaining == C.LENGTH_UNSET) {
+ // If the input stream has already ended, do nothing. The socket may be re-used.
+ if (inputStream.read() == -1) {
+ return;
+ }
+ } else if (bytesRemaining <= MAX_BYTES_TO_DRAIN) {
+ // There isn't much data left. Prefer to allow it to drain, which may allow the
+ // socket to be re-used.
+ return;
+ }
+ final String className = inputStream.getClass().getName();
+ if ("com.android.okhttp.internal.http.HttpTransport$ChunkedInputStream"
+ .equals(className)
+ || "com.android.okhttp.internal.http.HttpTransport$FixedLengthInputStream"
+ .equals(className)) {
+ final Class superclass = inputStream.getClass().getSuperclass();
+ final Method unexpectedEndOfInput = checkNotNull(superclass).getDeclaredMethod(
+ "unexpectedEndOfInput");
+ unexpectedEndOfInput.setAccessible(true);
+ unexpectedEndOfInput.invoke(inputStream);
+ }
+ } catch (final Exception e) {
+ // If an IOException then the connection didn't ever have an input stream, or it was
+ // closed already. If another type of exception then something went wrong, most likely
+ // the device isn't using okhttp.
+ }
+ }
+
+ /**
+ * Closes the current connection quietly, if there is one.
+ */
+ private void closeConnectionQuietly() {
+ if (connection != null) {
+ try {
+ connection.disconnect();
+ } catch (final Exception e) {
+ Log.e(TAG, "Unexpected error while disconnecting", e);
+ }
+ connection = null;
+ }
+ }
+
+ private static boolean isCompressed(@NonNull final HttpURLConnection connection) {
+ final String contentEncoding = connection.getHeaderField("Content-Encoding");
+ return "gzip".equalsIgnoreCase(contentEncoding);
+ }
+
+ /**
+ * Builds a {@code range} parameter for the given position and length.
+ *
+ *
+ * To fetch its contents, YouTube use range requests which append a {@code range} parameter
+ * to videoplayback URLs instead of the {@code Range} header (even if the server respond
+ * correctly when requesting a range of a ressouce with it).
+ *
+ *
+ *
+ * The parameter works in the same way as the header.
+ *
+ *
+ * @param position The request position.
+ * @param length The request length, or {@link C#LENGTH_UNSET} if the request is unbounded.
+ * @return The corresponding {@code range} parameter, or {@code null} if this parameter is
+ * unnecessary because the whole resource is being requested.
+ */
+ @Nullable
+ private static String buildRangeParameter(final long position, final long length) {
+ if (position == 0 && length == C.LENGTH_UNSET) {
+ return null;
+ }
+
+ final StringBuilder rangeParameter = new StringBuilder();
+ rangeParameter.append("&range=");
+ rangeParameter.append(position);
+ rangeParameter.append("-");
+ if (length != C.LENGTH_UNSET) {
+ rangeParameter.append(position + length - 1);
+ }
+ return rangeParameter.toString();
+ }
+
+ private static final class NullFilteringHeadersMap
+ extends ForwardingMap> {
+ private final Map> headers;
+
+ NullFilteringHeadersMap(final Map> headers) {
+ this.headers = headers;
+ }
+
+ @NonNull
+ @Override
+ protected Map> delegate() {
+ return headers;
+ }
+
+ @Override
+ public boolean containsKey(@Nullable final Object key) {
+ return key != null && super.containsKey(key);
+ }
+
+ @Nullable
+ @Override
+ public List get(@Nullable final Object key) {
+ return key == null ? null : super.get(key);
+ }
+
+ @NonNull
+ @Override
+ public Set keySet() {
+ return Sets.filter(super.keySet(), Objects::nonNull);
+ }
+
+ @NonNull
+ @Override
+ public Set>> entrySet() {
+ return Sets.filter(super.entrySet(), entry -> entry.getKey() != null);
+ }
+
+ @Override
+ public int size() {
+ return super.size() - (super.containsKey(null) ? 1 : 0);
+ }
+
+ @Override
+ public boolean isEmpty() {
+ return super.isEmpty() || (super.size() == 1 && super.containsKey(null));
+ }
+
+ @Override
+ public boolean containsValue(@Nullable final Object value) {
+ return super.standardContainsValue(value);
+ }
+
+ @Override
+ public boolean equals(@Nullable final Object object) {
+ return object != null && super.standardEquals(object);
+ }
+
+ @Override
+ public int hashCode() {
+ return super.standardHashCode();
+ }
+ }
+}
+
diff --git a/app/src/main/java/org/schabi/newpipe/player/event/PlayerGestureListener.java b/app/src/main/java/org/schabi/newpipe/player/event/PlayerGestureListener.java
index 794fe9b3c..a7fb40c47 100644
--- a/app/src/main/java/org/schabi/newpipe/player/event/PlayerGestureListener.java
+++ b/app/src/main/java/org/schabi/newpipe/player/event/PlayerGestureListener.java
@@ -126,6 +126,14 @@ public class PlayerGestureListener
}
private void onScrollMainVolume(final float distanceX, final float distanceY) {
+ // If we just started sliding, change the progress bar to match the system volume
+ if (player.getVolumeRelativeLayout().getVisibility() != View.VISIBLE) {
+ final float volumePercent = player
+ .getAudioReactor().getVolume() / (float) maxVolume;
+ player.getVolumeProgressBar().setProgress(
+ (int) (volumePercent * player.getMaxGestureLength()));
+ }
+
player.getVolumeProgressBar().incrementProgressBy((int) distanceY);
final float currentProgressPercent = (float) player
.getVolumeProgressBar().getProgress() / player.getMaxGestureLength();
diff --git a/app/src/main/java/org/schabi/newpipe/player/event/PlayerServiceEventListener.java b/app/src/main/java/org/schabi/newpipe/player/event/PlayerServiceEventListener.java
index f8d03087e..359eab8b2 100644
--- a/app/src/main/java/org/schabi/newpipe/player/event/PlayerServiceEventListener.java
+++ b/app/src/main/java/org/schabi/newpipe/player/event/PlayerServiceEventListener.java
@@ -1,6 +1,6 @@
package org.schabi.newpipe.player.event;
-import com.google.android.exoplayer2.ExoPlaybackException;
+import com.google.android.exoplayer2.PlaybackException;
public interface PlayerServiceEventListener extends PlayerEventListener {
void onFullscreenStateChanged(boolean fullscreen);
@@ -9,7 +9,7 @@ public interface PlayerServiceEventListener extends PlayerEventListener {
void onMoreOptionsLongClicked();
- void onPlayerError(ExoPlaybackException error);
+ void onPlayerError(PlaybackException error, boolean isCatchableException);
void hideSystemUiIfNeeded();
}
diff --git a/app/src/main/java/org/schabi/newpipe/player/helper/AudioReactor.java b/app/src/main/java/org/schabi/newpipe/player/helper/AudioReactor.java
index b36f9f234..a05990816 100644
--- a/app/src/main/java/org/schabi/newpipe/player/helper/AudioReactor.java
+++ b/app/src/main/java/org/schabi/newpipe/player/helper/AudioReactor.java
@@ -14,7 +14,7 @@ import androidx.core.content.ContextCompat;
import androidx.media.AudioFocusRequestCompat;
import androidx.media.AudioManagerCompat;
-import com.google.android.exoplayer2.SimpleExoPlayer;
+import com.google.android.exoplayer2.ExoPlayer;
import com.google.android.exoplayer2.analytics.AnalyticsListener;
public class AudioReactor implements AudioManager.OnAudioFocusChangeListener, AnalyticsListener {
@@ -27,14 +27,14 @@ public class AudioReactor implements AudioManager.OnAudioFocusChangeListener, An
private static final int FOCUS_GAIN_TYPE = AudioManagerCompat.AUDIOFOCUS_GAIN;
private static final int STREAM_TYPE = AudioManager.STREAM_MUSIC;
- private final SimpleExoPlayer player;
+ private final ExoPlayer player;
private final Context context;
private final AudioManager audioManager;
private final AudioFocusRequestCompat request;
public AudioReactor(@NonNull final Context context,
- @NonNull final SimpleExoPlayer player) {
+ @NonNull final ExoPlayer player) {
this.player = player;
this.context = context;
this.audioManager = ContextCompat.getSystemService(context, AudioManager.class);
@@ -149,7 +149,8 @@ public class AudioReactor implements AudioManager.OnAudioFocusChangeListener, An
//////////////////////////////////////////////////////////////////////////*/
@Override
- public void onAudioSessionIdChanged(final EventTime eventTime, final int audioSessionId) {
+ public void onAudioSessionIdChanged(@NonNull final EventTime eventTime,
+ final int audioSessionId) {
notifyAudioSessionUpdate(true, audioSessionId);
}
private void notifyAudioSessionUpdate(final boolean active, final int audioSessionId) {
diff --git a/app/src/main/java/org/schabi/newpipe/player/helper/CacheFactory.java b/app/src/main/java/org/schabi/newpipe/player/helper/CacheFactory.java
index 9703a3588..d189616d1 100644
--- a/app/src/main/java/org/schabi/newpipe/player/helper/CacheFactory.java
+++ b/app/src/main/java/org/schabi/newpipe/player/helper/CacheFactory.java
@@ -1,93 +1,46 @@
package org.schabi.newpipe.player.helper;
import android.content.Context;
-import android.util.Log;
import androidx.annotation.NonNull;
-import com.google.android.exoplayer2.database.ExoDatabaseProvider;
import com.google.android.exoplayer2.upstream.DataSource;
import com.google.android.exoplayer2.upstream.DefaultDataSource;
-import com.google.android.exoplayer2.upstream.DefaultDataSourceFactory;
import com.google.android.exoplayer2.upstream.FileDataSource;
import com.google.android.exoplayer2.upstream.TransferListener;
import com.google.android.exoplayer2.upstream.cache.CacheDataSink;
import com.google.android.exoplayer2.upstream.cache.CacheDataSource;
-import com.google.android.exoplayer2.upstream.cache.LeastRecentlyUsedCacheEvictor;
import com.google.android.exoplayer2.upstream.cache.SimpleCache;
-import java.io.File;
+final class CacheFactory implements DataSource.Factory {
+ private static final int CACHE_FLAGS = CacheDataSource.FLAG_IGNORE_CACHE_ON_ERROR;
-/* package-private */ class CacheFactory implements DataSource.Factory {
- private static final String TAG = "CacheFactory";
+ private final Context context;
+ private final TransferListener transferListener;
+ private final DataSource.Factory upstreamDataSourceFactory;
+ private final SimpleCache cache;
- private static final String CACHE_FOLDER_NAME = "exoplayer";
- private static final int CACHE_FLAGS = CacheDataSource.FLAG_BLOCK_ON_CACHE
- | CacheDataSource.FLAG_IGNORE_CACHE_ON_ERROR;
-
- private final DefaultDataSourceFactory dataSourceFactory;
- private final File cacheDir;
- private final long maxFileSize;
-
- // Creating cache on every instance may cause problems with multiple players when
- // sources are not ExtractorMediaSource
- // see: https://stackoverflow.com/questions/28700391/using-cache-in-exoplayer
- // todo: make this a singleton?
- private static SimpleCache cache;
-
- CacheFactory(@NonNull final Context context,
- @NonNull final String userAgent,
- @NonNull final TransferListener transferListener) {
- this(context, userAgent, transferListener, PlayerHelper.getPreferredCacheSize(),
- PlayerHelper.getPreferredFileSize());
- }
-
- private CacheFactory(@NonNull final Context context,
- @NonNull final String userAgent,
- @NonNull final TransferListener transferListener,
- final long maxCacheSize,
- final long maxFileSize) {
- this.maxFileSize = maxFileSize;
-
- dataSourceFactory = new DefaultDataSourceFactory(context, userAgent, transferListener);
- cacheDir = new File(context.getExternalCacheDir(), CACHE_FOLDER_NAME);
- if (!cacheDir.exists()) {
- //noinspection ResultOfMethodCallIgnored
- cacheDir.mkdir();
- }
-
- if (cache == null) {
- final LeastRecentlyUsedCacheEvictor evictor
- = new LeastRecentlyUsedCacheEvictor(maxCacheSize);
- cache = new SimpleCache(cacheDir, evictor, new ExoDatabaseProvider(context));
- }
+ CacheFactory(final Context context,
+ final TransferListener transferListener,
+ final SimpleCache cache,
+ final DataSource.Factory upstreamDataSourceFactory) {
+ this.context = context;
+ this.transferListener = transferListener;
+ this.cache = cache;
+ this.upstreamDataSourceFactory = upstreamDataSourceFactory;
}
+ @NonNull
@Override
public DataSource createDataSource() {
- Log.d(TAG, "initExoPlayerCache: cacheDir = " + cacheDir.getAbsolutePath());
+ final DefaultDataSource dataSource = new DefaultDataSource.Factory(context,
+ upstreamDataSourceFactory)
+ .setTransferListener(transferListener)
+ .createDataSource();
- final DefaultDataSource dataSource = dataSourceFactory.createDataSource();
final FileDataSource fileSource = new FileDataSource();
- final CacheDataSink dataSink = new CacheDataSink(cache, maxFileSize);
-
+ final CacheDataSink dataSink
+ = new CacheDataSink(cache, PlayerHelper.getPreferredFileSize());
return new CacheDataSource(cache, dataSource, fileSource, dataSink, CACHE_FLAGS, null);
}
-
- public void tryDeleteCacheFiles() {
- if (!cacheDir.exists() || !cacheDir.isDirectory()) {
- return;
- }
-
- try {
- for (final File file : cacheDir.listFiles()) {
- final String filePath = file.getAbsolutePath();
- final boolean deleteSuccessful = file.delete();
-
- Log.d(TAG, "tryDeleteCacheFiles: " + filePath + " deleted = " + deleteSuccessful);
- }
- } catch (final Exception ignored) {
- Log.e(TAG, "Failed to delete file.", ignored);
- }
- }
}
diff --git a/app/src/main/java/org/schabi/newpipe/player/helper/MediaSessionManager.java b/app/src/main/java/org/schabi/newpipe/player/helper/MediaSessionManager.java
index 8d344c877..a8735dc08 100644
--- a/app/src/main/java/org/schabi/newpipe/player/helper/MediaSessionManager.java
+++ b/app/src/main/java/org/schabi/newpipe/player/helper/MediaSessionManager.java
@@ -13,13 +13,13 @@ import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.media.session.MediaButtonReceiver;
+import com.google.android.exoplayer2.ForwardingPlayer;
import com.google.android.exoplayer2.Player;
import com.google.android.exoplayer2.ext.mediasession.MediaSessionConnector;
import org.schabi.newpipe.MainActivity;
import org.schabi.newpipe.player.mediasession.MediaSessionCallback;
import org.schabi.newpipe.player.mediasession.PlayQueueNavigator;
-import org.schabi.newpipe.player.mediasession.PlayQueuePlaybackController;
import java.util.Optional;
@@ -55,9 +55,18 @@ public class MediaSessionManager {
.build());
sessionConnector = new MediaSessionConnector(mediaSession);
- sessionConnector.setControlDispatcher(new PlayQueuePlaybackController(callback));
sessionConnector.setQueueNavigator(new PlayQueueNavigator(mediaSession, callback));
- sessionConnector.setPlayer(player);
+ sessionConnector.setPlayer(new ForwardingPlayer(player) {
+ @Override
+ public void play() {
+ callback.play();
+ }
+
+ @Override
+ public void pause() {
+ callback.pause();
+ }
+ });
}
@Nullable
@@ -135,9 +144,7 @@ public class MediaSessionManager {
lastTitleHashCode = title.hashCode();
lastArtistHashCode = artist.hashCode();
lastDuration = duration;
- if (optAlbumArt.isPresent()) {
- lastAlbumArtHashCode = optAlbumArt.get().hashCode();
- }
+ optAlbumArt.ifPresent(bitmap -> lastAlbumArtHashCode = bitmap.hashCode());
}
private boolean checkIfMetadataShouldBeSet(
diff --git a/app/src/main/java/org/schabi/newpipe/player/helper/PlaybackParameterDialog.java b/app/src/main/java/org/schabi/newpipe/player/helper/PlaybackParameterDialog.java
index 5139ef9cd..19a5a645b 100644
--- a/app/src/main/java/org/schabi/newpipe/player/helper/PlaybackParameterDialog.java
+++ b/app/src/main/java/org/schabi/newpipe/player/helper/PlaybackParameterDialog.java
@@ -1,12 +1,17 @@
package org.schabi.newpipe.player.helper;
+import static org.schabi.newpipe.ktx.ViewUtils.animateRotation;
import static org.schabi.newpipe.player.Player.DEBUG;
import static org.schabi.newpipe.util.Localization.assureCorrectAppLanguage;
+import static org.schabi.newpipe.util.ThemeHelper.resolveDrawable;
import android.app.Dialog;
import android.content.Context;
+import android.graphics.drawable.Drawable;
+import android.graphics.drawable.LayerDrawable;
import android.os.Bundle;
import android.util.Log;
+import android.view.LayoutInflater;
import android.view.View;
import android.widget.CheckBox;
import android.widget.SeekBar;
@@ -14,95 +19,103 @@ import android.widget.TextView;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
+import androidx.annotation.StringRes;
import androidx.appcompat.app.AlertDialog;
import androidx.fragment.app.DialogFragment;
import androidx.preference.PreferenceManager;
import org.schabi.newpipe.R;
+import org.schabi.newpipe.databinding.DialogPlaybackParameterBinding;
+import org.schabi.newpipe.player.Player;
+import org.schabi.newpipe.util.SimpleOnSeekBarChangeListener;
import org.schabi.newpipe.util.SliderStrategy;
+import java.util.HashMap;
+import java.util.Map;
+import java.util.Objects;
+import java.util.function.Consumer;
+import java.util.function.DoubleConsumer;
+import java.util.function.DoubleFunction;
+import java.util.function.DoubleSupplier;
+
+import icepick.Icepick;
+import icepick.State;
+
public class PlaybackParameterDialog extends DialogFragment {
+ private static final String TAG = "PlaybackParameterDialog";
+
// Minimum allowable range in ExoPlayer
- private static final double MINIMUM_PLAYBACK_VALUE = 0.10f;
- private static final double MAXIMUM_PLAYBACK_VALUE = 3.00f;
+ private static final double MIN_PITCH_OR_SPEED = 0.10f;
+ private static final double MAX_PITCH_OR_SPEED = 3.00f;
- private static final char STEP_UP_SIGN = '+';
- private static final char STEP_DOWN_SIGN = '-';
+ private static final boolean PITCH_CTRL_MODE_PERCENT = false;
+ private static final boolean PITCH_CTRL_MODE_SEMITONE = true;
- private static final double STEP_ONE_PERCENT_VALUE = 0.01f;
- private static final double STEP_FIVE_PERCENT_VALUE = 0.05f;
- private static final double STEP_TEN_PERCENT_VALUE = 0.10f;
- private static final double STEP_TWENTY_FIVE_PERCENT_VALUE = 0.25f;
- private static final double STEP_ONE_HUNDRED_PERCENT_VALUE = 1.00f;
+ private static final double STEP_1_PERCENT_VALUE = 0.01f;
+ private static final double STEP_5_PERCENT_VALUE = 0.05f;
+ private static final double STEP_10_PERCENT_VALUE = 0.10f;
+ private static final double STEP_25_PERCENT_VALUE = 0.25f;
+ private static final double STEP_100_PERCENT_VALUE = 1.00f;
private static final double DEFAULT_TEMPO = 1.00f;
- private static final double DEFAULT_PITCH = 1.00f;
- private static final double DEFAULT_STEP = STEP_TWENTY_FIVE_PERCENT_VALUE;
+ private static final double DEFAULT_PITCH_PERCENT = 1.00f;
+ private static final double DEFAULT_STEP = STEP_25_PERCENT_VALUE;
private static final boolean DEFAULT_SKIP_SILENCE = false;
- @NonNull
- private static final String TAG = "PlaybackParameterDialog";
- @NonNull
- private static final String INITIAL_TEMPO_KEY = "initial_tempo_key";
- @NonNull
- private static final String INITIAL_PITCH_KEY = "initial_pitch_key";
+ private static final SliderStrategy QUADRATIC_STRATEGY = new SliderStrategy.Quadratic(
+ MIN_PITCH_OR_SPEED,
+ MAX_PITCH_OR_SPEED,
+ 1.00f,
+ 10_000);
- @NonNull
- private static final String TEMPO_KEY = "tempo_key";
- @NonNull
- private static final String PITCH_KEY = "pitch_key";
- @NonNull
- private static final String STEP_SIZE_KEY = "step_size_key";
+ private static final SliderStrategy SEMITONE_STRATEGY = new SliderStrategy() {
+ @Override
+ public int progressOf(final double value) {
+ return PlayerSemitoneHelper.percentToSemitones(value) + 12;
+ }
- @NonNull
- private final SliderStrategy strategy = new SliderStrategy.Quadratic(
- MINIMUM_PLAYBACK_VALUE, MAXIMUM_PLAYBACK_VALUE,
- /*centerAt=*/1.00f, /*sliderGranularity=*/10000);
+ @Override
+ public double valueOf(final int progress) {
+ return PlayerSemitoneHelper.semitonesToPercent(progress - 12);
+ }
+ };
@Nullable
private Callback callback;
- private double initialTempo = DEFAULT_TEMPO;
- private double initialPitch = DEFAULT_PITCH;
- private boolean initialSkipSilence = DEFAULT_SKIP_SILENCE;
- private double tempo = DEFAULT_TEMPO;
- private double pitch = DEFAULT_PITCH;
- private double stepSize = DEFAULT_STEP;
+ @State
+ double initialTempo = DEFAULT_TEMPO;
+ @State
+ double initialPitchPercent = DEFAULT_PITCH_PERCENT;
+ @State
+ boolean initialSkipSilence = DEFAULT_SKIP_SILENCE;
- @Nullable
- private SeekBar tempoSlider;
- @Nullable
- private TextView tempoCurrentText;
- @Nullable
- private TextView tempoStepDownText;
- @Nullable
- private TextView tempoStepUpText;
- @Nullable
- private SeekBar pitchSlider;
- @Nullable
- private TextView pitchCurrentText;
- @Nullable
- private TextView pitchStepDownText;
- @Nullable
- private TextView pitchStepUpText;
- @Nullable
- private CheckBox unhookingCheckbox;
- @Nullable
- private CheckBox skipSilenceCheckbox;
+ @State
+ double tempo = DEFAULT_TEMPO;
+ @State
+ double pitchPercent = DEFAULT_PITCH_PERCENT;
+ @State
+ boolean skipSilence = DEFAULT_SKIP_SILENCE;
- public static PlaybackParameterDialog newInstance(final double playbackTempo,
- final double playbackPitch,
- final boolean playbackSkipSilence,
- final Callback callback) {
+ private DialogPlaybackParameterBinding binding;
+
+ public static PlaybackParameterDialog newInstance(
+ final double playbackTempo,
+ final double playbackPitch,
+ final boolean playbackSkipSilence,
+ final Callback callback
+ ) {
final PlaybackParameterDialog dialog = new PlaybackParameterDialog();
dialog.callback = callback;
+
dialog.initialTempo = playbackTempo;
- dialog.initialPitch = playbackPitch;
-
- dialog.tempo = playbackTempo;
- dialog.pitch = playbackPitch;
-
+ dialog.initialPitchPercent = playbackPitch;
dialog.initialSkipSilence = playbackSkipSilence;
+
+ dialog.tempo = dialog.initialTempo;
+ dialog.pitchPercent = dialog.initialPitchPercent;
+ dialog.skipSilence = dialog.initialSkipSilence;
+
return dialog;
}
@@ -111,7 +124,7 @@ public class PlaybackParameterDialog extends DialogFragment {
//////////////////////////////////////////////////////////////////////////*/
@Override
- public void onAttach(final Context context) {
+ public void onAttach(@NonNull final Context context) {
super.onAttach(context);
if (context instanceof Callback) {
callback = (Callback) context;
@@ -121,28 +134,9 @@ public class PlaybackParameterDialog extends DialogFragment {
}
@Override
- public void onCreate(@Nullable final Bundle savedInstanceState) {
- assureCorrectAppLanguage(getContext());
- super.onCreate(savedInstanceState);
- if (savedInstanceState != null) {
- initialTempo = savedInstanceState.getDouble(INITIAL_TEMPO_KEY, DEFAULT_TEMPO);
- initialPitch = savedInstanceState.getDouble(INITIAL_PITCH_KEY, DEFAULT_PITCH);
-
- tempo = savedInstanceState.getDouble(TEMPO_KEY, DEFAULT_TEMPO);
- pitch = savedInstanceState.getDouble(PITCH_KEY, DEFAULT_PITCH);
- stepSize = savedInstanceState.getDouble(STEP_SIZE_KEY, DEFAULT_STEP);
- }
- }
-
- @Override
- public void onSaveInstanceState(final Bundle outState) {
+ public void onSaveInstanceState(@NonNull final Bundle outState) {
super.onSaveInstanceState(outState);
- outState.putDouble(INITIAL_TEMPO_KEY, initialTempo);
- outState.putDouble(INITIAL_PITCH_KEY, initialPitch);
-
- outState.putDouble(TEMPO_KEY, getCurrentTempo());
- outState.putDouble(PITCH_KEY, getCurrentPitch());
- outState.putDouble(STEP_SIZE_KEY, getCurrentStepSize());
+ Icepick.saveInstanceState(this, outState);
}
/*//////////////////////////////////////////////////////////////////////////
@@ -153,196 +147,345 @@ public class PlaybackParameterDialog extends DialogFragment {
@Override
public Dialog onCreateDialog(@Nullable final Bundle savedInstanceState) {
assureCorrectAppLanguage(getContext());
- final View view = View.inflate(getContext(), R.layout.dialog_playback_parameter, null);
- setupControlViews(view);
+ Icepick.restoreInstanceState(this, savedInstanceState);
+
+ binding = DialogPlaybackParameterBinding.inflate(LayoutInflater.from(getContext()));
+ initUI();
final AlertDialog.Builder dialogBuilder = new AlertDialog.Builder(requireActivity())
- .setView(view)
+ .setView(binding.getRoot())
.setCancelable(true)
- .setNegativeButton(R.string.cancel, (dialogInterface, i) ->
- setPlaybackParameters(initialTempo, initialPitch, initialSkipSilence))
- .setNeutralButton(R.string.playback_reset, (dialogInterface, i) ->
- setPlaybackParameters(DEFAULT_TEMPO, DEFAULT_PITCH, DEFAULT_SKIP_SILENCE))
- .setPositiveButton(R.string.ok, (dialogInterface, i) ->
- setCurrentPlaybackParameters());
+ .setNegativeButton(R.string.cancel, (dialogInterface, i) -> {
+ setAndUpdateTempo(initialTempo);
+ setAndUpdatePitch(initialPitchPercent);
+ setAndUpdateSkipSilence(initialSkipSilence);
+ updateCallback();
+ })
+ .setNeutralButton(R.string.playback_reset, (dialogInterface, i) -> {
+ setAndUpdateTempo(DEFAULT_TEMPO);
+ setAndUpdatePitch(DEFAULT_PITCH_PERCENT);
+ setAndUpdateSkipSilence(DEFAULT_SKIP_SILENCE);
+ updateCallback();
+ })
+ .setPositiveButton(R.string.ok, (dialogInterface, i) -> updateCallback());
return dialogBuilder.create();
}
/*//////////////////////////////////////////////////////////////////////////
- // Control Views
+ // UI Initialization and Control
//////////////////////////////////////////////////////////////////////////*/
- private void setupControlViews(@NonNull final View rootView) {
- setupHookingControl(rootView);
- setupSkipSilenceControl(rootView);
+ private void initUI() {
+ // Tempo
+ setText(binding.tempoMinimumText, PlayerHelper::formatSpeed, MIN_PITCH_OR_SPEED);
+ setText(binding.tempoMaximumText, PlayerHelper::formatSpeed, MAX_PITCH_OR_SPEED);
- setupTempoControl(rootView);
- setupPitchControl(rootView);
+ binding.tempoSeekbar.setMax(QUADRATIC_STRATEGY.progressOf(MAX_PITCH_OR_SPEED));
+ setAndUpdateTempo(tempo);
+ binding.tempoSeekbar.setOnSeekBarChangeListener(
+ getTempoOrPitchSeekbarChangeListener(
+ QUADRATIC_STRATEGY,
+ this::onTempoSliderUpdated));
- setStepSize(stepSize);
- setupStepSizeSelector(rootView);
+ registerOnStepClickListener(
+ binding.tempoStepDown,
+ () -> tempo,
+ -1,
+ this::onTempoSliderUpdated);
+ registerOnStepClickListener(
+ binding.tempoStepUp,
+ () -> tempo,
+ 1,
+ this::onTempoSliderUpdated);
+
+ // Pitch
+ binding.pitchToogleControlModes.setOnClickListener(v -> {
+ final boolean isCurrentlyVisible =
+ binding.pitchControlModeTabs.getVisibility() == View.GONE;
+ binding.pitchControlModeTabs.setVisibility(isCurrentlyVisible
+ ? View.VISIBLE
+ : View.GONE);
+ animateRotation(binding.pitchToogleControlModes,
+ Player.DEFAULT_CONTROLS_DURATION,
+ isCurrentlyVisible ? 180 : 0);
+ });
+
+ getPitchControlModeComponentMappings()
+ .forEach(this::setupPitchControlModeTextView);
+ // Initialization is done at the end
+
+ // Pitch - Percent
+ setText(binding.pitchPercentMinimumText, PlayerHelper::formatPitch, MIN_PITCH_OR_SPEED);
+ setText(binding.pitchPercentMaximumText, PlayerHelper::formatPitch, MAX_PITCH_OR_SPEED);
+
+ binding.pitchPercentSeekbar.setMax(QUADRATIC_STRATEGY.progressOf(MAX_PITCH_OR_SPEED));
+ setAndUpdatePitch(pitchPercent);
+ binding.pitchPercentSeekbar.setOnSeekBarChangeListener(
+ getTempoOrPitchSeekbarChangeListener(
+ QUADRATIC_STRATEGY,
+ this::onPitchPercentSliderUpdated));
+
+ registerOnStepClickListener(
+ binding.pitchPercentStepDown,
+ () -> pitchPercent,
+ -1,
+ this::onPitchPercentSliderUpdated);
+ registerOnStepClickListener(
+ binding.pitchPercentStepUp,
+ () -> pitchPercent,
+ 1,
+ this::onPitchPercentSliderUpdated);
+
+ // Pitch - Semitone
+ binding.pitchSemitoneSeekbar.setOnSeekBarChangeListener(
+ getTempoOrPitchSeekbarChangeListener(
+ SEMITONE_STRATEGY,
+ this::onPitchPercentSliderUpdated));
+
+ registerOnSemitoneStepClickListener(
+ binding.pitchSemitoneStepDown,
+ -1,
+ this::onPitchPercentSliderUpdated);
+ registerOnSemitoneStepClickListener(
+ binding.pitchSemitoneStepUp,
+ 1,
+ this::onPitchPercentSliderUpdated);
+
+ // Steps
+ getStepSizeComponentMappings()
+ .forEach(this::setupStepTextView);
+ // Initialize UI
+ setStepSizeToUI(getCurrentStepSize());
+
+ // Bottom controls
+ bindCheckboxWithBoolPref(
+ binding.unhookCheckbox,
+ R.string.playback_unhook_key,
+ true,
+ isChecked -> {
+ if (!isChecked) {
+ // when unchecked, slide back to the minimum of current tempo or pitch
+ ensureHookIsValidAndUpdateCallBack();
+ }
+ });
+
+ setAndUpdateSkipSilence(skipSilence);
+ binding.skipSilenceCheckbox.setOnCheckedChangeListener((compoundButton, isChecked) -> {
+ skipSilence = isChecked;
+ updateCallback();
+ });
+
+ // PitchControlMode has to be initialized at the end because it requires the unhookCheckbox
+ changePitchControlMode(isCurrentPitchControlModeSemitone());
}
- private void setupTempoControl(@NonNull final View rootView) {
- tempoSlider = rootView.findViewById(R.id.tempoSeekbar);
- final TextView tempoMinimumText = rootView.findViewById(R.id.tempoMinimumText);
- final TextView tempoMaximumText = rootView.findViewById(R.id.tempoMaximumText);
- tempoCurrentText = rootView.findViewById(R.id.tempoCurrentText);
- tempoStepUpText = rootView.findViewById(R.id.tempoStepUp);
- tempoStepDownText = rootView.findViewById(R.id.tempoStepDown);
+ // -- General formatting --
- if (tempoCurrentText != null) {
- tempoCurrentText.setText(PlayerHelper.formatSpeed(tempo));
- }
- if (tempoMaximumText != null) {
- tempoMaximumText.setText(PlayerHelper.formatSpeed(MAXIMUM_PLAYBACK_VALUE));
- }
- if (tempoMinimumText != null) {
- tempoMinimumText.setText(PlayerHelper.formatSpeed(MINIMUM_PLAYBACK_VALUE));
- }
-
- if (tempoSlider != null) {
- tempoSlider.setMax(strategy.progressOf(MAXIMUM_PLAYBACK_VALUE));
- tempoSlider.setProgress(strategy.progressOf(tempo));
- tempoSlider.setOnSeekBarChangeListener(getOnTempoChangedListener());
- }
+ private void setText(
+ final TextView textView,
+ final DoubleFunction formatter,
+ final double value
+ ) {
+ Objects.requireNonNull(textView).setText(formatter.apply(value));
}
- private void setupPitchControl(@NonNull final View rootView) {
- pitchSlider = rootView.findViewById(R.id.pitchSeekbar);
- final TextView pitchMinimumText = rootView.findViewById(R.id.pitchMinimumText);
- final TextView pitchMaximumText = rootView.findViewById(R.id.pitchMaximumText);
- pitchCurrentText = rootView.findViewById(R.id.pitchCurrentText);
- pitchStepDownText = rootView.findViewById(R.id.pitchStepDown);
- pitchStepUpText = rootView.findViewById(R.id.pitchStepUp);
+ // -- Steps --
- if (pitchCurrentText != null) {
- pitchCurrentText.setText(PlayerHelper.formatPitch(pitch));
- }
- if (pitchMaximumText != null) {
- pitchMaximumText.setText(PlayerHelper.formatPitch(MAXIMUM_PLAYBACK_VALUE));
- }
- if (pitchMinimumText != null) {
- pitchMinimumText.setText(PlayerHelper.formatPitch(MINIMUM_PLAYBACK_VALUE));
- }
-
- if (pitchSlider != null) {
- pitchSlider.setMax(strategy.progressOf(MAXIMUM_PLAYBACK_VALUE));
- pitchSlider.setProgress(strategy.progressOf(pitch));
- pitchSlider.setOnSeekBarChangeListener(getOnPitchChangedListener());
- }
+ private void registerOnStepClickListener(
+ final TextView stepTextView,
+ final DoubleSupplier currentValueSupplier,
+ final double direction, // -1 for step down, +1 for step up
+ final DoubleConsumer newValueConsumer
+ ) {
+ stepTextView.setOnClickListener(view -> {
+ newValueConsumer.accept(
+ currentValueSupplier.getAsDouble() + 1 * getCurrentStepSize() * direction);
+ updateCallback();
+ });
}
- private void setupHookingControl(@NonNull final View rootView) {
- unhookingCheckbox = rootView.findViewById(R.id.unhookCheckbox);
- if (unhookingCheckbox != null) {
- // restore whether pitch and tempo are unhooked or not
- unhookingCheckbox.setChecked(PreferenceManager
- .getDefaultSharedPreferences(requireContext())
- .getBoolean(getString(R.string.playback_unhook_key), true));
+ private void registerOnSemitoneStepClickListener(
+ final TextView stepTextView,
+ final int direction, // -1 for step down, +1 for step up
+ final DoubleConsumer newValueConsumer
+ ) {
+ stepTextView.setOnClickListener(view -> {
+ newValueConsumer.accept(PlayerSemitoneHelper.semitonesToPercent(
+ PlayerSemitoneHelper.percentToSemitones(this.pitchPercent) + direction));
+ updateCallback();
+ });
+ }
- unhookingCheckbox.setOnCheckedChangeListener((compoundButton, isChecked) -> {
- // save whether pitch and tempo are unhooked or not
- PreferenceManager.getDefaultSharedPreferences(requireContext())
- .edit()
- .putBoolean(getString(R.string.playback_unhook_key), isChecked)
- .apply();
+ // -- Pitch --
- if (!isChecked) {
- // when unchecked, slide back to the minimum of current tempo or pitch
- final double minimum = Math.min(getCurrentPitch(), getCurrentTempo());
- setSliders(minimum);
- setCurrentPlaybackParameters();
+ private void setupPitchControlModeTextView(
+ final boolean semitones,
+ final TextView textView
+ ) {
+ textView.setOnClickListener(view -> {
+ PreferenceManager.getDefaultSharedPreferences(requireContext())
+ .edit()
+ .putBoolean(getString(R.string.playback_adjust_by_semitones_key), semitones)
+ .apply();
+
+ changePitchControlMode(semitones);
+ });
+ }
+
+ private Map getPitchControlModeComponentMappings() {
+ final Map mappings = new HashMap<>();
+ mappings.put(PITCH_CTRL_MODE_PERCENT, binding.pitchControlModePercent);
+ mappings.put(PITCH_CTRL_MODE_SEMITONE, binding.pitchControlModeSemitone);
+ return mappings;
+ }
+
+ private void changePitchControlMode(final boolean semitones) {
+ // Bring all textviews into a normal state
+ final Map pitchCtrlModeComponentMapping =
+ getPitchControlModeComponentMappings();
+ pitchCtrlModeComponentMapping.forEach((v, textView) -> textView.setBackground(
+ resolveDrawable(requireContext(), R.attr.selectableItemBackground)));
+
+ // Mark the selected textview
+ final TextView textView = pitchCtrlModeComponentMapping.get(semitones);
+ if (textView != null) {
+ textView.setBackground(new LayerDrawable(new Drawable[]{
+ resolveDrawable(requireContext(), R.attr.dashed_border),
+ resolveDrawable(requireContext(), R.attr.selectableItemBackground)
+ }));
+ }
+
+ // Show or hide component
+ binding.pitchPercentControl.setVisibility(semitones ? View.GONE : View.VISIBLE);
+ binding.pitchSemitoneControl.setVisibility(semitones ? View.VISIBLE : View.GONE);
+
+ if (semitones) {
+ // Recalculate pitch percent when changing to semitone
+ // (as it could be an invalid semitone value)
+ final double newPitchPercent = calcValidPitch(pitchPercent);
+
+ // If the values differ set the new pitch
+ if (this.pitchPercent != newPitchPercent) {
+ if (DEBUG) {
+ Log.d(TAG, "Bringing pitchPercent to correct corresponding semitone: "
+ + "currentPitchPercent = " + pitchPercent + ", "
+ + "newPitchPercent = " + newPitchPercent
+ );
}
- });
+ this.onPitchPercentSliderUpdated(newPitchPercent);
+ updateCallback();
+ }
+ } else if (!binding.unhookCheckbox.isChecked()) {
+ // When changing to percent it's possible that tempo is != pitch
+ ensureHookIsValidAndUpdateCallBack();
}
}
- private void setupSkipSilenceControl(@NonNull final View rootView) {
- skipSilenceCheckbox = rootView.findViewById(R.id.skipSilenceCheckbox);
- if (skipSilenceCheckbox != null) {
- skipSilenceCheckbox.setChecked(initialSkipSilence);
- skipSilenceCheckbox.setOnCheckedChangeListener((compoundButton, isChecked) ->
- setCurrentPlaybackParameters());
- }
+ private boolean isCurrentPitchControlModeSemitone() {
+ return PreferenceManager.getDefaultSharedPreferences(requireContext())
+ .getBoolean(
+ getString(R.string.playback_adjust_by_semitones_key),
+ PITCH_CTRL_MODE_PERCENT);
}
- private void setupStepSizeSelector(@NonNull final View rootView) {
- final TextView stepSizeOnePercentText = rootView.findViewById(R.id.stepSizeOnePercent);
- final TextView stepSizeFivePercentText = rootView.findViewById(R.id.stepSizeFivePercent);
- final TextView stepSizeTenPercentText = rootView.findViewById(R.id.stepSizeTenPercent);
- final TextView stepSizeTwentyFivePercentText = rootView
- .findViewById(R.id.stepSizeTwentyFivePercent);
- final TextView stepSizeOneHundredPercentText = rootView
- .findViewById(R.id.stepSizeOneHundredPercent);
+ // -- Steps (Set) --
- if (stepSizeOnePercentText != null) {
- stepSizeOnePercentText.setText(getPercentString(STEP_ONE_PERCENT_VALUE));
- stepSizeOnePercentText
- .setOnClickListener(view -> setStepSize(STEP_ONE_PERCENT_VALUE));
- }
+ private void setupStepTextView(
+ final double stepSizeValue,
+ final TextView textView
+ ) {
+ setText(textView, PlaybackParameterDialog::getPercentString, stepSizeValue);
+ textView.setOnClickListener(view -> {
+ PreferenceManager.getDefaultSharedPreferences(requireContext())
+ .edit()
+ .putFloat(getString(R.string.adjustment_step_key), (float) stepSizeValue)
+ .apply();
- if (stepSizeFivePercentText != null) {
- stepSizeFivePercentText.setText(getPercentString(STEP_FIVE_PERCENT_VALUE));
- stepSizeFivePercentText
- .setOnClickListener(view -> setStepSize(STEP_FIVE_PERCENT_VALUE));
- }
-
- if (stepSizeTenPercentText != null) {
- stepSizeTenPercentText.setText(getPercentString(STEP_TEN_PERCENT_VALUE));
- stepSizeTenPercentText
- .setOnClickListener(view -> setStepSize(STEP_TEN_PERCENT_VALUE));
- }
-
- if (stepSizeTwentyFivePercentText != null) {
- stepSizeTwentyFivePercentText
- .setText(getPercentString(STEP_TWENTY_FIVE_PERCENT_VALUE));
- stepSizeTwentyFivePercentText
- .setOnClickListener(view -> setStepSize(STEP_TWENTY_FIVE_PERCENT_VALUE));
- }
-
- if (stepSizeOneHundredPercentText != null) {
- stepSizeOneHundredPercentText
- .setText(getPercentString(STEP_ONE_HUNDRED_PERCENT_VALUE));
- stepSizeOneHundredPercentText
- .setOnClickListener(view -> setStepSize(STEP_ONE_HUNDRED_PERCENT_VALUE));
- }
+ setStepSizeToUI(stepSizeValue);
+ });
}
- private void setStepSize(final double stepSize) {
- this.stepSize = stepSize;
+ private Map getStepSizeComponentMappings() {
+ final Map mappings = new HashMap<>();
+ mappings.put(STEP_1_PERCENT_VALUE, binding.stepSizeOnePercent);
+ mappings.put(STEP_5_PERCENT_VALUE, binding.stepSizeFivePercent);
+ mappings.put(STEP_10_PERCENT_VALUE, binding.stepSizeTenPercent);
+ mappings.put(STEP_25_PERCENT_VALUE, binding.stepSizeTwentyFivePercent);
+ mappings.put(STEP_100_PERCENT_VALUE, binding.stepSizeOneHundredPercent);
+ return mappings;
+ }
- if (tempoStepUpText != null) {
- tempoStepUpText.setText(getStepUpPercentString(stepSize));
- tempoStepUpText.setOnClickListener(view -> {
- onTempoSliderUpdated(getCurrentTempo() + stepSize);
- setCurrentPlaybackParameters();
- });
+ private void setStepSizeToUI(final double newStepSize) {
+ // Bring all textviews into a normal state
+ final Map stepSiteComponentMapping = getStepSizeComponentMappings();
+ stepSiteComponentMapping.forEach((v, textView) -> textView.setBackground(
+ resolveDrawable(requireContext(), R.attr.selectableItemBackground)));
+
+ // Mark the selected textview
+ final TextView textView = stepSiteComponentMapping.get(newStepSize);
+ if (textView != null) {
+ textView.setBackground(new LayerDrawable(new Drawable[]{
+ resolveDrawable(requireContext(), R.attr.dashed_border),
+ resolveDrawable(requireContext(), R.attr.selectableItemBackground)
+ }));
}
- if (tempoStepDownText != null) {
- tempoStepDownText.setText(getStepDownPercentString(stepSize));
- tempoStepDownText.setOnClickListener(view -> {
- onTempoSliderUpdated(getCurrentTempo() - stepSize);
- setCurrentPlaybackParameters();
- });
- }
+ // Bind to the corresponding control components
+ binding.tempoStepUp.setText(getStepUpPercentString(newStepSize));
+ binding.tempoStepDown.setText(getStepDownPercentString(newStepSize));
- if (pitchStepUpText != null) {
- pitchStepUpText.setText(getStepUpPercentString(stepSize));
- pitchStepUpText.setOnClickListener(view -> {
- onPitchSliderUpdated(getCurrentPitch() + stepSize);
- setCurrentPlaybackParameters();
- });
- }
+ binding.pitchPercentStepUp.setText(getStepUpPercentString(newStepSize));
+ binding.pitchPercentStepDown.setText(getStepDownPercentString(newStepSize));
+ }
- if (pitchStepDownText != null) {
- pitchStepDownText.setText(getStepDownPercentString(stepSize));
- pitchStepDownText.setOnClickListener(view -> {
- onPitchSliderUpdated(getCurrentPitch() - stepSize);
- setCurrentPlaybackParameters();
- });
+ private double getCurrentStepSize() {
+ return PreferenceManager.getDefaultSharedPreferences(requireContext())
+ .getFloat(getString(R.string.adjustment_step_key), (float) DEFAULT_STEP);
+ }
+
+ // -- Additional options --
+
+ private void setAndUpdateSkipSilence(final boolean newSkipSilence) {
+ this.skipSilence = newSkipSilence;
+ binding.skipSilenceCheckbox.setChecked(newSkipSilence);
+ }
+
+ @SuppressWarnings("SameParameterValue") // this method was written to be reusable
+ private void bindCheckboxWithBoolPref(
+ @NonNull final CheckBox checkBox,
+ @StringRes final int resId,
+ final boolean defaultValue,
+ @NonNull final Consumer onInitialValueOrValueChange
+ ) {
+ final boolean prefValue = PreferenceManager
+ .getDefaultSharedPreferences(requireContext())
+ .getBoolean(getString(resId), defaultValue);
+
+ checkBox.setChecked(prefValue);
+
+ onInitialValueOrValueChange.accept(prefValue);
+
+ checkBox.setOnCheckedChangeListener((compoundButton, isChecked) -> {
+ // save whether pitch and tempo are unhooked or not
+ PreferenceManager.getDefaultSharedPreferences(requireContext())
+ .edit()
+ .putBoolean(getString(resId), isChecked)
+ .apply();
+
+ onInitialValueOrValueChange.accept(isChecked);
+ });
+ }
+
+ /**
+ * Ensures that the slider hook is valid and if not sets and updates the sliders accordingly.
+ *
+ * You have to ensure by yourself that the hooking is active.
+ */
+ private void ensureHookIsValidAndUpdateCallBack() {
+ if (tempo != pitchPercent) {
+ setSliders(Math.min(tempo, pitchPercent));
+ updateCallback();
}
}
@@ -350,142 +493,106 @@ public class PlaybackParameterDialog extends DialogFragment {
// Sliders
//////////////////////////////////////////////////////////////////////////*/
- private SeekBar.OnSeekBarChangeListener getOnTempoChangedListener() {
- return new SeekBar.OnSeekBarChangeListener() {
+ private SeekBar.OnSeekBarChangeListener getTempoOrPitchSeekbarChangeListener(
+ final SliderStrategy sliderStrategy,
+ final DoubleConsumer newValueConsumer
+ ) {
+ return new SimpleOnSeekBarChangeListener() {
@Override
- public void onProgressChanged(final SeekBar seekBar, final int progress,
+ public void onProgressChanged(@NonNull final SeekBar seekBar,
+ final int progress,
final boolean fromUser) {
- final double currentTempo = strategy.valueOf(progress);
- if (fromUser) {
- onTempoSliderUpdated(currentTempo);
- setCurrentPlaybackParameters();
+ if (fromUser) { // ensure that the user triggered the change
+ newValueConsumer.accept(sliderStrategy.valueOf(progress));
+ updateCallback();
}
}
-
- @Override
- public void onStartTrackingTouch(final SeekBar seekBar) {
- // Do Nothing.
- }
-
- @Override
- public void onStopTrackingTouch(final SeekBar seekBar) {
- // Do Nothing.
- }
- };
- }
-
- private SeekBar.OnSeekBarChangeListener getOnPitchChangedListener() {
- return new SeekBar.OnSeekBarChangeListener() {
- @Override
- public void onProgressChanged(final SeekBar seekBar, final int progress,
- final boolean fromUser) {
- final double currentPitch = strategy.valueOf(progress);
- if (fromUser) { // this change is first in chain
- onPitchSliderUpdated(currentPitch);
- setCurrentPlaybackParameters();
- }
- }
-
- @Override
- public void onStartTrackingTouch(final SeekBar seekBar) {
- // Do Nothing.
- }
-
- @Override
- public void onStopTrackingTouch(final SeekBar seekBar) {
- // Do Nothing.
- }
};
}
private void onTempoSliderUpdated(final double newTempo) {
- if (unhookingCheckbox == null) {
- return;
- }
- if (!unhookingCheckbox.isChecked()) {
+ if (!binding.unhookCheckbox.isChecked()) {
setSliders(newTempo);
} else {
- setTempoSlider(newTempo);
+ setAndUpdateTempo(newTempo);
}
}
- private void onPitchSliderUpdated(final double newPitch) {
- if (unhookingCheckbox == null) {
- return;
- }
- if (!unhookingCheckbox.isChecked()) {
+ private void onPitchPercentSliderUpdated(final double newPitch) {
+ if (!binding.unhookCheckbox.isChecked()) {
setSliders(newPitch);
} else {
- setPitchSlider(newPitch);
+ setAndUpdatePitch(newPitch);
}
}
private void setSliders(final double newValue) {
- setTempoSlider(newValue);
- setPitchSlider(newValue);
+ setAndUpdateTempo(newValue);
+ setAndUpdatePitch(newValue);
}
- private void setTempoSlider(final double newTempo) {
- if (tempoSlider == null) {
- return;
- }
- tempoSlider.setProgress(strategy.progressOf(newTempo));
+ private void setAndUpdateTempo(final double newTempo) {
+ this.tempo = calcValidTempo(newTempo);
+
+ binding.tempoSeekbar.setProgress(QUADRATIC_STRATEGY.progressOf(tempo));
+ setText(binding.tempoCurrentText, PlayerHelper::formatSpeed, tempo);
}
- private void setPitchSlider(final double newPitch) {
- if (pitchSlider == null) {
- return;
+ private void setAndUpdatePitch(final double newPitch) {
+ this.pitchPercent = calcValidPitch(newPitch);
+
+ binding.pitchPercentSeekbar.setProgress(QUADRATIC_STRATEGY.progressOf(pitchPercent));
+ binding.pitchSemitoneSeekbar.setProgress(SEMITONE_STRATEGY.progressOf(pitchPercent));
+ setText(binding.pitchPercentCurrentText,
+ PlayerHelper::formatPitch,
+ pitchPercent);
+ setText(binding.pitchSemitoneCurrentText,
+ PlayerSemitoneHelper::formatPitchSemitones,
+ pitchPercent);
+ }
+
+ private double calcValidTempo(final double newTempo) {
+ return Math.max(MIN_PITCH_OR_SPEED, Math.min(MAX_PITCH_OR_SPEED, newTempo));
+ }
+
+ private double calcValidPitch(final double newPitch) {
+ final double calcPitch =
+ Math.max(MIN_PITCH_OR_SPEED, Math.min(MAX_PITCH_OR_SPEED, newPitch));
+
+ if (!isCurrentPitchControlModeSemitone()) {
+ return calcPitch;
}
- pitchSlider.setProgress(strategy.progressOf(newPitch));
+
+ return PlayerSemitoneHelper.semitonesToPercent(
+ PlayerSemitoneHelper.percentToSemitones(calcPitch));
}
/*//////////////////////////////////////////////////////////////////////////
// Helper
//////////////////////////////////////////////////////////////////////////*/
- private void setCurrentPlaybackParameters() {
- setPlaybackParameters(getCurrentTempo(), getCurrentPitch(), getCurrentSkipSilence());
- }
-
- private void setPlaybackParameters(final double newTempo, final double newPitch,
- final boolean skipSilence) {
- if (callback != null && tempoCurrentText != null && pitchCurrentText != null) {
- if (DEBUG) {
- Log.d(TAG, "Setting playback parameters to "
- + "tempo=[" + newTempo + "], "
- + "pitch=[" + newPitch + "]");
- }
-
- tempoCurrentText.setText(PlayerHelper.formatSpeed(newTempo));
- pitchCurrentText.setText(PlayerHelper.formatPitch(newPitch));
- callback.onPlaybackParameterChanged((float) newTempo, (float) newPitch, skipSilence);
+ private void updateCallback() {
+ if (callback == null) {
+ return;
}
- }
-
- private double getCurrentTempo() {
- return tempoSlider == null ? tempo : strategy.valueOf(tempoSlider.getProgress());
- }
-
- private double getCurrentPitch() {
- return pitchSlider == null ? pitch : strategy.valueOf(pitchSlider.getProgress());
- }
-
- private double getCurrentStepSize() {
- return stepSize;
- }
-
- private boolean getCurrentSkipSilence() {
- return skipSilenceCheckbox != null && skipSilenceCheckbox.isChecked();
+ if (DEBUG) {
+ Log.d(TAG, "Updating callback: "
+ + "tempo = " + tempo + ", "
+ + "pitchPercent = " + pitchPercent + ", "
+ + "skipSilence = " + skipSilence
+ );
+ }
+ callback.onPlaybackParameterChanged((float) tempo, (float) pitchPercent, skipSilence);
}
@NonNull
private static String getStepUpPercentString(final double percent) {
- return STEP_UP_SIGN + getPercentString(percent);
+ return '+' + getPercentString(percent);
}
@NonNull
private static String getStepDownPercentString(final double percent) {
- return STEP_DOWN_SIGN + getPercentString(percent);
+ return '-' + getPercentString(percent);
}
@NonNull
diff --git a/app/src/main/java/org/schabi/newpipe/player/helper/PlayerDataSource.java b/app/src/main/java/org/schabi/newpipe/player/helper/PlayerDataSource.java
index a2f0d7149..88f25e194 100644
--- a/app/src/main/java/org/schabi/newpipe/player/helper/PlayerDataSource.java
+++ b/app/src/main/java/org/schabi/newpipe/player/helper/PlayerDataSource.java
@@ -1,9 +1,13 @@
package org.schabi.newpipe.player.helper;
+import static org.schabi.newpipe.MainActivity.DEBUG;
+
import android.content.Context;
+import android.util.Log;
-import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import com.google.android.exoplayer2.database.StandaloneDatabaseProvider;
import com.google.android.exoplayer2.source.ProgressiveMediaSource;
import com.google.android.exoplayer2.source.SingleSampleMediaSource;
import com.google.android.exoplayer2.source.dash.DashMediaSource;
@@ -13,11 +17,23 @@ import com.google.android.exoplayer2.source.hls.playlist.DefaultHlsPlaylistTrack
import com.google.android.exoplayer2.source.smoothstreaming.DefaultSsChunkSource;
import com.google.android.exoplayer2.source.smoothstreaming.SsMediaSource;
import com.google.android.exoplayer2.upstream.DataSource;
-import com.google.android.exoplayer2.upstream.DefaultDataSourceFactory;
-import com.google.android.exoplayer2.upstream.DefaultLoadErrorHandlingPolicy;
+import com.google.android.exoplayer2.upstream.DefaultDataSource;
+import com.google.android.exoplayer2.upstream.DefaultHttpDataSource;
import com.google.android.exoplayer2.upstream.TransferListener;
+import com.google.android.exoplayer2.upstream.cache.LeastRecentlyUsedCacheEvictor;
+import com.google.android.exoplayer2.upstream.cache.SimpleCache;
+
+import org.schabi.newpipe.DownloaderImpl;
+import org.schabi.newpipe.extractor.services.youtube.dashmanifestcreators.YoutubeOtfDashManifestCreator;
+import org.schabi.newpipe.extractor.services.youtube.dashmanifestcreators.YoutubePostLiveStreamDvrDashManifestCreator;
+import org.schabi.newpipe.extractor.services.youtube.dashmanifestcreators.YoutubeProgressiveDashManifestCreator;
+import org.schabi.newpipe.player.datasource.NonUriHlsDataSourceFactory;
+import org.schabi.newpipe.player.datasource.YoutubeHttpDataSource;
+
+import java.io.File;
public class PlayerDataSource {
+ public static final String TAG = PlayerDataSource.class.getSimpleName();
public static final int LIVE_STREAM_EDGE_GAP_MILLIS = 10000;
@@ -28,74 +44,174 @@ public class PlayerDataSource {
* early.
*/
private static final double PLAYLIST_STUCK_TARGET_DURATION_COEFFICIENT = 15;
- private static final int MANIFEST_MINIMUM_RETRY = 5;
- private static final int EXTRACTOR_MINIMUM_RETRY = Integer.MAX_VALUE;
- private final DataSource.Factory cacheDataSourceFactory;
+ /**
+ * The maximum number of generated manifests per cache, in
+ * {@link YoutubeProgressiveDashManifestCreator}, {@link YoutubeOtfDashManifestCreator} and
+ * {@link YoutubePostLiveStreamDvrDashManifestCreator}.
+ */
+ private static final int MAX_MANIFEST_CACHE_SIZE = 500;
+
+ /**
+ * The folder name in which the ExoPlayer cache will be written.
+ */
+ private static final String CACHE_FOLDER_NAME = "exoplayer";
+
+ /**
+ * The {@link SimpleCache} instance which will be used to build
+ * {@link com.google.android.exoplayer2.upstream.cache.CacheDataSource}s instances (with
+ * {@link CacheFactory}).
+ */
+ private static SimpleCache cache;
+
+
+ private final int progressiveLoadIntervalBytes;
+
+ // Generic Data Source Factories (without or with cache)
private final DataSource.Factory cachelessDataSourceFactory;
+ private final CacheFactory cacheDataSourceFactory;
- public PlayerDataSource(@NonNull final Context context, @NonNull final String userAgent,
- @NonNull final TransferListener transferListener) {
- cacheDataSourceFactory = new CacheFactory(context, userAgent, transferListener);
- cachelessDataSourceFactory
- = new DefaultDataSourceFactory(context, userAgent, transferListener);
+ // YouTube-specific Data Source Factories (with cache)
+ // They use YoutubeHttpDataSource.Factory, with different parameters each
+ private final CacheFactory ytHlsCacheDataSourceFactory;
+ private final CacheFactory ytDashCacheDataSourceFactory;
+ private final CacheFactory ytProgressiveDashCacheDataSourceFactory;
+
+
+ public PlayerDataSource(final Context context,
+ final TransferListener transferListener) {
+
+ progressiveLoadIntervalBytes = PlayerHelper.getProgressiveLoadIntervalBytes(context);
+
+ // make sure the static cache was created: needed by CacheFactories below
+ instantiateCacheIfNeeded(context);
+
+ // generic data source factories use DefaultHttpDataSource.Factory
+ cachelessDataSourceFactory = new DefaultDataSource.Factory(context,
+ new DefaultHttpDataSource.Factory().setUserAgent(DownloaderImpl.USER_AGENT))
+ .setTransferListener(transferListener);
+ cacheDataSourceFactory = new CacheFactory(context, transferListener, cache,
+ new DefaultHttpDataSource.Factory().setUserAgent(DownloaderImpl.USER_AGENT));
+
+ // YouTube-specific data source factories use getYoutubeHttpDataSourceFactory()
+ ytHlsCacheDataSourceFactory = new CacheFactory(context, transferListener, cache,
+ getYoutubeHttpDataSourceFactory(false, false));
+ ytDashCacheDataSourceFactory = new CacheFactory(context, transferListener, cache,
+ getYoutubeHttpDataSourceFactory(true, true));
+ ytProgressiveDashCacheDataSourceFactory = new CacheFactory(context, transferListener, cache,
+ getYoutubeHttpDataSourceFactory(false, true));
+
+ // set the maximum size to manifest creators
+ YoutubeProgressiveDashManifestCreator.getCache().setMaximumSize(MAX_MANIFEST_CACHE_SIZE);
+ YoutubeOtfDashManifestCreator.getCache().setMaximumSize(MAX_MANIFEST_CACHE_SIZE);
+ YoutubePostLiveStreamDvrDashManifestCreator.getCache().setMaximumSize(
+ MAX_MANIFEST_CACHE_SIZE);
}
+
+ //region Live media source factories
public SsMediaSource.Factory getLiveSsMediaSourceFactory() {
- return new SsMediaSource.Factory(
- new DefaultSsChunkSource.Factory(cachelessDataSourceFactory),
- cachelessDataSourceFactory
- )
- .setLoadErrorHandlingPolicy(
- new DefaultLoadErrorHandlingPolicy(MANIFEST_MINIMUM_RETRY))
- .setLivePresentationDelayMs(LIVE_STREAM_EDGE_GAP_MILLIS);
+ return getSSMediaSourceFactory().setLivePresentationDelayMs(LIVE_STREAM_EDGE_GAP_MILLIS);
}
public HlsMediaSource.Factory getLiveHlsMediaSourceFactory() {
return new HlsMediaSource.Factory(cachelessDataSourceFactory)
.setAllowChunklessPreparation(true)
- .setLoadErrorHandlingPolicy(new DefaultLoadErrorHandlingPolicy(
- MANIFEST_MINIMUM_RETRY))
.setPlaylistTrackerFactory((dataSourceFactory, loadErrorHandlingPolicy,
playlistParserFactory) ->
new DefaultHlsPlaylistTracker(dataSourceFactory, loadErrorHandlingPolicy,
- playlistParserFactory, PLAYLIST_STUCK_TARGET_DURATION_COEFFICIENT)
- );
+ playlistParserFactory,
+ PLAYLIST_STUCK_TARGET_DURATION_COEFFICIENT));
}
public DashMediaSource.Factory getLiveDashMediaSourceFactory() {
return new DashMediaSource.Factory(
getDefaultDashChunkSourceFactory(cachelessDataSourceFactory),
- cachelessDataSourceFactory
- )
- .setLoadErrorHandlingPolicy(
- new DefaultLoadErrorHandlingPolicy(MANIFEST_MINIMUM_RETRY));
+ cachelessDataSourceFactory);
}
+ //endregion
- private DefaultDashChunkSource.Factory getDefaultDashChunkSourceFactory(
- final DataSource.Factory dataSourceFactory
- ) {
- return new DefaultDashChunkSource.Factory(dataSourceFactory);
- }
- public HlsMediaSource.Factory getHlsMediaSourceFactory() {
+ //region Generic media source factories
+ public HlsMediaSource.Factory getHlsMediaSourceFactory(
+ @Nullable final NonUriHlsDataSourceFactory.Builder hlsDataSourceFactoryBuilder) {
+ if (hlsDataSourceFactoryBuilder != null) {
+ hlsDataSourceFactoryBuilder.setDataSourceFactory(cacheDataSourceFactory);
+ return new HlsMediaSource.Factory(hlsDataSourceFactoryBuilder.build());
+ }
+
return new HlsMediaSource.Factory(cacheDataSourceFactory);
}
public DashMediaSource.Factory getDashMediaSourceFactory() {
return new DashMediaSource.Factory(
getDefaultDashChunkSourceFactory(cacheDataSourceFactory),
- cacheDataSourceFactory
- );
+ cacheDataSourceFactory);
}
- public ProgressiveMediaSource.Factory getExtractorMediaSourceFactory() {
+ public ProgressiveMediaSource.Factory getProgressiveMediaSourceFactory() {
return new ProgressiveMediaSource.Factory(cacheDataSourceFactory)
- .setLoadErrorHandlingPolicy(
- new DefaultLoadErrorHandlingPolicy(EXTRACTOR_MINIMUM_RETRY));
+ .setContinueLoadingCheckIntervalBytes(progressiveLoadIntervalBytes);
}
- public SingleSampleMediaSource.Factory getSampleMediaSourceFactory() {
+ public SsMediaSource.Factory getSSMediaSourceFactory() {
+ return new SsMediaSource.Factory(
+ new DefaultSsChunkSource.Factory(cachelessDataSourceFactory),
+ cachelessDataSourceFactory);
+ }
+
+ public SingleSampleMediaSource.Factory getSingleSampleMediaSourceFactory() {
return new SingleSampleMediaSource.Factory(cacheDataSourceFactory);
}
+ //endregion
+
+
+ //region YouTube media source factories
+ public HlsMediaSource.Factory getYoutubeHlsMediaSourceFactory() {
+ return new HlsMediaSource.Factory(ytHlsCacheDataSourceFactory);
+ }
+
+ public DashMediaSource.Factory getYoutubeDashMediaSourceFactory() {
+ return new DashMediaSource.Factory(
+ getDefaultDashChunkSourceFactory(ytDashCacheDataSourceFactory),
+ ytDashCacheDataSourceFactory);
+ }
+
+ public ProgressiveMediaSource.Factory getYoutubeProgressiveMediaSourceFactory() {
+ return new ProgressiveMediaSource.Factory(ytProgressiveDashCacheDataSourceFactory)
+ .setContinueLoadingCheckIntervalBytes(progressiveLoadIntervalBytes);
+ }
+ //endregion
+
+
+ //region Static methods
+ private static DefaultDashChunkSource.Factory getDefaultDashChunkSourceFactory(
+ final DataSource.Factory dataSourceFactory) {
+ return new DefaultDashChunkSource.Factory(dataSourceFactory);
+ }
+
+ private static YoutubeHttpDataSource.Factory getYoutubeHttpDataSourceFactory(
+ final boolean rangeParameterEnabled,
+ final boolean rnParameterEnabled) {
+ return new YoutubeHttpDataSource.Factory()
+ .setRangeParameterEnabled(rangeParameterEnabled)
+ .setRnParameterEnabled(rnParameterEnabled);
+ }
+
+ private static void instantiateCacheIfNeeded(final Context context) {
+ if (cache == null) {
+ final File cacheDir = new File(context.getExternalCacheDir(), CACHE_FOLDER_NAME);
+ if (DEBUG) {
+ Log.d(TAG, "instantiateCacheIfNeeded: cacheDir = " + cacheDir.getAbsolutePath());
+ }
+ if (!cacheDir.exists() && !cacheDir.mkdir()) {
+ Log.w(TAG, "instantiateCacheIfNeeded: could not create cache dir");
+ }
+
+ final LeastRecentlyUsedCacheEvictor evictor
+ = new LeastRecentlyUsedCacheEvictor(PlayerHelper.getPreferredCacheSize());
+ cache = new SimpleCache(cacheDir, evictor, new StandaloneDatabaseProvider(context));
+ }
+ }
+ //endregion
}
diff --git a/app/src/main/java/org/schabi/newpipe/player/helper/PlayerHelper.java b/app/src/main/java/org/schabi/newpipe/player/helper/PlayerHelper.java
index c51b6d5dd..2131861bf 100644
--- a/app/src/main/java/org/schabi/newpipe/player/helper/PlayerHelper.java
+++ b/app/src/main/java/org/schabi/newpipe/player/helper/PlayerHelper.java
@@ -34,6 +34,7 @@ import androidx.preference.PreferenceManager;
import com.google.android.exoplayer2.PlaybackParameters;
import com.google.android.exoplayer2.Player.RepeatMode;
import com.google.android.exoplayer2.SeekParameters;
+import com.google.android.exoplayer2.source.ProgressiveMediaSource;
import com.google.android.exoplayer2.trackselection.AdaptiveTrackSelection;
import com.google.android.exoplayer2.trackselection.ExoTrackSelection;
import com.google.android.exoplayer2.ui.AspectRatioFrameLayout;
@@ -44,11 +45,9 @@ import com.google.android.exoplayer2.util.MimeTypes;
import org.schabi.newpipe.R;
import org.schabi.newpipe.extractor.InfoItem;
import org.schabi.newpipe.extractor.MediaFormat;
-import org.schabi.newpipe.extractor.stream.AudioStream;
import org.schabi.newpipe.extractor.stream.StreamInfo;
import org.schabi.newpipe.extractor.stream.StreamInfoItem;
import org.schabi.newpipe.extractor.stream.SubtitlesStream;
-import org.schabi.newpipe.extractor.stream.VideoStream;
import org.schabi.newpipe.extractor.utils.Utils;
import org.schabi.newpipe.player.MainPlayer;
import org.schabi.newpipe.player.Player;
@@ -77,6 +76,20 @@ public final class PlayerHelper {
private static final NumberFormat SPEED_FORMATTER = new DecimalFormat("0.##x");
private static final NumberFormat PITCH_FORMATTER = new DecimalFormat("##%");
+ /**
+ * Maximum opacity allowed for Android 12 and higher to allow touches on other apps when using
+ * NewPipe's popup player.
+ *
+ *
+ * This value is hardcoded instead of being get dynamically with the method linked of the
+ * constant documentation below, because it is not static and popup player layout parameters
+ * are generated with static methods.
+ *
+ *
+ * @see WindowManager.LayoutParams#FLAG_NOT_TOUCHABLE
+ */
+ private static final float MAXIMUM_OPACITY_ALLOWED_FOR_S_AND_HIGHER = 0.8f;
+
@Retention(SOURCE)
@IntDef({AUTOPLAY_TYPE_ALWAYS, AUTOPLAY_TYPE_WIFI,
AUTOPLAY_TYPE_NEVER})
@@ -95,12 +108,14 @@ public final class PlayerHelper {
int MINIMIZE_ON_EXIT_MODE_POPUP = 2;
}
- private PlayerHelper() { }
+ private PlayerHelper() {
+ }
////////////////////////////////////////////////////////////////////////////
// Exposed helpers
////////////////////////////////////////////////////////////////////////////
+ @NonNull
public static String getTimeString(final int milliSeconds) {
final int seconds = (milliSeconds % 60000) / 1000;
final int minutes = (milliSeconds % 3600000) / 60000;
@@ -116,15 +131,18 @@ public final class PlayerHelper {
).toString();
}
+ @NonNull
public static String formatSpeed(final double speed) {
return SPEED_FORMATTER.format(speed);
}
+ @NonNull
public static String formatPitch(final double pitch) {
return PITCH_FORMATTER.format(pitch);
}
- public static String subtitleMimeTypesOf(final MediaFormat format) {
+ @NonNull
+ public static String subtitleMimeTypesOf(@NonNull final MediaFormat format) {
switch (format) {
case VTT:
return MimeTypes.TEXT_VTT;
@@ -143,6 +161,21 @@ public final class PlayerHelper {
? " (" + context.getString(R.string.caption_auto_generated) + ")" : "");
}
+ @NonNull
+ public static String captionLanguageStemOf(@NonNull final String language) {
+ if (!language.contains("(") || !language.contains(")")) {
+ return language;
+ }
+
+ if (language.startsWith("(")) {
+ // language text is right-to-left
+ final String[] parts = language.split("\\)");
+ return parts[parts.length - 1].trim();
+ }
+
+ return language.split("\\(")[0].trim();
+ }
+
@NonNull
public static String resizeTypeOf(@NonNull final Context context,
@ResizeMode final int resizeMode) {
@@ -160,18 +193,6 @@ public final class PlayerHelper {
}
}
- @NonNull
- public static String cacheKeyOf(@NonNull final StreamInfo info,
- @NonNull final VideoStream video) {
- return info.getUrl() + video.getResolution() + video.getFormat().getName();
- }
-
- @NonNull
- public static String cacheKeyOf(@NonNull final StreamInfo info,
- @NonNull final AudioStream audio) {
- return info.getUrl() + audio.getAverageBitrate() + audio.getFormat().getName();
- }
-
/**
* Given a {@link StreamInfo} and the existing queue items,
* provide the {@link SinglePlayQueue} consisting of the next video for auto queueing.
@@ -203,7 +224,7 @@ public final class PlayerHelper {
return null;
}
- if (relatedItems.get(0) != null && relatedItems.get(0) instanceof StreamInfoItem
+ if (relatedItems.get(0) instanceof StreamInfoItem
&& !urls.contains(relatedItems.get(0).getUrl())) {
return getAutoQueuedSinglePlayQueue((StreamInfoItem) relatedItems.get(0));
}
@@ -305,6 +326,7 @@ public final class PlayerHelper {
return 2 * 1024 * 1024L; // ExoPlayer CacheDataSink.MIN_RECOMMENDED_FRAGMENT_SIZE
}
+ @NonNull
public static ExoTrackSelection.Factory getQualitySelector() {
return new AdaptiveTrackSelection.Factory(
1000,
@@ -359,7 +381,7 @@ public final class PlayerHelper {
/**
* @param context the Android context
* @return the screen brightness to use. A value less than 0 (the default) means to use the
- * preferred screen brightness
+ * preferred screen brightness
*/
public static float getScreenBrightness(@NonNull final Context context) {
final SharedPreferences sp = getPreferences(context);
@@ -391,6 +413,19 @@ public final class PlayerHelper {
context.getContentResolver(), Settings.System.ACCELEROMETER_ROTATION, 0) == 0;
}
+ public static int getProgressiveLoadIntervalBytes(@NonNull final Context context) {
+ final String preferredIntervalBytes = getPreferences(context).getString(
+ context.getString(R.string.progressive_load_interval_key),
+ context.getString(R.string.progressive_load_interval_default_value));
+
+ if (context.getString(R.string.progressive_load_interval_exoplayer_default_value)
+ .equals(preferredIntervalBytes)) {
+ return ProgressiveMediaSource.DEFAULT_LOADING_CHECK_INTERVAL_BYTES;
+ }
+ // Keeping the same KiB unit used by ProgressiveMediaSource
+ return Integer.parseInt(preferredIntervalBytes) * 1024;
+ }
+
////////////////////////////////////////////////////////////////////////////
// Private helpers
////////////////////////////////////////////////////////////////////////////
@@ -437,7 +472,8 @@ public final class PlayerHelper {
return REPEAT_MODE_ONE;
case REPEAT_MODE_ONE:
return REPEAT_MODE_ALL;
- case REPEAT_MODE_ALL: default:
+ case REPEAT_MODE_ALL:
+ default:
return REPEAT_MODE_OFF;
}
}
@@ -505,7 +541,7 @@ public final class PlayerHelper {
player.getContext().getResources().getDimension(R.dimen.popup_default_width);
final float popupWidth = popupRememberSizeAndPos
? player.getPrefs().getFloat(player.getContext().getString(
- R.string.popup_saved_width_key), defaultSize)
+ R.string.popup_saved_width_key), defaultSize)
: defaultSize;
final float popupHeight = getMinimumVideoHeight(popupWidth);
@@ -521,10 +557,10 @@ public final class PlayerHelper {
final int centerY = (int) (player.getScreenHeight() / 2f - popupHeight / 2f);
popupLayoutParams.x = popupRememberSizeAndPos
? player.getPrefs().getInt(player.getContext().getString(
- R.string.popup_saved_x_key), centerX) : centerX;
+ R.string.popup_saved_x_key), centerX) : centerX;
popupLayoutParams.y = popupRememberSizeAndPos
? player.getPrefs().getInt(player.getContext().getString(
- R.string.popup_saved_y_key), centerY) : centerY;
+ R.string.popup_saved_y_key), centerY) : centerY;
return popupLayoutParams;
}
@@ -558,6 +594,12 @@ public final class PlayerHelper {
flags,
PixelFormat.TRANSLUCENT);
+ if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+ // Setting maximum opacity allowed for touch events to other apps for Android 12 and
+ // higher to prevent non interaction when using other apps with the popup player
+ closeOverlayLayoutParams.alpha = MAXIMUM_OPACITY_ALLOWED_FOR_S_AND_HIGHER;
+ }
+
closeOverlayLayoutParams.gravity = Gravity.LEFT | Gravity.TOP;
closeOverlayLayoutParams.softInputMode =
WindowManager.LayoutParams.SOFT_INPUT_ADJUST_RESIZE;
diff --git a/app/src/main/java/org/schabi/newpipe/player/helper/PlayerHolder.java b/app/src/main/java/org/schabi/newpipe/player/helper/PlayerHolder.java
index 06a2e52ab..4c09ed3c1 100644
--- a/app/src/main/java/org/schabi/newpipe/player/helper/PlayerHolder.java
+++ b/app/src/main/java/org/schabi/newpipe/player/helper/PlayerHolder.java
@@ -10,7 +10,7 @@ import android.util.Log;
import androidx.annotation.Nullable;
import androidx.core.content.ContextCompat;
-import com.google.android.exoplayer2.ExoPlaybackException;
+import com.google.android.exoplayer2.PlaybackException;
import com.google.android.exoplayer2.PlaybackParameters;
import org.schabi.newpipe.App;
@@ -233,9 +233,10 @@ public final class PlayerHolder {
}
@Override
- public void onPlayerError(final ExoPlaybackException error) {
+ public void onPlayerError(final PlaybackException error,
+ final boolean isCatchableException) {
if (listener != null) {
- listener.onPlayerError(error);
+ listener.onPlayerError(error, isCatchableException);
}
}
diff --git a/app/src/main/java/org/schabi/newpipe/player/helper/PlayerSemitoneHelper.java b/app/src/main/java/org/schabi/newpipe/player/helper/PlayerSemitoneHelper.java
new file mode 100644
index 000000000..f3a71d7cd
--- /dev/null
+++ b/app/src/main/java/org/schabi/newpipe/player/helper/PlayerSemitoneHelper.java
@@ -0,0 +1,38 @@
+package org.schabi.newpipe.player.helper;
+
+/**
+ * Converts between percent and 12-tone equal temperament semitones.
+ *
+ * @see
+ *
+ * Wikipedia: Equal temperament#Twelve-tone equal temperament
+ *
+ */
+public final class PlayerSemitoneHelper {
+ public static final int SEMITONE_COUNT = 12;
+
+ private PlayerSemitoneHelper() {
+ // No impl
+ }
+
+ public static String formatPitchSemitones(final double percent) {
+ return formatPitchSemitones(percentToSemitones(percent));
+ }
+
+ public static String formatPitchSemitones(final int semitones) {
+ return semitones > 0 ? "+" + semitones : "" + semitones;
+ }
+
+ public static double semitonesToPercent(final int semitones) {
+ return Math.pow(2, ensureSemitonesInRange(semitones) / (double) SEMITONE_COUNT);
+ }
+
+ public static int percentToSemitones(final double percent) {
+ return ensureSemitonesInRange(
+ (int) Math.round(SEMITONE_COUNT * Math.log(percent) / Math.log(2)));
+ }
+
+ private static int ensureSemitonesInRange(final int semitones) {
+ return Math.max(-SEMITONE_COUNT, Math.min(SEMITONE_COUNT, semitones));
+ }
+}
diff --git a/app/src/main/java/org/schabi/newpipe/player/listeners/view/PlaybackSpeedClickListener.kt b/app/src/main/java/org/schabi/newpipe/player/listeners/view/PlaybackSpeedClickListener.kt
new file mode 100644
index 000000000..52eff5a1c
--- /dev/null
+++ b/app/src/main/java/org/schabi/newpipe/player/listeners/view/PlaybackSpeedClickListener.kt
@@ -0,0 +1,47 @@
+package org.schabi.newpipe.player.listeners.view
+
+import android.util.Log
+import android.view.View
+import androidx.appcompat.widget.PopupMenu
+import org.schabi.newpipe.MainActivity
+import org.schabi.newpipe.player.Player
+import org.schabi.newpipe.player.helper.PlaybackParameterDialog
+
+/**
+ * Click listener for the playbackSpeed textview of the player
+ */
+class PlaybackSpeedClickListener(
+ private val player: Player,
+ private val playbackSpeedPopupMenu: PopupMenu
+) : View.OnClickListener {
+
+ companion object {
+ private const val TAG: String = "PlaybSpeedClickListener"
+ }
+
+ override fun onClick(v: View) {
+ if (MainActivity.DEBUG) {
+ Log.d(TAG, "onPlaybackSpeedClicked() called")
+ }
+
+ if (player.videoPlayerSelected()) {
+ PlaybackParameterDialog.newInstance(
+ player.playbackSpeed.toDouble(),
+ player.playbackPitch.toDouble(),
+ player.playbackSkipSilence
+ ) { speed: Float, pitch: Float, skipSilence: Boolean ->
+ player.setPlaybackParameters(
+ speed,
+ pitch,
+ skipSilence
+ )
+ }
+ .show(player.parentActivity!!.supportFragmentManager, null)
+ } else {
+ playbackSpeedPopupMenu.show()
+ player.isSomePopupMenuVisible = true
+ }
+
+ player.manageControlsAfterOnClick(v)
+ }
+}
diff --git a/app/src/main/java/org/schabi/newpipe/player/listeners/view/QualityClickListener.kt b/app/src/main/java/org/schabi/newpipe/player/listeners/view/QualityClickListener.kt
new file mode 100644
index 000000000..43e8288e6
--- /dev/null
+++ b/app/src/main/java/org/schabi/newpipe/player/listeners/view/QualityClickListener.kt
@@ -0,0 +1,41 @@
+package org.schabi.newpipe.player.listeners.view
+
+import android.annotation.SuppressLint
+import android.util.Log
+import android.view.View
+import androidx.appcompat.widget.PopupMenu
+import org.schabi.newpipe.MainActivity
+import org.schabi.newpipe.extractor.MediaFormat
+import org.schabi.newpipe.player.Player
+
+/**
+ * Click listener for the qualityTextView of the player
+ */
+class QualityClickListener(
+ private val player: Player,
+ private val qualityPopupMenu: PopupMenu
+) : View.OnClickListener {
+
+ companion object {
+ private const val TAG: String = "QualityClickListener"
+ }
+
+ @SuppressLint("SetTextI18n") // we don't need I18N because of a " "
+ override fun onClick(v: View) {
+ if (MainActivity.DEBUG) {
+ Log.d(TAG, "onQualitySelectorClicked() called")
+ }
+
+ qualityPopupMenu.show()
+ player.isSomePopupMenuVisible = true
+
+ val videoStream = player.selectedVideoStream
+ if (videoStream != null) {
+ player.binding.qualityTextView.text =
+ MediaFormat.getNameById(videoStream.formatId) + " " + videoStream.getResolution()
+ }
+
+ player.saveWasPlaying()
+ player.manageControlsAfterOnClick(v)
+ }
+}
diff --git a/app/src/main/java/org/schabi/newpipe/player/mediaitem/ExceptionTag.java b/app/src/main/java/org/schabi/newpipe/player/mediaitem/ExceptionTag.java
new file mode 100644
index 000000000..ebedf8c71
--- /dev/null
+++ b/app/src/main/java/org/schabi/newpipe/player/mediaitem/ExceptionTag.java
@@ -0,0 +1,99 @@
+package org.schabi.newpipe.player.mediaitem;
+
+import org.schabi.newpipe.extractor.stream.StreamInfo;
+import org.schabi.newpipe.extractor.stream.StreamType;
+import org.schabi.newpipe.player.playqueue.PlayQueueItem;
+
+import java.util.List;
+import java.util.Optional;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+/**
+ * This {@link MediaItemTag} object is designed to contain metadata for a stream
+ * that has failed to load. It supplies metadata from an underlying
+ * {@link PlayQueueItem}, which is used by the internal players to resolve actual
+ * playback info.
+ *
+ * This {@link MediaItemTag} does not contain any {@link StreamInfo} that can be
+ * used to start playback and can be detected by checking {@link ExceptionTag#getErrors()}
+ * when in generic form.
+ **/
+public final class ExceptionTag implements MediaItemTag {
+ @NonNull
+ private final PlayQueueItem item;
+ @NonNull
+ private final List errors;
+ @Nullable
+ private final Object extras;
+
+ private ExceptionTag(@NonNull final PlayQueueItem item,
+ @NonNull final List errors,
+ @Nullable final Object extras) {
+ this.item = item;
+ this.errors = errors;
+ this.extras = extras;
+ }
+
+ public static ExceptionTag of(@NonNull final PlayQueueItem playQueueItem,
+ @NonNull final List errors) {
+ return new ExceptionTag(playQueueItem, errors, null);
+ }
+
+ @NonNull
+ @Override
+ public List