Kreate v1.5.0 - BandcampExtractorHelper.java 源代码

package org.schabi.newpipe.extractor.services.bandcamp.extractors;

import androidx.core.graphics.TypefaceCompat$;
import com.grack.nanojson.JsonObject;
import com.grack.nanojson.JsonParser;
import com.grack.nanojson.JsonParserException;
import com.grack.nanojson.JsonWriter;
import j$.time.DateTimeException;
import j$.time.ZonedDateTime;
import j$.time.format.DateTimeFormatter;
import j$.util.Collection;
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.nio.charset.StandardCharsets;
import java.util.Collections;
import java.util.List;
import java.util.Locale;
import java.util.function.Function;
import java.util.function.Predicate;
import javax.annotation.Nonnull;
import javax.annotation.Nullable;
import org.jsoup.Jsoup;
import org.jsoup.nodes.Element;
import org.schabi.newpipe.extractor.Image;
import org.schabi.newpipe.extractor.NewPipe;
import org.schabi.newpipe.extractor.exceptions.ParsingException;
import org.schabi.newpipe.extractor.exceptions.ReCaptchaException;
import org.schabi.newpipe.extractor.localization.DateWrapper;
import org.schabi.newpipe.extractor.utils.ImageSuffix;
import org.schabi.newpipe.extractor.utils.Utils;

public final class BandcampExtractorHelper {
    public static final String BASE_API_URL = "https://bandcamp.com/api";
    public static final String BASE_URL = "https://bandcamp.com";
    private static final String IMAGES_DOMAIN_AND_PATH = "https://f4.bcbits.com/img/";
    private static final String IMAGE_URL_APPENDIX_AND_EXTENSION_REGEX = "_\\d+\\.\\w+";
    private static final List<ImageSuffix> IMAGE_URL_SUFFIXES_AND_RESOLUTIONS = TypefaceCompat$.ExternalSyntheticBackport0.m(new ImageSuffix[]{new ImageSuffix("10.jpg", -1, 1200, Image.ResolutionLevel.HIGH), new ImageSuffix("101.jpg", 90, -1, Image.ResolutionLevel.LOW), new ImageSuffix("170.jpg", 422, -1, Image.ResolutionLevel.MEDIUM), new ImageSuffix("171.jpg", 646, -1, Image.ResolutionLevel.MEDIUM), new ImageSuffix("20.jpg", -1, 1024, Image.ResolutionLevel.HIGH), new ImageSuffix("200.jpg", 420, -1, Image.ResolutionLevel.MEDIUM), new ImageSuffix("201.jpg", 280, -1, Image.ResolutionLevel.MEDIUM), new ImageSuffix("202.jpg", 140, -1, Image.ResolutionLevel.LOW), new ImageSuffix("204.jpg", 360, -1, Image.ResolutionLevel.MEDIUM), new ImageSuffix("205.jpg", 240, -1, Image.ResolutionLevel.MEDIUM), new ImageSuffix("206.jpg", 180, -1, Image.ResolutionLevel.MEDIUM), new ImageSuffix("207.jpg", 120, -1, Image.ResolutionLevel.LOW), new ImageSuffix("43.jpg", 100, -1, Image.ResolutionLevel.LOW), new ImageSuffix("44.jpg", 200, -1, Image.ResolutionLevel.MEDIUM)});

    private BandcampExtractorHelper() {
    }

    public static String getStreamUrlFromIds(long j, long j2, String str) throws ParsingException {
        try {
            return Utils.replaceHttpWithHttps(((JsonObject) JsonParser.object().from(NewPipe.getDownloader().get("https://bandcamp.com/api/mobile/22/tralbum_details?band_id=" + j + "&tralbum_id=" + j2 + "&tralbum_type=" + str.charAt(0)).responseBody())).getString("bandcamp_url"));
        } catch (JsonParserException | IOException | ReCaptchaException e) {
            throw new ParsingException("Ids could not be translated to URL", e);
        }
    }

    public static JsonObject getArtistDetails(String str) throws ParsingException {
        try {
            return (JsonObject) JsonParser.object().from(NewPipe.getDownloader().postWithContentTypeJson("https://bandcamp.com/api/mobile/22/band_details", Collections.EMPTY_MAP, JsonWriter.string().object().value("band_id", str).end().done().getBytes(StandardCharsets.UTF_8)).responseBody());
        } catch (IOException | ReCaptchaException | JsonParserException e) {
            throw new ParsingException("Could not download band details", e);
        }
    }

