正在查看： Kreate v1.5.0 应用的 YoutubeParsingHelper.java JAVA 源代码文件
本页面展示 JAVA 反编译生成的源代码文件，支持语法高亮显示。 仅供安全研究与技术分析使用，严禁用于任何非法用途。请遵守相关法律法规。
页面标题
页面副标题
Kreate v1.5.0 - YoutubeParsingHelper.java 源代码
package org.schabi.newpipe.extractor.services.youtube;
import androidx.core.graphics.TypefaceCompat$;
import com.grack.nanojson.JsonArray;
import com.grack.nanojson.JsonBuilder;
import com.grack.nanojson.JsonObject;
import com.grack.nanojson.JsonParser;
import com.grack.nanojson.JsonParserException;
import com.grack.nanojson.JsonWriter;
import j$.time.LocalDate;
import j$.time.OffsetDateTime;
import j$.time.ZoneOffset;
import j$.time.format.DateTimeParseException;
import j$.util.Collection;
import j$.util.Optional;
import j$.util.function.Function;
import j$.util.function.Predicate;
import j$.util.stream.Collectors;
import j$.util.stream.Stream;
import java.io.IOException;
import java.net.MalformedURLException;
import java.net.URL;
import java.nio.charset.StandardCharsets;
import java.util.HashMap;
import java.util.Iterator;
import java.util.List;
import java.util.Locale;
import java.util.Map;
import java.util.Random;
import java.util.Set;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.regex.Pattern;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import kotlin.UByte$;
import me.knighthat.innertube.Constants;
import org.jsoup.helper.HttpConnection;
import org.jsoup.nodes.Entities;
import org.mozilla.javascript.ES6Iterator;
import org.schabi.newpipe.extractor.Image;
import org.schabi.newpipe.extractor.NewPipe;
import org.schabi.newpipe.extractor.downloader.Response;
import org.schabi.newpipe.extractor.exceptions.AccountTerminatedException;
import org.schabi.newpipe.extractor.exceptions.ContentNotAvailableException;
import org.schabi.newpipe.extractor.exceptions.ExtractionException;
import org.schabi.newpipe.extractor.exceptions.ParsingException;
import org.schabi.newpipe.extractor.exceptions.ReCaptchaException;
import org.schabi.newpipe.extractor.localization.ContentCountry;
import org.schabi.newpipe.extractor.localization.Localization;
import org.schabi.newpipe.extractor.playlist.PlaylistInfo;
import org.schabi.newpipe.extractor.services.bandcamp.extractors.BandcampCommentsExtractor$$ExternalSyntheticLambda0;
import org.schabi.newpipe.extractor.services.bandcamp.extractors.BandcampCommentsExtractor$$ExternalSyntheticLambda1;
import org.schabi.newpipe.extractor.utils.JsonUtils;
import org.schabi.newpipe.extractor.utils.Parser;
import org.schabi.newpipe.extractor.utils.RandomStringFromAlphabetGenerator;
import org.schabi.newpipe.extractor.utils.Utils;
public final class YoutubeParsingHelper {
public static final String CONTENT_CHECK_OK = "contentCheckOk";
private static final String CONTENT_PLAYBACK_NONCE_ALPHABET = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_";
public static final String CPN = "cpn";
public static final String DISABLE_PRETTY_PRINT_PARAMETER = "prettyPrint=false";
private static final String FEED_BASE_CHANNEL_ID = "https://www.youtube.com/feeds/videos.xml?channel_id=";
private static final String FEED_BASE_USER = "https://www.youtube.com/feeds/videos.xml?user=";
public static final String RACY_CHECK_OK = "racyCheckOk";
public static final String VIDEO_ID = "videoId";
public static final String YOUTUBEI_V1_GAPIS_URL = "https://youtubei.googleapis.com/youtubei/v1/";
public static final String YOUTUBEI_V1_URL = "https://www.youtube.com/youtubei/v1/";
private static final String YOUTUBE_MUSIC_URL = "https://music.youtube.com";
private static String clientVersion = null;
private static boolean clientVersionExtracted = false;
private static String youtubeMusicClientVersion;
private static Optional<Boolean> hardcodedClientVersionValid = Optional.empty();
private static final String[] INNERTUBE_CONTEXT_CLIENT_VERSION_REGEXES = {"INNERTUBE_CONTEXT_CLIENT_VERSION\":\"([0-9\\.]+?)\"", "innertube_context_client_version\":\"([0-9\\.]+?)\"", "client.version=([0-9\\.]+)"};
private static final String[] INITIAL_DATA_REGEXES = {"window\\[\"ytInitialData\"\\]\\s*=\\s*(\\{.*?\\});", "var\\s*ytInitialData\\s*=\\s*(\\{.*?\\});"};
private static Random numberGenerator = new Random();
private static final Pattern C_WEB_PATTERN = Pattern.compile("&c=WEB");
private static final Pattern C_WEB_EMBEDDED_PLAYER_PATTERN = Pattern.compile("&c=WEB_EMBEDDED_PLAYER");
private static final Pattern C_TVHTML5_PLAYER_PATTERN = Pattern.compile("&c=TVHTML5");
private static final Pattern C_ANDROID_PATTERN = Pattern.compile("&c=ANDROID");
private static final Pattern C_IOS_PATTERN = Pattern.compile("&c=IOS");
private static final Set<String> GOOGLE_URLS = UByte$.ExternalSyntheticBackport0.m("google.", "m.google.", "www.google.");
private static final Set<String> INVIDIOUS_URLS = UByte$.ExternalSyntheticBackport0.m(new String[]{"invidio.us", "dev.invidio.us", "www.invidio.us", "redirect.invidious.io", "invidious.snopyta.org", "yewtu.be", "tube.connect.cafe", "tubus.eduvid.org", "invidious.kavin.rocks", "invidious.site", "invidious-us.kavin.rocks", "piped.kavin.rocks", "vid.mint.lgbt", "invidiou.site", "invidious.fdn.fr", "invidious.048596.xyz", "invidious.zee.li", "vid.puffyan.us", "ytprivate.com", "invidious.namazso.eu", "invidious.silkky.cloud", "ytb.trom.tf", "invidious.exonip.de", "inv.riverside.rocks", "invidious.blamefran.net", "y.com.cm", "invidious.moomoo.me", "yt.cyberhost.uk"});
private static final Set<String> YOUTUBE_URLS = UByte$.ExternalSyntheticBackport0.m("youtube.com", "www.youtube.com", "m.youtube.com", "music.youtube.com");
private static boolean consentAccepted = false;
private YoutubeParsingHelper() {
}
public static boolean isGoogleURL(String str) {
try {
final URL url = new URL(extractCachedUrlIfNeeded(str));
return Collection.-EL.stream(GOOGLE_URLS).anyMatch(new Predicate() {
@Override
public Predicate and(Predicate predicate) {
return Predicate.-CC.$default$and(this, predicate);
}
@Override
public java.util.function.Predicate negate() {
return Predicate.-CC.$default$negate(this);
}
@Override
public java.util.function.Predicate or(java.util.function.Predicate predicate) {
return Predicate.-CC.$default$or(this, predicate);
}
@Override
public final boolean test(Object obj) {
boolean startsWith;
startsWith = url.getHost().startsWith((String) obj);
return startsWith;
}
});
} catch (MalformedURLException unused) {
return false;
}
}
public static boolean isYoutubeURL(@Nonnull URL url) {
return YOUTUBE_URLS.contains(url.getHost().toLowerCase(Locale.ROOT));
}
public static boolean isYoutubeServiceURL(@Nonnull URL url) {
String host = url.getHost();
return host.equalsIgnoreCase("www.youtube-nocookie.com") || host.equalsIgnoreCase("youtu.be");
}
public static boolean isHooktubeURL(@Nonnull URL url) {
return url.getHost().equalsIgnoreCase("hooktube.com");
}
public static boolean isInvidiousURL(@Nonnull URL url) {
return INVIDIOUS_URLS.contains(url.getHost().toLowerCase(Locale.ROOT));
}
public static boolean isY2ubeURL(@Nonnull URL url) {
return url.getHost().equalsIgnoreCase("y2u.be");
}
public static int parseDurationString(@Nonnull String str) throws ParsingException, NumberFormatException {
String[] split;
if (str.contains(":")) {
split = str.split(":");
} else {
split = str.split("\\.");
}
int[] iArr = {24, 60, 60, 1};
int length = 4 - split.length;
if (length < 0) {
throw new ParsingException("Error duration string with unknown format: " + str);
}
int i = 0;
for (int i2 = 0; i2 < split.length; i2++) {
i = (i + convertDurationToInt(split[i2])) * iArr[i2 + length];
}
return i;
}
private static int convertDurationToInt(String str) {
if (str != null && !str.isEmpty()) {
try {
return Integer.parseInt(Utils.removeNonDigitCharacters(str));
} catch (NumberFormatException unused) {
}
}
return 0;
}
@Nonnull
public static String getFeedUrlFrom(@Nonnull String str) {
if (str.startsWith("user/")) {
return FEED_BASE_USER + str.replace("user/", "");
}
if (str.startsWith("channel/")) {
return FEED_BASE_CHANNEL_ID + str.replace("channel/", "");
}
return FEED_BASE_CHANNEL_ID + str;
}
public static OffsetDateTime parseDateFrom(String str) throws ParsingException {
try {
try {
return OffsetDateTime.parse(str);
} catch (DateTimeParseException e) {
throw new ParsingException("Could not parse date: \"" + str + "\"", e);
}
} catch (DateTimeParseException unused) {
return LocalDate.parse(str).atStartOfDay().atOffset(ZoneOffset.UTC);
}
}
public static boolean isYoutubeMixId(@Nonnull String str) {
return str.startsWith("RD");
}
public static boolean isYoutubeMyMixId(@Nonnull String str) {
return str.startsWith("RDMM");
}
public static boolean isYoutubeMusicMixId(@Nonnull String str) {
return str.startsWith("RDAMVM") || str.startsWith("RDCLAK");
}
public static boolean isYoutubeGenreMixId(@Nonnull String str) {
return str.startsWith("RDGMEM");
}
@Nonnull
public static String extractVideoIdFromMixId(String str) throws ParsingException {
if (Utils.isNullOrEmpty(str)) {
throw new ParsingException("Video id could not be determined from empty playlist id");
}
if (isYoutubeMyMixId(str)) {
return str.substring(4);
}
if (isYoutubeMusicMixId(str)) {
return str.substring(6);
}
if (isYoutubeGenreMixId(str)) {
throw new ParsingException("Video id could not be determined from genre mix id: " + str);
}
if (isYoutubeMixId(str)) {
if (str.length() != 13) {
throw new ParsingException("Video id could not be determined from mix id: " + str);
}
return str.substring(2);
}
throw new ParsingException("Video id could not be determined from playlist id: " + str);
}
@Nonnull
public static PlaylistInfo.PlaylistType extractPlaylistTypeFromPlaylistId(String str) throws ParsingException {
if (Utils.isNullOrEmpty(str)) {
throw new ParsingException("Could not extract playlist type from empty playlist id");
}
if (isYoutubeMusicMixId(str)) {
return PlaylistInfo.PlaylistType.MIX_MUSIC;
}
if (isYoutubeGenreMixId(str)) {
return PlaylistInfo.PlaylistType.MIX_GENRE;
}
if (isYoutubeMixId(str)) {
return PlaylistInfo.PlaylistType.MIX_STREAM;
}
return PlaylistInfo.PlaylistType.NORMAL;
}
public static PlaylistInfo.PlaylistType extractPlaylistTypeFromPlaylistUrl(String str) throws ParsingException {
try {
return extractPlaylistTypeFromPlaylistId(Utils.getQueryValue(Utils.stringToURL(str), "list"));
} catch (MalformedURLException e) {
throw new ParsingException("Could not extract playlist type from malformed url", e);
}
}
private static JsonObject getInitialData(String str) throws ParsingException {
try {
return (JsonObject) JsonParser.object().from(Utils.getStringResultFromRegexArray(str, INITIAL_DATA_REGEXES, 1));
} catch (JsonParserException | Parser.RegexException e) {
throw new ParsingException("Could not get ytInitialData", e);
}
}
public static boolean isHardcodedClientVersionValid() throws IOException, ExtractionException {
if (hardcodedClientVersionValid.isPresent()) {
return ((Boolean) hardcodedClientVersionValid.get()).booleanValue();
}
boolean z = false;
byte[] bytes = JsonWriter.string().object().object("context").object("client").value("hl", "en-GB").value("gl", "GB").value("clientName", "WEB").value("clientVersion", "2.20250122.04.00").value("platform", "DESKTOP").value("utcOffsetMinutes", 0).end().object("request").array("internalExperimentFlags").end().value("useSsl", true).end().object("user").value("lockedSafetyMode", false).end().end().value("fetchLiveState", true).end().done().getBytes(StandardCharsets.UTF_8);
Response postWithContentTypeJson = NewPipe.getDownloader().postWithContentTypeJson("https://www.youtube.com/youtubei/v1/guide?prettyPrint=false", getClientHeaders("1", "2.20250122.04.00"), bytes);
String responseBody = postWithContentTypeJson.responseBody();
int responseCode = postWithContentTypeJson.responseCode();
if (responseBody.length() > 5000 && responseCode == 200) {
z = true;
}
Optional<Boolean> of = Optional.of(Boolean.valueOf(z));
hardcodedClientVersionValid = of;
return ((Boolean) of.get()).booleanValue();
}
private static void extractClientVersionFromSwJs() throws IOException, ExtractionException {
if (clientVersionExtracted) {
return;
}
try {
clientVersion = Utils.getStringResultFromRegexArray(NewPipe.getDownloader().get("https://www.youtube.com/sw.js", getOriginReferrerHeaders(Constants.YOUTUBE_URL)).responseBody(), INNERTUBE_CONTEXT_CLIENT_VERSION_REGEXES, 1);
clientVersionExtracted = true;
} catch (Parser.RegexException e) {
throw new ParsingException("Could not extract YouTube WEB InnerTube client version from sw.js", e);
}
}
private static void extractClientVersionFromHtmlSearchResultsPage() throws IOException, ExtractionException {
if (clientVersionExtracted) {
return;
}
String responseBody = NewPipe.getDownloader().get("https://www.youtube.com/results?search_query=&ucbcb=1", getCookieHeader()).responseBody();
Stream map = Collection.-EL.stream(getInitialData(responseBody).getObject("responseContext").getArray("serviceTrackingParams")).filter(new BandcampCommentsExtractor$$ExternalSyntheticLambda0(JsonObject.class)).map(new BandcampCommentsExtractor$$ExternalSyntheticLambda1(JsonObject.class));
String clientVersionFromServiceTrackingParam = getClientVersionFromServiceTrackingParam(map, "CSI", "cver");
clientVersion = clientVersionFromServiceTrackingParam;
if (clientVersionFromServiceTrackingParam == null) {
try {
clientVersion = Utils.getStringResultFromRegexArray(responseBody, INNERTUBE_CONTEXT_CLIENT_VERSION_REGEXES, 1);
} catch (Parser.RegexException unused) {
}
}
if (Utils.isNullOrEmpty(clientVersion)) {
clientVersion = getClientVersionFromServiceTrackingParam(map, "ECATCHER", "client.version");
}
if (clientVersion == null) {
throw new ParsingException("Could not extract YouTube WEB InnerTube client version from HTML search results page");
}
clientVersionExtracted = true;
}
@Nullable
private static String getClientVersionFromServiceTrackingParam(@Nonnull Stream<JsonObject> stream, @Nonnull final String str, @Nonnull final String str2) {
return (String) stream.filter(new java.util.function.Predicate() {
@Override
public java.util.function.Predicate and(java.util.function.Predicate predicate) {
return Predicate.-CC.$default$and(this, predicate);
}
@Override
public java.util.function.Predicate negate() {
return Predicate.-CC.$default$negate(this);
}
@Override
public java.util.function.Predicate or(java.util.function.Predicate predicate) {
return Predicate.-CC.$default$or(this, predicate);
}
@Override
public final boolean test(Object obj) {
boolean equals;
equals = ((JsonObject) obj).getString("service", "").equals(str);
return equals;
}
}).flatMap(new Function() {
@Override
public Function andThen(Function function) {
return Function.-CC.$default$andThen(this, function);
}
@Override
public final Object apply(Object obj) {
Stream stream2;
stream2 = Collection.-EL.stream(((JsonObject) obj).getArray("params"));
return stream2;
}
@Override
public java.util.function.Function compose(java.util.function.Function function) {
return Function.-CC.$default$compose(this, function);
}
}).filter(new BandcampCommentsExtractor$$ExternalSyntheticLambda0(JsonObject.class)).map(new BandcampCommentsExtractor$$ExternalSyntheticLambda1(JsonObject.class)).filter(new java.util.function.Predicate() {
@Override
public java.util.function.Predicate and(java.util.function.Predicate predicate) {
return Predicate.-CC.$default$and(this, predicate);
}
@Override
public java.util.function.Predicate negate() {
return Predicate.-CC.$default$negate(this);
}
@Override
public java.util.function.Predicate or(java.util.function.Predicate predicate) {
return Predicate.-CC.$default$or(this, predicate);
}
@Override
public final boolean test(Object obj) {
boolean equals;
equals = ((JsonObject) obj).getString("key", "").equals(str2);
return equals;
}
}).map(new java.util.function.Function() {
@Override
public java.util.function.Function andThen(java.util.function.Function function) {
return Function.-CC.$default$andThen(this, function);
}
@Override
public final Object apply(Object obj) {
String string;
string = ((JsonObject) obj).getString(ES6Iterator.VALUE_PROPERTY);
return string;
}
@Override
public java.util.function.Function compose(java.util.function.Function function) {
return Function.-CC.$default$compose(this, function);
}
}).filter(new java.util.function.Predicate() {
@Override
public java.util.function.Predicate and(java.util.function.Predicate predicate) {
return Predicate.-CC.$default$and(this, predicate);
}
@Override
public java.util.function.Predicate negate() {
return Predicate.-CC.$default$negate(this);
}
@Override
public java.util.function.Predicate or(java.util.function.Predicate predicate) {
return Predicate.-CC.$default$or(this, predicate);
}
@Override
public final boolean test(Object obj) {
return YoutubeParsingHelper.lambda$getClientVersionFromServiceTrackingParam$5((String) obj);
}
}).findFirst().orElse((Object) null);
}
static boolean lambda$getClientVersionFromServiceTrackingParam$5(String str) {
return !Utils.isNullOrEmpty(str);
}
public static String getClientVersion() throws IOException, ExtractionException {
if (!Utils.isNullOrEmpty(clientVersion)) {
return clientVersion;
}
try {
extractClientVersionFromSwJs();
} catch (Exception unused) {
extractClientVersionFromHtmlSearchResultsPage();
}
if (clientVersionExtracted) {
return clientVersion;
}
if (isHardcodedClientVersionValid()) {
clientVersion = "2.20250122.04.00";
return "2.20250122.04.00";
}
throw new ExtractionException("Could not get YouTube WEB client version");
}
public static void resetClientVersion() {
clientVersion = null;
clientVersionExtracted = false;
}
public static void setNumberGenerator(Random random) {
numberGenerator = random;
}
public static boolean isHardcodedYoutubeMusicClientVersionValid() throws IOException, ReCaptchaException {
byte[] bytes = JsonWriter.string().object().object("context").object("client").value("clientName", "WEB_REMIX").value("clientVersion", "1.20250122.01.00").value("hl", "en-GB").value("gl", "GB").value("platform", "DESKTOP").value("utcOffsetMinutes", 0).end().object("request").array("internalExperimentFlags").end().value("useSsl", true).end().object("user").value("lockedSafetyMode", false).end().end().value("input", "").end().done().getBytes(StandardCharsets.UTF_8);
HashMap hashMap = new HashMap(getOriginReferrerHeaders("https://music.youtube.com"));
hashMap.putAll(getClientHeaders("67", "2.20250122.04.00"));
Response postWithContentTypeJson = NewPipe.getDownloader().postWithContentTypeJson("https://music.youtube.com/youtubei/v1/music/get_search_suggestions?prettyPrint=false", hashMap, bytes);
return postWithContentTypeJson.responseBody().length() > 500 && postWithContentTypeJson.responseCode() == 200;
}
public static String getYoutubeMusicClientVersion() throws IOException, ReCaptchaException, Parser.RegexException {
if (!Utils.isNullOrEmpty(youtubeMusicClientVersion)) {
return youtubeMusicClientVersion;
}
if (isHardcodedYoutubeMusicClientVersionValid()) {
youtubeMusicClientVersion = "1.20250122.01.00";
return "1.20250122.01.00";
}
try {
youtubeMusicClientVersion = Utils.getStringResultFromRegexArray(NewPipe.getDownloader().get("https://music.youtube.com/sw.js", getOriginReferrerHeaders("https://music.youtube.com")).responseBody(), INNERTUBE_CONTEXT_CLIENT_VERSION_REGEXES, 1);
} catch (Exception unused) {
youtubeMusicClientVersion = Utils.getStringResultFromRegexArray(NewPipe.getDownloader().get("https://music.youtube.com/?ucbcb=1", getCookieHeader()).responseBody(), INNERTUBE_CONTEXT_CLIENT_VERSION_REGEXES, 1);
}
return youtubeMusicClientVersion;
}
@Nullable
public static String getUrlFromNavigationEndpoint(@Nonnull JsonObject jsonObject) {
if (jsonObject.has("urlEndpoint")) {
String string = jsonObject.getObject("urlEndpoint").getString("url");
if (string.startsWith("https://www.youtube.com/redirect?")) {
string = string.substring(23);
}
if (string.startsWith("/redirect?")) {
for (String str : string.substring(10).split("&")) {
if (str.split("=")[0].equals("q")) {
return Utils.decodeUrlUtf8(str.split("=")[1]);
}
}
} else {
if (string.startsWith("http")) {
return string;
}
if (string.startsWith("/channel") || string.startsWith("/user") || string.startsWith("/watch")) {
return Constants.YOUTUBE_URL + string;
}
}
}
if (jsonObject.has("browseEndpoint")) {
JsonObject object = jsonObject.getObject("browseEndpoint");
String string2 = object.getString("canonicalBaseUrl");
String string3 = object.getString("browseId");
if (string3 != null) {
if (string3.startsWith("UC")) {
return "https://www.youtube.com/channel/" + string3;
}
if (string3.startsWith("VL")) {
return "https://www.youtube.com/playlist?list=" + string3.substring(2);
}
}
if (!Utils.isNullOrEmpty(string2)) {
return Constants.YOUTUBE_URL + string2;
}
}
if (jsonObject.has("watchEndpoint")) {
StringBuilder sb = new StringBuilder("https://www.youtube.com/watch?v=");
sb.append(jsonObject.getObject("watchEndpoint").getString(VIDEO_ID));
if (jsonObject.getObject("watchEndpoint").has("playlistId")) {
sb.append("&list=");
sb.append(jsonObject.getObject("watchEndpoint").getString("playlistId"));
}
if (jsonObject.getObject("watchEndpoint").has("startTimeSeconds")) {
sb.append("&t=");
sb.append(jsonObject.getObject("watchEndpoint").getInt("startTimeSeconds"));
}
return sb.toString();
}
if (jsonObject.has("watchPlaylistEndpoint")) {
return "https://www.youtube.com/playlist?list=" + jsonObject.getObject("watchPlaylistEndpoint").getString("playlistId");
}
if (!jsonObject.has("commandMetadata")) {
return null;
}
JsonObject object2 = jsonObject.getObject("commandMetadata").getObject("webCommandMetadata");
if (!object2.has("url")) {
return null;
}
return Constants.YOUTUBE_URL + object2.getString("url");
}
@Nullable
public static String getTextFromObject(JsonObject jsonObject, boolean z) {
if (Utils.isNullOrEmpty((Map) jsonObject)) {
return null;
}
if (jsonObject.has("simpleText")) {
return jsonObject.getString("simpleText");
}
JsonArray array = jsonObject.getArray("runs");
if (array.isEmpty()) {
return null;
}
StringBuilder sb = new StringBuilder();
Iterator it = array.iterator();
while (it.hasNext()) {
JsonObject jsonObject2 = (JsonObject) it.next();
String string = jsonObject2.getString("text");
if (z) {
if (jsonObject2.has("navigationEndpoint")) {
String urlFromNavigationEndpoint = getUrlFromNavigationEndpoint(jsonObject2.getObject("navigationEndpoint"));
if (!Utils.isNullOrEmpty(urlFromNavigationEndpoint)) {
string = "<a href=\"" + Entities.escape(urlFromNavigationEndpoint) + "\">" + Entities.escape(string) + "</a>";
}
}
boolean z2 = jsonObject2.has("bold") && jsonObject2.getBoolean("bold");
boolean z3 = jsonObject2.has("italics") && jsonObject2.getBoolean("italics");
boolean z4 = jsonObject2.has("strikethrough") && jsonObject2.getBoolean("strikethrough");
if (z2) {
sb.append("<b>");
}
if (z3) {
sb.append("<i>");
}
if (z4) {
sb.append("<s>");
}
sb.append(string);
if (z4) {
sb.append("</s>");
}
if (z3) {
sb.append("</i>");
}
if (z2) {
sb.append("</b>");
}
} else {
sb.append(string);
}
}
String sb2 = sb.toString();
return z ? sb2.replaceAll("\\n", "<br>").replaceAll(" {2}", " ") : sb2;
}
@Nonnull
public static String getTextFromObjectOrThrow(JsonObject jsonObject, String str) throws ParsingException {
String textFromObject = getTextFromObject(jsonObject);
if (textFromObject != null) {
return textFromObject;
}
throw new ParsingException("Could not extract text: " + str);
}
@Nullable
public static String getTextFromObject(JsonObject jsonObject) {
return getTextFromObject(jsonObject, false);
}
@Nullable
public static String getUrlFromObject(JsonObject jsonObject) {
if (Utils.isNullOrEmpty((Map) jsonObject)) {
return null;
}
JsonArray array = jsonObject.getArray("runs");
if (array.isEmpty()) {
return null;
}
Iterator it = array.iterator();
while (it.hasNext()) {
String urlFromNavigationEndpoint = getUrlFromNavigationEndpoint(((JsonObject) it.next()).getObject("navigationEndpoint"));
if (!Utils.isNullOrEmpty(urlFromNavigationEndpoint)) {
return urlFromNavigationEndpoint;
}
}
return null;
}
@Nullable
public static String getTextAtKey(@Nonnull JsonObject jsonObject, String str) {
if (jsonObject.isString(str)) {
return jsonObject.getString(str);
}
return getTextFromObject(jsonObject.getObject(str));
}
public static String fixThumbnailUrl(@Nonnull String str) {
if (str.startsWith("//")) {
str = str.substring(2);
}
if (str.startsWith(Utils.HTTP)) {
return Utils.replaceHttpWithHttps(str);
}
if (str.startsWith(Utils.HTTPS)) {
return str;
}
return Utils.HTTPS + str;
}
@Nonnull
public static List<Image> getThumbnailsFromInfoItem(@Nonnull JsonObject jsonObject) throws ParsingException {
try {
return getImagesFromThumbnailsArray(jsonObject.getObject("thumbnail").getArray("thumbnails"));
} catch (Exception e) {
throw new ParsingException("Could not get thumbnails from InfoItem", e);
}
}
@Nonnull
public static List<Image> getImagesFromThumbnailsArray(@Nonnull JsonArray jsonArray) {
return (List) Collection.-EL.stream(jsonArray).filter(new BandcampCommentsExtractor$$ExternalSyntheticLambda0(JsonObject.class)).map(new BandcampCommentsExtractor$$ExternalSyntheticLambda1(JsonObject.class)).filter(new java.util.function.Predicate() {
@Override
public java.util.function.Predicate and(java.util.function.Predicate predicate) {
return Predicate.-CC.$default$and(this, predicate);
}
@Override
public java.util.function.Predicate negate() {
return Predicate.-CC.$default$negate(this);
}
@Override
public java.util.function.Predicate or(java.util.function.Predicate predicate) {
return Predicate.-CC.$default$or(this, predicate);
}
@Override
public final boolean test(Object obj) {
return YoutubeParsingHelper.lambda$getImagesFromThumbnailsArray$6((JsonObject) obj);
}
}).map(new java.util.function.Function() {
@Override
public java.util.function.Function andThen(java.util.function.Function function) {
return Function.-CC.$default$andThen(this, function);
}
@Override
public final Object apply(Object obj) {
return YoutubeParsingHelper.lambda$getImagesFromThumbnailsArray$7((JsonObject) obj);
}
@Override
public java.util.function.Function compose(java.util.function.Function function) {
return Function.-CC.$default$compose(this, function);
}
}).collect(Collectors.toUnmodifiableList());
}
static boolean lambda$getImagesFromThumbnailsArray$6(JsonObject jsonObject) {
return !Utils.isNullOrEmpty(jsonObject.getString("url"));
}
static Image lambda$getImagesFromThumbnailsArray$7(JsonObject jsonObject) {
int i = jsonObject.getInt("height", -1);
return new Image(fixThumbnailUrl(jsonObject.getString("url")), i, jsonObject.getInt("width", -1), Image.ResolutionLevel.fromHeight(i));
}
@Nonnull
public static String getValidJsonResponseBody(@Nonnull Response response) throws ParsingException, MalformedURLException {
if (response.responseCode() == 404) {
throw new ContentNotAvailableException("Not found (\"" + response.responseCode() + org.schabi.newpipe.extractor.stream.Stream.ID_UNKNOWN + response.responseMessage() + "\")");
}
String responseBody = response.responseBody();
if (responseBody.length() < 50) {
throw new ParsingException("JSON response is too short");
}
URL url = new URL(response.latestUrl());
if (url.getHost().equalsIgnoreCase("www.youtube.com")) {
String path = url.getPath();
if (path.equalsIgnoreCase("/oops") || path.equalsIgnoreCase("/error")) {
throw new ContentNotAvailableException("Content unavailable");
}
}
String header = response.getHeader(HttpConnection.CONTENT_TYPE);
if (header == null || !header.toLowerCase().contains("text/html")) {
return responseBody;
}
throw new ParsingException("Got HTML document, expected JSON response (latest url was: \"" + response.latestUrl() + "\")");
}
public static JsonObject getJsonPostResponse(String str, byte[] bArr, Localization localization) throws IOException, ExtractionException {
Map<String, List<String>> youTubeHeaders = getYouTubeHeaders();
return JsonUtils.toJsonObject(getValidJsonResponseBody(NewPipe.getDownloader().postWithContentTypeJson(YOUTUBEI_V1_URL + str + "?prettyPrint=false", youTubeHeaders, bArr, localization)));
}
@Nonnull
public static JsonBuilder<JsonObject> prepareDesktopJsonBuilder(@Nonnull Localization localization, @Nonnull ContentCountry contentCountry) throws IOException, ExtractionException {
return JsonObject.builder().object("context").object("client").value("hl", localization.getLocalizationCode()).value("gl", contentCountry.getCountryCode()).value("clientName", "WEB").value("clientVersion", getClientVersion()).value("originalUrl", Constants.YOUTUBE_URL).value("platform", "DESKTOP").value("utcOffsetMinutes", 0).end().object("request").array("internalExperimentFlags").end().value("useSsl", true).end().object("user").value("lockedSafetyMode", false).end().end();
}
@Nonnull
public static String getAndroidUserAgent(@Nullable Localization localization) {
if (localization == null) {
localization = Localization.DEFAULT;
}
return "com.google.android.youtube/19.28.35 (Linux; U; Android 15; " + localization.getCountryCode() + ") gzip";
}
@Nonnull
public static String getIosUserAgent(@Nullable Localization localization) {
if (localization == null) {
localization = Localization.DEFAULT;
}
return "com.google.ios.youtube/20.03.02(iPhone16,2; U; CPU iOS 18_2_1 like Mac OS X; " + localization.getCountryCode() + ")";
}
@Nonnull
public static String getTvHtml5UserAgent() {
return "Mozilla/5.0 (PlayStation; PlayStation 4/12.00) AppleWebKit/605.1.15 (KHTML, like Gecko) Version/15.4 Safari/605.1.15";
}
@Nonnull
public static Map<String, List<String>> getYoutubeMusicHeaders() {
HashMap hashMap = new HashMap(getOriginReferrerHeaders("https://music.youtube.com"));
hashMap.putAll(getClientHeaders("67", youtubeMusicClientVersion));
return hashMap;
}
public static Map<String, List<String>> getYouTubeHeaders() throws ExtractionException, IOException {
Map<String, List<String>> clientInfoHeaders = getClientInfoHeaders();
clientInfoHeaders.put("Cookie", TypefaceCompat$.ExternalSyntheticBackport0.m(generateConsentCookie()));
return clientInfoHeaders;
}
public static Map<String, List<String>> getClientInfoHeaders() throws ExtractionException, IOException {
HashMap hashMap = new HashMap(getOriginReferrerHeaders(Constants.YOUTUBE_URL));
hashMap.putAll(getClientHeaders("1", getClientVersion()));
return hashMap;
}
public static Map<String, List<String>> getOriginReferrerHeaders(@Nonnull String str) {
List m = TypefaceCompat$.ExternalSyntheticBackport0.m(str);
return UByte$.ExternalSyntheticBackport0.m("Origin", m, "Referer", m);
}
static Map<String, List<String>> getClientHeaders(@Nonnull String str, @Nonnull String str2) {
return UByte$.ExternalSyntheticBackport0.m("X-YouTube-Client-Name", TypefaceCompat$.ExternalSyntheticBackport0.m(str), "X-YouTube-Client-Version", TypefaceCompat$.ExternalSyntheticBackport0.m(str2));
}
public static Map<String, List<String>> getCookieHeader() {
return UByte$.ExternalSyntheticBackport0.m("Cookie", TypefaceCompat$.ExternalSyntheticBackport0.m(generateConsentCookie()));
}
@Nonnull
public static String generateConsentCookie() {
String str;
if (isConsentAccepted()) {
str = "CAISAiAD";
} else {
str = "CAE=";
}
return "SOCS=".concat(str);
}
public static String extractCookieValue(String str, @Nonnull Response response) {
List<String> list = response.responseHeaders().get("set-cookie");
String str2 = "";
if (list == null) {
return "";
}
for (String str3 : list) {
int indexOf = str3.indexOf(str);
if (indexOf != -1) {
str2 = str3.substring(str.length() + indexOf + 1, str3.indexOf(";", indexOf));
}
}
return str2;
}
public static void defaultAlertsCheck(@Nonnull JsonObject jsonObject) throws ParsingException {
JsonArray array = jsonObject.getArray("alerts");
if (Utils.isNullOrEmpty((java.util.Collection<?>) array)) {
return;
}
JsonObject object = array.getObject(0).getObject("alertRenderer");
String textFromObject = getTextFromObject(object.getObject("text"));
if (object.getString("type", "").equalsIgnoreCase("ERROR")) {
if (textFromObject != null && (textFromObject.contains("This account has been terminated") || textFromObject.contains("This channel was removed"))) {
if (textFromObject.matches(".*violat(ed|ion|ing).*") || textFromObject.contains("infringement")) {
throw new AccountTerminatedException(textFromObject, AccountTerminatedException.Reason.VIOLATION);
}
throw new AccountTerminatedException(textFromObject);
}
throw new ContentNotAvailableException("Got error: \"" + textFromObject + "\"");
}
}
public static String extractCachedUrlIfNeeded(String str) {
if (str == null) {
return null;
}
return str.contains("webcache.googleusercontent.com") ? str.split("cache:")[1] : str;
}
public static boolean isVerified(JsonArray jsonArray) {
if (Utils.isNullOrEmpty((java.util.Collection<?>) jsonArray)) {
return false;
}
Iterator it = jsonArray.iterator();
while (it.hasNext()) {
String string = ((JsonObject) it.next()).getObject("metadataBadgeRenderer").getString("style");
if (string != null && (string.equals("BADGE_STYLE_TYPE_VERIFIED") || string.equals("BADGE_STYLE_TYPE_VERIFIED_ARTIST"))) {
return true;
}
}
return false;
}
public static boolean hasArtistOrVerifiedIconBadgeAttachment(@Nonnull JsonArray jsonArray) {
return Collection.-EL.stream(jsonArray).filter(new BandcampCommentsExtractor$$ExternalSyntheticLambda0(JsonObject.class)).map(new BandcampCommentsExtractor$$ExternalSyntheticLambda1(JsonObject.class)).anyMatch(new java.util.function.Predicate() {
@Override
public java.util.function.Predicate and(java.util.function.Predicate predicate) {
return Predicate.-CC.$default$and(this, predicate);
}
@Override
public java.util.function.Predicate negate() {
return Predicate.-CC.$default$negate(this);
}
@Override
public java.util.function.Predicate or(java.util.function.Predicate predicate) {
return Predicate.-CC.$default$or(this, predicate);
}
@Override
public final boolean test(Object obj) {
boolean anyMatch;
anyMatch = Collection.-EL.stream(((JsonObject) obj).getObject("element").getObject("type").getObject("imageType").getObject("image").getArray("sources")).filter(new BandcampCommentsExtractor$$ExternalSyntheticLambda0(JsonObject.class)).map(new BandcampCommentsExtractor$$ExternalSyntheticLambda1(JsonObject.class)).anyMatch(new java.util.function.Predicate() {
@Override
public java.util.function.Predicate and(java.util.function.Predicate predicate) {
return Predicate.-CC.$default$and(this, predicate);
}
@Override
public java.util.function.Predicate negate() {
return Predicate.-CC.$default$negate(this);
}
@Override
public java.util.function.Predicate or(java.util.function.Predicate predicate) {
return Predicate.-CC.$default$or(this, predicate);
}
@Override
public final boolean test(Object obj2) {
return YoutubeParsingHelper.lambda$hasArtistOrVerifiedIconBadgeAttachment$8((JsonObject) obj2);
}
});
return anyMatch;
}
});
}
static boolean lambda$hasArtistOrVerifiedIconBadgeAttachment$8(JsonObject jsonObject) {
String string = jsonObject.getObject("clientResource").getString("imageName");
return "CHECK_CIRCLE_FILLED".equals(string) || "AUDIO_BADGE".equals(string) || "MUSIC_FILLED".equals(string);
}
@Nonnull
public static String generateContentPlaybackNonce() {
return RandomStringFromAlphabetGenerator.generate(CONTENT_PLAYBACK_NONCE_ALPHABET, 16, numberGenerator);
}
@Nonnull
public static String generateTParameter() {
return RandomStringFromAlphabetGenerator.generate(CONTENT_PLAYBACK_NONCE_ALPHABET, 12, numberGenerator);
}
public static boolean isWebStreamingUrl(@Nonnull String str) {
return Parser.isMatch(C_WEB_PATTERN, str);
}
public static boolean isWebEmbeddedPlayerStreamingUrl(@Nonnull String str) {
return Parser.isMatch(C_WEB_EMBEDDED_PLAYER_PATTERN, str);
}
public static boolean isTvHtml5StreamingUrl(@Nonnull String str) {
return Parser.isMatch(C_TVHTML5_PLAYER_PATTERN, str);
}
public static boolean isAndroidStreamingUrl(@Nonnull String str) {
return Parser.isMatch(C_ANDROID_PATTERN, str);
}
public static boolean isIosStreamingUrl(@Nonnull String str) {
return Parser.isMatch(C_IOS_PATTERN, str);
}
public static void setConsentAccepted(boolean z) {
consentAccepted = z;
}
public static boolean isConsentAccepted() {
return consentAccepted;
}
@javax.annotation.Nullable
public static org.schabi.newpipe.extractor.stream.AudioTrackType extractAudioTrackType(java.lang.String r9) {
throw new UnsupportedOperationException("Method not decompiled: org.schabi.newpipe.extractor.services.youtube.YoutubeParsingHelper.extractAudioTrackType(java.lang.String):org.schabi.newpipe.extractor.stream.AudioTrackType");
}
@Nonnull
public static String getVisitorDataFromInnertube(@Nonnull InnertubeClientRequestInfo innertubeClientRequestInfo, @Nonnull Localization localization, @Nonnull ContentCountry contentCountry, @Nonnull Map<String, List<String>> map, @Nonnull String str, @Nullable String str2, boolean z) throws IOException, ExtractionException {
byte[] bytes = JsonWriter.string(prepareJsonBuilder(localization, contentCountry, innertubeClientRequestInfo, str2).done()).getBytes(StandardCharsets.UTF_8);
String string = JsonUtils.toJsonObject(getValidJsonResponseBody(NewPipe.getDownloader().postWithContentTypeJson(str + (z ? "guide" : "visitor_id") + "?prettyPrint=false", map, bytes))).getObject("responseContext").getString("visitorData");
if (Utils.isNullOrEmpty(string)) {
throw new ParsingException("Could not get visitorData");
}
return string;
}
@Nonnull
static JsonBuilder<JsonObject> prepareJsonBuilder(@Nonnull Localization localization, @Nonnull ContentCountry contentCountry, @Nonnull InnertubeClientRequestInfo innertubeClientRequestInfo, @Nullable String str) {
JsonBuilder<JsonObject> value = JsonObject.builder().object("context").object("client").value("clientName", innertubeClientRequestInfo.clientInfo.clientName).value("clientVersion", innertubeClientRequestInfo.clientInfo.clientVersion).value("clientScreen", innertubeClientRequestInfo.clientInfo.clientScreen).value("platform", innertubeClientRequestInfo.deviceInfo.platform);
if (innertubeClientRequestInfo.clientInfo.visitorData != null) {
value.value("visitorData", innertubeClientRequestInfo.clientInfo.visitorData);
}
if (innertubeClientRequestInfo.deviceInfo.deviceMake != null) {
value.value("deviceMake", innertubeClientRequestInfo.deviceInfo.deviceMake);
}
if (innertubeClientRequestInfo.deviceInfo.deviceModel != null) {
value.value("deviceModel", innertubeClientRequestInfo.deviceInfo.deviceModel);
}
if (innertubeClientRequestInfo.deviceInfo.osName != null) {
value.value("osName", innertubeClientRequestInfo.deviceInfo.osName);
}
if (innertubeClientRequestInfo.deviceInfo.osVersion != null) {
value.value("osVersion", innertubeClientRequestInfo.deviceInfo.osVersion);
}
if (innertubeClientRequestInfo.deviceInfo.androidSdkVersion > 0) {
value.value("androidSdkVersion", innertubeClientRequestInfo.deviceInfo.androidSdkVersion);
}
value.value("hl", localization.getLocalizationCode()).value("gl", contentCountry.getCountryCode()).value("utcOffsetMinutes", 0).end();
if (str != null) {
value.object("thirdParty").value("embedUrl", str).end();
}
value.object("request").array("internalExperimentFlags").end().value("useSsl", true).end().object("user").value("lockedSafetyMode", false).end().end();
return value;
}
}