导航菜单
登录 注册

页面标题

页面副标题

Kreate v1.5.0 - YoutubeSubscriptionExtractor.java 源代码

正在查看： Kreate v1.5.0 应用的 YoutubeSubscriptionExtractor.java JAVA 源代码文件

本页面展示 JAVA 反编译生成的源代码文件，支持语法高亮显示。 仅供安全研究与技术分析使用，严禁用于任何非法用途。请遵守相关法律法规。 


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

import com.grack.nanojson.JsonArray;
import com.grack.nanojson.JsonObject;
import com.grack.nanojson.JsonParser;
import com.grack.nanojson.JsonParserException;
import j$.io.BufferedReaderRetargetClass;
import j$.util.Objects;
import j$.util.function.Function;
import j$.util.function.Predicate;
import j$.util.stream.Collectors;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStream;
import java.io.InputStreamReader;
import java.io.UncheckedIOException;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Iterator;
import java.util.List;
import java.util.function.Function;
import java.util.function.Predicate;
import java.util.zip.ZipEntry;
import java.util.zip.ZipInputStream;
import javax.annotation.Nonnull;
import org.schabi.newpipe.extractor.exceptions.ExtractionException;
import org.schabi.newpipe.extractor.services.youtube.YoutubeService;
import org.schabi.newpipe.extractor.subscription.SubscriptionExtractor;
import org.schabi.newpipe.extractor.subscription.SubscriptionItem;
import org.schabi.newpipe.extractor.utils.Utils;

public class YoutubeSubscriptionExtractor extends SubscriptionExtractor {
    private static final String BASE_CHANNEL_URL = "https://www.youtube.com/channel/";

    public YoutubeSubscriptionExtractor(YoutubeService youtubeService) {
        super(youtubeService, Collections.singletonList(SubscriptionExtractor.ContentSource.INPUT_STREAM));
    }

    @Override
    public String getRelatedUrl() {
        return "https://takeout.google.com/takeout/custom/youtube";
    }

    @Override
    public List<SubscriptionItem> fromInputStream(@Nonnull InputStream inputStream) throws ExtractionException {
        return fromJsonInputStream(inputStream);
    }

    @Override
    public List<SubscriptionItem> fromInputStream(@Nonnull InputStream inputStream, @Nonnull String str) throws ExtractionException {
        str.hashCode();
        switch (str) {
            case "text/comma-separated-values":
            case "text/csv":
            case "csv":
                return fromCsvInputStream(inputStream);
            case "application/zip":
            case "zip":
                return fromZipInputStream(inputStream);
            case "application/json":
            case "json":
                return fromJsonInputStream(inputStream);
            default:
                throw new SubscriptionExtractor.InvalidSourceException("Unsupported content type: " + str);
        }
    }

    public List<SubscriptionItem> fromJsonInputStream(@Nonnull InputStream inputStream) throws ExtractionException {
        try {
            JsonArray jsonArray = (JsonArray) JsonParser.array().from(inputStream);
            ArrayList arrayList = new ArrayList();
            Iterator it = jsonArray.iterator();
            boolean z = false;
            while (it.hasNext()) {
                Object next = it.next();
                if (next instanceof JsonObject) {
                    JsonObject object = ((JsonObject) next).getObject("snippet");
                    String string = object.getObject("resourceId").getString("channelId", "");
                    if (string.length() == 24) {
                        arrayList.add(new SubscriptionItem(this.service.getServiceId(), BASE_CHANNEL_URL + string, object.getString("title", "")));
                    }
                }
                z = true;
            }
            if (z && arrayList.isEmpty()) {
                throw new SubscriptionExtractor.InvalidSourceException("Found only invalid channel ids");
            }
            return arrayList;
        } catch (JsonParserException e) {
            throw new SubscriptionExtractor.InvalidSourceException("Invalid json input stream", e);
        }
    }

    public List<SubscriptionItem> fromZipInputStream(@Nonnull InputStream inputStream) throws ExtractionException {
        try {
            ZipInputStream zipInputStream = new ZipInputStream(inputStream);
            while (true) {
                try {
                    ZipEntry nextEntry = zipInputStream.getNextEntry();
                    if (nextEntry != null) {
                        if (nextEntry.getName().toLowerCase().endsWith(".csv")) {
                            try {
                                List<SubscriptionItem> fromCsvInputStream = fromCsvInputStream(zipInputStream);
                                if (!fromCsvInputStream.isEmpty()) {
                                    zipInputStream.close();
                                    return fromCsvInputStream;
                                }
                            } catch (ExtractionException unused) {
                                continue;
                            }
                        }
                    } else {
                        zipInputStream.close();
                        throw new SubscriptionExtractor.InvalidSourceException("Unable to find a valid subscriptions.csv file (try extracting and selecting the csv file)");
                    }
                } finally {
                }
            }
        } catch (IOException e) {
            throw new SubscriptionExtractor.InvalidSourceException("Error reading contents of zip file", e);
        }
    }

    public List<SubscriptionItem> fromCsvInputStream(@Nonnull InputStream inputStream) throws ExtractionException {
        try {
            BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(inputStream));
            try {
                List<SubscriptionItem> list = (List) BufferedReaderRetargetClass.lines(bufferedReader).skip(1L).map(new Function() {
                    @Override
                    public Function andThen(Function function) {
                        return Function.-CC.$default$andThen(this, function);
                    }

                    @Override
                    public final Object apply(Object obj) {
                        String[] split;
                        split = ((String) obj).split(",");
                        return split;
                    }

                    @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 YoutubeSubscriptionExtractor.lambda$fromCsvInputStream$1((String[]) 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 YoutubeSubscriptionExtractor.this.m853x2cc59c7a((String[]) obj);
                    }

                    @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 Objects.nonNull((SubscriptionItem) obj);
                    }
                }).collect(Collectors.toUnmodifiableList());
                bufferedReader.close();
                return list;
            } catch (Throwable th) {
                try {
                    bufferedReader.close();
                } catch (Throwable th2) {
                    th.addSuppressed(th2);
                }
                throw th;
            }
        } catch (IOException | UncheckedIOException e) {
            throw new SubscriptionExtractor.InvalidSourceException("Error reading CSV file", e);
        }
    }

    static boolean lambda$fromCsvInputStream$1(String[] strArr) {
        return strArr.length >= 3;
    }

    SubscriptionItem m853x2cc59c7a(String[] strArr) {
        String replace = strArr[1].replace(Utils.HTTP, Utils.HTTPS);
        if (replace.startsWith(BASE_CHANNEL_URL)) {
            return new SubscriptionItem(this.service.getServiceId(), replace, strArr[2]);
        }
        return null;
    }
}