    @Nonnull
    public static String getImageUrl(long j, boolean z) {
        return IMAGES_DOMAIN_AND_PATH + (z ? 'a' : "") + j + "_10.jpg";
    }

    public static boolean isArtistDomain(String str) throws ParsingException {
        if (str.toLowerCase().matches("https?://.+\\.bandcamp\\.com(/.*)?")) {
            return true;
        }
        if (str.toLowerCase().matches("https?://bandcamp\\.com(/.*)?")) {
            return false;
        }
        try {
            return Jsoup.parse(NewPipe.getDownloader().get(Utils.replaceHttpWithHttps(str)).responseBody()).getElementsByClass("cart-wrapper").get(0).getElementsByTag("a").get(0).attr("href").equals("https://bandcamp.com/cart");
        } catch (IOException | ReCaptchaException unused) {
            throw new ParsingException("Could not determine whether URL is custom domain (not available? network error?)");
        } catch (IndexOutOfBoundsException | NullPointerException unused2) {
            return false;
        }
    }

    public static boolean isRadioUrl(String str) {
        return str.toLowerCase().matches("https?://bandcamp\\.com/\\?show=\\d+");
    }

    public static DateWrapper parseDate(String str) throws ParsingException {
        try {
            return new DateWrapper(ZonedDateTime.parse(str, DateTimeFormatter.ofPattern("dd MMM yyyy HH:mm:ss zzz", Locale.ENGLISH)).toOffsetDateTime(), false);
        } catch (DateTimeException e) {
            throw new ParsingException("Could not parse date '" + str + "'", e);
        }
    }

    @Nonnull
    public static List<Image> getImagesFromSearchResult(@Nonnull Element element) {
        return getImagesFromImageUrl((String) Collection.-EL.stream(element.getElementsByClass("art")).flatMap(new Function() {
            @Override
            public Function andThen(Function function) {
                return Function.-CC.$default$andThen(this, function);
            }

            @Override
            public final Object apply(Object obj) {
                Stream stream;
                stream = Collection.-EL.stream(((Element) obj).getElementsByTag("img"));
                return stream;
            }

            @Override
            public java.util.function.Function compose(java.util.function.Function function) {
                return Function.-CC.$default$compose(this, function);
            }
        }).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 attr;
                attr = ((Element) obj).attr("src");
                return attr;
            }

            @Override
            public java.util.function.Function compose(java.util.function.Function function) {
                return Function.-CC.$default$compose(this, function);
            }
        }).filter(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) {
                return BandcampExtractorHelper.lambda$getImagesFromSearchResult$2((String) obj);
            }
        }).findFirst().orElse(""));
    }

    static boolean lambda$getImagesFromSearchResult$2(String str) {
        return !Utils.isNullOrEmpty(str);
    }

    @Nonnull
    public static List<Image> getImagesFromImageUrl(@Nullable String str) {
        if (Utils.isNullOrEmpty(str)) {
            return Collections.EMPTY_LIST;
        }
        return getImagesFromImageBaseUrl(str.replaceFirst(IMAGE_URL_APPENDIX_AND_EXTENSION_REGEX, "_"));
    }

    @Nonnull
    public static List<Image> getImagesFromImageId(long j, boolean z) {
        if (j == 0) {
            return Collections.EMPTY_LIST;
        }
        return getImagesFromImageBaseUrl(IMAGES_DOMAIN_AND_PATH + (z ? 'a' : "") + j + "_");
    }

    @Nonnull
    private static List<Image> getImagesFromImageBaseUrl(@Nonnull final String str) {
        return (List) Collection.-EL.stream(IMAGE_URL_SUFFIXES_AND_RESOLUTIONS).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 BandcampExtractorHelper.lambda$getImagesFromImageBaseUrl$3(str, (ImageSuffix) obj);
            }

            @Override
            public java.util.function.Function compose(java.util.function.Function function) {
                return Function.-CC.$default$compose(this, function);
            }
        }).collect(Collectors.toUnmodifiableList());
    }

    static Image lambda$getImagesFromImageBaseUrl$3(String str, ImageSuffix imageSuffix) {
        return new Image(str + imageSuffix.getSuffix(), imageSuffix.getHeight(), imageSuffix.getWidth(), imageSuffix.getResolutionLevel());
    }
}